/*

* Copyright (c) 2006 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:   definitions of alf built-in visual support

*

*/

#include "alf/alfvisualhandlers.h"

#include "alftextstylehandlers.h"

#include "alf/alfconstants.h"

#include <uiacceltk/HuiTextVisual.h>

#include <uiacceltk/HuiGridLayout.h>

#include <uiacceltk/HuiImageVisual.h>

#include "alf/alfbrushhandlers.h"

#include <alf/alfvisual.h>

#include <alf/alftextvisual.h>

#include <uiacceltk/HuiLineVisual.h>

#include <uiacceltk/HuiMeshVisual.h>

#include <uiacceltk/huiproceduralmesh.h>

#include <uiacceltk/huim3gmesh.h>

#include <uiacceltk/HuiUtil.h>

#include <alf/alfmaterial.h>

#include "alf/alfserverutils.h"

#include "alfsrvvisualowner.h"

#include <AknsConstants.h>

#include "alf/alfappui.h"

#include "alfsrvdropshadowhandler.h"

#include <AknFontSpecification.h> // @todo mka

#include <gdi.h> // @todo mka

#include <uiacceltk/HuiCanvasVisual.h>

// Remove when EAlfVisualEnableTransformation handing is fixed

#include "alfappsrvsession.h"

#include "alfsrvsubsessionbase.h"

#include "alfsrvtransformationsubsession.h"

#ifdef RD_ALF_IN_PLATFORM

#include <aknlayout2hierarchy.h>

#endif

#include <avkon.hrh> //     ELayoutAlignNone, etc

#include "HuiFxEngine.h"

#include "HuiFxEffect.h"

struct CAlfVisualHandler::TPrivateData

    {

    CAlfSrvVisualOwner* iVisualOwner;

    };

//----------------------------

// Visual base

//----------------------------

EXPORT_C MAlfExtension* CAlfVisualHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)

    {

    CAlfVisualHandler* me = new (ELeave) CAlfVisualHandler(aResolver);

    CleanupStack::PushL(me);

    me->ConstructL(NULL, *aOwner, aParentLayout);

    CleanupStack::Pop();

    return me;

    }

EXPORT_C CAlfVisualHandler::CAlfVisualHandler(MAlfInterfaceProvider& aResolver):iResolver(aResolver)

    {

    }

EXPORT_C void CAlfVisualHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)

    {

    if (!aVisual)

        {

        iVisual = CHuiVisual::AddNewL(aOwner, aParentLayout);          

        }

    else 

        {

        iVisual = aVisual;    

        }

    iPrivateData = new (ELeave) TPrivateData;

    iPrivateData->iVisualOwner = NULL;

    }

EXPORT_C CAlfVisualHandler::~CAlfVisualHandler()

    {

    if ( iPrivateData )

        {

        if ( iPrivateData->iVisualOwner )

            {

            if ( iVisual ) // If the visual has not been deleted already

                {

                iVisual->SetOwner( *iPrivateData->iVisualOwner->RealOwner() );

                }

            delete iPrivateData->iVisualOwner;

            iPrivateData->iVisualOwner = NULL;

            }

        }

    delete iPrivateData;

    iPrivateData = NULL;

    iVisual = NULL;

    }

EXPORT_C void CAlfVisualHandler::Release()

    {

    delete this;

    }

EXPORT_C TAny* CAlfVisualHandler::GetInterface(const THuiInterfaceSupport& aInterface)

    {

    switch (aInterface)

        {

        case EHuiObjectTypeVisual:

            return iVisual;

        case EAlfVisualHandler:

            return this;

        default:

            return 0;

        }

    }

void NullChildVisualHandlerPointers(

    CHuiVisual& iVisual, 

    const RPointerArray<CAlfSrvSubSessionBase>& aArray)

    {

    for(TInt i = iVisual.Count() - 1; i >= 0; --i)

        {

        NullChildVisualHandlerPointers( iVisual.Visual(i), aArray );

        }

    for ( TInt h = 0 ; h < aArray.Count(); h++ )

        {

        if ( aArray[h]->AsHuiVisual() == &iVisual )

            {

            CAlfVisualHandler* visualHandler = static_cast<CAlfVisualHandler*>( aArray[h]->AsCommandHandler() );

            visualHandler->HuiVisualAboutToTerminate();

            }

        }

    }

void CAlfVisualHandler::HuiVisualAboutToTerminate()

    {

    iVisual = NULL;

    }

EXPORT_C void CAlfVisualHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)

    {

    switch (aCommandId)

        {

        case EAlfVisualRemoveAndDestroyAll:

            {

            // we need to NULL all the child visual handlers

            CHuiVisual* tmp = iVisual;

            CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

            RPointerArray<CAlfSrvSubSessionBase> array;

            TRAP_IGNORE( session.GetSubsessionsByTypeL( array, EAlfVisualHandler ) );

            NullChildVisualHandlerPointers(*iVisual, array);

            array.Close();

            tmp->RemoveAndDestroyAllD();

            tmp = NULL;

            break;                

            }

        case EAlfVisualUpdateChildrenLayout:

            {

            TInt* transitionTime = (TInt*) aInputBuffer.Ptr();

            iVisual->UpdateChildrenLayout( *transitionTime >= 0 ? *transitionTime : CHuiStatic::LayoutTransitionTime() );

            break;

            }

        case  EAlfVisualSetOpacity:

            {

            TAlfTimedValue* opacity = (TAlfTimedValue*) aInputBuffer.Ptr() ;

            AlfTimedValueUtility::CopyTimedValue(*opacity, iVisual->iOpacity, iResolver);

            break;    

            }

        case EAlfVisualGetOpacity:

            {

            TAlfTimedValue opacity;

            AlfTimedValueUtility::CopyTimedValue(iVisual->iOpacity, opacity);

            TPckg<TAlfTimedValue> resultPckg(opacity);

            aResponse = resultPckg; // awkward     

            break;

            }

        case  EAlfVisualLocalToDisplay:

            {

            TAlfRealPoint* alfPoint = (TAlfRealPoint*) aInputBuffer.Ptr();

            const THuiRealPoint realPoint( alfPoint->iX, alfPoint->iY );

            THuiRealPoint result = iVisual->LocalToDisplay( realPoint );

            // if the visual is showing, the container layout rect is included

            // in the LocalToDisplay calculations

            if ( iVisual->Display() )

                {

                // if not showing, we need to add the display rect offset.

                CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

                result -= session.ClientDrawingArea().iTl;

                }

            TAlfRealPoint alf_point(result.iX, result.iY);

            TPckg<TAlfRealPoint> resultPckg(alf_point);            

            aResponse = resultPckg; // awkward 

            break;     

            }

        case  EAlfVisualDisplayToLocal:

            {

            TAlfRealPoint* alfPoint = (TAlfRealPoint*) aInputBuffer.Ptr();

            THuiRealPoint realPoint( alfPoint->iX, alfPoint->iY );

            // if the visual is showing, the container layout rect is included

            // in the DisplayToLocal calculations

            if ( iVisual->Display() )

                {

                // if not showing, we need to reduce the display rect offset

                // from the comparision value.

                CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

                realPoint += session.ClientDrawingArea().iTl;

                }

            THuiRealPoint result = iVisual->DisplayToLocal( realPoint );

            TAlfRealPoint alf_point(result.iX, result.iY);

            TPckg<TAlfRealPoint> resultPckg(alf_point);            

            aResponse = resultPckg; // awkward 

            break;     

            }

        case  EAlfVisualDisplayRectTarget:

            {

            THuiRealRect huiResult = iVisual->DisplayRectTarget();

            if ( iVisual->Display() )

                {

                CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

                huiResult.Move( -session.ClientDrawingArea().iTl.iX, -session.ClientDrawingArea().iTl.iY ); 

                }

            TAlfRealRect alfResult;

            alfResult.iTl.iX = huiResult.iTl.iX;

            alfResult.iTl.iY = huiResult.iTl.iY;

            alfResult.iBr.iX = huiResult.iBr.iX;

            alfResult.iBr.iY = huiResult.iBr.iY;

            TPckg<TAlfRealRect> resultPckg(alfResult);

            aResponse = resultPckg; // awkward 

            break;            

            }

        case  EAlfVisualPos:

            {

            TAlfTimedPoint result;

            AlfTimedPointUtility::CopyTimedPoint(iVisual->Pos(), result);             

            TPckg<TAlfTimedPoint> resultPckg(result);

            aResponse = resultPckg; // awkward 

            break;            

            }

        case  EAlfVisualSetPos:

            {

            TAlfVisualPos* pos = (TAlfVisualPos*) aInputBuffer.Ptr();

            THuiRealPoint huiPoint( pos->iPoint.iX, pos->iPoint.iY );

            iVisual->SetPos(huiPoint, pos->iTime);

            break;            

            }

        case EAlfVisualMoveToFront:

            { 

            iVisual->MoveToFront();

            break;            

            }

        case EAlfVisualSize:

            {

            TAlfTimedPoint a_size;

            AlfTimedPointUtility::CopyTimedPoint(iVisual->Size(), a_size);             

            TPckg<TAlfTimedPoint> sizePckg(a_size);

            aResponse = sizePckg; // awkward 

            break;            

            }

        case EAlfVisualSetSize:

            {

            TAlfVisualSize* size = (TAlfVisualSize*) aInputBuffer.Ptr();

            iVisual->SetSize(THuiRealSize( size->iSize.iWidth,size->iSize.iHeight ) , size->iTime);

            break;            

            }

        case EAlfVisualBrushArrayReset:

            {

            if ( iVisual ) // during destruction the iVisual is already deleted

                {

                iVisual->EnableBrushesL( EFalse );

                }

            break;

            }

        case EAlfVisualBrushArrayAppend:

            {

            TInt2* params = (TInt2*) aInputBuffer.Ptr();

            const THuiOwnership ownership = (THuiOwnership)params->iInt2;

            CHuiBrush* brush = (CHuiBrush*)iResolver.GetInterfaceL(EHuiObjectTypeBrush, params->iInt1);

            iVisual->EnableBrushesL();

            iVisual->Brushes()->AppendL(brush,ownership);

            CAlfBrushHandler* holder = (CAlfBrushHandler*) iResolver.GetInterfaceL(EAlfBrushHandler, params->iInt1);

            // If the brush array is taking the ownership...

            if ( ownership == EHuiHasOwnership )

                {

                // ... the brush holder cannot have it anymore

                holder->SetOwnership(EFalse);

                }

            break;

            }

        case EAlfVisualBrushArrayInsert:

            {

            TInt3* params = (TInt3*) aInputBuffer.Ptr();

            CHuiBrush* brush = (CHuiBrush*)iResolver.GetInterfaceL(EHuiObjectTypeBrush, params->iInt1);

            iVisual->EnableBrushesL();

            iVisual->Brushes()->InsertL(params->iInt3, brush,(THuiOwnership)params->iInt2);

            CAlfBrushHandler* holder = (CAlfBrushHandler*) iResolver.GetInterfaceL(EAlfBrushHandler, params->iInt1);

            holder->SetOwnership(!params->iInt2); // THuiOwnership matches boolean 

            break;

            }

        case EAlfVisualBrushArrayRemove:

            {

            if ( iVisual ) // iVisual is NULL:led i.e. deleted

                {

                TInt* params = (TInt*) aInputBuffer.Ptr();

                iVisual->EnableBrushesL();

                iVisual->Brushes()->Remove(*params);

                }

            break;

            }

        case EAlfVisualSetFlag:

            {

            THuiVisualFlags* params = (THuiVisualFlags*) aInputBuffer.Ptr();

            iVisual->SetFlag( *params );

            break;

            }

        case EAlfVisualSetFlags:

            {

            TUint* params = (TUint*) aInputBuffer.Ptr();

            iVisual->SetFlags( *params );

            break;

            }

        case EAlfVisualClearFlag:

            {

            THuiVisualFlags* params = (THuiVisualFlags*) aInputBuffer.Ptr();

            iVisual->ClearFlag( *params );

            break;

            }

        case EAlfVisualClearFlags:

            {

            TUint* params = (TUint*) aInputBuffer.Ptr();

            iVisual->ClearFlags( *params );

            break;

            }

        case EAlfVisualFlags:

            {

            const TUint flags = iVisual->Flags();

            TPckg<TUint> flagsPckg(flags);

            aResponse = flagsPckg; // awkward 

            break;

            }

        case EAlfVisualSetPaddingInt:

            {

            TInt* params = (TInt*) aInputBuffer.Ptr();

            iVisual->SetPadding( *params );

            break;

            }

        case EAlfVisualSetPaddingPoint:

            {

            TPoint* params = (TPoint*) aInputBuffer.Ptr();

            iVisual->SetPadding( *params );

            break;

            }

        case EAlfVisualSetPaddingBox:

            {

            TAlfBoxMetric* metric = (TAlfBoxMetric*) aInputBuffer.Ptr();

            THuiMetric newMetricLeft(metric->iLeft.iMagnitude, metric->iLeft.iUnit, metric->iLeft.iReferenceTextStyleId);

            THuiMetric newMetricRight(metric->iRight.iMagnitude, metric->iRight.iUnit, metric->iRight.iReferenceTextStyleId);

            THuiMetric newMetricTop(metric->iTop.iMagnitude, metric->iTop.iUnit, metric->iTop.iReferenceTextStyleId);

            THuiMetric newMetricBottom(metric->iBottom.iMagnitude, metric->iBottom.iUnit, metric->iBottom.iReferenceTextStyleId);

            THuiBoxMetric newBoxMetric(newMetricLeft, newMetricRight, newMetricTop, newMetricBottom);

            iVisual->SetPadding(newBoxMetric);

            break;

            }

        case EAlfVisualPaddingInPixels:

            {

            const THuiRealRect huiResult = iVisual->PaddingInPixels();  

            TAlfRealRect alfResult;

            alfResult.iTl.iX = huiResult.iTl.iX;

            alfResult.iTl.iY = huiResult.iTl.iY;

            alfResult.iBr.iX = huiResult.iBr.iX;

            alfResult.iBr.iY = huiResult.iBr.iY;

            TPckg<TAlfRealRect> resultPckg(alfResult);           

            aResponse = resultPckg; // awkward 

            break;    

        }

        case EAlfVisualEnableTransformation:

            {

            TInt2* params = (TInt2*) aInputBuffer.Ptr();

            const TBool isTransformed = params->iInt2;

            const TInt transHandle = params->iInt1;

            // @todo: nasty hack

            CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

            CAlfSrvSubSessionBase& transSubSession = session.SubSession( transHandle );

            CAlfSrvTransformationSubSession& transformationSubSession = 

                static_cast<CAlfSrvTransformationSubSession&>(transSubSession);

            // Enable transformation

            iVisual->EnableTransformationL( isTransformed );

            CHuiTransformation* transformation = NULL;

            if ( isTransformed )

                {

                transformation = &iVisual->Transformation();

                }

            transformationSubSession.SetTransformation( transformation );

            break;

            }

        case EAlfVisualDepthOffset:

            {

            TAlfTimedValue value;

            AlfTimedValueUtility::CopyTimedValue(iVisual->iDepthOffset, value);             

            TPckg<TAlfTimedValue> resultPckg(value);            

            aResponse = resultPckg; // awkward                 

            break;    

            }

        case EAlfVisualSetDepthOffset:

            {

            TAlfTimedValue* params = (TAlfTimedValue*) aInputBuffer.Ptr();            

            AlfTimedValueUtility::CopyTimedValue(*params, iVisual->iDepthOffset, iResolver);

            break;    

            }

        case EAlfVisualSetMinSize:

            {

            TSize* params = (TSize*) aInputBuffer.Ptr();

            iVisual->SetMinSize( *params );            

            break;    

            }

        case EAlfVisualGetMinSize:

            {

            TSize result = iVisual->MinSize();            

            TPckg<TSize> resultPckg(result);

            aResponse = resultPckg; // awkward 

            break;    

            }

        case EAlfVisualSetMinSizeInBaseUnits:

            {

            TAlfRealSize* params = (TAlfRealSize*) aInputBuffer.Ptr();

            const THuiRealSize minSize(params->iWidth, params->iHeight);

            iVisual->SetMinSize( minSize );            

            break;    

            }

        case EAlfVisualGetMinSizeInBaseUnits:

            {

            THuiRealSize result = iVisual->MinSizeInBaseUnits(); 

            TAlfRealSize alfResult(result.iWidth, result.iHeight);  

            TPckg<TAlfRealSize> resultPckg(alfResult);

            aResponse = resultPckg; // awkward 

            break;    

            }

        case EAlfVisualSetMaxSize:

            {