Change HuiStatic.cpp to avoid VFP instructions in the static initialiser - avoids Bug 3937
/*
* 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 <uiacceltk/HuiUtil.h>
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<TAlfTimedValue> 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<TAlfTimedValue> 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<TAlfTimedPoint> 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<TAlfVisualPos> 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<TAlfTimedPoint> 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<TAlfVisualSize> 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<TAlfVisualFlags> 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<TUint> 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<TAlfVisualFlags> 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<TUint> 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<TUint> 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<TInt> 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<TAlfRealPoint> pointPckg(aPoint);
TAlfRealPoint result;
TPckg<TAlfRealPoint> 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<TAlfRealPoint> pointPckg(aPoint);
TAlfRealPoint result;
TPckg<TAlfRealPoint> 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<TAlfRealRect> 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<TInt2> 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<TInt> 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<TPoint> 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<TAlfBoxMetric> 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<TAlfRealRect> 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<TAlfTimedValue> 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<TAlfTimedValue> 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<TSize> 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<TAlfRealSize> 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<TSize> 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<TAlfRealSize> 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<TSize> 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<TAlfRealSize> 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<TSize> 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<TAlfRealSize> 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<TAlfVisualPos> 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<TAlfVisualPosSize> 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<TAlfRealRect> 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<TReal32> 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<TAlfTimedPoint> 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<TAlfTimedPoint> 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<TInt3> 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<TInt2> 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<TInt> inPckg(inData);
TBool answer = EFalse;
TPckg<TBool> 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<TInt> 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<TInt> 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<TInt> 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<TBool> 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<TBool> 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;
params.iHandle = Identifier();
TPckg<TAlfVisualEffectParams> 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;
params.iHandle = Identifier();
TPckg<TAlfVisualEffectParams> 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 );
}
}