diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/ServerCore/Src/alfstaticfactory.cpp --- /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 +#include +#include +#include +#include +#include +#include +#include +#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(iControl); + case EHuiInterfaceVisualOwner: + return static_cast(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(&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 (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(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 +