--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/uiacceltk/hitchcock/coretoolkit/src/HuiCommand.cpp Tue Feb 02 07:56:43 2010 +0200
@@ -0,0 +1,829 @@
+/*
+* Copyright (c) 2006-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: Implementation of THuiCommand and derived command classes.
+*
+*/
+
+
+
+#include "uiacceltk/HuiCommand.h" // Class definition
+#include "uiacceltk/HuiStatic.h"
+#include "uiacceltk/HuiEnv.h"
+#include "uiacceltk/HuiScheduler.h"
+#include "uiacceltk/huieventhandler.h"
+#include "uiacceltk/HuiDisplay.h"
+#include "uiacceltk/HuiEvent.h"
+#include "uiacceltk/HuiControlGroup.h"
+#include "uiacceltk/HuiVisuals.h"
+#include "uiacceltk/HuiTransformation.h"
+#include "uiacceltk/HuiUtil.h"
+
+
+THuiCommand::THuiCommand(THuiCommandType aType)
+ : iType(aType), iSenderType(EHuiCommandObjectTypeNone), iSender(NULL)
+ {
+ }
+
+
+EXPORT_C THuiCommand::~THuiCommand()
+ {
+ iSender = NULL;
+ }
+
+
+EXPORT_C void THuiCommand::SetSender(THuiCommandObjectType aType, TAny* aSender)
+ {
+ iSenderType = aType;
+ iSender = aSender;
+ }
+
+
+EXPORT_C THuiCommandType THuiCommand::Type() const
+ {
+ return iType;
+ }
+
+
+EXPORT_C const THuiObjectCommand* THuiCommand::ObjectCommand() const
+ {
+ return NULL;
+ }
+
+
+EXPORT_C THuiCommandObjectType THuiCommand::SenderType() const
+ {
+ return iSenderType;
+ }
+
+
+EXPORT_C TAny* THuiCommand::Sender() const
+ {
+ return iSender;
+ }
+
+
+EXPORT_C CHuiVisual* THuiCommand::SenderVisual() const
+ {
+ if(iSenderType == EHuiCommandObjectTypeVisual)
+ {
+ return reinterpret_cast<CHuiVisual*>(iSender);
+ }
+ return NULL;
+ }
+
+
+EXPORT_C CHuiControl* THuiCommand::SenderControl() const
+ {
+ if(iSenderType == EHuiCommandObjectTypeControl)
+ {
+ return reinterpret_cast<CHuiControl*>(iSender);
+ }
+ return NULL;
+ }
+
+
+EXPORT_C CHuiControlGroup* THuiCommand::SenderControlGroup() const
+ {
+ if(iSenderType == EHuiCommandObjectTypeControlGroup)
+ {
+ return reinterpret_cast<CHuiControlGroup*>(iSender);
+ }
+ return NULL;
+ }
+
+EXPORT_C void THuiCommand::CommandExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParams*/)
+ {
+ }
+
+EXPORT_C THuiActionCommand::THuiActionCommand(TInt aId)
+ : THuiCommand(EHuiCommandTypeAction), iId(aId)
+ {
+ }
+
+
+EXPORT_C void THuiActionCommand::ExecuteL(CHuiEnv& aEnv) const
+ {
+ TInt error = aEnv.ReportAction(*this);
+ if(error != KErrNone)
+ {
+ // Leave with the error code if one of the observers failed.
+ User::Leave(error);
+ }
+ }
+
+
+EXPORT_C TInt THuiActionCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C TInt THuiActionCommand::Id() const
+ {
+ return iId;
+ }
+
+EXPORT_C void THuiActionCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+THuiObjectCommand::THuiObjectCommand(THuiCommandType aType, TAny* aDataOwnerObject, THuiOp aOperation)
+ : THuiCommand(aType), iObject(aDataOwnerObject), iOperation(aOperation)
+ {
+ }
+
+
+EXPORT_C TAny* THuiObjectCommand::Object() const
+ {
+ return iObject;
+ }
+
+
+EXPORT_C THuiOp THuiObjectCommand::Operation() const
+ {
+ return iOperation;
+ }
+
+EXPORT_C TInt THuiObjectCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C const THuiObjectCommand* THuiObjectCommand::ObjectCommand() const
+ {
+ // All object commands can be casted to THuiObjectCommand.
+ return this;
+ }
+
+EXPORT_C void THuiObjectCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ HUI_DEBUG1(_L("THuiObjectCommand::ExecuteL() - Unknown op %i."), Operation());
+ }
+
+EXPORT_C void THuiObjectCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiGroupCommand::THuiGroupCommand(CHuiControlGroup& aGroup, THuiOp aOperation,
+ CHuiDisplay* aDisplay)
+ : THuiObjectCommand(EHuiCommandTypeGroup, &aGroup, aOperation),
+ iDisplay(aDisplay)
+ {
+ }
+
+
+EXPORT_C void THuiGroupCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EHuiOpShow:
+ if(iDisplay)
+ {
+ iDisplay->Roster().ShowL(ControlGroup());
+ }
+ break;
+
+ case EHuiOpHide:
+ if(iDisplay)
+ {
+ iDisplay->Roster().Hide(ControlGroup());
+ }
+ break;
+
+ case EHuiOpEnableInput:
+ ControlGroup().SetAcceptInput(ETrue);
+ break;
+
+ case EHuiOpDisableInput:
+ ControlGroup().SetAcceptInput(EFalse);
+ break;
+
+ default:
+ HUI_DEBUG1(_L("THuiGroupCommand::ExecuteL() - Unknown op %i."), Operation());
+ break;
+ }
+ }
+
+
+EXPORT_C TInt THuiGroupCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CHuiControlGroup& THuiGroupCommand::ControlGroup() const
+ {
+ return *static_cast<CHuiControlGroup*>(Object());
+ }
+
+
+EXPORT_C CHuiDisplay* THuiGroupCommand::Display() const
+ {
+ return iDisplay;
+ }
+
+EXPORT_C void THuiGroupCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiControlCommand::THuiControlCommand(CHuiControl& aControl, THuiOp aOperation)
+ : THuiObjectCommand(EHuiCommandTypeControl, &aControl, aOperation)
+ {
+ }
+
+
+EXPORT_C void THuiControlCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ HUI_DEBUG1(_L("THuiControlCommand::ExecuteL() - Unknown op %i."), Operation());
+ }
+
+
+EXPORT_C TInt THuiControlCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CHuiControl& THuiControlCommand::Control() const
+ {
+ return *static_cast<CHuiControl*>(Object());
+ }
+
+EXPORT_C void THuiControlCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiVisualCommand::THuiVisualCommand(CHuiVisual& aVisual, THuiOp aOperation,
+ TInt aSetFlags, TInt aClearFlags)
+ : THuiObjectCommand(EHuiCommandTypeVisual, &aVisual, aOperation),
+ iSetFlags(aSetFlags), iClearFlags(aClearFlags)
+ {
+ }
+
+
+EXPORT_C void THuiVisualCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EHuiOpRemoveAndDestroyAll:
+ Visual().RemoveAndDestroyAllD();
+ // The object is no longer valid after this.
+ break;
+ case EHuiOpEnableTransformation:
+ HUI_DEBUG(_L("THuiVisualCommand::ExecuteL() -- Enable transformation."));
+ Visual().EnableTransformationL(ETrue);
+ break;
+
+ case EHuiOpDisableTransformation:
+ HUI_DEBUG(_L("THuiVisualCommand::ExecuteL() -- Disable transformation."));
+ Visual().EnableTransformationL(EFalse);
+ break;
+
+ case EHuiOpModifyFlags:
+ if(iSetFlags)
+ {
+ Visual().SetFlags(iSetFlags);
+ }
+ if(iClearFlags)
+ {
+ Visual().ClearFlags(iClearFlags);
+ }
+ break;
+
+ default:
+ HUI_DEBUG1(_L("THuiVisualCommand::ExecuteL() - Unknown op %i."), Operation());
+ break;
+ }
+ }
+
+
+EXPORT_C TInt THuiVisualCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CHuiVisual& THuiVisualCommand::Visual() const
+ {
+ return *static_cast<CHuiVisual*>(Object());
+ }
+
+
+EXPORT_C TInt THuiVisualCommand::FlagsToSet() const
+ {
+ return iSetFlags;
+ }
+
+
+EXPORT_C TInt THuiVisualCommand::FlagsToClear() const
+ {
+ return iClearFlags;
+ }
+
+EXPORT_C void THuiVisualCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiImageCommand::THuiImageCommand(CHuiImageVisual& aImageVisual,
+ const THuiImage& aImage,
+ THuiOp aOperation)
+ : THuiObjectCommand(EHuiCommandTypeImage, &aImageVisual, aOperation),
+ iImage(aImage)
+ {
+ }
+
+
+EXPORT_C void THuiImageCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EHuiOpSetPrimaryImage:
+ ImageVisual().SetImage(iImage);
+ break;
+
+ case EHuiOpSetSecondaryImage:
+ ImageVisual().SetSecondaryImage(iImage);
+ break;
+
+ default:
+ HUI_DEBUG1(_L("THuiImageCommand::ExecuteL() - Unknown op %i."), Operation());
+ break;
+ }
+ }
+
+
+EXPORT_C TInt THuiImageCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CHuiImageVisual& THuiImageCommand::ImageVisual() const
+ {
+ return *static_cast<CHuiImageVisual*>( Object() );
+ }
+
+
+EXPORT_C const THuiImage& THuiImageCommand::Image() const
+ {
+ return iImage;
+ }
+
+EXPORT_C void THuiImageCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiTextCommand::THuiTextCommand(CHuiTextVisual& aTextVisual, const TDesC& aText,
+ THuiOp aOperation)
+ : THuiObjectCommand(EHuiCommandTypeText, &aTextVisual, aOperation),
+ iText(aText)
+ {
+ }
+
+
+EXPORT_C void THuiTextCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EHuiOpSetText:
+ TextVisual().SetTextL(iText);
+ break;
+
+ default:
+ HUI_DEBUG1(_L("THuiTextCommand::ExecuteL() - Unknown op %i."), Operation());
+ break;
+ }
+ }
+
+
+EXPORT_C TInt THuiTextCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CHuiTextVisual& THuiTextCommand::TextVisual() const
+ {
+ return *static_cast<CHuiTextVisual*>( Object() );
+ }
+
+
+EXPORT_C const TDesC& THuiTextCommand::Text() const
+ {
+ return iText;
+ }
+
+EXPORT_C void THuiTextCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiValueCommand::THuiValueCommand(TAny* aOwner, THuiTimedValue& aValue,
+ TReal32 aTarget, TInt aTransitionTime) __SOFTFP
+ : THuiObjectCommand(EHuiCommandTypeValue, aOwner, EHuiOpSet),
+ iTimedValue(aValue), iTarget(aTarget), iTransitionTime(aTransitionTime),
+ iSpeed(0.0)
+ {
+ }
+
+
+EXPORT_C THuiValueCommand::THuiValueCommand(TAny* aOwner, THuiTimedValue& aValue,
+ THuiOp aOperation,
+ TReal32 aTarget, TReal32 aTiming) __SOFTFP
+ : THuiObjectCommand(EHuiCommandTypeValue, aOwner, aOperation),
+ iTimedValue(aValue), iTarget(aTarget), iTransitionTime(0),
+ iSpeed(0.0)
+ {
+ if(aOperation == EHuiOpSetWithSpeed)
+ {
+ iSpeed = aTiming;
+ }
+ else
+ {
+ iTransitionTime = TInt(aTiming);
+ }
+ }
+
+
+EXPORT_C void THuiValueCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ // Check for interpolation style change ops.
+ TInt op = Operation();
+ if(op >= EHuiOpSetStyle && op < EHuiOpSetStyle + EHuiTimedValueStyleLast)
+ {
+ iTimedValue.SetStyle(THuiInterpolationStyle(op - EHuiOpSetStyle));
+ }
+
+ switch(Operation())
+ {
+ case EHuiOpSet:
+ iTimedValue.Set(iTarget, iTransitionTime);
+ break;
+
+ case EHuiOpSetWithSpeed:
+ iTimedValue.SetWithSpeed(iTarget, iSpeed);
+ break;
+
+ default:
+ HUI_DEBUG1(_L("THuiValueCommand::ExecuteL() - Unknown op %i."), Operation());
+ break;
+ }
+ }
+
+
+EXPORT_C TInt THuiValueCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C THuiTimedValue& THuiValueCommand::TimedValue() const
+ {
+ return iTimedValue;
+ }
+
+
+EXPORT_C TReal32 THuiValueCommand::Target() const __SOFTFP
+ {
+ return iTarget;
+ }
+
+
+EXPORT_C TInt THuiValueCommand::TransitionTime() const
+ {
+ return iTransitionTime;
+ }
+
+
+EXPORT_C TReal32 THuiValueCommand::Speed() const __SOFTFP
+ {
+ return iSpeed;
+ }
+
+EXPORT_C void THuiValueCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiPointCommand::THuiPointCommand(TAny* aOwner, THuiTimedPoint& aPoint,
+ THuiOp aOperation)
+ : THuiObjectCommand(EHuiCommandTypePoint, aOwner, aOperation),
+ iTimedPoint(aPoint), iTransitionTime(0), iSpeed(0.0)
+ {
+ }
+
+
+EXPORT_C THuiPointCommand::THuiPointCommand(TAny* aOwner, THuiTimedPoint& aPoint,
+ THuiRealPoint aTarget, TInt aTransitionTime) __SOFTFP
+ : THuiObjectCommand(EHuiCommandTypePoint, aOwner, EHuiOpSet),
+ iTimedPoint(aPoint), iTarget(aTarget),
+ iTransitionTime(aTransitionTime), iSpeed(0.0)
+ {
+ }
+
+
+EXPORT_C THuiPointCommand::THuiPointCommand(TAny* aOwner, THuiTimedPoint& aPoint,
+ THuiOp aOperation,
+ THuiRealPoint aTarget, TReal32 aTiming) __SOFTFP
+ : THuiObjectCommand(EHuiCommandTypePoint, aOwner, aOperation),
+ iTimedPoint(aPoint), iTarget(aTarget),
+ iTransitionTime(0), iSpeed(0.0)
+ {
+ if(aOperation == EHuiOpSetWithSpeed)
+ {
+ iSpeed = aTiming;
+ }
+ else
+ {
+ iTransitionTime = TInt(aTiming);
+ }
+ }
+
+
+EXPORT_C void THuiPointCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ // Check for interpolation style change ops.
+ TInt op = Operation();
+ if(op >= EHuiOpSetStyle && op < EHuiOpSetStyle + EHuiTimedValueStyleLast)
+ {
+ iTimedPoint.SetStyle(THuiInterpolationStyle(op - EHuiOpSetStyle));
+ }
+
+ switch(Operation())
+ {
+ case EHuiOpSet:
+ iTimedPoint.Set(iTarget, iTransitionTime);
+ break;
+
+ case EHuiOpSetWithSpeed:
+ iTimedPoint.SetWithSpeed(iTarget, iSpeed);
+ break;
+
+ default:
+ HUI_DEBUG1(_L("THuiPointCommand::ExecuteL() - Unknown op %i."), Operation());
+ break;
+ }
+ }
+
+
+EXPORT_C TInt THuiPointCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C THuiTimedPoint& THuiPointCommand::TimedPoint() const
+ {
+ return iTimedPoint;
+ }
+
+
+EXPORT_C THuiRealPoint THuiPointCommand::Target() const __SOFTFP
+ {
+ return iTarget;
+ }
+
+
+EXPORT_C TInt THuiPointCommand::TransitionTime() const
+ {
+ return iTransitionTime;
+ }
+
+
+EXPORT_C TReal32 THuiPointCommand::Speed() const __SOFTFP
+ {
+ return iSpeed;
+ }
+
+EXPORT_C void THuiPointCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiTransformationCommand::THuiTransformationCommand(
+ TAny* aOwner, CHuiTransformation& aTransformation, THuiOp aOperation, TInt aStep)
+ : THuiObjectCommand(EHuiCommandTypeTransformation, aOwner, aOperation),
+ iTransformation(aTransformation), iStep(aStep)
+ {
+ }
+
+
+EXPORT_C void THuiTransformationCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ switch(Operation())
+ {
+ case EHuiOpLoadIdentity:
+ iTransformation.LoadIdentity();
+ break;
+
+ case EHuiOpTranslate:
+ if(iStep != EStepNone)
+ {
+ CHuiTransformation::TTransform& xs = iTransformation.Step(iStep);
+ xs.iType = CHuiTransformation::ETypeTranslate;
+ xs.iParams[EHuiTransformParamTranslateX] = iX;
+ xs.iParams[EHuiTransformParamTranslateY] = iY;
+ xs.iParams[EHuiTransformParamTranslateZ] = iZ;
+ }
+ else
+ {
+ iTransformation.Translate(iX, iY);
+ }
+ break;
+
+ case EHuiOpScale:
+ if(iStep != EStepNone)
+ {
+ CHuiTransformation::TTransform& xs = iTransformation.Step(iStep);
+ xs.iType = CHuiTransformation::ETypeScale;
+ xs.iParams[EHuiTransformParamScaleX] = iX;
+ xs.iParams[EHuiTransformParamScaleY] = iY;
+ xs.iParams[EHuiTransformParamScaleZ] = iZ;
+ }
+ else
+ {
+ iTransformation.Scale(iX, iY, iZ);
+ }
+ break;
+
+ case EHuiOpRotate:
+ if(iStep != EStepNone)
+ {
+ CHuiTransformation::TTransform& xs = iTransformation.Step(iStep);
+ xs.iType = CHuiTransformation::ETypeRotate;
+ xs.iParams[EHuiTransformParamRotateAngle] = iAngle;
+ xs.iParams[EHuiTransformParamRotateAxisX] = iX;
+ xs.iParams[EHuiTransformParamRotateAxisY] = iY;
+ xs.iParams[EHuiTransformParamRotateAxisZ] = iZ;
+ }
+ else
+ {
+ THuiTimedValue unsuspended;
+ unsuspended = iX;
+ TReal32 x = unsuspended.Now();
+ unsuspended = iY;
+ TReal32 y = unsuspended.Now();
+ unsuspended = iZ;
+ TReal32 z = unsuspended.Now();
+ iTransformation.Rotate(iAngle, x, y, z);
+ }
+ break;
+
+ default:
+ HUI_DEBUG1(_L("THuiTransformationCommand::ExecuteL() - Unknown op %i."), Operation());
+ break;
+ }
+ }
+
+
+EXPORT_C TInt THuiTransformationCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C CHuiTransformation& THuiTransformationCommand::Transformation() const
+ {
+ return iTransformation;
+ }
+
+
+EXPORT_C TInt THuiTransformationCommand::Step() const
+ {
+ return iStep;
+ }
+
+
+EXPORT_C void THuiTransformationCommand::SetX(const THuiTimedValue& aValue)
+ {
+ iX = aValue;
+ iX.Suspend();
+ }
+
+
+EXPORT_C void THuiTransformationCommand::SetY(const THuiTimedValue& aValue)
+ {
+ iY = aValue;
+ iY.Suspend();
+ }
+
+
+EXPORT_C void THuiTransformationCommand::SetZ(const THuiTimedValue& aValue)
+ {
+ iZ = aValue;
+ iZ.Suspend();
+ }
+
+
+EXPORT_C void THuiTransformationCommand::SetAngle(const THuiTimedValue& aValue)
+ {
+ iAngle = aValue;
+ iAngle.Suspend();
+ }
+
+EXPORT_C void THuiTransformationCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiMarkerCommand::THuiMarkerCommand(TInt aId)
+ : THuiCommand(THuiCommandType(EHuiCommandTypeMarkerFirst + aId))
+ {
+ }
+
+
+EXPORT_C void THuiMarkerCommand::ExecuteL(CHuiEnv& /*aEnv*/) const
+ {
+ HUI_DEBUG1(_L("THuiMarkerCommand::ExecuteL() - Marker %i reached."), Id());
+ }
+
+
+EXPORT_C TInt THuiMarkerCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C TInt THuiMarkerCommand::Id() const
+ {
+ return Type() - EHuiCommandTypeMarkerFirst;
+ }
+
+EXPORT_C void THuiMarkerCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+
+
+EXPORT_C THuiCustomEventCommand::THuiCustomEventCommand(TInt aEventParam, MHuiEventHandler* aRecipient)
+ : THuiObjectCommand(EHuiCommandTypeCustomEvent, aRecipient, EHuiOpNone),
+ iEventParam(aEventParam)
+ {
+ }
+
+
+EXPORT_C void THuiCustomEventCommand::ExecuteL(CHuiEnv& aEnv) const
+ {
+ THuiEvent customEvent(iEventParam);
+
+ if(Recipient())
+ {
+ Recipient()->OfferEventL(customEvent);
+ }
+ else
+ {
+ aEnv.BroadcastEventL(customEvent);
+ }
+ }
+
+
+EXPORT_C TInt THuiCustomEventCommand::Size() const
+ {
+ return sizeof(*this);
+ }
+
+
+EXPORT_C MHuiEventHandler* THuiCustomEventCommand::Recipient() const
+ {
+ return static_cast<MHuiEventHandler*>( Object() );
+ }
+
+
+EXPORT_C TInt THuiCustomEventCommand::Param() const
+ {
+ return iEventParam;
+ }
+
+EXPORT_C void THuiCustomEventCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)
+ {
+ THuiObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );
+ }
+