diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/Client/src/alfvisual.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/Client/src/alfvisual.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1661 @@ +/* +* 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: Visual base class. +* +*/ + + + +#include "alf/alfvisual.h" +#include "alf/alfenv.h" +#include "alf/alflayout.h" +#include "alf/alfcontrol.h" +#include "alf/alfbrusharray.h" +#include "alfclient.h" +#include "alf/alfdisplay.h" +#include "alf/alfroster.h" +#include "alf/alfgencomponent.h" +#include "alf/alftimedvalue.h" +#include "alf/alfconstants.h" +#include "alflogger.h" +#include "alf/alfmappingfunctions.h" +#include "alf/alftransformation.h" +#include "alf/alfstatic.h" +#include "alf/alfutil.h" +#include "alf/alfdropshadow.h" + +#include + +NONSHARABLE_CLASS(CAlfVisualOwnerNotification) : public CBase, public MAlfAsyncOpObserver + { +public: + CAlfVisualOwnerNotification( CAlfVisual& aVisual ); + ~CAlfVisualOwnerNotification(); +protected: + void AlfAsyncOpCompleted(TInt aCommandId, TInt aStatus); +private: + CAlfVisual& iVisual; + TInt iCommandId; + TBuf8<1> iDumBuffer; + }; + +CAlfVisualOwnerNotification::CAlfVisualOwnerNotification( CAlfVisual& aVisual ) + : iVisual( aVisual ) + { + iCommandId = 0; + TRAPD( err, iCommandId = iVisual.Comms()->DoAsynchronousCmdL( EAlfVisualLayoutUpdatedNotification, iDumBuffer, iDumBuffer, this ) ); + __ASSERT_ALWAYS( err == KErrNone, USER_INVARIANT() ); + } + +CAlfVisualOwnerNotification::~CAlfVisualOwnerNotification() + { + TBuf8<1> dum; + if ( iCommandId ) + { + iVisual.Comms()->DoSynchronousCmd( EAlfVisualLayoutUpdatedNotificationCancel, dum, dum ); + iVisual.Comms()->CancelAsynchCmd( iCommandId ); + iCommandId = 0; + } + } + +void CAlfVisualOwnerNotification::AlfAsyncOpCompleted(TInt /*aCommandId*/, TInt aStatus) + { + iCommandId = 0; + if ( aStatus == KErrNone ) + { + TRAPD( err, iCommandId = iVisual.Comms()->DoAsynchronousCmdL( EAlfVisualLayoutUpdatedNotification, iDumBuffer, iDumBuffer, this ) ); + __ASSERT_ALWAYS( err == KErrNone, USER_INVARIANT() ); + iVisual.Owner().VisualLayoutUpdated( iVisual ); + } + } + +// Private data +struct CAlfVisual::TPrivateData + { + CAlfLayout* iLayout; // Not owned. + CAlfDisplay* iDisplay; // Not Owned. + TAlfTimedValue iOpacity; // Owned. + CAlfControl* iOwner; // Not owned. + HBufC8* iTag; // Owned. + CAlfBrushArray* iBrushes; // Owned. + CAlfGenComponent* iComms; // owned + CAlfTransformation* iTransform; // Owned. + TAlfBoxMetric iPadding;// Owned + CAlfVisualOwnerNotification* iVisualOwnerNotification; // Own + CAlfDropShadow* iDropShadowHandler; + }; + +// ======== MACRO DEFINITIONS ======== + +void AssertPaddingsWereSetUsingDeprecatedPixelAPIs(const TAlfBoxMetric& aMetric) + { + __ASSERT_DEBUG( + (aMetric.iLeft.iMagnitude == aMetric.iRight.iMagnitude) && + (aMetric.iTop.iMagnitude == aMetric.iBottom.iMagnitude) && + (aMetric.iLeft.iUnit == EAlfUnitPixel) && + (aMetric.iRight.iUnit == EAlfUnitPixel) && + (aMetric.iTop.iUnit == EAlfUnitPixel) && + (aMetric.iBottom.iUnit == EAlfUnitPixel) + , USER_INVARIANT()); +#ifndef _DEBUG // Remove compile warnings + TAlfBoxMetric tmp = aMetric; + tmp = tmp; +#endif + } + + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Constructor +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfVisual::CAlfVisual() + { + } + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::ConstructL(CAlfControl& aOwner) + { + iData = new (ELeave) TPrivateData; + + iData->iLayout = NULL; + iData->iDisplay = NULL; + iData->iOwner = &aOwner; + iData->iTag = NULL; + iData->iBrushes = NULL; + iData->iComms = NULL; + iData->iTransform = NULL; + iData->iPadding = TAlfBoxMetric(TAlfMetric(0)); + iData->iVisualOwnerNotification = NULL; + iData->iDropShadowHandler = NULL; + } + + +// --------------------------------------------------------------------------- +// ConstructL +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::ConstructL(CAlfControl& aOwner, TInt aImplementationId, TInt aImplementationUid, const TDesC8& aConstructionParams ) + { + + ConstructL(aOwner); + + if (!iData->iComms) + { + iData->iComms = CAlfGenComponent::NewL( + aOwner.Env(), + aImplementationId, + aImplementationUid, + aConstructionParams); + } + + } + + + + +// --------------------------------------------------------------------------- +// Destructor +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfVisual::~CAlfVisual() + { + if ( iData ) + { + delete iData->iDropShadowHandler; + iData->iDropShadowHandler = NULL; + + delete iData->iVisualOwnerNotification; + iData->iVisualOwnerNotification = NULL; + + // If the visual is still attached to a layout, it is time to remove it. + if(iData->iLayout) + { + iData->iLayout->Remove(this); + } + + delete iData->iBrushes; + iData->iBrushes = NULL; + + delete iData->iTransform; + iData->iTransform = NULL; + + delete iData->iTag; + iData->iTag = NULL; + + delete iData->iComms; + } + delete iData; + iData = NULL; + } + +// --------------------------------------------------------------------------- +// Destroys a hierarchy of visuals, along with this visual. The visuals +// are first removed from their owner. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::RemoveAndDestroyAllD() + { + TBuf8<1> dum; + // Remove and destory from the server side + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualRemoveAndDestroyAll,KNullDesC8, dum); + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::RemoveAndDestroyAllD ignore error %d", err ) + } + + DoRemoveAndDestroyAllD(); + } + +EXPORT_C void CAlfVisual::DoRemoveAndDestroyAllD() + { + __ASSERT_ALWAYS( iData->iOwner, USER_INVARIANT() ); + + iData->iOwner->VisualDestroyed(*this); + delete this; + } + +// --------------------------------------------------------------------------- +// Returns subsession identifier, 0 by default. +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CAlfVisual::Identifier() const + { + return iData->iComms->Identifier(); + } + +// --------------------------------------------------------------------------- +// Sets layout for the visual. +// --------------------------------------------------------------------------- +// +void CAlfVisual::SetLayout(CAlfLayout* aLayout) + { + iData->iLayout = aLayout; + } + +// --------------------------------------------------------------------------- +// Returns current opacity +// --------------------------------------------------------------------------- +// +EXPORT_C const TAlfTimedValue& CAlfVisual::Opacity() const + { + TPckg buf(iData->iOpacity); + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualGetOpacity, KNullDesC8, buf); + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::Opacity panic error %d", err ) + USER_INVARIANT(); + } + + return iData->iOpacity; + } + +// --------------------------------------------------------------------------- +// Sets opacity. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetOpacity( const TAlfTimedValue& aOpacity ) + { + TPckgC buf(aOpacity); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetOpacity, buf); + + if ( err == KErrNone ) + { + iData->iOpacity = aOpacity; + } + else + { + __ALFLOGSTRING1( "CAlfVisual::SetOpacity panic error %d", err ) + USER_INVARIANT(); + } + } + +// --------------------------------------------------------------------------- +// Returns position +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfTimedPoint CAlfVisual::Pos() const + { + TAlfTimedPoint point; + TPckg buf(point); + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualPos, KNullDesC8, buf); + + if (err) + { + __ALFLOGSTRING1( "CAlfVisual::Pos panic error %d", err ) + USER_INVARIANT(); + } + + return point; + } + + +// --------------------------------------------------------------------------- +// Sets the position of the visual. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetPos(const TAlfRealPoint& aPos, TInt aTransitionTime) + { + TAlfVisualPos pos = { aPos, aTransitionTime }; + + TPckgC buf(pos); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetPos, buf); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::SetPos panic error %d", err ) + USER_INVARIANT(); + } + } + +// --------------------------------------------------------------------------- +// Returns the size of the visual. +// --------------------------------------------------------------------------- +// +EXPORT_C const TAlfTimedPoint CAlfVisual::Size() const + { + TAlfTimedPoint size; + TPckg buf(size); + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualSize, KNullDesC8, buf); + + if (err) + { + __ALFLOGSTRING1( "CAlfVisual::Size panic error %d", err ) + USER_INVARIANT(); + } + + return size; + } + +// --------------------------------------------------------------------------- +// Sets the size of the visual. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetSize(const TAlfRealSize& aSize, TInt aTransitionTime) + { + TAlfVisualSize size = { aSize, aTransitionTime }; + + TPckgC buf(size); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetSize, buf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::SetSize panic error %d", err ) + USER_INVARIANT(); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetFlag(TAlfVisualFlags aFlag) + { + TPckgC inBuf(aFlag); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetFlag, inBuf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::SetFlag panic error %d", err ) + USER_INVARIANT(); + } + + if ( aFlag == EAlfVisualFlagLayoutUpdateNotification && !iData->iVisualOwnerNotification ) + { + iData->iVisualOwnerNotification = new CAlfVisualOwnerNotification( *this ); + __ASSERT_ALWAYS( iData->iVisualOwnerNotification , USER_INVARIANT() ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetFlags(TUint aAnyFlags) + { + TPckgC inBuf(aAnyFlags); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetFlags, inBuf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::SetFlags panic error %d", err ) + USER_INVARIANT(); + } + + if ( aAnyFlags & EAlfVisualFlagLayoutUpdateNotification && !iData->iVisualOwnerNotification ) + { + iData->iVisualOwnerNotification = new CAlfVisualOwnerNotification( *this ); + __ASSERT_ALWAYS( iData->iVisualOwnerNotification , USER_INVARIANT() ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::ClearFlag(TAlfVisualFlags aFlag) + { + TPckgC inBuf(aFlag); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualClearFlag, inBuf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::ClearFlag panic error %d", err ) + USER_INVARIANT(); + } + + if ( aFlag == EAlfVisualFlagLayoutUpdateNotification && iData->iVisualOwnerNotification ) + { + delete iData->iVisualOwnerNotification; + iData->iVisualOwnerNotification = NULL; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::ClearFlags(TUint aAnyFlags) + { + TPckgC inBuf(aAnyFlags); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualClearFlags, inBuf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::ClearFlags panic error %d", err ) + USER_INVARIANT(); + } + + if ( aAnyFlags & EAlfVisualFlagLayoutUpdateNotification && iData->iVisualOwnerNotification ) + { + delete iData->iVisualOwnerNotification; + iData->iVisualOwnerNotification = NULL; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TUint CAlfVisual::Flags() const + { + TUint flags = 0; + TPckg outBuf(flags); + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualFlags, KNullDesC8, outBuf); + + if (err) + { + __ALFLOGSTRING1( "CAlfVisual::Flags panic error %d", err ) + USER_INVARIANT(); + } + + return flags; + } + +// --------------------------------------------------------------------------- +// Returns layout +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfLayout* CAlfVisual::Layout() const + { + return iData->iLayout; + } + +// --------------------------------------------------------------------------- +// Returns env. +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfEnv& CAlfVisual::Env() const + { + if (!iData || !iData->iOwner) // try to save what there's left to save + { + return CAlfStatic::Env(); + } + + return iData->iOwner->Env(); + } + +// --------------------------------------------------------------------------- +// Returns tag. +// --------------------------------------------------------------------------- +// +EXPORT_C const TDesC8& CAlfVisual::Tag() const + { + if(iData && iData->iTag) + { + return *iData->iTag; + } + + return KNullDesC8; + } + +// --------------------------------------------------------------------------- +// Returns display +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfDisplay* CAlfVisual::Display() const + { + const CAlfVisual* iter = this; + + while(iter) + { + if(iter->iData->iDisplay) + { + return iter->iData->iDisplay; + } + iter = iter->Layout(); + } + + // Not shown on any display. + return NULL; + } + +// --------------------------------------------------------------------------- +// Update child layout to the server +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::UpdateChildrenLayout(TInt aTransitionTime) + { + TPckgC buf(aTransitionTime); + TBuf8<1> dum; + + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualUpdateChildrenLayout, buf, dum); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::UpdateChildrenLayout panic error %d", err ) + USER_INVARIANT(); + } + } + +// --------------------------------------------------------------------------- +// Enables brush usage. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::EnableBrushesL(TBool aEnabled) + { + if(aEnabled && !iData->iBrushes) + { + iData->iBrushes = CAlfBrushArray::NewL(*this); + } + else if(!aEnabled && iData->iBrushes) + { + delete iData->iBrushes; + iData->iBrushes = NULL; + } + else + { + // for PC lint + } + } + +// --------------------------------------------------------------------------- +// Returns brush array +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfBrushArray* CAlfVisual::Brushes() + { + return iData->iBrushes; + } + +// --------------------------------------------------------------------------- +// Converts point. +// --------------------------------------------------------------------------- +// +EXPORT_C TPoint CAlfVisual::LocalToDisplay(const TPoint& aPoint) const + { + const TAlfRealPoint realPoint = LocalToDisplay(TAlfRealPoint(aPoint)); + return TPoint( AlfUtil::RoundFloatToInt( realPoint.iX ),AlfUtil::RoundFloatToInt( realPoint.iY ) ); + } + +// --------------------------------------------------------------------------- +// Converts point. +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfRealPoint CAlfVisual::LocalToDisplay( + const TAlfRealPoint& aPoint) const + { + TPckgC pointPckg(aPoint); + TAlfRealPoint result; + TPckg resultPckg(result); + + TInt err = iData->iComms->DoSynchronousCmd(EAlfVisualLocalToDisplay, pointPckg, resultPckg); + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::LocalToDisplay panic error %d", err ) + USER_INVARIANT(); + } + + return result; + } + +// --------------------------------------------------------------------------- +// Converts point. +// --------------------------------------------------------------------------- +// +EXPORT_C TPoint CAlfVisual::DisplayToLocal(const TPoint& aPoint) const + { + const TAlfRealPoint realPoint = DisplayToLocal(TAlfRealPoint(aPoint)); + return TPoint( AlfUtil::RoundFloatToInt( realPoint.iX ),AlfUtil::RoundFloatToInt( realPoint.iY ) ); + } + +// --------------------------------------------------------------------------- +// Converts point. +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfRealPoint CAlfVisual::DisplayToLocal(const TAlfRealPoint& aPoint) const + { + TPckgC pointPckg(aPoint); + TAlfRealPoint result; + TPckg resultPckg(result); + + TInt err = iData->iComms->DoSynchronousCmd(EAlfVisualDisplayToLocal, pointPckg, resultPckg); + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::DisplayToLocal panic error %d", err ) + USER_INVARIANT(); + } + + return result; + } + +// --------------------------------------------------------------------------- +// Gets display rect +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfRealRect CAlfVisual::DisplayRectTarget() const + { + TAlfRealRect rect; + TPckg rectPckg(rect); + + TInt err = iData->iComms->DoSynchronousCmd(EAlfVisualDisplayRectTarget, KNullDesC8, rectPckg); + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::DisplayRectTarget panic error %d", err ) + USER_INVARIANT(); + } + + return rect; + } + +// --------------------------------------------------------------------------- +// Moves visual to front. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::MoveToFront( TInt aTransitionTime ) + { + if (iData->iLayout) + { + iData->iLayout->MoveVisualToFront(*this, aTransitionTime); + } + } + +// --------------------------------------------------------------------------- +// Enables transformation. +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::EnableTransformationL(TBool aIsTransformed) + { + if ( aIsTransformed && iData->iTransform ) + { + // Already enabled + return; + } + + if ( !aIsTransformed && !iData->iTransform ) + { + // Already disabled + return; + } + + if ( aIsTransformed ) + { + iData->iTransform = CAlfTransformation::NewL( Env() ); + } + + // use the server handle from the transformation object if present + TInt transformationHandle = + iData->iTransform ? + iData->iTransform->ServerHandle() : + 0 ; + + TInt2 inData(transformationHandle,aIsTransformed); + TPckgC inPckg(inData); + + TBuf8<1> outDum; + + TInt err = iData->iComms->DoSynchronousCmd(EAlfVisualEnableTransformation, inPckg, outDum); + + if ( err == KErrNone && !aIsTransformed ) + { + delete iData->iTransform; + iData->iTransform = NULL; + } + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::EnableTransformationL leave error %d", err ) + delete iData->iTransform; + iData->iTransform = NULL; + User::Leave( err ); + } + } + +// --------------------------------------------------------------------------- +// Returns transformation +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfTransformation& CAlfVisual::Transformation() + { + __ASSERT_ALWAYS( iData->iTransform, USER_INVARIANT() ); + return *iData->iTransform; + } + + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetPadding(TInt aPadding) + { + TPckgC inBuf(aPadding); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetPaddingInt, inBuf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::SetPadding panic error %d", err ) + USER_INVARIANT(); + } + + iData->iPadding = TAlfBoxMetric(TAlfMetric(aPadding)); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetPadding(const TPoint& aPadding) + { + TPckgC inBuf(aPadding); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetPaddingPoint, inBuf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::SetPadding panic error %d", err ) + USER_INVARIANT(); + } + + iData->iPadding = TAlfBoxMetric(TAlfXYMetric(TAlfMetric(aPadding.iX), TAlfMetric(aPadding.iY))); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetPadding(const TAlfBoxMetric& aPadding) + { + TPckgC inBuf(aPadding); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetPaddingBox, inBuf ); + + if (err) // for now + { + __ALFLOGSTRING1( "CAlfVisual::SetPadding panic error %d", err ) + USER_INVARIANT(); + } + + iData->iPadding = aPadding; + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfRealRect CAlfVisual::PaddingInPixels() const + { + TBufC8<1> inDum; + TAlfRealRect value; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualPaddingInPixels, inDum, outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::DisplayRect ignore error %d", err ) + } + + return value; + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetTagL(const TDesC8& aTag) + { + ASSERT(iData); + + delete iData->iTag; + iData->iTag = 0; + + iData->iTag = aTag.AllocL(); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CAlfVisual::IsTagged() const + { + return (iData && iData->iTag); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfVisual* CAlfVisual::FindTag(const TDesC8& aTag) + { + // Look for the tag in this visual's tag descriptor. + if(iData && iData->iTag && TagMatches(aTag)) + { + return this; + } + else + { + // Could not find it. + return NULL; + } + } + +// --------------------------------------------------------------------------- +// Returns comms module for accessing the client-server APIs. +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfGenComponent* CAlfVisual::Comms() const + { + ASSERT(iData); + return iData->iComms; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +TBool CAlfVisual::TagMatches(const TDesC8& aTag) const + { + if(!aTag.Length() || !iData || !iData->iTag ) + { + // No tag specified; doesn't match anything. + return EFalse; + } + + TPtrC8 region = iData->iTag->Des(); + TPtrC8 tag; + TInt index = 0; + + while(region.Length() > 0) + { + // Is there a colon in the region? + index = region.Locate(KAlfTagSeparator); + if(index != KErrNotFound) + { + // A separator exists in the region. + tag.Set(region.Left(index)); + region.Set(region.Right(region.Length() - index - 1)); + } + else + { + tag.Set(region); + region.Set(region.Right(0)); + } + + if(!tag.Compare(aTag)) + { + // Matches. + return ETrue; + } + } + + // No match could be found. + return EFalse; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfTimedValue CAlfVisual::DepthOffset() const + { + TBufC8<1> inDum; + TAlfTimedValue value; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualDepthOffset, inDum, + outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::DepthOffset ignore error %d", err ) + } + return value; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetDepthOffset(const TAlfTimedValue& aDepthOffset) + { + TPckgC inPckg(aDepthOffset); + TInt err = Comms()->DoCmdNoReply(EAlfVisualSetDepthOffset, inPckg ); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::SetDepthOffset ignore error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfControl& CAlfVisual::Owner() const + { + return *iData->iOwner; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetOwner(CAlfControl& aOwner) + { + iData->iOwner = &aOwner; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetOrigin(TAlfVisualHOrigin aHoriz, + TAlfVisualVOrigin aVert) + { + ClearFlags(EAlfVisualFlagHOriginCenter | EAlfVisualFlagHOriginRight); + switch(aHoriz) + { + case EAlfVisualHOriginCenter: + SetFlag(EAlfVisualFlagHOriginCenter); + break; + + case EAlfVisualHOriginRight: + SetFlag(EAlfVisualFlagHOriginRight); + break; + + default: + break; + } + + ClearFlags(EAlfVisualFlagVOriginCenter | EAlfVisualFlagVOriginBottom); + switch(aVert) + { + case EAlfVisualVOriginCenter: + SetFlag(EAlfVisualFlagVOriginCenter); + break; + + case EAlfVisualVOriginBottom: + SetFlag(EAlfVisualFlagVOriginBottom); + break; + + default: + break; + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfVisualHOrigin CAlfVisual::HorizontalOrigin() const + { + TUint flags = Flags(); + if(flags & EAlfVisualFlagHOriginCenter) + { + return EAlfVisualHOriginCenter; + } + if(flags & EAlfVisualFlagHOriginRight) + { + return EAlfVisualHOriginRight; + } + return EAlfVisualHOriginLeft; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfVisualVOrigin CAlfVisual::VerticalOrigin() const + { + TUint flags = Flags(); + if(flags & EAlfVisualFlagVOriginCenter) + { + return EAlfVisualVOriginCenter; + } + if(flags & EAlfVisualFlagVOriginBottom) + { + return EAlfVisualVOriginBottom; + } + return EAlfVisualVOriginTop; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::AlignByOrigin(TAlfRealRect& aRect) const + { + switch(HorizontalOrigin()) + { + case EAlfVisualHOriginCenter: + aRect.Move(-aRect.Width()/2.0, 0.0); + break; + + case EAlfVisualHOriginRight: + aRect.Move(-aRect.Width(), 0.0); + break; + + default: + break; + } + + switch(VerticalOrigin()) + { + case EAlfVisualVOriginCenter: + aRect.Move(0.0, -aRect.Height()/2.0); + break; + + case EAlfVisualVOriginBottom: + aRect.Move(0.0, -aRect.Height()); + break; + + default: + break; + } + } + +// --------------------------------------------------------------------------- +// deprecated +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetMinSize(const TSize& aMinSize) + { + TPckgC inPckg(aMinSize); + TInt err = Comms()->DoCmdNoReply(EAlfVisualSetMinSize, inPckg ); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::SetMinSize ignore error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetMinSize(const TAlfRealSize& aMinSize) + { + TPckgC inPckg(aMinSize); + TInt err = Comms()->DoCmdNoReply(EAlfVisualSetMinSizeInBaseUnits, inPckg ); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::SetMinSize ignore error %d", err ) + } + } + + +// --------------------------------------------------------------------------- +// deprecated +// --------------------------------------------------------------------------- +// +EXPORT_C TSize CAlfVisual::MinSize() const + { + TBufC8<1> inDum; + TSize value; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualGetMinSize, inDum, + outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::MinSize ignore error %d", err ) + } + + return value; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfRealSize CAlfVisual::MinSizeInBaseUnits() const + { + TBufC8<1> inDum; + TAlfRealSize value; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualGetMinSizeInBaseUnits, inDum, + outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::MinSizeInBaseUnit ignore error %d", err ) + } + + return value; + } + +// --------------------------------------------------------------------------- +// deprecated +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetMaxSize(const TSize& aMaxSize) + { + TPckgC inPckg(aMaxSize); + TInt err = Comms()->DoCmdNoReply(EAlfVisualSetMaxSize, inPckg); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::SetMaxSize ignore error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetMaxSize(const TAlfRealSize& aMaxSize) + { + TPckgC inPckg(aMaxSize); + TInt err = Comms()->DoCmdNoReply(EAlfVisualSetMaxSizeInBaseUnits, inPckg); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::SetMaxSize ignore error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// deprecated +// --------------------------------------------------------------------------- +// +EXPORT_C TSize CAlfVisual::MaxSize() const + { + TBufC8<1> inDum; + TSize value; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualGetMaxSize, inDum, + outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::MaxSize ignore error %d", err ) + } + + return value; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfRealSize CAlfVisual::MaxSizeInBaseUnits() const + { + TBufC8<1> inDum; + TAlfRealSize value; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualGetMaxSizeInBaseUnits, inDum, + outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::MaxSizeInBaseUnits ignore error %d", err ) + } + + return value; + } + + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetRect(const TAlfRealRect& aRect, TInt aTransitionTime) + { + SetPos(aRect.iTl, aTransitionTime); + SetSize(TAlfRealSize(aRect.Size().iWidth, aRect.Size().iHeight), + aTransitionTime); + } + +// --------------------------------------------------------------------------- +// deprecated +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::Move(const TPoint& aOffset, TInt aTransitionTime) + { + TAlfTimedPoint pos = Pos(); + TReal32 xpos = pos.Target().iX + aOffset.iX; + TReal32 ypos = pos.Target().iY + aOffset.iY; + TAlfRealPoint newPos(xpos, ypos); + SetPos(newPos, aTransitionTime); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::Move(const TAlfRealPoint& aOffset, TInt aTransitionTime) + { + TAlfVisualPos pos = { aOffset, aTransitionTime }; + + TPckgC buf(pos); + + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualMove, buf ); + + if (err) + { + __ALFLOGSTRING1( "CAlfVisual::Move ignore error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::Mimic(CAlfVisual& aVisual, TInt aTransitionTime) + { + SetPos(aVisual.Pos().Target(), aTransitionTime); + SetSize(aVisual.Size().Target(), aTransitionTime); + } + +// --------------------------------------------------------------------------- +// deprecated +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetCenteredPosAndSize(const TPoint& aCenterPoint, + const TSize& aSize, + TInt aTransitionTime) + { + SetPos(TPoint(aCenterPoint.iX - aSize.iWidth/2, + aCenterPoint.iY - aSize.iHeight/2), aTransitionTime); + SetSize(aSize, aTransitionTime); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetCenteredPosAndSize(const TAlfRealPoint& aCenterPoint, + const TAlfRealSize& aSize, + TInt aTransitionTime) + { + TAlfVisualPosSize posSize = { aCenterPoint, aSize, aTransitionTime }; + + TPckgC buf(posSize); + + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetCenteredPosAndSize, buf); + + if (err) + { + __ALFLOGSTRING1( "CAlfVisual::SetCenteredPosAndSize ignore error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TAlfRealRect CAlfVisual::DisplayRect() const + { + TBufC8<1> inDum; + TAlfRealRect value; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualDisplayRect, inDum, outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::DisplayRect ignore error %d", err ) + } + + return value; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TReal32 CAlfVisual::EffectiveOpacity() const __SOFTFP + { + // We could do this locally, but because Opacity()-method calls anyway + // server we do one server call here instead of multiple Opacity()-calls. + TBufC8<1> inDum; + TReal32 value = 1.0; + TPckg outBuf(value); + TInt err = Comms()->DoSynchronousCmd(EAlfVisualEffectiveOpacity, inDum, + outBuf); + + if ( err ) + { + __ALFLOGSTRING1( "CAlfVisual::EffectiveOpacity ignore error %d", err ) + } + + return value; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetClipping(TBool aClipping) + { + if(aClipping) + { + SetFlag(EAlfVisualFlagClipping); + } + else + { + ClearFlag(EAlfVisualFlagClipping); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CAlfVisual::Clipping() const + { + return (Flags() & EAlfVisualFlagClipping) != 0; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TPoint CAlfVisual::Padding() const + { + AssertPaddingsWereSetUsingDeprecatedPixelAPIs(iData->iPadding); + return TPoint(iData->iPadding.iLeft.iMagnitude, iData->iPadding.iTop.iMagnitude); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C const TAlfBoxMetric& CAlfVisual::PaddingAsMetric() const + { + return iData->iPadding; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CAlfVisual::HorizontalPadding() const + { + AssertPaddingsWereSetUsingDeprecatedPixelAPIs(iData->iPadding); + return iData->iPadding.iLeft.iMagnitude; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CAlfVisual::VerticalPadding() const + { + AssertPaddingsWereSetUsingDeprecatedPixelAPIs(iData->iPadding); + return iData->iPadding.iTop.iMagnitude; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +void CAlfVisual::SetDisplay(CAlfDisplay* aDisplay) + { + iData->iDisplay = aDisplay; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetPos(const TAlfTimedPoint& aPos) + { + TPckgC buf(aPos); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetPosTimed, buf); + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::SetPos panic error %d", err ) + USER_INVARIANT(); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetSize(const TAlfTimedPoint& aSize) + { + TPckgC buf(aSize); + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualSetSizeTimed, buf ); + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::SetSize panic error %d", err ) + USER_INVARIANT(); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TInt CAlfVisual::CopyValues(const CAlfVisual& aVisual, TInt aBitmask, TInt aTransitionTime ) + { + if (aVisual.Identifier()) + { + return KErrArgument; + } + + TInt3 inData(aVisual.Identifier(),aBitmask,aTransitionTime); + TPckgC inPckg(inData); + TBuf8<1> dum; + + return iData->iComms->DoSynchronousCmd( EAlfVisualCopyValuesFromOtherVisual, inPckg, dum ); + } + +// --------------------------------------------------------------------------- +// future proofing +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::PropertyOwnerExtension(const TUid& aExtensionUid, TAny** aExtensionParams) + { + CAlfPropertyOwner::PropertyOwnerExtension(aExtensionUid,aExtensionParams); + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetTactileFeedbackL( TInt aEventType, TInt aFeedbackType ) + { + __ASSERT_ALWAYS( aFeedbackType >= 0, USER_INVARIANT() ); + __ASSERT_ALWAYS( aEventType >= 0, USER_INVARIANT() ); + + TInt2 inData(aEventType,aFeedbackType); + TPckgC inPckg(inData); + TBuf8<1> dum; + + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualSetTactileFeedback, inPckg, dum ); + + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::SetTactileFeedbackL leave error %d", err ) + User::Leave( err ); + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C TBool CAlfVisual::HasTactileFeedback( TInt aEventType ) const + { + TInt inData(aEventType); + TPckgC inPckg(inData); + + TBool answer = EFalse; + TPckg outPckg(answer); + + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualHasTactileFeedback, inPckg, outPckg ); + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::HasTactileFeedback ignore error %d", err ) + } + return answer; + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::RemoveTactileFeedback( TInt aEventType ) + { + TInt inData(aEventType); + TPckgC inPckg(inData); + + TInt err = iData->iComms->DoCmdNoReply( EAlfVisualRemoveTactileFeedback, inPckg ); + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::RemoveTactileFeedback ignore error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::Pause(TInt aPropertiesBitmask) + { + TPckgC inPckg(aPropertiesBitmask); + TBuf8<1> dum; + + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualPauseProperties, inPckg, dum ); + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::Pause ignored error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::Resume(TInt aPropertiesBitmask) + { + TPckgC inPckg(aPropertiesBitmask); + TBuf8<1> dum; + + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualResumeProperties, inPckg, dum ); + if ( err != KErrNone ) + { + __ALFLOGSTRING1( "CAlfVisual::Resume ignored error %d", err ) + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::EnableDropShadowL( TBool aEnable ) + { + if ( aEnable && !iData->iDropShadowHandler ) + { + // create instance. + CAlfDropShadow* dropShadowHandler = CAlfDropShadow::NewL( *Comms() ); + + TPckgC inPckg(aEnable); + TBuf8<1> dum; + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualEnableDropShadow, inPckg, dum ); + + if (err!=KErrNone) + { + __ALFLOGSTRING1( "CAlfVisual::EnableDropShadowL leave error %d", err ) + delete dropShadowHandler; + User::Leave( err ); + } + iData->iDropShadowHandler = dropShadowHandler; + } + else if ( !aEnable && iData->iDropShadowHandler ) + { + // delete the instance. + TPckgC inPckg(aEnable); + TBuf8<1> dum; + TInt err = iData->iComms->DoSynchronousCmd( EAlfVisualEnableDropShadow, inPckg, dum ); + + if (err!=KErrNone) + { + __ALFLOGSTRING1( "CAlfVisual::EnableDropShadowL leave error %d", err ) + User::Leave( err ); + } + + delete iData->iDropShadowHandler; + iData->iDropShadowHandler = NULL; + } + else + { + // For PC lint + } + } + +// --------------------------------------------------------------------------- +// +// --------------------------------------------------------------------------- +// +EXPORT_C CAlfDropShadow* CAlfVisual::DropShadowHandler() const + { + return iData->iDropShadowHandler; + } + +EXPORT_C void CAlfVisual::SetEffectL( const TDesC& aEffectFile ) + { + TBuf8<1> dumDum; + TAlfVisualEffectParams params; + params.iFileName = aEffectFile; + + TPckg paramsPckg(params); + + TInt err = KErrNone; + if ( aEffectFile.Length() == 0 ) + { + err = iData->iComms->DoSynchronousCmd(EAlfVisualRemoveEffect, paramsPckg, dumDum); + } + else + { + err = iData->iComms->DoSynchronousCmd(EAlfVisualSetEffect, paramsPckg, dumDum); + } + if (err) + { + __ALFLOGSTRING1( "CAlfVisual::SetEffectL leave error %d", err ) + User::Leave( err ); + } + } + +// --------------------------------------------------------------------------- +// SetGroupEffectL +// --------------------------------------------------------------------------- +// +EXPORT_C void CAlfVisual::SetGroupEffectL( const TDesC& aEffectFile, TInt aGroupHandle ) + { + TBuf8<1> dumDum; + TAlfVisualEffectParams params; + params.iFileName = aEffectFile; + params.iGroupHandle = aGroupHandle; + + TPckg paramsPckg(params); + + TInt err = KErrNone; + if ( aEffectFile.Length() == 0 ) + { + err = iData->iComms->DoSynchronousCmd(EAlfVisualRemoveEffect, paramsPckg, dumDum); + } + else + { + err = iData->iComms->DoSynchronousCmd(EAlfVisualSetGroupEffect, paramsPckg, dumDum); + } + if (err) + { + __ALFLOGSTRING1( "CAlfVisual::SetGroupEffectL leave error %d", err ) + User::Leave( err ); + } + } +