diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/ServerCore/Src/alfbrushhandlers.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/ServerCore/Src/alfbrushhandlers.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1293 @@ +/* +* Copyright (c) 2007 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: All the built in brush handlers +* +*/ + + + +#include "alf/alfbrushhandlers.h" +#include "alf/alfconstants.h" +#include "alf/alfserverutils.h" +#include "alf/alfmetric.h" +#include +#include +#include +#include +#include +#include +#include +#include + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfBrushHandler::CAlfBrushHandler(MAlfInterfaceProvider& aResolver) + : iResolver( aResolver ), iOwnsBrush(ETrue) + { + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBrushHandler::ConstructL( CHuiBrush* aBrush ) + { + if (!aBrush) + { + // the child class needs to provide the brush instance. + USER_INVARIANT(); + } + else + { + iBrush = aBrush; + } + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfBrushHandler::~CAlfBrushHandler() + { + if ( iOwnsBrush ) + { + delete iBrush; + } + iBrush = NULL; + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBrushHandler::Release() + { + delete this; + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C TAny* CAlfBrushHandler::GetInterface( + const THuiInterfaceSupport& aInterface) + { + switch ( aInterface ) + { + case EHuiObjectTypeBrush: + return iBrush; + case EAlfBrushHandler: + return this; + + default: + return NULL; + } + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBrushHandler::HandleCmdL( + TInt aCommandId, + const TDesC8& aInputBuffer, + TDes8& aResponse) + { + switch (aCommandId) + { + case EAlfBrushGetOpacity: + { + TAlfTimedValue opacity; + AlfTimedValueUtility::CopyTimedValue(iBrush->iOpacity, opacity); + TPckg resultPckg(opacity); + + aResponse = resultPckg; // awkward + break; + } + case EAlfBrushSetOpacity: + { + TAlfTimedValue* opacity = (TAlfTimedValue*) aInputBuffer.Ptr() ; + AlfTimedValueUtility::CopyTimedValue(*opacity, iBrush->iOpacity, iResolver); + break; + } + + case EAlfBrushSetLayer: + { + THuiBrushLayer* layer = (THuiBrushLayer*) aInputBuffer.Ptr() ; + iBrush->SetLayer( *layer ); + break; + } + case EAlfBrushClipToVisual: + { + TBool clip = iBrush->ClipToVisual(); + TPckg resultPckg(clip); + aResponse = resultPckg; // awkward + break; + } + case EAlfBrushSetClipToVisual: + { + TBool* clip = (TBool*) aInputBuffer.Ptr() ; + iBrush->SetClipToVisual(*clip); + break; + } + + default: + User::Leave(KErrNotSupported); + } + } + +// --------------------------------------------------------------------------- +// New method +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBrushHandler::SetOwnership(TBool aHolderOwnsBrush) + { + iOwnsBrush = aHolderOwnsBrush; + } + +EXPORT_C void CAlfBrushHandler::BrushHandlerExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParams*/) + { + + } + + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfBorderBrushHandler::CAlfBorderBrushHandler( + MAlfInterfaceProvider& aResolver) +: CAlfBrushHandler( aResolver ) + { + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBorderBrushHandler::ConstructL( + CHuiBrush* aBrush, + TAlfXYMetric aThickness, + TAlfXYMetric aEdgeOffset) + { + if (!aBrush) + { + THuiXYMetric huiThickness; + THuiXYMetric huiEdgeOffset; + AlfXYMetricUtility::CopyMetric(aThickness, huiThickness); + AlfXYMetricUtility::CopyMetric(aEdgeOffset, huiEdgeOffset); + + CHuiBorderBrush* borderBrush = CHuiBorderBrush::NewLC( + huiThickness, huiEdgeOffset); + CAlfBrushHandler::ConstructL( borderBrush ); + CleanupStack::Pop( borderBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C MAlfExtension* CAlfBorderBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, + TAlfXYMetric aThickness, + TAlfXYMetric aEdgeOffset) + { + CAlfBorderBrushHandler* self = new( ELeave ) CAlfBorderBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( + NULL, + aThickness, + aEdgeOffset ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBorderBrushHandler::ConstructL( + CHuiBrush* aBrush, + TInt aThicknessWidth, + TInt aThicknessHeight, + TInt aEdgeOffsetX, + TInt aEdgeOffsetY ) + { + if (!aBrush) + { + CHuiBorderBrush* borderBrush = CHuiBorderBrush::NewLC( + aThicknessWidth, + aThicknessHeight, + aEdgeOffsetX, + aEdgeOffsetY); + CAlfBrushHandler::ConstructL( borderBrush ); + CleanupStack::Pop( borderBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C MAlfExtension* CAlfBorderBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, + TInt aThicknessWidth, + TInt aThicknessHeight, + TInt aEdgeOffsetX, + TInt aEdgeOffsetY ) + { + CAlfBorderBrushHandler* self = new( ELeave ) CAlfBorderBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( + NULL, + aThicknessWidth, + aThicknessHeight, + aEdgeOffsetX, + aEdgeOffsetY ); + CleanupStack::Pop( self ); + return self; + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfBorderBrushHandler::~CAlfBorderBrushHandler() + { + } + + + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBorderBrushHandler::Release() + { + delete this; + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C TAny* CAlfBorderBrushHandler::GetInterface( + const THuiInterfaceSupport& aInterface) + { + return CAlfBrushHandler::GetInterface(aInterface); + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfBorderBrushHandler::HandleCmdL( + TInt aCommandId, + const TDesC8& aInputBuffer, + TDes8& aResponse) + { + CHuiBorderBrush* borderBrush = static_cast(iBrush); + + switch (aCommandId) + { + case EAlfBorderBrushSetImage: + { + TAlfImageParams* params = (TAlfImageParams*) aInputBuffer.Ptr(); + + // Todo: is is safe enough to handle textures as direct casts.. + TInt handle = params->iTextureHandle; + MHuiTexture* texture = reinterpret_cast(handle); + THuiImage huiImage; + if (texture) + { + huiImage = THuiImage(*texture, + params->iTl.iX.ValueNow(), + params->iTl.iY.ValueNow(), + params->iBr.iX.ValueNow(), + params->iBr.iY.ValueNow()); + + // We take transition time from one, assuming it is same for everyone. + TInt transitionTime = params->iBr.iY.TimeToTargetinMilliSeconds(); + + huiImage.SetTexCoords(params->iTl.iX.Target(), + params->iTl.iY.Target(), + params->iBr.iX.Target(), + params->iBr.iY.Target(), + transitionTime ); + } + + borderBrush->SetImage( huiImage ); + break; + } + + case EAlfBorderBrushSetColor: + { + TRgb* color = (TRgb*) aInputBuffer.Ptr(); + borderBrush->SetColor( *color ); + break; + } + + case EAlfBorderBrushSetThickness: + { + TAlfTimedPoint* value = (TAlfTimedPoint*) aInputBuffer.Ptr(); + AlfTimedPointUtility::CopyTimedPoint(*value, borderBrush->iThickness, iResolver); + break; + } + case EAlfBorderBrushSetThicknessMetric: + { + TAlfXYMetric* value = (TAlfXYMetric*) aInputBuffer.Ptr(); + THuiXYMetric huivalue; + AlfXYMetricUtility::CopyMetric(*value, huivalue); + borderBrush->SetThickness(huivalue); + break; + } + + case EAlfBorderBrushGetThickness: + { + TAlfTimedPoint value; + AlfTimedPointUtility::CopyTimedPoint(borderBrush->iThickness, value); + TPckg resultPckg(value); + aResponse = resultPckg; + break; + } + + case EAlfBorderBrushSetEdgeOffset: + { + TAlfTimedPoint* value = (TAlfTimedPoint*) aInputBuffer.Ptr(); + AlfTimedPointUtility::CopyTimedPoint(*value, borderBrush->iEdgeOffset, iResolver); + break; + } + case EAlfBorderBrushSetEdgeOffsetMetric: + { + TAlfXYMetric* value = (TAlfXYMetric*) aInputBuffer.Ptr(); + THuiXYMetric huivalue; + AlfXYMetricUtility::CopyMetric(*value, huivalue); + borderBrush->SetEdgeOffset(huivalue); + break; + } + + case EAlfBorderBrushGetEdgeOffset: + { + TAlfTimedPoint value; + AlfTimedPointUtility::CopyTimedPoint(borderBrush->iEdgeOffset, value); + TPckg resultPckg(value); + aResponse = resultPckg; + break; + } + + case EAlfBorderBrushSetImageOffset: + { + TAlfTimedPoint* value = (TAlfTimedPoint*) aInputBuffer.Ptr(); + AlfTimedPointUtility::CopyTimedPoint(*value, borderBrush->iImageOffset, iResolver); + break; + } + case EAlfBorderBrushSetImageOffsetMetric: + { + TAlfXYMetric* value = (TAlfXYMetric*) aInputBuffer.Ptr(); + THuiXYMetric huivalue; + AlfXYMetricUtility::CopyMetric(*value, huivalue); + borderBrush->SetImageOffset(huivalue); + break; + } + + case EAlfBorderBrushGetImageOffset: + { + TAlfTimedPoint value; + AlfTimedPointUtility::CopyTimedPoint(borderBrush->iImageOffset, value); + TPckg resultPckg(value); + aResponse = resultPckg; + break; + } + + default: + CAlfBrushHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse); + } + } + +EXPORT_C void CAlfBorderBrushHandler::BrushHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParams) + { + CAlfBrushHandler::BrushHandlerExtension(aExtensionUid, aExtensionParams); + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfImageBrushHandler::CAlfImageBrushHandler( + MAlfInterfaceProvider& aResolver) +: CAlfBrushHandler( aResolver ) + { + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfImageBrushHandler::ConstructL( + CHuiBrush* aBrush, THuiImage aImage) + { + if (!aBrush) + { + CHuiImageBrush* imageBrush = CHuiImageBrush::NewLC(aImage); + CAlfBrushHandler::ConstructL( imageBrush ); + CleanupStack::Pop( imageBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C MAlfExtension* CAlfImageBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, THuiImage aImage ) + { + CAlfImageBrushHandler* self = new( ELeave ) CAlfImageBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( NULL , aImage ); + CleanupStack::Pop( self ); + return self; + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfImageBrushHandler::~CAlfImageBrushHandler() + { + } + + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfImageBrushHandler::Release() + { + delete this; + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C TAny* CAlfImageBrushHandler::GetInterface( + const THuiInterfaceSupport& aInterface) + { + return CAlfBrushHandler::GetInterface(aInterface); + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfImageBrushHandler::HandleCmdL( + TInt aCommandId, + const TDesC8& aInputBuffer, + TDes8& aResponse) + { + CHuiImageBrush* imageBrush = static_cast(iBrush); + + switch (aCommandId) + { + case EAlfImageBrushSetBorders: + { + TAlfImageBrushParams* params = (TAlfImageBrushParams*) aInputBuffer.Ptr(); + imageBrush->SetBorders(params->iLeftBorderWidth, + params->iRightBorderWidth, + params->iTopBorderWidth, + params->iBottomBorderWidth); + break; + } + case EAlfImageBrushSetImage: + { + TAlfImageBrushParams* params = (TAlfImageBrushParams*) aInputBuffer.Ptr(); + MHuiTexture* texture = reinterpret_cast (params->iTextureHandle); + THuiImage huiImage; + if (texture) + { + huiImage.SetTexture(*texture); + + huiImage.SetTexCoords(params->iTl.iX.Target(), + params->iTl.iY.Target(), + params->iBr.iX.Target(), + params->iBr.iY.Target()); + } + + imageBrush->SetImage(huiImage); + imageBrush->SetBorders(params->iLeftBorderWidth, + params->iRightBorderWidth, + params->iTopBorderWidth, + params->iBottomBorderWidth); + break; + } + + case EAlfImageBrushSetScaleMode: + { + CHuiImageVisual::TScaleMode* scale = (CHuiImageVisual::TScaleMode*) aInputBuffer.Ptr() ; + imageBrush->SetScaleMode( *scale ); + break; + } + + case EAlfImageBrushSetScale: + { + TAlfTimedValue* scale = (TAlfTimedValue*) aInputBuffer.Ptr() ; + AlfTimedValueUtility::CopyTimedValue(*scale, imageBrush->iScale, iResolver); + break; + } + + case EAlfImageBrushScale: + { + TAlfTimedValue scale; + AlfTimedValueUtility::CopyTimedValue(imageBrush->iScale, scale); + TPckg resultPckg(scale); + aResponse = resultPckg; + break; + } + + case EAlfImageBrushSetOffset: + { + TAlfTimedPoint* offset = (TAlfTimedPoint*) aInputBuffer.Ptr(); + AlfTimedPointUtility::CopyTimedPoint(*offset, imageBrush->iImageOffset, iResolver); + break; + } + + case EAlfImageBrushOffset: + { + TAlfTimedPoint point; + AlfTimedPointUtility::CopyTimedPoint(imageBrush->iImageOffset, point); + TPckg buf(point); + aResponse = buf; + break; + } + + default: + CAlfBrushHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse); + } + } + +EXPORT_C void CAlfImageBrushHandler::BrushHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParams) + { + CAlfBrushHandler::BrushHandlerExtension(aExtensionUid, aExtensionParams); + } + + + +// SHADOW BORDER BRUSH HANDLER + +EXPORT_C MAlfExtension* CAlfShadowBorderBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, + TInt aWidth ) + { + CAlfShadowBorderBrushHandler* self = new( ELeave ) CAlfShadowBorderBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( + NULL, + aWidth ); + CleanupStack::Pop( self ); + return self; + } + +EXPORT_C CAlfShadowBorderBrushHandler::CAlfShadowBorderBrushHandler( + MAlfInterfaceProvider& aResolver ) + : CAlfBrushHandler( aResolver ) + { + } + +EXPORT_C void CAlfShadowBorderBrushHandler::ConstructL( + CHuiBrush* aBrush, + TInt aWidth) + { + if (!aBrush) + { + CHuiShadowBorderBrush* shadowBorderBrush = CHuiShadowBorderBrush::NewLC( + aWidth ); + CAlfBrushHandler::ConstructL( shadowBorderBrush ); + CleanupStack::Pop( shadowBorderBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + +EXPORT_C MAlfExtension* CAlfShadowBorderBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, + TAlfMetric aWidth ) + { + CAlfShadowBorderBrushHandler* self = new( ELeave ) CAlfShadowBorderBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( + NULL, + aWidth ); + CleanupStack::Pop( self ); + return self; + } + +EXPORT_C void CAlfShadowBorderBrushHandler::ConstructL( + CHuiBrush* aBrush, + TAlfMetric aWidth) + { + if (!aBrush) + { + THuiMetric huiWidth; + AlfMetricUtility::CopyMetric(aWidth, huiWidth); + CHuiShadowBorderBrush* shadowBorderBrush = CHuiShadowBorderBrush::NewLC( + huiWidth ); + CAlfBrushHandler::ConstructL( shadowBorderBrush ); + CleanupStack::Pop( shadowBorderBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + +EXPORT_C CAlfShadowBorderBrushHandler::~CAlfShadowBorderBrushHandler() + { + } + + +EXPORT_C void CAlfShadowBorderBrushHandler::Release() + { + delete this; + } + +EXPORT_C TAny* CAlfShadowBorderBrushHandler::GetInterface( + const THuiInterfaceSupport& aInterface) + { + return CAlfBrushHandler::GetInterface( aInterface ); + } + +EXPORT_C void CAlfShadowBorderBrushHandler::HandleCmdL( + TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse) + { + CHuiShadowBorderBrush* shadowBorderBrush = static_cast(iBrush); + + switch ( aCommandId ) + { + case EAlfShadowBorderBrushGetWidth: + { + TAlfTimedValue value; + AlfTimedValueUtility::CopyTimedValue(shadowBorderBrush->iWidth, value); + + TPckg resultPckg(value); + aResponse = resultPckg; // awkward + break; + } + + case EAlfShadowBorderBrushSetWidth: + { + TAlfTimedValue* value = (TAlfTimedValue*) aInputBuffer.Ptr() ; + AlfTimedValueUtility::CopyTimedValue(*value, shadowBorderBrush->iWidth, iResolver); + break; + } + + case EAlfShadowBorderBrushSetWidthMetric: + { + TAlfMetric* value = (TAlfMetric*) aInputBuffer.Ptr() ; + THuiMetric huivalue; + AlfMetricUtility::CopyMetric(*value, huivalue); + shadowBorderBrush->SetWidth(huivalue); + break; + } + default: + CAlfBrushHandler::HandleCmdL( aCommandId, aInputBuffer, aResponse ); + } + } + +EXPORT_C void CAlfShadowBorderBrushHandler::BrushHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParams) + { + CAlfBrushHandler::BrushHandlerExtension(aExtensionUid, aExtensionParams); + } + +// DROP SHADOW BRUSH HANDLER + +EXPORT_C MAlfExtension* CAlfDropShadowBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, + TInt aDepth ) + { + CAlfDropShadowBrushHandler* self = new( ELeave ) CAlfDropShadowBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( + NULL, + aDepth ); + CleanupStack::Pop( self ); + return self; + } + +EXPORT_C MAlfExtension* CAlfDropShadowBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, + TAlfMetric aDepth ) + { + CAlfDropShadowBrushHandler* self = new( ELeave ) CAlfDropShadowBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( + NULL, + aDepth ); + CleanupStack::Pop( self ); + return self; + } + +EXPORT_C CAlfDropShadowBrushHandler::CAlfDropShadowBrushHandler( + MAlfInterfaceProvider& aResolver) + : CAlfBrushHandler( aResolver ) + { + } + +EXPORT_C void CAlfDropShadowBrushHandler::ConstructL( + CHuiBrush* aBrush, + TAlfMetric aDepth ) + { + if (!aBrush) + { + THuiMetric huiDepth; + AlfMetricUtility::CopyMetric(aDepth, huiDepth); + CHuiDropShadowBrush* dropShadowBrush = CHuiDropShadowBrush::NewLC( + huiDepth ); + CAlfBrushHandler::ConstructL( dropShadowBrush ); + CleanupStack::Pop( dropShadowBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + +EXPORT_C void CAlfDropShadowBrushHandler::ConstructL( + CHuiBrush* aBrush, + TInt aDepth ) + { + if (!aBrush) + { + CHuiDropShadowBrush* dropShadowBrush = CHuiDropShadowBrush::NewLC( + aDepth ); + CAlfBrushHandler::ConstructL( dropShadowBrush ); + CleanupStack::Pop( dropShadowBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + +EXPORT_C CAlfDropShadowBrushHandler::~CAlfDropShadowBrushHandler() + { + } + + +EXPORT_C void CAlfDropShadowBrushHandler::Release() + { + delete this; + } + +EXPORT_C TAny* CAlfDropShadowBrushHandler::GetInterface( + const THuiInterfaceSupport& aInterface) + { + return CAlfBrushHandler::GetInterface( aInterface ); + } + +EXPORT_C void CAlfDropShadowBrushHandler::HandleCmdL( + TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse) + { + CHuiDropShadowBrush* dropShadowBrush = static_cast(iBrush); + + switch ( aCommandId ) + { + case EAlfDropShadowBrushGetSoftness: + { + TAlfTimedValue value; + AlfTimedValueUtility::CopyTimedValue(dropShadowBrush->iSoftness, value); + TPckg resultPckg(value); + aResponse = resultPckg; // awkward + break; + } + + case EAlfDropShadowBrushSetSoftness: + { + TAlfTimedValue* value = (TAlfTimedValue*) aInputBuffer.Ptr() ; + AlfTimedValueUtility::CopyTimedValue(*value, dropShadowBrush->iSoftness, iResolver); + break; + } + case EAlfDropShadowBrushSetSoftnessMetric: + { + TAlfMetric* value = (TAlfMetric*) aInputBuffer.Ptr() ; + THuiMetric huivalue; + AlfMetricUtility::CopyMetric(*value, huivalue); + dropShadowBrush->SetSoftness(huivalue); + break; + } + + case EAlfDropShadowBrushGetDepth: + { + TAlfTimedValue value; + AlfTimedValueUtility::CopyTimedValue(dropShadowBrush->iDepth, value); + + TPckg resultPckg(value); + aResponse = resultPckg; // awkward + break; + } + + case EAlfDropShadowBrushSetDepth: + { + TAlfTimedValue* value = (TAlfTimedValue*) aInputBuffer.Ptr() ; + AlfTimedValueUtility::CopyTimedValue(*value, dropShadowBrush->iDepth, iResolver); + break; + } + case EAlfDropShadowBrushSetDepthMetric: + { + TAlfMetric* value = (TAlfMetric*) aInputBuffer.Ptr() ; + THuiMetric huivalue; + AlfMetricUtility::CopyMetric(*value, huivalue); + dropShadowBrush->SetDepth(huivalue); + break; + } + case EAlfDropShadowBrushSetColor: + { + TRgb* value = (TRgb*) aInputBuffer.Ptr() ; + dropShadowBrush->SetColor(*value); + break; + } + default: + CAlfBrushHandler::HandleCmdL( aCommandId, aInputBuffer, aResponse ); + } + } + +EXPORT_C void CAlfDropShadowBrushHandler::BrushHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParams) + { + CAlfBrushHandler::BrushHandlerExtension(aExtensionUid, aExtensionParams); + } + + + +// GRADIENT BRUSH HANDLER + +EXPORT_C MAlfExtension* CAlfGradientBrushHandler::NewL( + MAlfInterfaceProvider& aResolver ) + { + CAlfGradientBrushHandler* self = new( ELeave ) CAlfGradientBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( NULL ); + CleanupStack::Pop( self ); + return self; + } + +EXPORT_C CAlfGradientBrushHandler::CAlfGradientBrushHandler( + MAlfInterfaceProvider& aResolver) + : CAlfBrushHandler( aResolver ) + { + } + +EXPORT_C void CAlfGradientBrushHandler::ConstructL( + CHuiBrush* aBrush ) + { + if (!aBrush) + { + CHuiGradientBrush* gradientBrush = CHuiGradientBrush::NewLC(); + CAlfBrushHandler::ConstructL( gradientBrush ); + CleanupStack::Pop( gradientBrush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + +EXPORT_C CAlfGradientBrushHandler::~CAlfGradientBrushHandler() + { + } + + +EXPORT_C void CAlfGradientBrushHandler::Release() + { + delete this; + } + +EXPORT_C TAny* CAlfGradientBrushHandler::GetInterface( + const THuiInterfaceSupport& aInterface) + { + return CAlfBrushHandler::GetInterface( aInterface ); + } + +EXPORT_C void CAlfGradientBrushHandler::HandleCmdL( + TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse) + { + CHuiGradientBrush* dropShadowBrush = static_cast(iBrush); + + switch ( aCommandId ) + { + case EAlfGradientBrushSetDirection: + { + CHuiGradientBrush::TDirection* value = (CHuiGradientBrush::TDirection*) aInputBuffer.Ptr(); + dropShadowBrush->SetDirection( *value ); + break; + } + + case EAlfGradientBrushSetColor: + { + TAlfGradientBrushSetColorParams* value = (TAlfGradientBrushSetColorParams*) aInputBuffer.Ptr(); + dropShadowBrush->SetColor( value->iColor, value->iOpacity ); + break; + } + + case EAlfGradientBrushSetImage: + { + TAlfImageParams* params = (TAlfImageParams*) aInputBuffer.Ptr(); + + // Todo: is is safe enough to handle textures as direct casts.. + TInt handle = params->iTextureHandle; + MHuiTexture* texture = reinterpret_cast(handle); + THuiImage huiImage; + if (texture) + { + huiImage = THuiImage(*texture, + params->iTl.iX.ValueNow(), + params->iTl.iY.ValueNow(), + params->iBr.iX.ValueNow(), + params->iBr.iY.ValueNow()); + + // We take transition time from one, assuming it is same for everyone. + TInt transitionTime = params->iBr.iY.TimeToTargetinMilliSeconds(); + + huiImage.SetTexCoords(params->iTl.iX.Target(), + params->iTl.iY.Target(), + params->iBr.iX.Target(), + params->iBr.iY.Target(), + transitionTime ); + } + + dropShadowBrush->SetImage( huiImage ); + break; + } + + case EAlfGradientBrushColor: + { + TInt* value = (TInt*) aInputBuffer.Ptr(); + const TRgb result = dropShadowBrush->Color( *value ); + TPckg resultPckg(result); + aResponse = resultPckg; // awkward + break; + } + + case EAlfGradientBrushOpacity: + { + TInt* value = (TInt*) aInputBuffer.Ptr(); + const TReal32 result = dropShadowBrush->Opacity( *value ); + TPckg resultPckg(result); + aResponse = resultPckg; // awkward + break; + } + + case EAlfGradientBrushAppendColor: + { + TAlfGradientBrushAppendColorParams* value = (TAlfGradientBrushAppendColorParams*) aInputBuffer.Ptr(); + dropShadowBrush->AppendColorL( value->iPosition, value->iColor, value->iOpacity ); + break; + } + + default: + CAlfBrushHandler::HandleCmdL( aCommandId, aInputBuffer, aResponse ); + } + } + +EXPORT_C void CAlfGradientBrushHandler::BrushHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParams) + { + CAlfBrushHandler::BrushHandlerExtension(aExtensionUid, aExtensionParams); + } + + +// FRAME BRUSH HANDLER + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfFrameBrushHandler::CAlfFrameBrushHandler( + MAlfInterfaceProvider& aResolver) +: CAlfBrushHandler( aResolver ) + { + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfFrameBrushHandler::ConstructL( + CHuiBrush* aBrush, const TAknsItemID& aIID, TInt aEdgeOffsetX, TInt aEdgeOffsetY) + { + if (!aBrush) + { + CHuiFrameBrush* brush = CHuiFrameBrush::NewLC(aIID,aEdgeOffsetX,aEdgeOffsetY); + CAlfBrushHandler::ConstructL( brush ); + CleanupStack::Pop( brush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfFrameBrushHandler::ConstructL( + CHuiBrush* aBrush, const TAknsItemID& aIID, TAlfXYMetric aEdgeOffset) + { + if (!aBrush) + { + THuiXYMetric huiEdgeOffset; + AlfXYMetricUtility::CopyMetric(aEdgeOffset, huiEdgeOffset); + CHuiFrameBrush* brush = CHuiFrameBrush::NewLC(aIID, huiEdgeOffset); + CAlfBrushHandler::ConstructL( brush ); + CleanupStack::Pop( brush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfFrameBrushHandler::ConstructL( + CHuiBrush* aBrush, const THuiImage& aImage, TAlfXYMetric aEdgeOffset) + { + if (!aBrush) + { + THuiXYMetric huiEdgeOffset; + AlfXYMetricUtility::CopyMetric(aEdgeOffset, huiEdgeOffset); + + CHuiFrameBrush* brush = CHuiFrameBrush::NewLC(aImage, huiEdgeOffset); + CAlfBrushHandler::ConstructL( brush ); + CleanupStack::Pop( brush ); + } + else + { + CAlfBrushHandler::ConstructL( aBrush ); + } + } + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C MAlfExtension* CAlfFrameBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, const TAknsItemID& aIID, TInt aEdgeOffsetX, TInt aEdgeOffsetY ) + { + CAlfFrameBrushHandler* self = new( ELeave ) CAlfFrameBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( NULL , aIID, aEdgeOffsetX, aEdgeOffsetY ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C MAlfExtension* CAlfFrameBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, const TAknsItemID& aIID, TAlfXYMetric aEdgeOffset ) + { + CAlfFrameBrushHandler* self = new( ELeave ) CAlfFrameBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( NULL , aIID, aEdgeOffset ); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C MAlfExtension* CAlfFrameBrushHandler::NewL( + MAlfInterfaceProvider& aResolver, const THuiImage& aImage, TAlfXYMetric aEdgeOffset) + { + CAlfFrameBrushHandler* self = new( ELeave ) CAlfFrameBrushHandler( aResolver ); + CleanupStack::PushL( self ); + self->ConstructL( NULL , aImage, aEdgeOffset ); + CleanupStack::Pop( self ); + return self; + } + + +// --------------------------------------------------------------------------- +// ?description_if_needed +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfFrameBrushHandler::~CAlfFrameBrushHandler() + { + } + + + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfFrameBrushHandler::Release() + { + delete this; + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C TAny* CAlfFrameBrushHandler::GetInterface( + const THuiInterfaceSupport& aInterface) + { + return CAlfBrushHandler::GetInterface(aInterface); + } + +// --------------------------------------------------------------------------- +// From class ?base_class. +// ?implementation_description +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfFrameBrushHandler::HandleCmdL( + TInt aCommandId, + const TDesC8& aInputBuffer, + TDes8& aResponse) + { + CHuiFrameBrush* frameBrush = static_cast(iBrush); + + switch (aCommandId) + { + case EAlfFrameBrushSetFrameRects: + { + TAlfFrameBrushParams* params = (TAlfFrameBrushParams*) aInputBuffer.Ptr(); + frameBrush->SetFrameRectsL(params->iInnerRect, params->iOuterRect); + break; + } + case EAlfFrameBrushSetEdgeOffsetMetric: + { + TAlfXYMetric* params = (TAlfXYMetric*) aInputBuffer.Ptr(); + THuiXYMetric huimetric; + AlfXYMetricUtility::CopyMetric(*params, huimetric); + frameBrush->SetEdgeOffset(huimetric); + break; + } + case EAlfFrameBrushSetImage: + { + TAlfImageParams* params = (TAlfImageParams*)aInputBuffer.Ptr(); + // Todo: is is safe enough to handle textures as direct casts.. + TInt handle = params->iTextureHandle; + MHuiTexture* texture = reinterpret_cast(handle); + THuiImage huiImage; + if (texture) + { + huiImage = THuiImage(*texture, + params->iTl.iX.ValueNow(), + params->iTl.iY.ValueNow(), + params->iBr.iX.ValueNow(), + params->iBr.iY.ValueNow()); + + // We take transition time from one, assuming it is same for everyone. + TInt transitionTime = params->iBr.iY.TimeToTargetinMilliSeconds(); + + huiImage.SetTexCoords(params->iTl.iX.Target(), + params->iTl.iY.Target(), + params->iBr.iX.Target(), + params->iBr.iY.Target(), + transitionTime ); + } + + frameBrush->SetImage(huiImage); + + break; + } + case EAlfFrameBrushSetFramePartImage: + { + TAlfFrameBrushFramePartImageParams* params = (TAlfFrameBrushFramePartImageParams*)aInputBuffer.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 ); + } + + CHuiFrameBrush::TFrameParts part = CHuiFrameBrush::TFrameParts(params->iFramePart); + frameBrush->SetImage(part, huiImage); + + break; + } + default: + CAlfBrushHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse); + } + } + +EXPORT_C void CAlfFrameBrushHandler::BrushHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParams) + { + CAlfBrushHandler::BrushHandlerExtension(aExtensionUid, aExtensionParams); + } +