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



TInt CElementWrapper::SetSourceRotation(const TElementRotation aElementRotation)
    {
    if(iSurfaceId.IsNull())
        return KErrGeneral;
    
    if(aElementRotation < 0 || aElementRotation > 3)
        return KErrArgument;
    
    iRotation = aElementRotation;
    iUpdateFlags |= EUpdate_SettingValid|EUpdate_SOURCE_ROTATION;

    iOpenWfcWrapper.SetCompositionModified();
    
    return KErrNone;
    }

MWsElement::TElementRotation CElementWrapper::SourceRotation() const
    {
    if(iSurfaceId.IsNull())
        return EElementAntiClockwise0; //default rotation

    return iRotation;
    }

TInt CElementWrapper::SetTargetRendererFlags(const TUint32& aTargetRendererFlags)
    {
    iTargetRendererFlags = aTargetRendererFlags;
    if (iTargetRendererFlags & EElementTransparencyGlobalAlpha)
        {
        iUpdateFlags |= EUpdate_SettingValid|EUpdate_GLOBAL_ALPHA;
        }
    
    if (iTargetRendererFlags & EElementTransparencySource)
        {
        iUpdateFlags |= EUpdate_SettingValid|EUpdate_TRANSPARENCY_TYPES;
        }
    
    return KErrNone;
    }

TInt CElementWrapper::SetRenderStageFlags(const TUint32& aRenderStageFlags)
    {
    iRenderStageFlags = aRenderStageFlags;
    
    return KErrNone;
    }

void CElementWrapper::GetTargetRendererFlags(TUint32& aTargetRendererFlags) const
    {
    aTargetRendererFlags = iTargetRendererFlags;
    }

void CElementWrapper::GetRenderStageFlags(TUint32& aRenderStageFlags) const
    {
    aRenderStageFlags = iRenderStageFlags;
    }

MWsElement* CElementWrapper::ElementAbove()
    {
    //Check this element has not already been reequsted to be removed
    if (iUpdateFlags&EUpdate_Remove)
        {
        return NULL;
        }
    else
        {
        return iElementAbove;
        }
    }

MWsElement* CElementWrapper::ElementBelow()
    {
    //Check this element has not already been reequsted to be removed
    if (iUpdateFlags&EUpdate_Remove)
        {
        return NULL;
        }
    else
        {
        return iElementBelow;
        }
    }

TInt CElementWrapper::ConnectSurface(const TSurfaceId& aSurface)
    {
    TInt err = KErrNone;
     if (aSurface!=iSurfaceId)
        {
        if (!aSurface.IsNull())
            {
            if(!iOpenWfcWrapper.IncEltRefRegSource(aSurface))
                {
                return KErrNotFound;
                }
            else
                {
                RSurfaceManager::TInfoBuf buff;
                err = err = SurfaceInfo(aSurface, buff);
                if (err != KErrNone)
                    {
                    return iOpenWfcWrapper.DecEltRefRegSource(aSurface);
                    }
                else
                    {
                    iSurfaceSize=buff().iSize;
                    }
                }
            }
        else
            {
            iSurfaceSize.SetSize(0,0);
            }
        UnsetSurface(iSurfaceId);
        iSurfaceId=aSurface;
        iUpdateFlags |= EUpdate_SettingValid|EUpdate_SOURCE;
        if (iSourcRect.IsEmpty())
            {
            iUpdateFlags |= EUpdate_SettingValid|EUpdate_SOURCE_RECTANGLE;
            }
        }
    else
        {   //Note this code is simply here to return the error!
        if (!iSurfaceId.IsNull())
            {
            if (iOpenWfcWrapper.IncEltRefRegSource(iSurfaceId))
                {
                iOpenWfcWrapper.DecEltRefRegSource(iSurfaceId);
                }
            else
                {
                return KErrNotFound;
                }
            }
        }
    
    iOpenWfcWrapper.SetCompositionModified();
    
    return err;
    }

const TSurfaceId& CElementWrapper::ConnectedSurface() const
    {
    return iSurfaceId;
    }

/** 
 * Sets the element source to match the surface ID and optionally locks the reference count until next composition.
 **/
void CElementWrapper::SetEltSourceComposed()
    {
    iUpdateFlags |= EUpdate_SceneCommited;
    }

/** 
 * Sets the element source to match the surface ID and optionally locks the reference count until next composition.
 **/
void CElementWrapper::SetEltSource(WFCElement aElement)const
    {
    WFCSource source = WFC_INVALID_HANDLE;
    if (!iSurfaceId.IsNull())
        {
        source=iOpenWfcWrapper.IncEltRefRegSource(iSurfaceId);
        if(source)
            {
            TInt remains=iOpenWfcWrapper.DecEltRefRegSource(iSurfaceId);
            OPENWFC_ASSERT_DEBUG(remains>0,EPanicWfcNoStreamSurface);
            }
        }
    wfcSetElementAttribi(iOpenWfcWrapper.Device(),aElement,WFC_ELEMENT_SOURCE,source);
    }

/** 
 * Internal method releases the previous registered surface, and clears the caller's member var.
 * @return true if any resources released
 **/
TBool CElementWrapper::UnsetSurface(TSurfaceId& aSurface)
    {
    if (!aSurface.IsNull())
        {
        TInt err = iOpenWfcWrapper.DecEltRefRegSource(aSurface);
        OPENWFC_ASSERT_DEBUG(err >= 0,EPanicWfcSourceLookupOnElementRemoval);
        aSurface = aSurface.CreateNullId();
        return (err == KErrNone); //>0 indicates object count non-zero
        }
    return EFalse;
    }

void CElementWrapper::SetEltTransparencyTypes(WFCElement aElement)const
    {
    TInt transType = WFC_TRANSPARENCY_NONE;
    if (iTargetRendererFlags & EElementTransparencySource)
        {
        transType |= WFC_TRANSPARENCY_SOURCE;
        }
    if (iTargetRendererFlags & EElementTransparencyGlobalAlpha)
        {
        transType |= WFC_TRANSPARENCY_ELEMENT_GLOBAL_ALPHA;
        }
    wfcSetElementAttribi(iOpenWfcWrapper.Device(),aElement,WFC_ELEMENT_TRANSPARENCY_TYPES,transType);
    }

void CElementWrapper::HelpStreamGetHeader(khronos_int32_t* aWidth, khronos_int32_t* aHeight)const
    {
    if (aWidth)
        {
        *aWidth=iSurfaceSize.iWidth;
        }
    if (aHeight)
        {
        *aHeight=iSurfaceSize.iHeight;
        }
    }

/**
 *  Maps the source rectangle to fp values matching the region and destination rectangle data over a element object.
 *  This is when the source rectangle changes.
 *  Only repositions existing elements
 **/
void CElementWrapper::SetEltSourceRectangle(WFCElement aElement)
    {
    TRect srcRect;
    GetSourceRectangle(srcRect);
    if (!iDestinationClippingRect.IsEmpty())
    	{
    	 TRect destinationRect=iDestinationRect;
    	 destinationRect.Intersection(iDestinationClippingRect);
    	 if(!destinationRect.IsEmpty())
    		 {
    		 srcRect = SetSourceDestRect(iDestinationRect,destinationRect,srcRect,iFlipped,iRotation);
    		 }
    	}
    float rect[4]={srcRect.iTl.iX,srcRect.iTl.iY,srcRect.Width(),srcRect.Height()};
    wfcSetElementAttribfv(iOpenWfcWrapper.Device(),aElement,WFC_ELEMENT_SOURCE_RECTANGLE,4,rect);
    }

void CElementWrapper::SetEltSourceFlip(WFCElement aElement)const
    {
    wfcSetElementAttribi(iOpenWfcWrapper.Device(),aElement,WFC_ELEMENT_SOURCE_FLIP, iFlipped);
    }

/**
 *  Maps the region and destination rectangle data into a element object
 *  taking into account the source rectangle mapping and region data
 *  @return KErrNone or KErrMemory
 **/
void CElementWrapper::SetEltDestinationRectangle(WFCElement aElement)const
    {
    TRect destinationRect=iDestinationRect;
    if (!iDestinationClippingRect.IsEmpty())
    	{
    	destinationRect.Intersection(iDestinationClippingRect);
    	}
    float destRect[4]={destinationRect.iTl.iX,destinationRect.iTl.iY,destinationRect.Width()<0?0:destinationRect.Width(),destinationRect.Height()<0?0:destinationRect.Height()};
    wfcSetElementAttribfv(iOpenWfcWrapper.Device(),aElement,WFC_ELEMENT_DESTINATION_RECTANGLE,4,destRect);

    LILOG(("### EXIT SetEltDestinationRectangle()"));
    }

/**
 *  Maps the region and destination rectangle data into a element object.
 *  taking in to account the source rectangle mapping and region data
 *  @param aOffset  an offset ADDED to every destination rectangle
 *  @return KErrNone or KErrMemory
 **/
void CElementWrapper::SetEltDestinationRectangle(WFCElement aElement, const TPoint& aOffset)const
    {
    TRect destinationRect=iDestinationRect;
    if (!iDestinationClippingRect.IsEmpty())
        {
        destinationRect.Intersection(iDestinationClippingRect);
        }
    float rect[4]={destinationRect.iTl.iX+aOffset.iX,destinationRect.iTl.iY+aOffset.iY,destinationRect.Width(),destinationRect.Height()};
    wfcSetElementAttribfv(iOpenWfcWrapper.Device(),aElement,WFC_ELEMENT_DESTINATION_RECTANGLE,4,rect);
    }

void CElementWrapper::RemoveAfter(CElementWrapper** apElementBelow)
    {
    iUpdateFlags&=~(EUpdate_Insert|EUpdate_Remove);
    if(apElementBelow)
        {
        *apElementBelow = iElementAbove;
        if (iElementAbove)
            {
            iElementAbove->iElementBelow = iElementBelow;
            }
        }
    iElementBelow = NULL;
    iElementAbove = NULL;
    }

void CElementWrapper::InsertAfter(CElementWrapper*& aRefElementBelow, CElementWrapper* aElementBelow, TOwfUpdates aUpdateFlag)
    {
    OPENWFC_ASSERT_DEBUG(aUpdateFlag&(EUpdate_Insert|aUpdateFlag&EUpdate_Remove|aUpdateFlag&EUpdate_Destroy), EPanicUnexpectedErrorElementScene);
    iUpdateFlags |= EUpdate_SettingValid|aUpdateFlag;
    iElementAbove = aRefElementBelow;
    iElementBelow = aElementBelow;
    aRefElementBelow = this;
    if (iElementAbove)
        {
        iElementAbove->iElementBelow = this;
        }
    }

/* Returns a pointer referencing this object from below.
 * @return the pointer or null if there is no "below" object
 */
CElementWrapper** CElementWrapper::RefsMyElementBelow()
    {
    if (iElementBelow)
        {
        return &iElementBelow->iElementAbove;
        }

    return NULL;
    }

CElementWrapper*& CElementWrapper::MyElementAbove()
    {
    return iElementAbove;
    }

TInt CElementWrapper::WfcRotation(MWsElement::TElementRotation aRotation)
    {
    switch (aRotation)
        {
    case EElementAntiClockwise0:
        return WFC_ROTATION_0;
    case EElementAntiClockwise90:
        return WFC_ROTATION_270;
    case EElementAntiClockwise180:
        return WFC_ROTATION_180;
    default: // EElementAntiClockwise270
        return WFC_ROTATION_90;
        }
    }

TBool CElementWrapper::IsNewElementLegal()const
    {
    //OWF SI will fail if certain illegal element attributes are passed to it.
    //Various members must be non-zero:
        //destination rectangle
        //source
        //global alpha
    if (iDestinationRect.IsEmpty() || iSurfaceId.IsNull()||iGlobalAlpha==0)
        {
        return EFalse;
        }
    //If the source rectangle is set it must be inside the surface size
    if (!iSourcRect.IsEmpty())
        {
        if (iSourcRect.iTl.iX<0 || iSourcRect.iTl.iY<0)
            {
            return EFalse;
            }
        TInt32 width;
        TInt32 height;
        HelpStreamGetHeader(&width,&height);
        if (iSourcRect.iBr.iX>width || iSourcRect.iBr.iY>height)
            {
            return EFalse;
            }
        }
    //If mask is defined and enabled, Mask size must match destination rectangle size
        //masks are currently not implemented
    //If mask is enabled then source alpha must not be enabled
        //masks are currently not implemented
    return ETrue;
    }
/** 
 * Flushes any flagged scene or attribute changes into the element objects
 * @return  EFalse if no flushing occurred - for any reason
 **/
TBool CElementWrapper::FlushSceneChanges()
    {
    TInt updateFlags=iUpdateFlags;
    if  ((updateFlags&EUpdate_AttributesIllegal) && !(updateFlags&EUpdate_SettingValid))
        {
        return EFalse;
        }
    
    if (updateFlags==EUpdate_None)
        {
        return EFalse;
        }

    if (updateFlags&(EUpdate_Remove|EUpdate_Destroy) && (updateFlags&EUpdate_SceneCommited))
        {
        wfcRemoveElement(iOpenWfcWrapper.Device(),iElement);
        }
    
    if (updateFlags&EUpdate_Destroy)
        {
        return EFalse;
        }
    
    if (updateFlags&(EUpdate_Remove|EUpdate_Destroy))
        {
        iUpdateFlags&=~(EUpdate_Insert|EUpdate_Remove|EUpdate_SceneCommited);
        return EFalse;
        }
    
    TBool isElementLegal=IsNewElementLegal();
    if (!isElementLegal)
        {   //If the element would not be legal then it must not be inserted
            //It may even need to be removed.
        if (updateFlags&EUpdate_SceneCommited)
            {   //it is in the scene, remove it
            wfcRemoveElement(iOpenWfcWrapper.Device(),iElement);
            updateFlags &= ~EUpdate_SceneCommited;
            }

        //Re-flag the update but also set a flag
        //so that we don't bother to check legality again until another attribute change.
        updateFlags&=~EUpdate_SettingValid;
        updateFlags|=EUpdate_AttributesIllegal;
        iUpdateFlags=updateFlags;

        LILOG(("### EXIT CElementWrapper::FlushSceneChanges() FALSE"));
        return EFalse;
        }

    WFCElement elementBelow=WFC_INVALID_HANDLE;
    if ((updateFlags&(EUpdate_Insert|EUpdate_AttributesIllegal)))
        {
        if (CElementWrapper* elementWrapperBelow=iElementBelow)
            {
            while (elementWrapperBelow && elementWrapperBelow->iUpdateFlags&EUpdate_AttributesIllegal)
                {
                elementWrapperBelow=elementWrapperBelow->iElementBelow;
                }
            if (elementWrapperBelow)
                {
                elementBelow=elementWrapperBelow->iElement;
                }
            }
        }
    
    iUpdateFlags = EUpdate_SceneCommited;
    
    if ((updateFlags&~EUpdate_Remove))
        {
        FlushAttributeChanges(iElement, updateFlags);
        if (updateFlags&(EUpdate_Insert|EUpdate_AttributesIllegal))
            {
            wfcInsertElement(iOpenWfcWrapper.Device(),iElement,elementBelow);
            }
        }

     FlushAttributeChanges(iElement, EUpdate_ALL_ATTRIBS|EUpdate_DontLockSource);
     wfcInsertElement(iOpenWfcWrapper.Device(),iElement,elementBelow);

    LILOG(("### EXIT CElementWrapper::FlushSceneChanges() FALSE"));
    return ETrue;
    }

void CElementWrapper::FlushAttributeChanges(WFCElement aElement, TInt aUpdateFlags)
    {
    LILOG(("### ENTER FlushAttributeChanges() aStart(%d), aPastMax(%d), uFl(0x%x)", aStart, aPastMax, aUpdateFlags));

    //At present all attribute changes are flushed immediately... assert that behaviour.
    if (aUpdateFlags&EUpdate_SOURCE_GEOMETRY_SET)
        {
        SetEltSourceRectangle(aElement);
        }
    if (aUpdateFlags&(EUpdate_SOURCE|EUpdate_SettingValid))
        {
        SetEltSource(aElement);
        }
    if (aUpdateFlags&EUpdate_SOURCE_FLIP)
        {
        SetEltSourceFlip(aElement);
        }
    if (aUpdateFlags&EUpdate_SOURCE_ROTATION)
        {
        TInt wfcRot=WfcRotation(iRotation);
        wfcSetElementAttribi(iOpenWfcWrapper.Device(),iElement,WFC_ELEMENT_SOURCE_ROTATION,wfcRot);
        }
    if (aUpdateFlags&EUpdate_TRANSPARENCY_TYPES)
        {
        SetEltTransparencyTypes(aElement);
        }
    if (aUpdateFlags&EUpdate_GLOBAL_ALPHA)
        {
        wfcSetElementAttribi(iOpenWfcWrapper.Device(),aElement,WFC_ELEMENT_GLOBAL_ALPHA,iGlobalAlpha);
        }
    if (aUpdateFlags&EUpdate_DESTINATION_RECTANGLE)
        {
        SetEltDestinationRectangle(aElement);
        }
    LILOG(("### EXIT FlushAttributeChanges()"));
    }

TInt CElementWrapper::ReplicateElements(WFCContext aContext, WFCElement& aPreviousTargetElement,const TPoint& aOffset)
    {
    if (aContext == WFC_INVALID_HANDLE)
        {
        return KErrArgument;
        }
    
    if (!IsNewElementLegal())
        {
        return KErrNone;
        }

    WFCDevice device = iOpenWfcWrapper.Device();
    WFCContext onScreenContext = iOpenWfcWrapper.OnScreenContext();
    // clean the existing system errors and look for new ones
    wfcGetError(device);
    WFCSource targetImageSource = wfcCreateSourceFromStream(device, aContext, reinterpret_cast<WFCNativeStreamType>(&iSurfaceId), NULL);
    if (targetImageSource == WFC_INVALID_HANDLE)
        {
        return COpenWfcWrapper::TranslateOpenWfcError(wfcGetError(device));
        }
     
    WFCElement targetElement = WFC_INVALID_HANDLE;

    // the elements are created but we don't get hold of them for longer than we need
    // all elements created now are to be destroyed when composition is completed
    targetElement = wfcCreateElement(device, aContext, NULL);
    if (targetElement == WFC_INVALID_HANDLE)
        {
        return COpenWfcWrapper::TranslateOpenWfcError(wfcGetError(device));
        }

    // we can just flush the attributes to the new elements because the off-screen context attributes
    // share the same device with the on-screen context. If this changes make device a parameter!
    wfcSetElementAttribi(device,targetElement,WFC_ELEMENT_SOURCE,targetImageSource);
    FlushAttributeChanges(targetElement, (EUpdate_ALL_ATTRIBS&~(EUpdate_SOURCE|EUpdate_DESTINATION_RECTANGLE)));
    SetEltDestinationRectangle(targetElement, aOffset);
    wfcInsertElement(iOpenWfcWrapper.Device(),targetElement,aPreviousTargetElement);
    aPreviousTargetElement = targetElement;

    return COpenWfcWrapper::TranslateOpenWfcError(wfcGetError(device));
    }

TInt CElementWrapper::SurfaceInfo(const TSurfaceId& aSurface, RSurfaceManager::TInfoBuf& aInfo)
    {
    TInt err = KErrNone;
    switch(aSurface.Type())
        {
        case TSurfaceTypes::ESurfaceManagerSurface:
            {
            err = Owner().SurfaceManager().SurfaceInfo(aSurface, aInfo);                   
            break;
            }
        case TSurfaceId::EScreenSurface:      
            {
            TInt screenId = aSurface.iInternal[TSurfaceId::TScreenSurfaceUsage::EScreenField];
            TInt width = 0;
            err = HAL::Get(screenId, HALData::EDisplayXPixels, width);
            if (err != KErrNone)
                {
                iOpenWfcWrapper.DecEltRefRegSource(aSurface);
                return err;
                }
            
            TInt height = 0;
            err = HAL::Get(screenId, HALData::EDisplayYPixels, height);
            if (err != KErrNone)
                {
                iOpenWfcWrapper.DecEltRefRegSource(aSurface);
                return err;
                }
            
            aInfo().iSize = TSize(width, height);      
            
#ifdef  SYMBIAN_ROTATION_MODE_CHANGES
            TInt displayMode = aSurface.iInternal[TSurfaceId::TScreenSurfaceUsage::EHalField];
#else
            TInt displayMode = 0;
            err = HAL::Get(screenId, HALData::EDisplayMode, displayMode);
            if (err != KErrNone)
                {
                iOpenWfcWrapper.DecEltRefRegSource(aSurface);
                return err;
                }                       
#endif                      

#if defined(SYMBIAN_ROTATION_MODE_CHANGES)
            if (displayMode & TSurfaceId::TScreenSurfaceUsage::EHalFlippedFlag) // 90 | 270 degree rotation
                {
                // Swap dimensions and recalculate stride. Assume no padding for now.
                aInfo().iSize.iWidth = height;
                aInfo().iSize.iHeight = width;
                //"vertical" stride has already been fetched
                }
#elif defined(SYMBIAN_ROTATION_CHANGES)
            if (aSurface.iInternal[1] & (2 | 8))    // 90 | 270 degree rotation
                {
                // Swap dimensions and recalculate stride. Assume no padding for now.
                aInfo().iSize.iWidth = height;
                aInfo().iSize.iHeight = width;
                }
#endif                          
            
            break;
            }
        default:
            err = KErrNotSupported;
        }    
    
    return err;
    }
