// 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;

    }