// Copyright (c) 2008-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:

// 

//

#include "openwfcpanics.h"

#include "elementwrapper.h"

#include <WF/wfc.h>

#include <graphics/surfacetypes.h>

#include <hal.h>

CElementWrapper* CElementWrapper::NewL(COpenWfcWrapper& aCOpenWfcWrapper, CElementWrapper*& aCleanupPrevRef)

    {

    CElementWrapper* wrapper = new (ELeave) CElementWrapper(aCOpenWfcWrapper);

    CleanupStack::PushL(wrapper);

    wrapper->ConstructL(aCleanupPrevRef);

    CleanupStack::Pop(wrapper);

    return wrapper;

    }

CElementWrapper::CElementWrapper(COpenWfcWrapper& aOpenWfcWrapper):

    iUpdateFlags(EUpdate_ALL_ATTRIBS),iOpenWfcWrapper(aOpenWfcWrapper),iGlobalAlpha(0xff),

    iFlipped(EFalse),iRotation(MWsElement::EElementAntiClockwise0)

    {

    }

CElementWrapper::~CElementWrapper()

    {

    wfcDestroyElement(iOpenWfcWrapper.Device(),iElement);

    UnsetSurface(iSurfaceId);

    iUpdateFlags = EUpdate_None;

    if (iCleanupNext)

        {

        iCleanupNext->iCleanupPrevRef=iCleanupPrevRef;

        }

    *iCleanupPrevRef=iCleanupNext;

    }

void CElementWrapper::ConstructL(CElementWrapper*& aCleanupPrevRef)

    {

    if (aCleanupPrevRef)

        {

        iCleanupNext=aCleanupPrevRef;

        iCleanupNext->iCleanupPrevRef=&iCleanupNext;

        }

    aCleanupPrevRef=this;

    iCleanupPrevRef=&aCleanupPrevRef;

    iElement=wfcCreateElement(iOpenWfcWrapper.Device(),iOpenWfcWrapper.OnScreenContext(),NULL);

    if (iElement==WFC_INVALID_HANDLE)

        {   //if context and device are good then only explanation is memory

        #ifdef _DEBUG

            WFCErrorCode wfcErr = 

        #endif

        wfcGetError(iOpenWfcWrapper.Device());

        OPENWFC_ASSERT_DEBUG(wfcErr==WFC_ERROR_OUT_OF_MEMORY,EPanicUnexpectedErrorElementConstruct);

        User::Leave(KErrNoMemory);

        }

    }

TInt CElementWrapper::SetSourceRectangle(const TRect& aSrc)

    {

    if(iSurfaceId.IsNull())

        return KErrGeneral;

    //Check aSrc rect is within the bounds of the source image

    TInt32 width,height;

    HelpStreamGetHeader(&width,&height);

    if(aSrc.iTl.iX < 0 || aSrc.iTl.iY < 0 || aSrc.iBr.iX > width || aSrc.iBr.iY > height)

        {

        return KErrArgument;

        }

    iSourcRect = aSrc;

    iUpdateFlags |= EUpdate_SettingValid|EUpdate_SOURCE_RECTANGLE;

    iOpenWfcWrapper.SetCompositionModified();

    return KErrNone;

    }

TInt CElementWrapper::GetSourceRectangle(TRect& aSrc)

    {

    if(iSurfaceId.IsNull())

        return KErrGeneral;

    if (iSourcRect.IsEmpty())

        {        

        //get true source rectangle from surface

        TInt32 width,height;

        HelpStreamGetHeader(&width,&height);

        aSrc.iTl.iX = 0;

        aSrc.iTl.iY = 0;

        aSrc.iBr.iX = width;

        aSrc.iBr.iY = height;

        }

    else

        {

        aSrc=iSourcRect;

        }

    return KErrNone;

    }

TInt CElementWrapper::SetSourceFlipping(const TBool aFlip)

    {

    if(iSurfaceId.IsNull())

        return KErrGeneral;

    iFlipped = aFlip;

    iUpdateFlags |= EUpdate_SettingValid|EUpdate_SOURCE_FLIP;

    return KErrNone;

    }

TBool CElementWrapper::SourceFlipping() const

    {

    if(iSurfaceId.IsNull())

        return EFalse; //default is not flipped

    return iFlipped;

    }

TInt CElementWrapper::SetGlobalAlpha(const TInt aAlpha)

    {

    if (aAlpha!=iGlobalAlpha)

        {

        if ((aAlpha>=0xff)!=(iGlobalAlpha==0xff))

            {

            iUpdateFlags |= EUpdate_SettingValid|EUpdate_TRANSPARENCY_TYPES;

            }

        if (aAlpha < 0)

            {

            iGlobalAlpha = 0;

            }

        else

            {

            iGlobalAlpha = aAlpha > 0xff ? 0xff : aAlpha;

            }

        iUpdateFlags |= EUpdate_SettingValid|EUpdate_GLOBAL_ALPHA;

        }

    iOpenWfcWrapper.SetCompositionModified();

    return KErrNone;

    }

void CElementWrapper::GlobalAlpha(TInt& aAlpha) const

    {

    aAlpha = iGlobalAlpha;

    }

TInt CElementWrapper::SetDestinationRectangle(const TRect& aDest)

    {

    if(iSurfaceId.IsNull())

        return KErrGeneral;

    //Check aDest is not out of bounds

    if(aDest.iBr.iX < aDest.iTl.iX || aDest.iBr.iY < aDest.iTl.iY)

        {

        return KErrArgument;

        }

    TRect compositionDestRect;

    TRect lastCompositionDestRect;

    GetDestinationRectangle(lastCompositionDestRect);

    TInt err = KErrNone;

    //always do the translate

    err = iOpenWfcWrapper.DisplayPolicy()->MapCoordinates(EApplicationSpace, aDest, ECompositionSpace, compositionDestRect);

    if(compositionDestRect != lastCompositionDestRect)

        {

        iDestinationRect=aDest;

        iUpdateFlags |= EUpdate_SettingValid|EUpdate_DESTINATION_RECTANGLE;

        iOpenWfcWrapper.SetCompositionModified();

        }

    return err;

    }

TInt CElementWrapper::GetDestinationRectangle(TRect& aDest) const

    {

    if(iSurfaceId.IsNull())

        return KErrGeneral;

    aDest=iDestinationRect;

    return KErrNone;

    }

TInt CElementWrapper::SetDestinationClippingRect(const TRect& aDestClipRect)

	{

	if(iSurfaceId.IsNull())

        return KErrGeneral;

    TRect compositionDestClipRect;

    TRect lastCompositionDestClipRect;

    GetDestinationClippingRect(lastCompositionDestClipRect);

    TInt err = KErrNone;

    //always do the translate

    err = iOpenWfcWrapper.DisplayPolicy()->MapCoordinates(EApplicationSpace, aDestClipRect, ECompositionSpace, compositionDestClipRect);

    if(compositionDestClipRect != lastCompositionDestClipRect)

    	{

    	TRect destClipRect(aDestClipRect);

		//Check if the destination clip rectangle is not empty

		if (!destClipRect.IsEmpty())

			{

			//Calculate the intersection of the destination clipped rectangle

			destClipRect.Intersection(iDestinationRect);

			if (!destClipRect.IsEmpty())

				{

				// Check if the clipped rectangle is valid,it doesn't have coordinates

				if (destClipRect.iTl.iX < 0 || destClipRect.iTl.iY < 0)

					{

					return KErrArgument;

					}

				}

			}

		if (iDestinationClippingRect != aDestClipRect)

			{

			iDestinationClippingRect = aDestClipRect;

			iUpdateFlags |= EUpdate_SettingValid | EUpdate_DESTINATION_CLIP_RECTANGLE;

			iOpenWfcWrapper.SetCompositionModified();

			}

		err = KErrNone;

		}

	return err;

	}

TInt CElementWrapper::GetDestinationClippingRect(TRect& aDestClipRect) const

    {

	if(iSurfaceId.IsNull())

        return KErrGeneral;

    aDestClipRect = iDestinationClippingRect;

    return KErrNone;

    }

/*

Fast swap of two 32-bit TInt type integers.

@param aA Argument one. 

@param aB Argument two.

*/

inline void SwapInt(TInt& aA, TInt& aB)

   {

   aA ^= aB;

   aB ^= aA;

   aA ^= aB;

   }

/*

 Rectangle corner point enumeration.

 Consider TopLeft     point as 0

 Consider TopRight    point as 1

 Consider BottomRight point as 2

 Consider BottomLeft  point as 3

*/

enum TRectangleCornerPoint

    {

    ETopLeft,

    ETopRight,

    EBottomRight,

    EBottomLeft

    };

/**

 Get Bottom right corner of the rectangle. 

 @param aRect input rectangle.

 @return Bottom right corner point coordinates of rectangle.

 */

inline TPoint BottomRight(const TRect& aRect)

    {

    return aRect.iBr;

    }

/**

 Get Top left corner of the rectangle. 

 @param aRect input rectangle.

 @return Top left corner point coordinates of rectangle.

 */

inline TPoint TopLeft(const TRect& aRect)

    {

    return aRect.iTl;

    }

/**

 Get Top right corner of the rectangle. 

 @param aRect input rectangle.

 @return Top right corner point coordinates of rectangle.

 */

inline TPoint TopRight(const TRect& aRect)

    {

    return TPoint(aRect.iBr.iX, aRect.iTl.iY);

    }

/**

 Get Bottom left corner of the rectangle. 

 @param aRect input rectangle.

 @return Bottom left corner point coordinates of rectangle.

 */

inline TPoint BottomLeft(const TRect& aRect)

    {

    return TPoint(aRect.iTl.iX, aRect.iBr.iY);

    }

/*

 Make horizontal flip of the corner point.

 */

inline TRectangleCornerPoint FlipRectangleCorner(TRectangleCornerPoint aSourceRectCorner)

    {

    return static_cast<TRectangleCornerPoint> (static_cast<TInt> (aSourceRectCorner ^ 0x00000003));

    }

/*

 Make clockwise rotation of corner point. 

 */

inline TRectangleCornerPoint RotateRectangleCorner(TRectangleCornerPoint aSourceRectCorner,const MWsElement::TElementRotation& aElementRotation)

    {

    return static_cast<TRectangleCornerPoint> ((static_cast<TInt> (aSourceRectCorner) + static_cast<TInt> (aElementRotation)) & 0x00000003);

    }

/*

 Check if there is an inverted aspect ratio. 

 */

inline TBool CheckInvertedAspectRatio(const MWsElement::TElementRotation& aElementRotation)

    {

    return  (aElementRotation & 0x00000001);

    }

/**

 Compare the dedicated rectangle corner coordinates of two rectangles.

 @param aCorner rectangle corner point.

 @param aRect1 the first rectangle to compare.

 @param aRect2 the second rectangle to compare.

 @return ETrue if the checked corner coordinates are the same. 

 */

TBool CheckTwoRectangleCorners(TRectangleCornerPoint aCorner,const TRect& aRect1,const TRect& aRect2)

    {

    aCorner = static_cast<TRectangleCornerPoint> (static_cast<TInt> (aCorner) & 0x00000003); // Normalize rectangle corner value

    switch (aCorner)

        {

        case ETopLeft:

            return (TopLeft(aRect1) == TopLeft(aRect2));

        case ETopRight:

            return (TopRight(aRect1) == TopRight(aRect2));

        case EBottomRight:

            return (BottomRight(aRect1) == BottomRight(aRect2));

        case EBottomLeft:

            return (BottomLeft(aRect1) == BottomLeft(aRect2));

        default:

            return EFalse;

        }

    }

/**

 Calculate the new source rectangle extent when a window is clipped by it parent window. 

 Destination clipped rectangle should match to the source rectangle with taking into account 

 flip, scaling and rotation.

 @param aDestElementRect destination element rectangle without parent window clipping   

 @param aDestElementClippedRect destination element rectangle clipped by the parent window.

 @param aSrcOriginalElementRect  source element rectangle without any clipping changes.

 @param aElementFlip horizontal flip flag.

 @param aElementRotation target anti clockwise rotation factor.

 @return clipped source rectangle.

 */  

TRect CElementWrapper::SetSourceDestRect(const TRect& aDestElementRect,const TRect& aDestElementClippedRect,const TRect& aSrcOriginalElementRect,const TBool& aElementFlip,const MWsElement::TElementRotation& aElementRotation) const

    {

	if ((aSrcOriginalElementRect.Width() == 0) || (aSrcOriginalElementRect.Height() == 0))

		{

		// There are either width or height equal zero.

		return TRect();

		}

	TRectangleCornerPoint sourceRectangleCorner = ETopLeft;

	TRect destElementMovedClippedRect(aDestElementClippedRect);

	destElementMovedClippedRect.Intersection(aDestElementRect);

	TBool fullFlipRotationScale = EFalse;

	// Compare four corner points of Destination moved and Destination moved clipped rectangles.

	// Find the first equal corner coordinates for Destination moved and Destination moved clipped rectangles.

	// It is the Fixed or non changeable point/corner of the source rectangle.

	if (destElementMovedClippedRect.IsEmpty())

		{

		return TRect();

		}

	for (sourceRectangleCorner = ETopLeft; ((TInt) sourceRectangleCorner) <= ((TInt) EBottomLeft);)

		{

		if (CheckTwoRectangleCorners(sourceRectangleCorner, aDestElementRect, destElementMovedClippedRect))

			{

			break;

			}

		sourceRectangleCorner = static_cast<TRectangleCornerPoint> ((TInt) sourceRectangleCorner + 1);

		}

	// There are no equals coordinates, hence, it must be calculated with different  by different way

	if ((TInt) sourceRectangleCorner > (TInt) EBottomLeft)

		{

		sourceRectangleCorner = ETopLeft;

		fullFlipRotationScale = ETrue;

		}

	// Clockwise rotate of the detected Fixed point/corner.  

	sourceRectangleCorner = RotateRectangleCorner(sourceRectangleCorner, aElementRotation);

	// If flip flag set, then make horizontal flip of the Fixed point.

	if (aElementFlip)

		{

		sourceRectangleCorner = FlipRectangleCorner(sourceRectangleCorner);

		}

	// Make scale calculation for the source clipping

	TInt dX = 0;

	TInt dY = 0;

	if (fullFlipRotationScale)

		{

		dX = ((aDestElementRect.iTl.iX - aDestElementClippedRect.iTl.iX) * aSrcOriginalElementRect.Width()) / aDestElementRect.Width();

		dY = ((aDestElementRect.iTl.iY - aDestElementClippedRect.iTl.iY) * aSrcOriginalElementRect.Height()) / aDestElementRect.Height();

		}

	TInt clipSrcWidth = (destElementMovedClippedRect.Width() * aSrcOriginalElementRect.Width()) / aDestElementRect.Width();

	TInt clipSrcHeight = (destElementMovedClippedRect.Height() * aSrcOriginalElementRect.Height()) / aDestElementRect.Height();

	TRect resultSourceRect = aSrcOriginalElementRect;

	// Swap the clipping width and height if the target was rotated on 90 or 270 degrees.

	if (CheckInvertedAspectRatio(aElementRotation))

		{

		SwapInt(clipSrcWidth, clipSrcHeight);

		SwapInt(dX, dY);

		}

	// Assuming that coordinates of the source Fixed corner/point was not changed due to clipping,

	// calculate coordinates of an opposite point to the Fixed corner/point.

	// This point must be differ from original source  for providing proper clipping visual result.

	switch (sourceRectangleCorner)

		{

		case ETopLeft:

			{

			// If TopRight of aDestElementRect is not the same as TopRight of aDestElementClippedRect 

			if (!CheckTwoRectangleCorners(ETopRight, aDestElementRect, destElementMovedClippedRect))

				{// calculate point ETopRight

				resultSourceRect.iBr.iX = resultSourceRect.iTl.iX + clipSrcWidth;

				}

			// If BottomLeft of aDestElementRect is not the same as BottomLeft of aDestElementClippedRect

			if (!CheckTwoRectangleCorners(EBottomLeft, aDestElementRect, destElementMovedClippedRect))

				{// calculate point EBottomLeft

				resultSourceRect.iBr.iY = resultSourceRect.iTl.iY + clipSrcHeight;

				}

			if (fullFlipRotationScale)

				{

				resultSourceRect.iTl.iX += dX;

				resultSourceRect.iTl.iY += dY;

				}

			}

			break;

		case ETopRight:

			{

			// if TopLeft of aDestElementRect is not the same as TopLeft of aDestElementClippedRect

			if (!CheckTwoRectangleCorners(ETopLeft, aDestElementRect, destElementMovedClippedRect))

				{// calculate point ETopLeft

				resultSourceRect.iTl.iX = resultSourceRect.iBr.iX - clipSrcWidth;

				}

			// if BottomRight of aDestElementRect is not the same as BottomRight of aDestElementClippedRect

			if (!CheckTwoRectangleCorners(EBottomRight, aDestElementRect, destElementMovedClippedRect))

				{// calculate point EBottomRight

				resultSourceRect.iBr.iY = resultSourceRect.iTl.iY + clipSrcHeight;

				}

			if (fullFlipRotationScale)

				{

				resultSourceRect.iBr.iX -= dX;

				resultSourceRect.iTl.iY += dY;

				}

			}

			break;

		case EBottomRight:

			{

			// if BottomLeft of aDestElementRect is not the same as BottomLeft of aDestElementClippedRect

			if (!CheckTwoRectangleCorners(EBottomLeft, aDestElementRect, destElementMovedClippedRect))

				{// calculate point EBottomLeft

				resultSourceRect.iTl.iX = resultSourceRect.iBr.iX - clipSrcWidth;

				}

			// if TopRight of aDestElementRect is not the same as TopRight of aDestElementClippedRect

			if (!CheckTwoRectangleCorners(ETopRight, aDestElementRect, destElementMovedClippedRect))

				{// calculate point ETopRight

				resultSourceRect.iTl.iY = resultSourceRect.iBr.iY - clipSrcHeight;

				}

			if (fullFlipRotationScale)

				{

				resultSourceRect.iBr.iX -= dX;

				resultSourceRect.iBr.iY -= dY;

				}

			}

			break;

		case EBottomLeft:

			{

			// if BottomRight of aDestElementRect is not the same as BottomRight of aDestElementClippedRect don't change width

			if (CheckTwoRectangleCorners(EBottomRight, aDestElementRect, destElementMovedClippedRect))

				{// calculate point EBottomRight

				resultSourceRect.iBr.iX = resultSourceRect.iTl.iX + clipSrcWidth;

				}

			// if TopLeft of aDestElementRect is not the same as TopLeft of aDestElementClippedRect

			if (CheckTwoRectangleCorners(ETopLeft, aDestElementRect, destElementMovedClippedRect))

				{// calculate point ETopLeft

				resultSourceRect.iTl.iY = resultSourceRect.iBr.iY - clipSrcHeight;

				}

			if (fullFlipRotationScale)

				{

				resultSourceRect.iTl.iX += dX;

				resultSourceRect.iBr.iY -= dY;

				}

			}

			break;

		}

	return resultSourceRect;

	}