/*

* 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 "alf/alflayouthandlers.h"

#include <uiacceltk/HuiGridLayout.h>

#include <uiacceltk/HuiDeckLayout.h>

#include <uiacceltk/HuiAnchorLayout.h>

#include <uiacceltk/HuiFlowLayout.h>

#include <uiacceltk/huiviewportlayout.h>

#include <uiacceltk/HuiCurvePathLayout.h>

#include <uiacceltk/HuiRealPoint.h>

#include <uiacceltk/HuiUtil.h>

#include "alf/alfconstants.h"

#include "alf/alfserverutils.h"

#include "alfmappingfunctionhandlers.h"

#include <aknlayout2hierarchy.h>

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

// Layout base

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

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

    {

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

    CleanupStack::PushL(me);

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

    CleanupStack::Pop();

    return me;

    }

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

    {

    }

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

    {

    if (!aVisual)

        {

        CHuiLayout* layout = CHuiLayout::AddNewL(aOwner, aParentLayout);     

        CAlfVisualHandler::ConstructL(layout, aOwner, aParentLayout);

        }

    else

        {

        CAlfVisualHandler::ConstructL(aVisual, aOwner, aParentLayout);

        }

    }

EXPORT_C CAlfLayoutHandler::~CAlfLayoutHandler()

    {

    }

EXPORT_C void CAlfLayoutHandler::Release()

    {

    delete this;

    }

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

    {

    switch (aInterface)

        {

        case EHuiObjectTypeLayout:

            return static_cast<CHuiLayout*>(iVisual);

        default:

            return CAlfVisualHandler::GetInterface(aInterface);

        }

    }

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

    {

    CHuiLayout* layout = static_cast<CHuiLayout*>(iVisual);

    switch (aCommandId)

        {

        case  EAlfLayoutAppendVisual:           

            {

            // 1 - visual ID  2 - transition time

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

            CHuiVisual* visual = (CHuiVisual*)iResolver.GetInterfaceL(EHuiObjectTypeVisual, params->iInt1);

            if (layout->FindVisual(visual) == KErrNotFound)

                {

                layout->AppendL(visual, params->iInt2);

                }

            else

                {

                User::Leave(KErrAlreadyExists);

                } 

            break;                

            }

        case  EAlfLayoutRemoveVisual:

            {

            // 1 - visual ID  2 - transition time

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

            CHuiVisual* visual = NULL;

            TRAPD( err, visual = (CHuiVisual*)iResolver.GetInterfaceL(EHuiObjectTypeVisual, params->iInt1) );

            if ( err != KErrNone )

                {

                // Visual has been deleted already

                return;

                }

            layout->Remove(visual, params->iInt2);

            // todo: we should do the following, but it panic if this is called in RemoveAndDestroyAlld() loop

            /*

            // if visual is showing, we should add it under the host container

            CHuiControlGroup* childGroup = visual->Owner().ControlGroup();

            if ( childGroup && visual->Display() )

                {

                // must be a control

                CHuiControl* control = static_cast<CHuiControl*>(&visual->Owner());

                if ( control->Host() ) // showing if host if host is defined.

                    {

                    CHuiLayout* containerLayout = control->Host()->ContainerLayout( control );

                    __ASSERT_DEBUG( containerLayout, USER_INVARIANT() );

                    if ( containerLayout )

                        {

                        // Should we InsertL instead, so we would have the original

                        // root visual order?

                        containerLayout->AppendL( visual );

                        }

                    }

                }*/

            break;    

            }

        case  EAlfLayoutReorderVisual:

            {

            // 1 - visual ID  2 - position  3 - transition time

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

            CHuiVisual* visual = (CHuiVisual*)iResolver.GetInterfaceL(EHuiObjectTypeVisual, params->iInt1);

            layout->Reorder(*visual, params->iInt2, params->iInt3);

            break;    

            }

        case EAlfLayoutVisualFromIndex:

            {

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

            CHuiVisual& visual = layout->Visual(*index);

            // todo: can handle be negative ?

            TInt handle = iResolver.GetHandleFromInterface(EHuiObjectTypeVisual, &visual);

            //User::LeaveIfError(handle);

            TPckg<TInt> pckg(handle);

            aResponse = pckg;

            break;

            }

        case  EAlfLayoutEnableScrolling:           

            {

            TBool* enable = (TBool*) aInputBuffer.Ptr();

            layout->EnableScrollingL(*enable);

            break;                

            }

        case  EAlfLayoutScrollOffset:

            {

            TAlfTimedPoint point;

            AlfTimedPointUtility::CopyTimedPoint(layout->ScrollOffset(), point);

            TPckg<TAlfTimedPoint> buf(point);

            aResponse = buf;

            break;    

            }

        case EAlfLayoutSetScrollOffset:

            {

            TAlfTimedPoint* offset = (TAlfTimedPoint*) aInputBuffer.Ptr();

            AlfTimedPointUtility::CopyTimedPoint(*offset, layout->ScrollOffset(), iResolver);            

            break;

            }

        case  EAlfLayoutChildOrdinal:           

            { // client should know this as well

            const TInt* index = (TInt*) aInputBuffer.Ptr();

            TInt ordinal(0);

            TPckg<TInt> ordinalPckg(ordinal);

            ordinal = layout->ChildOrdinal(*index);

            aResponse = ordinalPckg;

            break;                

            }

        case  EAlfLayoutChildPos:

            {

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

            TAlfPosInt result =

                {

                pos->iPoint,

                EFalse

                };

            TPckg<TAlfPosInt> resp(result);

            result.iInt = layout->ChildPos(pos->iInt, result.iPoint);

            aResponse = resp;            

            break;    

            }

        case EAlfLayoutChildSize:

            {

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

            TAlfSizeInt result = 

                {

                size->iSize,

                EFalse

                };

            TPckg<TAlfSizeInt> resp(result);

            result.iInt = layout->ChildSize(size->iInt, result.iSize);

            aResponse = resp;            

            break;

            }

        case EAlfLayoutSetTransitionTime:

            {

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

            layout->SetTransitionTime(*ttime);

            break;    

            }

        case EAlfLayoutSetInnerPaddingPoint:

            {            

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

            layout->SetInnerPadding(*padding);

            break;    

            }

        case EAlfLayoutSetInnerPaddingMetric:

            {            

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

            THuiMetric newMetricX(metric->iX.iMagnitude, metric->iX.iUnit, metric->iX.iReferenceTextStyleId);

            THuiMetric newMetricY(metric->iY.iMagnitude, metric->iY.iUnit, metric->iY.iReferenceTextStyleId);

            THuiXYMetric newMetric(newMetricX, newMetricY);

            layout->SetInnerPadding(newMetric);

            break;    

            }

        case EAlfLayoutInnerPaddingInBaseUnits:

            {

            THuiRealPoint point = layout->InnerPaddingInBaseUnits();

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

            TPckg<TAlfRealPoint> resp(result);

            aResponse = resp;

            break;

            }

        case EAlfLayoutVirtualSize:

            {

            TSize virtualSize = layout->VirtualSize();

            TPckg<TSize> pckg(virtualSize);

            aResponse = pckg;                        

            break;    

            }

        case EAlfLayoutSetBaseUnit:

            {            

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

            THuiMetric newMetric(metric->iMagnitude, metric->iUnit, metric->iReferenceTextStyleId);

            layout->SetBaseUnit(newMetric);

            break;

            }

        case EAlfLayoutSetBaseUnitXY:

            {            

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

            THuiMetric newMetricX(metric->iX.iMagnitude, metric->iX.iUnit, metric->iX.iReferenceTextStyleId);

            THuiMetric newMetricY(metric->iY.iMagnitude, metric->iY.iUnit, metric->iY.iReferenceTextStyleId);

            THuiXYMetric newMetric(newMetricX, newMetricY);

            layout->SetBaseUnit(newMetric);

            break;

            }

        case EAlfLayoutBaseUnit:

            {            

            THuiXYMetric metric = layout->BaseUnit();

            TAlfMetric newMetricX(metric.iX.iMagnitude, metric.iX.iUnit, metric.iX.iReferenceTextStyleId);

            TAlfMetric newMetricY(metric.iY.iMagnitude, metric.iY.iUnit, metric.iY.iReferenceTextStyleId);

            TAlfXYMetric newMetric(newMetricX, newMetricY);

            TPckg<TAlfXYMetric> resp(newMetric);

            aResponse = resp;

            break;

            }

        case EAlfVisualCopyValuesFromOtherVisual:

        case EAlfVisualPauseProperties:

        case EAlfVisualResumeProperties:        

            {

            if (aCommandId == EAlfVisualCopyValuesFromOtherVisual)

               {

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

               CHuiLayout* sourceLayout = (CHuiLayout*) iResolver.GetInterfaceL( EHuiObjectTypeLayout, inptr->iInt1 );

               if (inptr->iInt2&AlfVisualProperties::ELayoutScrollOffset)

                   {

                   layout->ScrollOffset().Set(sourceLayout->ScrollOffset().Target(), inptr->iInt3 );

                   }

               }

            else if (aCommandId == EAlfVisualPauseProperties)

               {

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

               if (*inptr&AlfVisualProperties::ELayoutScrollOffset)

                   {

                   layout->ScrollOffset().iX.Suspend();

                   layout->ScrollOffset().iY.Suspend();

                   }

               }

            else // EAlfVisualResumeProperties)

               {

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

               if (*inptr&AlfVisualProperties::ELayoutScrollOffset)

                   {

                   layout->ScrollOffset().iX.Suspend(EFalse);

                   layout->ScrollOffset().iY.Suspend(EFalse);

                   }

               }

            } // FALL THROUGH !!

        default:

            CAlfVisualHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);

        }

    }

EXPORT_C void CAlfLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)

    {

    CAlfVisualHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);

    }

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

// anchor layout

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

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

    {

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

    CleanupStack::PushL(me);

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

    CleanupStack::Pop();

    return me;

    }

EXPORT_C CAlfAnchorLayoutHandler::CAlfAnchorLayoutHandler(MAlfInterfaceProvider& aResolver):CAlfLayoutHandler(aResolver)

    {

    }

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

    {

    if (!aVisual)

        {

        CHuiAnchorLayout* layout = CHuiAnchorLayout::AddNewL(aOwner, aParentLayout);     

        CAlfLayoutHandler::ConstructL(layout, aOwner, aParentLayout);

        }

    else

        {

        CAlfLayoutHandler::ConstructL(aVisual, aOwner, aParentLayout);

        }

    }

EXPORT_C CAlfAnchorLayoutHandler::~CAlfAnchorLayoutHandler()

    {

    }

EXPORT_C void CAlfAnchorLayoutHandler::Release()

    {

    delete this;

    }

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

    {

    return CAlfLayoutHandler::GetInterface(aInterface);

    }

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

    {

    CHuiAnchorLayout* anchorLayout = static_cast<CHuiAnchorLayout*>(iVisual); 

    switch (aCommandId)

        {

        case EAlfAnchorLayoutReset:

            {

            anchorLayout->Reset();

            break;

            }

        case EAlfAnchorLayoutSetAnchor:

            {

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

            THuiTimedPoint tpoint;

            AlfTimedPointUtility::CopyTimedPoint(params->iOffset, tpoint, iResolver);            

            // Set anchor

            TInt error = anchorLayout->SetAnchor( 

                THuiAnchor(params->iAnchor),

                params->iOrdinal,

                THuiAnchorOrigin(params->iHorizOrigin),

                THuiAnchorOrigin(params->iVertOrigin),

                THuiAnchorMetric(params->iHorizMetric),

                THuiAnchorMetric(params->iVertMetric),

                tpoint

                );

            User::LeaveIfError( error );

            break;

            }

        case EAlfAnchorLayoutSetRelativeAnchorRect:

            {

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

            TInt error = anchorLayout->SetRelativeAnchorRect

                (

                params->iOrdinal,

                THuiAnchorOrigin(params->iTlHorizOrigin),

                THuiAnchorOrigin(params->iTlVertOrigin),

                THuiRealPoint(params->iTopLeftOffset.iX, params->iTopLeftOffset.iY),

                THuiAnchorOrigin(params->iBrHorizOrigin),

                THuiAnchorOrigin(params->iBrVertOrigin),

                THuiRealPoint(params->iBottomRightOffset.iX, params->iBottomRightOffset.iY)

                );

            User::LeaveIfError( error );

            break;

            }

        case EAlfAnchorLayoutRemoveAnchor:

            {

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

            anchorLayout->RemoveAnchor( (THuiAnchor)params->iInt1, params->iInt2 );

            break;

            }

        case EAlfAnchorLayoutAttachEdge:

            {

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

            THuiMetric metric(params->iOffset.iMagnitude, params->iOffset.iUnit, params->iOffset.iReferenceTextStyleId);

            TInt error = anchorLayout->Attach( 

                params->iOrdinal,

                THuiAnchorType(params->iType),

                metric,

                THuiAnchorAttachmentOrigin(params->iAttachmentOrigin),

                params->iAttachmentOrdinal);

            User::LeaveIfError( error );

            break;

            }

        case EAlfAnchorLayoutAttachCorner:

            {

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

            THuiMetric metricX(params->iOffset.iX.iMagnitude, params->iOffset.iX.iUnit, params->iOffset.iX.iReferenceTextStyleId);

            THuiMetric metricY(params->iOffset.iY.iMagnitude, params->iOffset.iY.iUnit, params->iOffset.iY.iReferenceTextStyleId);

            THuiXYMetric metric(metricX, metricY);

            TInt error = anchorLayout->Attach( 

                params->iOrdinal,

                THuiAnchorType(params->iType),

                metric,

                THuiAnchorAttachmentOrigin(params->iAttachmentOrigin),

                params->iAttachmentOrdinal);

            User::LeaveIfError( error );

            break;

            }

        case EAlfAnchorLayoutAttachBox:

            {

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

            THuiMetric metricLeft(params->iOffset.iLeft.iMagnitude, params->iOffset.iLeft.iUnit, params->iOffset.iLeft.iReferenceTextStyleId);

            THuiMetric metricRight(params->iOffset.iRight.iMagnitude, params->iOffset.iRight.iUnit, params->iOffset.iRight.iReferenceTextStyleId);

            THuiMetric metricTop(params->iOffset.iTop.iMagnitude, params->iOffset.iTop.iUnit, params->iOffset.iTop.iReferenceTextStyleId);

            THuiMetric metricBottom(params->iOffset.iBottom.iMagnitude, params->iOffset.iBottom.iUnit, params->iOffset.iBottom.iReferenceTextStyleId);

            THuiBoxMetric metric(metricLeft, metricRight, metricTop, metricBottom);

            TInt error = anchorLayout->Attach( 

                params->iOrdinal,

                metric,

                THuiAnchorAttachmentOrigin(params->iAttachmentOrigin),

                params->iAttachmentOrdinal);

            User::LeaveIfError( error );

            break;

            }

        case EAlfAnchorLayoutDetachAll:

            {

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

            anchorLayout->Detach(*params);

            break;

            }

        case EAlfAnchorLayoutDetach:

            {

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

            anchorLayout->Detach( params->iInt1, (THuiAnchorType)params->iInt2 );

            break;

            }