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