diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/ServerCore/Src/alflayouthandlers.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/ServerCore/Src/alflayouthandlers.cpp	Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,1350 @@
+/*
+* 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;
+            }
+            
+        default:
+            CAlfLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+        }
+    }
+
+EXPORT_C void CAlfAnchorLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+
+
+
+//----------------------------
+// LCT Pane layout
+//----------------------------
+EXPORT_C MAlfExtension* CAlfLCTAnchorLayoutHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)
+    {
+    CAlfLCTAnchorLayoutHandler* me = new (ELeave) CAlfLCTAnchorLayoutHandler(aResolver);
+    CleanupStack::PushL(me);
+    me->ConstructL(NULL, *aOwner, aParentLayout);
+    CleanupStack::Pop();
+    return me;
+    }
+
+
+EXPORT_C CAlfLCTAnchorLayoutHandler::CAlfLCTAnchorLayoutHandler(MAlfInterfaceProvider& aResolver):CAlfAnchorLayoutHandler(aResolver)
+    {
+    }
+
+
+EXPORT_C void CAlfLCTAnchorLayoutHandler::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 CAlfLCTAnchorLayoutHandler::~CAlfLCTAnchorLayoutHandler()
+    {
+    }
+
+EXPORT_C void CAlfLCTAnchorLayoutHandler::Release()
+    {
+    delete this;
+    }
+
+
+EXPORT_C TAny* CAlfLCTAnchorLayoutHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+    {
+    return CAlfLayoutHandler::GetInterface(aInterface);
+    }
+
+
+EXPORT_C void CAlfLCTAnchorLayoutHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)
+    {
+    switch (aCommandId)
+        {
+        case EAlfLCTAnchorLayoutSetAnchors:
+            {
+#ifdef RD_ALF_IN_PLATFORM
+            CHuiAnchorLayout* anchorLayout = static_cast<CHuiAnchorLayout*>(iVisual); 
+            TAlfLCTAnchorSetAnchorsParams* params = (TAlfLCTAnchorSetAnchorsParams*)aInputBuffer.Ptr();
+
+            TAknLayoutHierarchyComponentHandle handle;
+            handle.SetApiId(params->iApiId);
+            handle.SetComponentId(params->iComponentId);
+            handle.SetVarietyIndex(params->iVarietyIndex);
+            handle.SetColumn(params->iColumn);
+            handle.SetRow(params->iRow);
+
+            THuiTimedPoint tpoint;
+            AlfTimedPointUtility::CopyTimedPoint(params->iOffset, tpoint, iResolver);
+    
+            // we can access the layout data as a window line, whatever type component is specified.
+            TAknWindowLineLayout componentLayout = AknLayout2Hierarchy::GetWindowComponentLayout(handle).LayoutLineNoEmptys();
+            SetAnchors(anchorLayout, params->iOrdinal, componentLayout, tpoint);
+#endif
+
+            break;
+            }
+            
+        default:
+            CAlfAnchorLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+        }
+    }
+
+EXPORT_C void CAlfLCTAnchorLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfAnchorLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+
+#ifdef RD_ALF_IN_PLATFORM
+ TBool CAlfLCTAnchorLayoutHandler::IsParentRelative(TInt aVal) const
+    {
+    return aVal > ELayoutP-ELayoutPRange && aVal <= ELayoutP;
+    }
+#else //RD_ALF_IN_PLATFORM
+ TBool CAlfLCTAnchorLayoutHandler::IsParentRelative(TInt /*aVal*/) const
+    {
+    return EFalse;
+    }
+#endif //  RD_ALF_IN_PLATFORM
+
+#ifdef RD_ALF_IN_PLATFORM
+void CAlfLCTAnchorLayoutHandler::SetAnchors(CHuiAnchorLayout* aAnchor, TInt aOrdinal, const TAknWindowLineLayout& aLine, const THuiTimedPoint& aTimedPoint)
+    {
+    DoSetAnchors(aAnchor, aOrdinal, aLine.il, aLine.it, aLine.ir, aLine.ib, aTimedPoint);
+    }
+#else //RD_ALF_IN_PLATFORM
+void CAlfLCTAnchorLayoutHandler::SetAnchors(CHuiAnchorLayout* /*aAnchor*/, TInt /*aOrdinal*/, const TAknWindowLineLayout& /*aLine*/, const THuiTimedPoint& /*aTimedPoint*/)
+    {
+    }
+#endif //  RD_ALF_IN_PLATFORM
+    
+#ifdef RD_ALF_IN_PLATFORM
+void CAlfLCTAnchorLayoutHandler::DoSetAnchors(CHuiAnchorLayout* aLayout, TInt aOrdinal, TInt aLeft, TInt aTop, TInt aRight, TInt aBottom, const THuiTimedPoint& aTimedPoint)
+    {
+    TInt left = aLeft;
+    TInt top = aTop;
+    TInt right = aRight;
+    TInt bottom = aBottom;
+    THuiAnchorOrigin originLeft = EHuiAnchorOriginLeft;
+    THuiAnchorOrigin originTop = EHuiAnchorOriginTop;
+    THuiAnchorOrigin originRight = EHuiAnchorOriginRight;
+    THuiAnchorOrigin originBottom = EHuiAnchorOriginBottom;
+
+    // when measuring from the opposite anchor, have to change sign
+    if(IsParentRelative(left))
+        {
+        left = -(ELayoutP - left);
+        originLeft = EHuiAnchorOriginRight;
+        }
+    if(IsParentRelative(top))
+        {
+        top = -(ELayoutP - top);
+        originTop = EHuiAnchorOriginBottom;
+        }
+    if(IsParentRelative(right))
+        {
+        right = -(ELayoutP - right);
+        originRight = EHuiAnchorOriginLeft;
+        }
+    if(IsParentRelative(bottom))
+        {
+        bottom = -(ELayoutP - bottom);
+        originBottom = EHuiAnchorOriginTop;
+        }
+    THuiTimedPoint point(aTimedPoint);
+
+    point.iX = left;
+    point.iY = top;
+    aLayout->SetAnchor(
+        EHuiAnchorTopLeft, aOrdinal,
+        originLeft, originTop,
+        EHuiAnchorMetricAbsolute, EHuiAnchorMetricAbsolute,
+        point);
+
+    // right and bottom anchors are still measured in positive x and y
+    point.iX = -right;
+    point.iY = -bottom;
+    aLayout->SetAnchor(
+        EHuiAnchorBottomRight, aOrdinal,
+        originRight, originBottom,
+        EHuiAnchorMetricAbsolute, EHuiAnchorMetricAbsolute,
+        point); 
+    }
+#else // RD_ALF_IN_PLATFORM
+void CAlfLCTAnchorLayoutHandler::DoSetAnchors(CHuiAnchorLayout* /*aLayout*/, TInt /*aOrdinal*/, TInt /*aLeft*/, TInt /*aTop*/, TInt /*aRight*/, TInt /*aBottom*/, const THuiTimedPoint& /*aTimedPoint*/)
+    {
+    }
+#endif // RD_ALF_IN_PLATFORM
+
+
+
+//----------------------------
+// grid layout
+//----------------------------
+EXPORT_C MAlfExtension* CAlfGridLayoutHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)
+    {
+    CAlfGridLayoutHandler* me = new (ELeave) CAlfGridLayoutHandler(aResolver);
+    CleanupStack::PushL(me);
+    me->ConstructL(NULL, *aOwner, aParentLayout);
+    CleanupStack::Pop();
+    return me;
+    }
+
+
+EXPORT_C CAlfGridLayoutHandler::CAlfGridLayoutHandler(MAlfInterfaceProvider& aResolver):CAlfLayoutHandler(aResolver)
+    {
+    }
+
+
+EXPORT_C void CAlfGridLayoutHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)
+    {
+    if (!aVisual)
+        {
+        CHuiGridLayout* layout = CHuiGridLayout::AddNewL(aOwner, 0,0, aParentLayout);     
+        CAlfLayoutHandler::ConstructL(layout, aOwner, aParentLayout);
+        }
+    else
+        {
+        CAlfLayoutHandler::ConstructL(aVisual, aOwner, aParentLayout);
+        }
+    }
+
+
+EXPORT_C CAlfGridLayoutHandler::~CAlfGridLayoutHandler()
+    {
+    }
+
+
+EXPORT_C void CAlfGridLayoutHandler::Release()
+    {
+    delete this;
+    }
+
+
+EXPORT_C TAny* CAlfGridLayoutHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+    {
+    return CAlfLayoutHandler::GetInterface(aInterface);
+    }
+
+
+EXPORT_C void CAlfGridLayoutHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)
+    {
+    CHuiGridLayout* gridLayout = static_cast<CHuiGridLayout*>(iVisual); 
+    switch (aCommandId)
+        {
+        case EAlfGridLayoutSetColumns:
+            {
+            TInt* count = (TInt*) aInputBuffer.Ptr();
+            gridLayout->SetColumnsL(*count);
+            break;
+            }
+
+        case EAlfGridLayoutSetRows:
+            {
+            TInt* count = (TInt*) aInputBuffer.Ptr();
+            gridLayout->SetRowsL(*count);
+            break;
+            }
+            
+        case EAlfGridLayoutSetColumnWeights:
+            {
+            RArray<TInt> array;
+            CleanupClosePushL( array );
+            InternalizeL(aInputBuffer, array);
+            gridLayout->SetColumnsL(array);
+            CleanupStack::PopAndDestroy( &array );
+            break;
+            }
+            
+        case EAlfGridLayoutSetRowsWeights:
+            {
+            RArray<TInt> array;
+            CleanupClosePushL( array );
+            InternalizeL(aInputBuffer, array);
+            gridLayout->SetRowsL(array);
+            CleanupStack::PopAndDestroy( &array );
+            break;
+            }
+
+        case EAlfGridLayoutSetExpanding:
+            {
+            TInt* flags = (TInt*) aInputBuffer.Ptr();
+            gridLayout->SetExpanding(*flags);
+            break;
+            }
+                    
+        case EAlfGridLayoutOrdinalToBlock:
+            {
+            TInt* ordinal = (TInt*) aInputBuffer.Ptr();
+            TPoint pos(0,0);
+            TPckg<TPoint> posPckg(pos);
+            pos = gridLayout->OrdinalToBlock(*ordinal);
+            aResponse = posPckg;
+            break;
+            }
+
+        case EAlfGridLayoutColumnCount:
+            {
+            TInt count(0);
+            TPckg<TInt> countPckg(count);
+            count = gridLayout->DimensionCount(EHuiGridColumn);
+            aResponse = countPckg;
+            break;
+            }
+            
+        case EAlfGridLayoutRowCount:
+            {
+            TInt count(0);
+            TPckg<TInt> countPckg(count);
+            count = gridLayout->DimensionCount(EHuiGridRow);
+            aResponse = countPckg;
+            break;
+            }
+            
+        case EAlfGridLayoutFillWeights:
+            {
+            TAlfGridLayoutFillWeightsParams* params = (TAlfGridLayoutFillWeightsParams*)aInputBuffer.Ptr();
+            THuiGridDimension dim = (THuiGridDimension)params->iDim;
+            THuiMetric metric(params->iWeight.iMagnitude, params->iWeight.iUnit, params->iWeight.iReferenceTextStyleId);
+            gridLayout->FillWeightsL(dim, params->iCount, metric);
+            break;
+            }
+
+        case EAlfGridLayoutAppendWeight:
+            {
+            TAlfGridLayoutAppendWeightParams* params = (TAlfGridLayoutAppendWeightParams*)aInputBuffer.Ptr();
+            THuiGridDimension dim = (THuiGridDimension)params->iDim;
+            THuiMetric metric(params->iWeight.iMagnitude, params->iWeight.iUnit, params->iWeight.iReferenceTextStyleId);
+            gridLayout->AppendWeightL(dim, metric);
+            break;
+            }
+            
+        case EAlfGridLayoutInsertWeight:
+            {
+            TAlfGridLayoutInsertWeightParams* params = (TAlfGridLayoutInsertWeightParams*)aInputBuffer.Ptr();
+            THuiGridDimension dim = (THuiGridDimension)params->iDim;
+            THuiMetric metric(params->iWeight.iMagnitude, params->iWeight.iUnit, params->iWeight.iReferenceTextStyleId);
+            gridLayout->InsertWeightL(dim, metric, params->iPos);
+            break;
+            }
+            
+        case EAlfGridLayoutReplaceWeight:
+            {
+            TAlfGridLayoutReplaceWeightParams* params = (TAlfGridLayoutReplaceWeightParams*)aInputBuffer.Ptr();
+            THuiGridDimension dim = (THuiGridDimension)params->iDim;
+            THuiMetric metric(params->iWeight.iMagnitude, params->iWeight.iUnit, params->iWeight.iReferenceTextStyleId);
+            gridLayout->ReplaceWeightL(dim, metric, params->iPos);
+            break;
+            }
+            
+        case EAlfGridLayoutRemoveWeight:
+            {
+            TAlfGridLayoutRemoveWeightParams* params = (TAlfGridLayoutRemoveWeightParams*)aInputBuffer.Ptr();
+            THuiGridDimension dim = (THuiGridDimension)params->iDim;
+            gridLayout->RemoveWeightL(dim, params->iPos);
+            break;
+            }
+            
+        case EAlfGridLayoutWeight:
+            {
+            TAlfGridLayoutWeightParams* params = (TAlfGridLayoutWeightParams*)aInputBuffer.Ptr();
+            THuiGridDimension dim = (THuiGridDimension)params->iDim;
+            THuiMetric huiWeight = gridLayout->Weight(dim, params->iPos);
+
+            TAlfMetric alfWeight(huiWeight.iMagnitude, huiWeight.iUnit, huiWeight.iReferenceTextStyleId);;
+            TPckg<TAlfMetric> weightPckg(alfWeight);
+            aResponse = weightPckg;
+            break;
+            }
+            
+        case EAlfGridLayoutCount:
+            {
+            THuiGridDimension* dim = (THuiGridDimension*) aInputBuffer.Ptr();
+            TInt count(0);
+            TPckg<TInt> countPckg(count);
+            count = gridLayout->DimensionCount(*dim);
+            aResponse = countPckg;
+            break;
+            }
+            
+        case EAlfGridLayoutSetLayoutModeFlags:
+            {
+            TInt2* params = (TInt2*) aInputBuffer.Ptr();
+            gridLayout->SetLayoutModeFlags((THuiGridDimension)params->iInt1, (TUint)params->iInt2);
+            break;                
+            }
+                    
+        case EAlfGridLayoutLayoutModeFlags:
+            {
+            THuiGridDimension* dim = (THuiGridDimension*) aInputBuffer.Ptr();
+            TInt flags(0);
+            TPckg<TInt> flagsPckg(flags);
+            flags = gridLayout->LayoutModeFlags(*dim);
+            aResponse = flagsPckg;            
+            break;                
+            }
+            
+        case EAlfGridLayoutClearLayoutModeFlags:                
+            {
+            TInt2* params = (TInt2*) aInputBuffer.Ptr();
+            gridLayout->ClearLayoutModeFlags((THuiGridDimension)params->iInt1, (TUint)params->iInt2);         
+            break;                
+            }
+            
+        default:
+            CAlfLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+        }
+        
+    }
+
+EXPORT_C void CAlfGridLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+
+//----------------------------
+// LCT grid layout
+//----------------------------
+EXPORT_C MAlfExtension* CAlfLCTGridLayoutHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)
+    {
+    CAlfLCTGridLayoutHandler* me = new (ELeave) CAlfLCTGridLayoutHandler(aResolver);
+    CleanupStack::PushL(me);
+    me->ConstructL(NULL, *aOwner, aParentLayout);
+    CleanupStack::Pop();
+    return me;
+    }
+
+
+EXPORT_C CAlfLCTGridLayoutHandler::CAlfLCTGridLayoutHandler(MAlfInterfaceProvider& aResolver):CAlfGridLayoutHandler(aResolver)
+    {
+    }
+
+
+EXPORT_C void CAlfLCTGridLayoutHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)
+    {
+    if (!aVisual)
+        {
+        CHuiGridLayout* layout = CHuiGridLayout::AddNewL(aOwner, 1, 1, aParentLayout);     
+        CAlfGridLayoutHandler::ConstructL(layout, aOwner, aParentLayout);
+        }
+    else
+        {
+        CAlfGridLayoutHandler::ConstructL(aVisual, aOwner, aParentLayout);
+        }
+    }
+
+
+EXPORT_C CAlfLCTGridLayoutHandler::~CAlfLCTGridLayoutHandler()
+    {
+    }
+
+
+EXPORT_C void CAlfLCTGridLayoutHandler::Release()
+    {
+    delete this;
+    }
+
+
+EXPORT_C TAny* CAlfLCTGridLayoutHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+    {
+    return CAlfGridLayoutHandler::GetInterface(aInterface);
+    }
+
+
+EXPORT_C void CAlfLCTGridLayoutHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)
+    {
+    switch (aCommandId)
+        {
+        case EAlfLCTGridLayoutSetColsAndRows:
+            {
+#ifdef RD_ALF_IN_PLATFORM
+            CHuiGridLayout* gridLayout = static_cast<CHuiGridLayout*>(iVisual); 
+            TAlfLCTGridSetColsAndRowsParams* params = (TAlfLCTGridSetColsAndRowsParams*)aInputBuffer.Ptr();
+
+            TAknLayoutHierarchyComponentHandle handle;
+            handle.SetApiId(params->iApiId);
+            handle.SetComponentId(params->iComponentId);
+            handle.SetVarietyIndex(params->iVarietyIndex);
+
+            THuiTimedPoint tpoint;
+            AlfTimedPointUtility::CopyTimedPoint(params->iOffset, tpoint, iResolver);
+    
+            // get the cols and rows directly from the param limits
+            // @todo maybe need to use anchors, or set rows and cols by item height?
+            TAknLayoutScalableParameterLimits limits = AknLayout2Hierarchy::GetParamLimits(handle);
+            gridLayout->SetColumnsL(limits.LastColumn()+1);
+            gridLayout->SetRowsL(limits.LastRow()+1);
+#endif
+            break;
+            }
+        default:
+            CAlfGridLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+        }
+        
+    }
+
+EXPORT_C void CAlfLCTGridLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfGridLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+ 
+//----------------------------
+// deck layout
+//----------------------------
+EXPORT_C MAlfExtension* CAlfDeckLayoutHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)
+    {
+    CAlfDeckLayoutHandler* me = new (ELeave) CAlfDeckLayoutHandler(aResolver);
+    CleanupStack::PushL(me);
+    me->ConstructL(NULL, *aOwner, aParentLayout);
+    CleanupStack::Pop();
+    return me;
+    }
+
+
+EXPORT_C CAlfDeckLayoutHandler::CAlfDeckLayoutHandler(MAlfInterfaceProvider& aResolver):CAlfLayoutHandler(aResolver)
+    {
+    }
+
+
+EXPORT_C void CAlfDeckLayoutHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)
+    {
+    if (!aVisual)
+        {
+        CHuiDeckLayout* layout = CHuiDeckLayout::AddNewL(aOwner, aParentLayout);     
+        CAlfLayoutHandler::ConstructL(layout, aOwner, aParentLayout);
+        }
+    else
+        {
+        CAlfLayoutHandler::ConstructL(aVisual, aOwner, aParentLayout);
+        }
+    }
+
+
+EXPORT_C CAlfDeckLayoutHandler::~CAlfDeckLayoutHandler()
+    {
+    }
+
+EXPORT_C TAny* CAlfDeckLayoutHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+    {
+    return CAlfLayoutHandler::GetInterface(aInterface);
+    }
+
+
+EXPORT_C void CAlfDeckLayoutHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)
+    {
+    CAlfLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+    }
+
+EXPORT_C void CAlfDeckLayoutHandler::Release()
+    {
+    delete this;
+    }
+
+EXPORT_C void CAlfDeckLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+
+
+//----------------------------
+// flow layout
+//----------------------------
+EXPORT_C MAlfExtension* CAlfFlowLayoutHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)
+    {
+    CAlfFlowLayoutHandler* me = new (ELeave) CAlfFlowLayoutHandler(aResolver);
+    CleanupStack::PushL(me);
+    me->ConstructL(NULL, *aOwner, aParentLayout);
+    CleanupStack::Pop();
+    return me;
+    }
+
+
+EXPORT_C CAlfFlowLayoutHandler::CAlfFlowLayoutHandler(MAlfInterfaceProvider& aResolver):CAlfLayoutHandler(aResolver)
+    {
+    }
+
+
+EXPORT_C void CAlfFlowLayoutHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)
+    {
+    if (!aVisual)
+        {
+        CHuiFlowLayout* layout = CHuiFlowLayout::AddNewL(aOwner, CHuiFlowLayout::EFlowVertical, aParentLayout);     
+        CAlfLayoutHandler::ConstructL(layout, aOwner, aParentLayout);
+        }
+    else
+        {
+        CAlfLayoutHandler::ConstructL(aVisual, aOwner, aParentLayout);
+        }
+    }
+
+
+EXPORT_C CAlfFlowLayoutHandler::~CAlfFlowLayoutHandler()
+    {
+    }
+
+
+EXPORT_C void CAlfFlowLayoutHandler::Release()
+    {
+    delete this;
+    }
+
+
+EXPORT_C TAny* CAlfFlowLayoutHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+    {
+    return CAlfLayoutHandler::GetInterface(aInterface);
+    }
+
+
+EXPORT_C void CAlfFlowLayoutHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)
+    {
+    CHuiFlowLayout* flowLayout = static_cast<CHuiFlowLayout*>(iVisual); 
+    switch (aCommandId)
+        {
+        case EAlfFlowLayoutSetFlowDirection:
+            {
+            CHuiFlowLayout::TFlowDirection* params =  (CHuiFlowLayout::TFlowDirection*) aInputBuffer.Ptr();
+            flowLayout->SetFlowDirection( *params );
+            break;
+            }
+        case EAlfFlowLayoutSetCentering:
+            {
+            TBool* params =  (TBool*) aInputBuffer.Ptr();
+            flowLayout->SetCentering( *params );
+            break;
+            }
+        case EAlfFlowLayoutSetMode:
+            {
+            TInt* params = (TInt*) aInputBuffer.Ptr();
+            flowLayout->SetMode( *params );
+            break;
+            }
+           
+        default:
+            CAlfLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+        }
+    }
+
+
+EXPORT_C void CAlfFlowLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+
+ 
+ // CURVE PATH LAYOUT
+ 
+ 
+struct CAlfCurvePathLayoutHandler::TCurvePathLayoutPrivateData
+    {
+    };
+ 
+EXPORT_C MAlfExtension* CAlfCurvePathLayoutHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)
+    {
+    CAlfCurvePathLayoutHandler* me = new (ELeave) CAlfCurvePathLayoutHandler(aResolver);
+    CleanupStack::PushL(me);
+    me->ConstructL(NULL, *aOwner, aParentLayout);
+    CleanupStack::Pop();
+    return me;
+    }
+    
+EXPORT_C CAlfCurvePathLayoutHandler::CAlfCurvePathLayoutHandler(MAlfInterfaceProvider& aResolver)
+:CAlfLayoutHandler(aResolver)
+    {
+    }
+    
+EXPORT_C void CAlfCurvePathLayoutHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)
+    {
+    if (!aVisual)
+        {
+        CHuiCurvePathLayout* layout = CHuiCurvePathLayout::AddNewL(aOwner, aParentLayout);     
+        CAlfLayoutHandler::ConstructL(layout, aOwner, aParentLayout);
+        }
+    else
+        {
+        CAlfLayoutHandler::ConstructL(aVisual, aOwner, aParentLayout);
+        }
+        
+    // Not needed currently
+    //iCurvePathLayoutPrivateData = new (ELeave) TCurvePathLayoutPrivateData;
+    }
+    
+EXPORT_C CAlfCurvePathLayoutHandler::~CAlfCurvePathLayoutHandler()
+    {
+    if ( iCurvePathLayoutPrivateData )
+        {
+        // Delete private data (not used currently)
+        }
+    delete iCurvePathLayoutPrivateData;
+    iCurvePathLayoutPrivateData = NULL;
+    }
+
+EXPORT_C void CAlfCurvePathLayoutHandler::Release()
+    {
+    delete this;
+    }
+    
+EXPORT_C TAny* CAlfCurvePathLayoutHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+    {
+    CHuiCurvePathLayout* curvePathLayout = static_cast<CHuiCurvePathLayout*>(iVisual); 
+    
+    switch ( aInterface )
+        {
+        case EHuiInterfaceMappingFunction:
+            return static_cast<MHuiMappingFunction*>(curvePathLayout);
+        case EHuiObjectTypeCurvePathProvider:
+            return &curvePathLayout->CurvePath();
+        default:
+            return CAlfLayoutHandler::GetInterface(aInterface);
+        }
+    }
+    
+EXPORT_C void CAlfCurvePathLayoutHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)
+    {
+    CHuiCurvePathLayout* curvePathLayout = static_cast<CHuiCurvePathLayout*>(iVisual); 
+    
+    switch( aCommandId )
+        {
+        case EAlfCurvePathLayoutMapValue:
+            {
+            TIntTReal* mapValues = (TIntTReal*) aInputBuffer.Ptr();
+            const TReal32 returnValue = curvePathLayout->MapValue( mapValues->iReal, mapValues->iInt );
+            TPckg<TReal32> returnValuePckg(returnValue);
+            aResponse = returnValuePckg; 
+            break;
+            }
+        default:
+            CAlfLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+            break;
+        }
+    }
+
+EXPORT_C void CAlfCurvePathLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+
+//----------------------------
+// viewport layout
+//----------------------------
+EXPORT_C MAlfExtension* CAlfViewportLayoutHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)
+    {
+    CAlfViewportLayoutHandler* me = new (ELeave) CAlfViewportLayoutHandler(aResolver);
+    CleanupStack::PushL(me);
+    me->ConstructL(NULL, *aOwner, aParentLayout);
+    CleanupStack::Pop();
+    return me;
+    }
+
+
+EXPORT_C CAlfViewportLayoutHandler::CAlfViewportLayoutHandler(MAlfInterfaceProvider& aResolver):CAlfLayoutHandler(aResolver)
+    {
+    }
+
+
+EXPORT_C void CAlfViewportLayoutHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)
+    {
+    if (!aVisual)
+        {
+        CHuiViewportLayout* layout = CHuiViewportLayout::AddNewL(aOwner, aParentLayout);     
+        CAlfLayoutHandler::ConstructL(layout, aOwner, aParentLayout);
+        }
+    else
+        {
+        CAlfLayoutHandler::ConstructL(aVisual, aOwner, aParentLayout);
+        }
+    }
+
+
+EXPORT_C CAlfViewportLayoutHandler::~CAlfViewportLayoutHandler()
+    {
+    }
+
+EXPORT_C void CAlfViewportLayoutHandler::Release()
+    {
+    delete this;
+    }
+
+
+EXPORT_C TAny* CAlfViewportLayoutHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+    {
+    return CAlfLayoutHandler::GetInterface(aInterface);
+    }
+
+
+EXPORT_C void CAlfViewportLayoutHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)
+    {
+    CHuiViewportLayout* viewportLayout = static_cast<CHuiViewportLayout*>(iVisual); 
+    switch (aCommandId)
+        {
+        case EAlfViewportLayoutSetVirtualSize:
+            {
+            TAlfTimedPoint* newSize = (TAlfTimedPoint*) aInputBuffer.Ptr();
+
+            THuiTimedPoint tpoint;
+            AlfTimedPointUtility::CopyTimedPoint(*newSize, tpoint, iResolver);                  
+            
+            viewportLayout->SetVirtualSize(tpoint.RealTarget().AsSize(), HUI_ROUND_FLOAT_TO_INT(newSize->TimeToTargetinMilliSeconds().iX));            
+            break;
+            }
+            
+        case EAlfViewportLayoutSetViewportSize:
+            {
+            TAlfTimedPoint* newSize = (TAlfTimedPoint*) aInputBuffer.Ptr();
+
+            THuiTimedPoint tpoint;      
+            AlfTimedPointUtility::CopyTimedPoint(*newSize, tpoint, iResolver);                              
+            viewportLayout->SetViewportSize(tpoint.RealTarget().AsSize(), HUI_ROUND_FLOAT_TO_INT(newSize->TimeToTargetinMilliSeconds().iX));            
+            break;
+            }
+            
+        case EAlfViewportLayoutSetViewportPos:
+            {
+            TAlfTimedPoint* newPos = (TAlfTimedPoint*) aInputBuffer.Ptr();
+
+            THuiTimedPoint tpoint;
+            AlfTimedPointUtility::CopyTimedPoint(*newPos, tpoint, iResolver);                              
+            viewportLayout->SetViewportPos(tpoint.RealTarget(), HUI_ROUND_FLOAT_TO_INT(newPos->TimeToTargetinMilliSeconds().iX));            
+            break;
+            }
+            
+        default:
+            CAlfLayoutHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);
+        }
+    }
+
+EXPORT_C void CAlfViewportLayoutHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)
+    {
+    CAlfLayoutHandler::VisualHandlerExtension(aExtensionUid, aExtensionParameters);
+    }
+
+
+// end of file