--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/ServerCore/Src/alfstaticfactory.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,523 @@
+/*
+* 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: factory for alf built-in hitchcock compenents
+*
+*/
+
+
+#include <e32cmn.h>
+#include <uiacceltk/HuiControl.h>
+#include <uiacceltk/HuiVisual.h>
+#include <uiacceltk/HuiLayout.h>
+#include <uiacceltk/HuiTexture.h>
+#include <uiacceltk/HuiEvent.h>
+#include <uiacceltk/HuiDisplay.h>
+#include <uiacceltk/HuiUtil.h>
+#include "alf/alfvisualhandlers.h"
+#include "alf/alflayouthandlers.h"
+#include "alf/alfbrushhandlers.h"
+#include "alftextstylehandlers.h"
+#include "alf/alfappsrvsessionbase.h"
+#include "alfstaticfactory.h"
+#include "alf/alfconstants.h"
+#include "alfmappingfunctionhandlers.h"
+#include "alf/alfmetric.h"
+
+
+CHuiVisual* FindLastHittingChild( const CHuiVisual& aParentVisual,
+ const TPoint& aDisplayPoint )
+ {
+ // If we want that the pointer event are passed only to the visuals which
+ // (effective) opacity is greater than 50%, this would be the place to
+ // implement it.
+ for ( TInt i = aParentVisual.Count() - 1 ; i >= 0 ; i-- )
+ {
+ // DisplayRect() returns the current value of the rectange. If the pointer
+ // hit needs to be compared to the target rect, change this function call
+ // from DisplayRect() into DisplayRectTarget()
+ const TRect rect = aParentVisual.Visual( i ).DisplayRect();
+ if ( rect.Contains( aDisplayPoint ) )
+ {
+ CHuiVisual* leaf =
+ FindLastHittingChild( aParentVisual.Visual( i ), aDisplayPoint );
+ return leaf ? leaf : &aParentVisual.Visual( i );
+ }
+ }
+ return NULL;
+ }
+
+//----------------------------
+// Control, private so declaration directly here
+//----------------------------
+
+NONSHARABLE_CLASS(CAlfControl2): public CHuiControl
+ {
+public:
+ CAlfControl2(CHuiEnv& aSharedEnv, CAlfControl2** ptr, CAlfAppSrvSessionBase* aSession):
+ CHuiControl(aSharedEnv),
+ iPtr(ptr),
+ iSession(aSession)
+ {}
+
+ TBool OfferEventL(const THuiEvent& aEvent)
+ {
+ if ( aEvent.IsPointerEvent() )
+ {
+ // Update event coordinates to match the "client rect" of the application
+ THuiEvent eventWithLocalCoordinates(aEvent);
+
+ // Set the iParentPosition coordinates to be ralative to the
+ // visual aread of the display i.e the root visuals.
+ const TPoint clientDrawingAreaTl = iSession->ClientDrawingArea().iTl;
+ eventWithLocalCoordinates.iPointerEvent.iParentPosition -= clientDrawingAreaTl;
+
+ if ( aEvent.Visual() )
+ {
+ // If visual is found, move the iPosition coordinates to be relative to the
+ // visual area.
+ const THuiRealRect realVisualArea = aEvent.Visual()->DisplayRect();
+ const TPoint intVisualTl(
+ HUI_ROUND_FLOAT_TO_INT( realVisualArea.iTl.iX ),
+ HUI_ROUND_FLOAT_TO_INT( realVisualArea.iTl.iY ) );
+
+ eventWithLocalCoordinates.iPointerEvent.iPosition -= intVisualTl;
+ }
+ else
+ {
+ // If there is no accociated visual, set iPosotion coordinates to be relative to
+ // the display visual area.
+ eventWithLocalCoordinates.iPointerEvent.iPosition -= clientDrawingAreaTl;
+ }
+
+ TBool isLongTap = aEvent.iPointerEvent.iType == TPointerEvent::EButtonRepeat;
+ if ( isLongTap )
+ {
+ iSession->StartPointerHandling();
+ }
+ iSession->HandleEventL(this, aEvent.Visual() , eventWithLocalCoordinates);
+ if ( isLongTap )
+ {
+ iSession->FlushPointerHandling();
+ }
+ }
+ return EFalse; // let env offer event to all ctrls it hits
+ }
+
+ ~CAlfControl2()
+ {
+ *iPtr = 0;
+
+ // Remove possbile pointer observers
+ if ( Env().DisplayCount() )
+ {
+ CHuiDisplay& disp = Env().PrimaryDisplay(); // assume one display
+ disp.Roster().Observers(EHuiInputPointerDrag).RemoveIfFound(*this);
+ disp.Roster().Observers(EHuiInputPointerLongTap).RemoveIfFound(*this);
+ disp.Roster().Observers(EHuiInputPointerUnhandled).RemoveIfFound(*this);
+ }
+ }
+
+private:
+ CAlfControl2** iPtr;
+ CAlfAppSrvSessionBase* iSession;
+ };
+
+
+NONSHARABLE_CLASS(CAlfControlHandler): public CBase, public MAlfExtension
+ {
+public:
+ static MAlfExtension* NewL(const TDesC8& aInputBuffer, CHuiEnv& aSharedEnv, CAlfAppSrvSessionBase* aSession );
+private:
+ void Release();
+ TAny* GetInterface(const THuiInterfaceSupport& aInterface);
+ void HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse);
+ CAlfControl2* iControl;
+ ~CAlfControlHandler()
+ {
+ if (iControl && !iControl->ControlGroup())
+ {
+ delete iControl;
+ }
+ }
+ };
+
+MAlfExtension* CAlfControlHandler::NewL(const TDesC8& /*aInputBuffer*/, CHuiEnv& aSharedEnv, CAlfAppSrvSessionBase* aSession)
+ {
+ CAlfControlHandler* me = new (ELeave) CAlfControlHandler();
+ CleanupStack::PushL(me);
+ me->iControl = new (ELeave) CAlfControl2(aSharedEnv, &me->iControl, aSession);
+ CleanupStack::Pop();
+ return me;
+ }
+
+void CAlfControlHandler::Release()
+ {
+ delete this;
+ }
+
+TAny* CAlfControlHandler::GetInterface(const THuiInterfaceSupport& aInterface)
+ {
+ switch (aInterface)
+ {
+ case EHuiObjectTypeControl:
+ return static_cast<CHuiControl*>(iControl);
+ case EHuiInterfaceVisualOwner:
+ return static_cast<MHuiVisualOwner*>(iControl);
+ default:
+ return 0;
+
+ }
+
+ }
+
+void CAlfControlHandler::HandleCmdL(TInt /*aCommandId*/, const TDesC8& /*aInputBuffer*/, TDes8& /*aResponse*/)
+ {
+ }
+
+
+MAlfExtension* TAlfFixedFactory::CreateExtensionL(const TInt aObjectId, const TDesC8& aInitialParams, MAlfInterfaceProvider& aResolver )
+ {
+
+ MAlfExtension* result = 0;
+ switch(aObjectId)
+ {
+ case EAlfCntrlCreate:
+ {
+ result = CAlfControlHandler::NewL(aInitialParams, *aResolver.SharedHuiEnv(), static_cast<CAlfAppSrvSessionBase*>(&aResolver));
+ break;
+ }
+
+ case EAlfVisualCreate:
+ case EAlfTextVisualCreate:
+ case EAlfLCTTextVisualCreate:
+ case EAlfLayoutCreate:
+ case EAlfAnchorLayoutCreate:
+ case EAlfLCTAnchorLayoutCreate:
+ case EAlfDeckLayoutCreate:
+ case EAlfFlowLayoutCreate:
+ case EAlfCurvePathLayoutCreate:
+ case EAlfGridLayoutCreate:
+ case EAlfLCTGridLayoutCreate:
+ case EAlfViewportLayoutCreate:
+ case EAlfImageVisualCreate:
+ case EAlfLineVisualCreate:
+ case EAlfCanvasVisualCreate:
+ {
+ TInt2* params = (TInt2*)aInitialParams.Ptr();
+
+ CHuiControl* owner = 0;
+ CHuiLayout* parentLayout = 0;
+
+ if (!params->iInt1)
+ {
+ User::Leave(KErrArgument);
+ }
+ else
+ { // currently we must use concrete owner as interface does not provide means to
+ // transfer ownership
+ owner = (CHuiControl*) aResolver.GetInterfaceL(EHuiObjectTypeControl, params->iInt1 );
+ }
+
+ if (params->iInt2) // not compulsory
+ {
+ parentLayout = (CHuiLayout*) aResolver.GetInterfaceL(EHuiObjectTypeLayout, params->iInt2 );
+ }
+
+ if (aObjectId == EAlfVisualCreate)
+ result = CAlfVisualHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId == EAlfTextVisualCreate)
+ result = CAlfTextVisualHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId == EAlfLCTTextVisualCreate)
+ result = CAlfLCTTextVisualHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId == EAlfImageVisualCreate)
+ result = CAlfImageVisualHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfLayoutCreate)
+ result = CAlfLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfAnchorLayoutCreate)
+ result = CAlfAnchorLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfLCTAnchorLayoutCreate)
+ result = CAlfLCTAnchorLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfGridLayoutCreate)
+ result = CAlfGridLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfLCTGridLayoutCreate)
+ result = CAlfLCTGridLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfDeckLayoutCreate)
+ result = CAlfDeckLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfFlowLayoutCreate)
+ result = CAlfFlowLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfViewportLayoutCreate)
+ result = CAlfViewportLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfCurvePathLayoutCreate)
+ result = CAlfCurvePathLayoutHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfLineVisualCreate)
+ result = CAlfLineVisualHandler::NewL(aResolver, owner, parentLayout);
+ else if (aObjectId ==EAlfCanvasVisualCreate)
+ result = CAlfCanvasVisualHandler::NewL(aResolver, owner, parentLayout);
+
+ ASSERT(result); // missing obejct would be clear implementation error
+ break;
+ }
+
+ case EAlfMeshVisualCreate:
+ {
+ TInt3* params = (TInt3*)aInitialParams.Ptr();
+
+ CHuiControl* owner = 0;
+ THuiMeshType type = EHuiMeshTypeProcedural;
+ CHuiLayout* parentLayout = 0;
+
+ if (!params->iInt1)
+ {
+ User::Leave(KErrArgument);
+ }
+ else
+ { // currently we must use concrete owner as interface does not provide means to
+ // transfer ownership
+ owner = (CHuiControl*) aResolver.GetInterfaceL(EHuiObjectTypeControl, params->iInt1 );
+ }
+
+
+ if (params->iInt2) // not compulsory
+ {
+ parentLayout = (CHuiLayout*) aResolver.GetInterfaceL(EHuiObjectTypeLayout, params->iInt2 );
+ }
+
+ result = CAlfMeshVisualHandler::NewL(aResolver, owner, type, parentLayout);
+
+ ASSERT(result); // missing obejct would be clear implementation error
+ break;
+ }
+
+ case EAlfBorderBrushCreate:
+ {
+ TAlfCreateBorderBrushParams* params = (TAlfCreateBorderBrushParams*)aInitialParams.Ptr();
+
+ result = CAlfBorderBrushHandler::NewL(
+ aResolver,
+ params->iThicknessWidth,
+ params->iThicknessHeight,
+ params->iEdgeOffsetX,
+ params->iEdgeOffsetY );
+ }
+ break;
+ case EAlfBorderBrushCreateMetric:
+ {
+ TAlfCreateBorderBrushMetricParams* params = (TAlfCreateBorderBrushMetricParams*)aInitialParams.Ptr();
+
+ result = CAlfBorderBrushHandler::NewL(
+ aResolver,
+ params->iThickness,
+ params->iEdgeOffset );
+ }
+ break;
+
+ case EAlfImageBrushCreate:
+ {
+ TAlfImageBrushParams* params = (TAlfImageBrushParams*)aInitialParams.Ptr();
+ MHuiTexture* texture = reinterpret_cast<MHuiTexture*> (params->iTextureHandle);
+ result = CAlfImageBrushHandler::NewL(aResolver, THuiImage(*texture));
+ }
+ break;
+
+ case EAlfShadowBorderBrushCreate:
+ {
+ TInt* params = (TInt*)aInitialParams.Ptr();
+ result = CAlfShadowBorderBrushHandler::NewL(aResolver, *params);
+ break;
+ }
+ case EAlfShadowBorderBrushCreateMetric:
+ {
+ TAlfMetric* params = (TAlfMetric*)aInitialParams.Ptr();
+ result = CAlfShadowBorderBrushHandler::NewL(aResolver, *params);
+ break;
+ }
+
+ case EAlfDropShadowBrushCreate:
+ {
+ TInt* params = (TInt*)aInitialParams.Ptr();
+ result = CAlfDropShadowBrushHandler::NewL(aResolver, *params);
+ break;
+ }
+ case EAlfDropShadowBrushCreateMetric:
+ {
+ TAlfMetric* params = (TAlfMetric*)aInitialParams.Ptr();
+ result = CAlfDropShadowBrushHandler::NewL(aResolver, *params);
+ break;
+ }
+
+ case EAlfGradientBrushCreate:
+ {
+ result = CAlfGradientBrushHandler::NewL( aResolver );
+ break;
+ }
+ case EAlfFrameBrushCreate:
+ {
+ TAlfFrameBrushParams* params = (TAlfFrameBrushParams*)aInitialParams.Ptr();
+ result = CAlfFrameBrushHandler::NewL(aResolver, params->iFrameIID, params->iEdgeOffsetX, params->iEdgeOffsetY);
+ }
+ break;
+ case EAlfFrameBrushCreateMetric:
+ {
+ TAlfFrameBrushMetricParams* params = (TAlfFrameBrushMetricParams*)aInitialParams.Ptr();
+ result = CAlfFrameBrushHandler::NewL(aResolver, params->iFrameIID, params->iEdgeOffset);
+ }
+ break;
+ case EAlfFrameBrushCreateImage:
+ {
+ TAlfFrameBrushImageParams* params = (TAlfFrameBrushImageParams*)aInitialParams.Ptr();
+
+ // Todo: is is safe enough to handle textures as direct casts..
+ TInt handle = params->iImage.iTextureHandle;
+ MHuiTexture* texture = reinterpret_cast<MHuiTexture*>(handle);
+ THuiImage huiImage;
+ if (texture)
+ {
+ huiImage = THuiImage(*texture,
+ params->iImage.iTl.iX.ValueNow(),
+ params->iImage.iTl.iY.ValueNow(),
+ params->iImage.iBr.iX.ValueNow(),
+ params->iImage.iBr.iY.ValueNow());
+
+ // We take transition time from one, assuming it is same for everyone.
+ TInt transitionTime = params->iImage.iBr.iY.TimeToTargetinMilliSeconds();
+
+ huiImage.SetTexCoords(params->iImage.iTl.iX.Target(),
+ params->iImage.iTl.iY.Target(),
+ params->iImage.iBr.iX.Target(),
+ params->iImage.iBr.iY.Target(),
+ transitionTime );
+ }
+
+ result = CAlfFrameBrushHandler::NewL(aResolver, huiImage, params->iEdgeOffset);
+ }
+ break;
+
+ case EAlfMappingFunctionConstantCreate:
+ {
+ TReal32* params = (TReal32*)aInitialParams.Ptr();
+ result = new (ELeave) TAlfConstantMappingFunctionHandler(
+ aResolver,
+ *params );
+ break;
+ }
+
+ case EAlfMappingFunctionLinearCreate:
+ {
+ TReal2* params = (TReal2*)aInitialParams.Ptr();
+ result = new (ELeave) TAlfLinearMappingFunctionHandler(
+ aResolver,
+ params->iReal1,
+ params->iReal2 );
+ break;
+ }
+
+ case EAlfMappingFunctionSineCreate:
+ {
+ TReal2* params = (TReal2*)aInitialParams.Ptr();
+ result = new (ELeave) TAlfSineMappingFunctionHandler(
+ aResolver,
+ params->iReal1,
+ params->iReal2 );
+ break;
+ }
+
+ case EAlfMappingFunctionCosineCreate:
+ {
+ TReal2* params = (TReal2*)aInitialParams.Ptr();
+ result = new (ELeave) TAlfCosineMappingFunctionHandler(
+ aResolver,
+ params->iReal1,
+ params->iReal2 );
+ break;
+ }
+
+ case EAlfMappingFunctionAverageCreate:
+ {
+ TInt2* params = (TInt2*)aInitialParams.Ptr();
+
+ MHuiMappingFunction* func1 = NULL;
+ MHuiMappingFunction* func2 = NULL;
+
+ if ( params->iInt1 )
+ {
+ func1 = (MHuiMappingFunction*) aResolver.GetInterfaceL(EHuiInterfaceMappingFunction, params->iInt1 );
+ }
+
+ if ( params->iInt2 )
+ {
+ func2 = (MHuiMappingFunction*) aResolver.GetInterfaceL(EHuiInterfaceMappingFunction, params->iInt2 );
+ }
+
+
+ result = new (ELeave) TAlfAverageMappingFunctionHandler(
+ aResolver,
+ func1,
+ func2
+ );
+ }
+ break;
+
+ case EAlfCurvePathCreate:
+ {
+ CHuiCurvePath* curvePath = NULL;
+ TInt* params = (TInt*)aInitialParams.Ptr();
+ if ( *params )
+ {
+ curvePath = (CHuiCurvePath*) aResolver.GetInterfaceL(EHuiObjectTypeCurvePathProvider, *params );
+ }
+ result = CAlfCurvePathHandler::NewL( aResolver,curvePath );
+ break;
+ }
+ case EAlfMappingFunctionTableCreate:
+ {
+ result = new (ELeave) TAlfTableMappingFunctionHandler(aResolver);
+ break;
+ }
+
+ case EAlfPlatformTextStyleCreate:
+ {
+ TInt2* params = (TInt2*)aInitialParams.Ptr();
+ result = new (ELeave) TAlfTextStyleHandler(aResolver, params->iInt1, params->iInt2, EAlfPlatformTextStyleCreate);
+ break;
+ }
+
+ case EAlfPreconfiguredTextStyleCreate:
+ {
+ TInt* params = (TInt*)aInitialParams.Ptr();
+ result = new (ELeave) TAlfTextStyleHandler(aResolver, *params, 0, EAlfPreconfiguredTextStyleCreate);
+ break;
+ }
+
+ case EAlfPlatformTextStyleCopy:
+ {
+ TInt* params = (TInt*)aInitialParams.Ptr();
+ result = new (ELeave) TAlfTextStyleHandler(aResolver, *params, 0, EAlfPlatformTextStyleCopy);
+ break;
+ }
+
+ default:
+ User::Leave(KErrNotSupported);
+ break;
+ }
+
+ return result;
+ }
+
+void TAlfFixedFactory::Release()
+ {
+ delete this;
+ }
+
+// end of file
+