--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/inc/graphics/openwfc/surfaceconfiguration.inl Tue Jul 20 13:27:44 2010 +0300
@@ -0,0 +1,432 @@
+// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of "Eclipse Public License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.eclipse.org/legal/epl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// Sets all members to default values. Initializes the size field to match the object size.
+//
+//
+/**
+@file
+@publishedpartner
+@released
+*/
+
+inline TSurfaceConfiguration::TSurfaceConfiguration()
+ {}
+
+/**
+Copy constructor. This constructor will read the size field of the source and target
+objects and only copy the minimum set of fields indicated. Any remaining fields in the target
+object will be set to default values.
+
+@param aSurfaceConfiguration Config to copy
+*/
+inline TSurfaceConfiguration::TSurfaceConfiguration(const TSurfaceConfiguration& aSurfaceConfiguration):
+ TSurfaceConfiguration2(0)
+ {
+ TInt tempSize = aSurfaceConfiguration.Size();
+ if (tempSize > sizeof(*this))
+ {
+ tempSize = sizeof(*this);
+ }
+ Mem::Copy(this, &aSurfaceConfiguration, tempSize);
+ iSize = tempSize;
+ }
+
+/**
+This constructor will take any value, but it is designed to be used with
+a value returned by RWsSession::PreferredSurfaceConfigurationSize,
+and initializes the members to represent an object compatible with that.
+
+If the aPreferredMaxSize is larger than the actual size of TSurfaceConfiguration, indicating
+that the server supports a newer version of the interface than the caller is aware of, then
+the actual size is used.
+
+If the aPreferredMaxSize is smaller than the actual size of TSurfaceConfiguration, indicating
+that the server supports an earlier version of the interface, then this value is used. It must
+match the Size() member of one of the defined hierarchy of TSurfaceConfiguration classes.
+
+@param aPreferredMaxSize User defined max size
+@see RWsSession::PreferredSurfaceConfigurationSize
+*/
+inline TSurfaceConfiguration::TSurfaceConfiguration(TInt aPreferredMaxSize):
+ TSurfaceConfiguration2(sizeof(*this))
+ {
+ if (sizeof(*this) > aPreferredMaxSize)
+ {
+ iSize = aPreferredMaxSize;
+ }
+ }
+
+/** Default constructor for configuration 1
+*/
+inline TSurfaceConfiguration1::TSurfaceConfiguration1():TSurfaceConfigurationSize(sizeof(*this))
+ ,iExtent(TRect::EUninitialized), iViewport(TRect::EUninitialized)
+ {}
+
+/**
+Constructor for configuration 1 passing through a size already calculated
+
+@param aSize Size of the class already calculated and being passed up through the classes
+*/
+inline TSurfaceConfiguration1::TSurfaceConfiguration1(TInt aSize):TSurfaceConfigurationSize(aSize)
+ ,iExtent(TRect::EUninitialized), iViewport(TRect::EUninitialized)
+ {}
+
+/**
+The method sets the surface ID to be set as the background surface.
+
+The default initial value held in this class for surface ID is the null surface ID.
+
+Note that SetBackgroundSurface() will not accept a null surface ID, so this parameter must always be set.
+
+@param aSurfaceId Surface ID to set
+@return KErrNone on success or a system-wide error code
+ - KErrNotSupported if not supported.
+@post The Surface Id values are updated in the object of this class if supported. The
+SetBackgroundSurface API must be called passing object of this class as parameter to
+get the desired effect.
+*/
+inline TInt TSurfaceConfiguration1::SetSurfaceId (const TSurfaceId& aSurfaceId)
+ {
+ if (MemberAccessible(iSurfaceId))
+ {
+ iSurfaceId = aSurfaceId;
+ return KErrNone;
+ }
+ return KErrNotSupported;
+ }
+
+/**
+The method gets the surface ID stored in the object of this class.
+
+@param aSurfaceId User surface id to be set
+@post The aSurface parameter is filled in.
+@post If the instance of TSurfaceConfiguration is too small, the null surface ID will be set.
+*/
+inline void TSurfaceConfiguration1::GetSurfaceId (TSurfaceId& aSurfaceId) const
+ {
+ if (MemberAccessible(iSurfaceId))
+ {
+ aSurfaceId = iSurfaceId;
+ }
+ else
+ {
+ aSurfaceId.CreateNullId();
+ }
+ }
+
+/**
+The method sets the area of the surface that should be mapped to the specified window area.
+The viewport is in surface coordinates.
+
+In SetBackgroundSurface(), if not set or if the set viewport is empty, the size of the whole surface
+is used as the viewport. If the surface is changed then the viewport will track the size of
+the surface.
+
+Setting any ordinate of the viewport outside the surface size is not required specified behavior for
+this interface. The call will not fail if any ordinates are out of range, and the internal NGA Composition
+handling of this case will produce a representative image. This current behavior is that the NGA Composition
+will clamp any out-of-range ordinate to the size of the surface.
+
+@param aViewport A rectangle of the area, in relative coordinates to the surface
+@return KErrNone on success or a system-wide error code
+ - KErrNotSupported if not supported.
+@post The viewport values are updated in the object of this class. This does not imply that the
+viewport is set for the surface. The SetBackgroundSurface API must be called passing an object of
+this class as parameter to get the desired effect.
+*/
+inline TInt TSurfaceConfiguration1::SetViewport (const TRect& aViewport)
+ {
+ if (MemberAccessible(iViewport))
+ {
+ iViewport = aViewport;
+ return KErrNone;
+ }
+ return KErrNotSupported;
+ }
+
+/**
+This method gets the viewport stored in the object of this class. The viewport is in surface
+coordinates.
+
+If viewport was not set or an empty viewport was set, the value returned is an empty viewport. This
+is an indication that the viewport used by the server is equal to the size of the surface. The
+actual size of the surface is not returned.
+
+@param aViewport User viewport to be set.
+@post The aViewport rectangle is filled in.
+@post If the instance of TSurfaceConfiguration is too small, the empty viewport rectangle will be returned.
+*/
+inline void TSurfaceConfiguration1::GetViewport (TRect& aViewport) const
+ {
+ if (MemberAccessible(iViewport))
+ {
+ aViewport = iViewport;
+ }
+ else
+ {
+ aViewport = TRect();
+ }
+ }
+
+/**
+This method sets the relative orientation of viewport to window extent. The default value is
+EGraphicsOrientationNormal.
+
+The rotation effect is applied to the input viewport area, around the centre-point of the viewport.
+
+@param aOrientation User orientation to be set
+@return KErrNone on success or a system-wide error code
+ - KErrNotSupported if not supported.
+ - KErrArgument if aOrientation is out of range
+@post The orientation is updated in the object of this class. This does not imply that the orientation
+is set for the surface content. The SetBackgroundSurface API must be called passing an object of
+this class as parameter to get the desired effect.
+*/
+inline TInt TSurfaceConfiguration1::SetOrientation (CFbsBitGc::TGraphicsOrientation aOrientation)
+ {
+ if (MemberAccessible(iOrientation))
+ {
+ __ASSERT_COMPILE(CFbsBitGc::EGraphicsOrientationNormal==0 &&
+ CFbsBitGc::EGraphicsOrientationRotated270 == 3);
+ if(aOrientation < CFbsBitGc::EGraphicsOrientationNormal ||
+ aOrientation > CFbsBitGc::EGraphicsOrientationRotated270)
+ {
+ return KErrArgument;
+ }
+ iOrientation = aOrientation;
+ return KErrNone;
+ }
+ return KErrNotSupported;
+ }
+
+/**
+The method gets the surface orientation angle stored in the object of this class. It is the
+relative orientation of viewport to window extent. If orientation was not set, the value returned
+will be EGraphicsOrientationNormal.
+
+@return orientation in this object
+@post If the instance of TSurfaceConfiguration is too small, the default EGraphicsOrientationNormal
+setting will be returned.
+*/
+inline CFbsBitGc::TGraphicsOrientation TSurfaceConfiguration1::Orientation() const
+ {
+ if (MemberAccessible(iOrientation))
+ {
+ return iOrientation;
+ }
+ else
+ {
+ return CFbsBitGc::EGraphicsOrientationNormal;
+ }
+ }
+
+/**
+This method sets the area of the window where the surface content is to be placed. The extent is
+in window coordinates.
+
+If not set or if the set extent is empty, the size of the entire window is used as the default extent.
+The default extent changes according to the change in the window size. The empty extent is an indication
+to the server that the extent should fill the entire window without the client tracking the change in
+the window size.
+
+In SetBackgroundSurface() it is legal to set the extent larger than the window, or the window may
+become smaller than the extent. In these cases the output will be transformed on the basis of this
+larger extent, but then clipped to the window outline.
+
+@param aExtent Area on the window where the surface contents specified by viewport
+should be mapped
+@return KErrNone on success or a system-wide error code
+ - KErrNotSupported if not supported.
+@post The extent values are updated in the object of this class. This does not imply that the
+extent is set for the surface. The SetBackgroundSurface API must be called passing an object of
+this class as parameter to get the desired effect.
+*/
+inline TInt TSurfaceConfiguration1::SetExtent(const TRect& aExtent)
+ {
+ if (MemberAccessible(iExtent))
+ {
+ iExtent = aExtent;
+ return KErrNone;
+ }
+ return KErrNotSupported;
+ }
+
+/**
+The method gets the extent stored in the object of this class. The extent is in window coordinates.
+
+If extent was not set or an empty extent was set, the value returned will be an empty extent. This
+is an indication that the extent used by the server is equal to the size of the window. The actual
+size of the window is not returned.
+
+@param aExtent User extent to be set
+@post The aExtent parameter is filled in
+@post If the instance of TSurfaceConfiguration is too small, the empty extent rectangle will be returned.
+*/
+inline void TSurfaceConfiguration1::GetExtent(TRect& aExtent) const
+ {
+ if (MemberAccessible(iExtent))
+ {
+ aExtent = iExtent;
+ }
+ else
+ {
+ aExtent = TRect();
+ }
+ }
+
+/**
+This method identifies which attributes are available to use.
+
+Generally, any version of the server will accept any version of TSurfaceConfiguration, ignoring
+newer version attributes it does not recognize and substituting defaults for attributes not present
+in older version.
+
+However, by using this method in conjunction with GetBackgroundSurface() the intelligent client can
+identify which blocks of attributes are actually present and supported after a call to
+GetBackgroundSurface, avoiding preparing complex attributes, or reducing user-interface control
+gadgets.
+
+@return ETrue if all these attributes are available to use; otherwise EFalse
+*/
+inline TBool TSurfaceConfiguration1::SupportsAllMembers()
+ {
+ if (Size() >= sizeof(*this))
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+/**
+Constructs the TSurfaceConfigurationSize class, enters the size field and blanks everything else
+
+@param aSize The size to set for the configuration
+@return ETrue If all these attributes are available to use; otherwise EFalse
+*/
+inline TSurfaceConfigurationSize::TSurfaceConfigurationSize(TInt aSize)
+ {
+ Mem::FillZ(this,aSize);
+ iSize = aSize;
+ }
+
+/**
+Reads the size field. The size is set automatically in the constructor, or by the
+GetBackgroundSurface method to indicate the sender’s supported structure size, and imply a
+compatible version identifier. The size reported after GetBackgroundSurface will match
+the expected size of one of the hierarchy of TSurfaceConfiguration classes documented in the
+header, and will never exceed the constructed size.
+
+@return ETrue if all these attributes are available to use; otherwise EFalse
+*/
+inline TInt TSurfaceConfigurationSize::Size() const
+ {
+ return iSize;
+ }
+
+inline TBool TSurfaceConfigurationSize::operator == (const TSurfaceConfigurationSize& aRhs)const
+ {
+ return aRhs.Size()==Size(); //If the two objects are not the same version then we can't compare them!
+ }
+inline TBool TSurfaceConfiguration1::operator == (const TSurfaceConfiguration1& aRhs)const
+ {
+ if (!TSurfaceConfigurationSize::operator ==(aRhs))
+ return EFalse; //Check for earlier version compatability
+ if (Size()<sizeof(*this))
+ return ETrue; //If the objects are smaller than this then the check is complete
+ return (iSurfaceId==aRhs.iSurfaceId)
+ && (iOrientation==aRhs.iOrientation)
+ && (iExtent==aRhs.iExtent)
+ && (iViewport==aRhs.iViewport)
+ ;
+ }
+
+/** Default constructor for configuration 2
+*/
+inline TSurfaceConfiguration2::TSurfaceConfiguration2():TSurfaceConfiguration1(sizeof(*this))
+ ,iFlip(EFalse)
+ {}
+
+/**
+Constructor for configuration 2 passing through a size already calculated
+
+@param aSize Size of the class already calculated and being passed up through the classes
+*/
+inline TSurfaceConfiguration2::TSurfaceConfiguration2(TInt aSize):TSurfaceConfiguration1(aSize)
+ ,iFlip(EFalse)
+ {}
+
+/**
+This method sets the flip attribute to the surface. The default value is
+EFalse.
+
+@param aFlip When ETrue enalbes flip in the x-axis
+@post The flip attribute is updated in the object of this class. This does not imply that the flip
+is set for the surface content. The SetBackgroundSurface API must be called passing an object of
+this class as parameter to get the desired effect.
+@return KErrNone on success
+ - KErrNotSupported if flip is not supported.
+*/
+inline TInt TSurfaceConfiguration2::SetFlip(TBool aFlip)
+ {
+ if (MemberAccessible(iFlip))
+ {
+ iFlip = aFlip;
+ return KErrNone;
+ }
+ return KErrNotSupported;
+ }
+
+/**
+The method gets the flip attribute of the surface stored in the object of this class. If the flip was not set, the value returned
+will be EFalse.
+
+@return ETrue if flip is enabled
+@post If the instance of TSurfaceConfiguration is too small, the default EFalse
+setting will be returned.
+*/
+inline TBool TSurfaceConfiguration2::Flip() const
+ {
+ if (MemberAccessible(iFlip))
+ {
+ return iFlip;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+inline TBool TSurfaceConfiguration2::SupportsAllMembers()
+ {
+ if (Size() >= sizeof(*this))
+ {
+ return ETrue;
+ }
+ else
+ {
+ return EFalse;
+ }
+ }
+
+inline TBool TSurfaceConfiguration2::operator == (const TSurfaceConfiguration2& aRhs)const
+ {
+ if (!TSurfaceConfiguration1::operator ==(aRhs))
+ return EFalse; //Check for earlier version compatability
+ if (Size()<sizeof(*this))
+ return ETrue; //If the objects are smaller than this then the check is complete
+ return iFlip==aRhs.iFlip;
+ }