1 /*

     2 * Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:   Implementation of the commands

    15 *

    16 */

    17 

    18 

    19 

    20 #include "alf/alfcommand.h"

    21 #include "alf/alfevent.h"

    22 #include "alf/alfcontrol.h"

    23 #include "alf/alfenv.h"

    24 #include "alf/alftextvisual.h"

    25 #include "alf/alfeventhandler.h"

    26 #include "alf/alfdisplay.h"

    27 #include "alf/alfroster.h"

    28 #include "alf/alfcontrolgroup.h"

    29 #include "alf/alfimagevisual.h"

    30 #include "alf/alftransformation.h"

    31 #include "alflogger.h"

    32 

    33 // ======== MEMBER FUNCTIONS ========

    34 

    35 

    36 EXPORT_C TAlfCommand::TAlfCommand(TAlfCommandType aType)

    37         : iType(aType)

    38     {

    39     }

    40 

    41 

    42 EXPORT_C TAlfCommand::~TAlfCommand()

    43     {

    44     }

    45 

    46 

    47 EXPORT_C TAlfCommandType TAlfCommand::Type() const

    48     {

    49     return iType;

    50     }

    51     

    52 EXPORT_C void TAlfCommand::CommandExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParams*/)

    53     {

    54     }

    55 

    56 

    57 EXPORT_C const TAlfObjectCommand* TAlfCommand::ObjectCommand() const

    58     {

    59     return NULL;

    60     }

    61 

    62 // GROUP COMMAND

    63 

    64 EXPORT_C TAlfGroupCommand::TAlfGroupCommand(CAlfControlGroup& aGroup, TAlfOp aOperation,

    65                                             CAlfDisplay* aDisplay)

    66         : TAlfObjectCommand(EAlfCommandTypeGroup, &aGroup, aOperation),

    67           iDisplay(aDisplay)

    68     {

    69     }

    70 

    71 

    72 EXPORT_C void TAlfGroupCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

    73     {

    74     __ALFLOGSTRING1( "TAlfGroupCommand::ExecuteL operation %d", Operation() )

    75     switch(Operation())

    76         {

    77         case EAlfOpShow:

    78             if(iDisplay)

    79                 {

    80                 iDisplay->Roster().ShowL(ControlGroup());

    81                 }

    82             break;

    83 

    84         case EAlfOpHide:

    85             if(iDisplay)

    86                 {

    87                 iDisplay->Roster().Hide(ControlGroup());

    88                 }

    89             break;

    90 

    91         case EAlfOpEnableInput:

    92             ControlGroup().SetAcceptInput(ETrue);

    93             break;

    94 

    95         case EAlfOpDisableInput:

    96             ControlGroup().SetAcceptInput(EFalse);

    97             break;

    98 

    99         default:

   100             __ALFLOGSTRING1( "TAlfGroupCommand::ExecuteL Unknown operation %d", Operation() )

   101             break;

   102         }

   103     }

   104 

   105 

   106 EXPORT_C TInt TAlfGroupCommand::Size() const

   107     {

   108     return sizeof(*this);

   109     }

   110 

   111 

   112 EXPORT_C CAlfControlGroup& TAlfGroupCommand::ControlGroup() const

   113     {

   114     return *(CAlfControlGroup*) Object();

   115     }

   116 

   117 

   118 EXPORT_C CAlfDisplay* TAlfGroupCommand::Display() const

   119     {

   120     return iDisplay;

   121     }

   122     

   123 EXPORT_C void TAlfGroupCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   124     {

   125     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   126     }

   127     

   128 // CONTROL COMMAND

   129 

   130 EXPORT_C TAlfControlCommand::TAlfControlCommand(CAlfControl& aControl, TAlfOp aOperation)

   131         : TAlfObjectCommand(EAlfCommandTypeControl, &aControl, aOperation)

   132     {

   133     }

   134 

   135 

   136 EXPORT_C void TAlfControlCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   137     {

   138     __ALFLOGSTRING1( "TAlfControlCommand::ExecuteL Unknown operation %d", Operation() )

   139     }

   140 

   141 

   142 EXPORT_C TInt TAlfControlCommand::Size() const

   143     {

   144     return sizeof(*this);

   145     }

   146 

   147 

   148 EXPORT_C CAlfControl& TAlfControlCommand::Control() const

   149     {

   150     return *(CAlfControl*) Object();

   151     }

   152     

   153 EXPORT_C void TAlfControlCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   154     {

   155     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   156     }

   157 

   158 // VISUAL COMMAND

   159 

   160 

   161 EXPORT_C TAlfVisualCommand::TAlfVisualCommand(CAlfVisual& aVisual, TAlfOp aOperation,

   162                                               TInt aSetFlags, TInt aClearFlags)

   163         : TAlfObjectCommand(EAlfCommandTypeVisual, &aVisual, aOperation),

   164           iSetFlags(aSetFlags), iClearFlags(aClearFlags)

   165     {

   166     }

   167 

   168 

   169 EXPORT_C void TAlfVisualCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   170     {

   171     switch(Operation())

   172         {

   173         case EAlfOpRemoveAndDestroyAll:

   174             Visual().RemoveAndDestroyAllD();

   175             // The object is no longer valid after this.

   176             break;

   177         case EAlfOpEnableTransformation:

   178             Visual().EnableTransformationL(ETrue);

   179             break;

   180 

   181         case EAlfOpDisableTransformation:

   182             Visual().EnableTransformationL(EFalse);

   183             break;

   184 

   185         case EAlfOpModifyFlags:

   186             if(iSetFlags)

   187                 {

   188                 Visual().SetFlags(iSetFlags);

   189                 }

   190             if(iClearFlags)

   191                 {

   192                 Visual().ClearFlags(iClearFlags);

   193                 }

   194             break;

   195 

   196         default:

   197             __ALFLOGSTRING1( "TAlfVisualCommand::ExecuteL Unknown operation %d", Operation() )

   198             break;

   199         }

   200     }

   201 

   202 

   203 EXPORT_C TInt TAlfVisualCommand::Size() const

   204     {

   205     return sizeof(*this);

   206     }

   207 

   208 

   209 EXPORT_C CAlfVisual& TAlfVisualCommand::Visual() const

   210     {

   211     return *(CAlfVisual*) Object();

   212     }

   213 

   214 

   215 EXPORT_C TInt TAlfVisualCommand::FlagsToSet() const

   216     {

   217     return iSetFlags;

   218     }

   219 

   220 

   221 EXPORT_C TInt TAlfVisualCommand::FlagsToClear() const

   222     {

   223     return iClearFlags;

   224     }

   225     

   226 EXPORT_C void TAlfVisualCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   227     {

   228     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   229     }

   230 

   231 // IMAGE COMMAND

   232 

   233 EXPORT_C TAlfImageCommand::TAlfImageCommand(CAlfImageVisual& aImageVisual,

   234                                             const TAlfImage& aImage,

   235                                             TAlfOp aOperation)

   236         : TAlfObjectCommand(EAlfCommandTypeImage, &aImageVisual, aOperation),

   237           iImage(aImage)

   238     {

   239     }

   240 

   241 

   242 EXPORT_C void TAlfImageCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   243     {

   244     switch(Operation())

   245         {

   246         case EAlfOpSetPrimaryImage:

   247             ImageVisual().SetImage(iImage);

   248             break;

   249 

   250         case EAlfOpSetSecondaryImage:

   251             ImageVisual().SetSecondaryImage(iImage);

   252             break;

   253 

   254         default:

   255             __ALFLOGSTRING1( "TAlfImageCommand::ExecuteL Unknown operation %d", Operation() )

   256             break;

   257         }

   258     }

   259 

   260 

   261 EXPORT_C TInt TAlfImageCommand::Size() const

   262     {

   263     return sizeof(*this);

   264     }

   265 

   266 

   267 EXPORT_C CAlfImageVisual& TAlfImageCommand::ImageVisual() const

   268     {

   269     return *(CAlfImageVisual*) Object();

   270     }

   271 

   272 

   273 EXPORT_C const TAlfImage& TAlfImageCommand::Image() const

   274     {

   275     return iImage;

   276     }

   277 

   278 EXPORT_C void TAlfImageCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   279     {

   280     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   281     }

   282 

   283     

   284 // ACTION COMMAND

   285 

   286 EXPORT_C TAlfActionCommand::TAlfActionCommand(TInt aId)

   287         : TAlfCommand(EAlfCommandTypeAction), iId(aId)

   288     {

   289     }

   290 

   291 EXPORT_C void TAlfActionCommand::ExecuteL(CAlfEnv& aEnv) const

   292     {

   293     TInt error = aEnv.ReportAction(*this);

   294     if(error != KErrNone)

   295         {

   296         // Leave with the error code if one of the observers failed.

   297         User::Leave(error);

   298         }

   299     }

   300 

   301 EXPORT_C TInt TAlfActionCommand::Size() const

   302     {

   303     return sizeof(*this);

   304     }

   305 

   306 

   307 EXPORT_C TInt TAlfActionCommand::Id() const

   308     {

   309     return iId;

   310     }

   311 

   312 EXPORT_C void TAlfActionCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   313     {

   314     TAlfCommand::CommandExtension( aExtensionUid, aExtensionParams );

   315     }

   316 

   317 // OBJECT COMMAND

   318 

   319 

   320 EXPORT_C TAlfObjectCommand::TAlfObjectCommand(TAlfCommandType aType, TAny* aDataOwnerObject, TAlfOp aOperation)

   321         : TAlfCommand(aType), iObject(aDataOwnerObject), iOperation(aOperation)

   322     {

   323     }

   324 

   325 EXPORT_C TInt TAlfObjectCommand::Size() const

   326     {

   327     return sizeof(*this);

   328     }

   329     

   330 EXPORT_C void TAlfObjectCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   331     {

   332     __ALFLOGSTRING1( "TAlfObjectCommand::ExecuteL Unknown operation %d", Operation() )

   333     }

   334 

   335 EXPORT_C TAny* TAlfObjectCommand::Object() const

   336     {

   337     return iObject;

   338     }

   339 

   340 

   341 EXPORT_C TAlfOp TAlfObjectCommand::Operation() const

   342     {

   343     return iOperation;

   344     }

   345 

   346 

   347 EXPORT_C const TAlfObjectCommand* TAlfObjectCommand::ObjectCommand() const

   348     {

   349     // All object commands can be casted to TAlfObjectCommand.

   350     return this;

   351     }

   352     

   353 EXPORT_C void TAlfObjectCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   354     {

   355     TAlfCommand::CommandExtension( aExtensionUid, aExtensionParams );

   356     }

   357 

   358 

   359 // TEXT COMMAND

   360 

   361 EXPORT_C TAlfTextCommand::TAlfTextCommand(CAlfTextVisual& aTextVisual, const TDesC& aText,

   362                                           TAlfOp aOperation)

   363         : TAlfObjectCommand(EAlfCommandTypeText, &aTextVisual, aOperation),

   364           iText(aText)

   365     {

   366     }

   367 

   368 EXPORT_C void TAlfTextCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   369     {

   370     switch(Operation())

   371         {

   372         case EAlfOpSetText:

   373             TextVisual().SetTextL(iText);

   374             break;

   375 

   376         default:

   377             __ALFLOGSTRING1( "TAlfTextCommand::ExecuteL Unknown operation %d", Operation() )

   378             break;

   379         }

   380     }

   381 

   382 

   383 EXPORT_C TInt TAlfTextCommand::Size() const

   384     {

   385     return sizeof(*this);

   386     }

   387 

   388 

   389 EXPORT_C CAlfTextVisual& TAlfTextCommand::TextVisual() const

   390     {

   391     return *(CAlfTextVisual*) Object();

   392     }

   393 

   394 

   395 EXPORT_C const TDesC& TAlfTextCommand::Text() const

   396     {

   397     return iText;

   398     }

   399 

   400 EXPORT_C void TAlfTextCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   401     {

   402     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   403     }

   404 

   405 // VALUE COMMAND

   406 

   407 EXPORT_C TAlfValueCommand::TAlfValueCommand(TAny* aObject, TAlfValueCommandTarget aObjectType,

   408                                             TReal32 aTarget, TInt aTransitionTime) __SOFTFP

   409         : TAlfObjectCommand(EAlfCommandTypeValue, aObject, EAlfOpSet),

   410           iTimedValue(aObjectType), iTarget(aTarget), iTransitionTime(aTransitionTime),

   411           iSpeed(0.0)

   412     {

   413     }

   414 

   415 

   416 EXPORT_C TAlfValueCommand::TAlfValueCommand(TAny* aObject, TAlfValueCommandTarget aObjectType,

   417                                             TAlfOp aOperation,

   418                                             TReal32 aTarget, TReal32 aTiming) __SOFTFP

   419         : TAlfObjectCommand(EAlfCommandTypeValue, aObject, aOperation),

   420           iTimedValue(aObjectType), iTarget(aTarget), iTransitionTime(0),

   421           iSpeed(0.0)

   422     {

   423     if(aOperation == EAlfOpSetWithSpeed)

   424         {

   425         iSpeed = aTiming;

   426         }

   427     else

   428         {

   429         iTransitionTime = TInt(aTiming);

   430         }

   431     }

   432 

   433 EXPORT_C void TAlfValueCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   434     {

   435     TAlfTimedValue value;

   436     

   437     TInt op = Operation();

   438     if(op >= EAlfOpSetStyle && op < EAlfOpSetStyle + EAlfTimedValueStyleLast)

   439         {

   440         value.SetStyle(TAlfInterpolationStyle(op - EAlfOpSetStyle));

   441         }

   442     

   443     switch(Operation())

   444         {

   445         case EAlfOpSet:

   446             {

   447             value.SetTarget( iTarget, iTransitionTime );

   448             break;

   449             }

   450         case EAlfOpSetWithSpeed:

   451             {

   452             value.SetTargetWithSpeed(iTarget, iSpeed);

   453             break;

   454             }

   455         default:

   456             __ALFLOGSTRING1( "TAlfValueCommand::ExecuteL Unknown operation %d", Operation() )

   457             break;

   458         }

   459         

   460     switch( TimedValue() )

   461         {

   462         case EAlfValueCommandVisualSetOpacity:

   463             {

   464             CAlfVisual*visual = (CAlfVisual*) Object();

   465             visual->SetOpacity( value );

   466             break;

   467             }

   468         default:

   469             __ALFLOGSTRING1( "TAlfValueCommand::ExecuteL Unknown target %d", TimedValue() )

   470             break;

   471         }

   472     }

   473 

   474 

   475 EXPORT_C TInt TAlfValueCommand::Size() const

   476     {

   477     return sizeof(*this);

   478     }

   479 

   480 

   481 EXPORT_C TAlfValueCommandTarget TAlfValueCommand::TimedValue() const

   482     {

   483     return iTimedValue;

   484     }

   485 

   486 

   487 EXPORT_C TReal32 TAlfValueCommand::Target() const __SOFTFP

   488     {

   489     return iTarget;

   490     }

   491 

   492 

   493 EXPORT_C TInt TAlfValueCommand::TransitionTime() const

   494     {

   495     return iTransitionTime;

   496     }

   497 

   498 

   499 EXPORT_C TReal32 TAlfValueCommand::Speed() const __SOFTFP

   500     {

   501     return iSpeed;

   502     }

   503     

   504 EXPORT_C void TAlfValueCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   505     {

   506     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   507     }

   508     

   509 // POINT COMMAND

   510 

   511 EXPORT_C TAlfPointCommand::TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType,

   512                                             TAlfOp aOperation)

   513         : TAlfObjectCommand(EAlfCommandTypePoint, aObject, aOperation),

   514           iTimedPoint(aObjectType), iTransitionTime(0), iSpeed(0.0)

   515     {

   516     }

   517 

   518 

   519 EXPORT_C TAlfPointCommand::TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType,

   520                                             TAlfRealPoint aTarget, TInt aTransitionTime,

   521                                             TParameterTarget aParameterTarget)

   522         : TAlfObjectCommand(EAlfCommandTypePoint, aObject, EAlfOpSet),

   523           iTimedPoint(aObjectType), iTarget(aTarget),

   524           iTransitionTime(aTransitionTime), iSpeed(0.0), iParameterTarget(aParameterTarget)

   525     {

   526     }

   527 

   528 

   529 EXPORT_C TAlfPointCommand::TAlfPointCommand(TAny* aObject, TAlfPointCommandTarget aObjectType,

   530                                             TAlfOp aOperation,

   531                                             TAlfRealPoint aTarget, TReal32 aTiming,

   532                                             TParameterTarget aParameterTarget) __SOFTFP

   533         : TAlfObjectCommand(EAlfCommandTypePoint, aObject, aOperation),

   534           iTimedPoint(aObjectType), iTarget(aTarget),

   535           iTransitionTime(0), iSpeed(0.0), iParameterTarget(aParameterTarget)

   536     {

   537     if(aOperation == EAlfOpSetWithSpeed)

   538         {

   539         iSpeed = aTiming;

   540         }

   541     else

   542         {

   543         iTransitionTime = TInt(aTiming);

   544         }

   545     }

   546 

   547 

   548 EXPORT_C void TAlfPointCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   549     {        

   550     TAlfTimedPoint point;

   551     

   552     // Check for interpolation style change ops.

   553     TInt op = Operation();

   554     if(op >= EAlfOpSetStyle && op < EAlfOpSetStyle + EAlfTimedValueStyleLast)

   555         {

   556         point.SetStyle(TAlfInterpolationStyle(op - EAlfOpSetStyle));

   557         }

   558         

   559     switch( Operation() )

   560         {

   561         case EAlfOpSet:

   562             point.SetTarget(iTarget, iTransitionTime);

   563             break;

   564 

   565         case EAlfOpSetWithSpeed:

   566             point.SetTargetWithSpeed(iTarget, iSpeed);

   567             break;

   568 

   569         default:

   570             __ALFLOGSTRING1( "TAlfPointCommand::ExecuteL() - Unknown op %d.", Operation())

   571             break;

   572         }

   573     

   574     if ( iParameterTarget == EBoth || iParameterTarget == EXOnly )

   575         {

   576         point.iX.SetTarget( iTarget.iX, iTransitionTime );

   577         }

   578                  

   579     if ( iParameterTarget == EBoth || iParameterTarget == EYOnly )

   580         {

   581         point.iY.SetTarget( iTarget.iY, iTransitionTime );

   582         }

   583         

   584     switch( TimedPoint() )

   585         {

   586         case EAlfPointCommandVisualSetPos:

   587             {

   588             CAlfVisual* visual = (CAlfVisual*) Object();

   589             visual->SetPos( point );

   590             break;

   591             }

   592         case EAlfPointCommandVisualSetSize:

   593             {

   594             CAlfVisual*visual = (CAlfVisual*) Object();

   595             visual->SetSize( point );

   596             break;

   597             }

   598         

   599         default:

   600             __ALFLOGSTRING1( "TAlfPointCommand::ExecuteL Unknown target %d", TimedPoint() )

   601             break;

   602         }    

   603     }

   604 

   605 

   606 EXPORT_C TInt TAlfPointCommand::Size() const

   607     {

   608     return sizeof(*this);

   609     }

   610 

   611 

   612 EXPORT_C TAlfPointCommandTarget TAlfPointCommand::TimedPoint() const

   613     {

   614     return iTimedPoint;

   615     }

   616 

   617 

   618 EXPORT_C TAlfRealPoint TAlfPointCommand::Target() const

   619     {

   620     return iTarget;

   621     }

   622 

   623 

   624 EXPORT_C TInt TAlfPointCommand::TransitionTime() const

   625     {

   626     return iTransitionTime;

   627     }

   628 

   629 

   630 EXPORT_C TReal32 TAlfPointCommand::Speed() const __SOFTFP

   631     {

   632     return iSpeed;

   633     }

   634     

   635 EXPORT_C void TAlfPointCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   636     {

   637     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   638     }

   639 

   640 // TRANSFORMATION COMMAND

   641 

   642 EXPORT_C TAlfTransformationCommand::TAlfTransformationCommand(

   643     TAny* aOwner, CAlfTransformation& aTransformation, TAlfOp aOperation, TInt aStep)

   644         : TAlfObjectCommand(EAlfCommandTypeTransformation, aOwner, aOperation),

   645           iTransformation(aTransformation), iStep(aStep)

   646     {

   647     // Set default values for transformation

   648     switch(aOperation)

   649         {

   650         case EAlfOpRotate:

   651             iX = TAlfTimedValue(0.0f);

   652             iY = TAlfTimedValue(0.0f);

   653             iZ = TAlfTimedValue(1.0f);

   654         break;

   655         case EAlfOpScale:

   656             iX = TAlfTimedValue(1.0f);

   657             iY = TAlfTimedValue(1.0f);

   658             iZ = TAlfTimedValue(1.0f);

   659         break;        

   660         default:

   661         break;

   662         }

   663     }

   664 

   665 

   666 EXPORT_C void TAlfTransformationCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   667     {

   668     switch(Operation())

   669         {

   670         case EAlfOpLoadIdentity:

   671             iTransformation.LoadIdentity();

   672             break;

   673 

   674         case EAlfOpTranslate:

   675             if(iStep != EStepNone)

   676                 {

   677                 CAlfTransformation::TTransform xs = iTransformation.Step(iStep);

   678                 xs.iType = CAlfTransformation::ETypeTranslate;

   679                 xs.iParams[EAlfTransformParamTranslateX] = iX;

   680                 xs.iParams[EAlfTransformParamTranslateY] = iY;

   681                 xs.iParams[EAlfTransformParamTranslateZ] = iZ;

   682                 iTransformation.ReplaceStep(iStep,xs);

   683                 }

   684             else

   685                 {

   686                 iTransformation.Translate(iX, iY);

   687                 }

   688             break;

   689 

   690         case EAlfOpScale:

   691             if(iStep != EStepNone)

   692                 {

   693                 CAlfTransformation::TTransform xs = iTransformation.Step(iStep);

   694                 xs.iType = CAlfTransformation::ETypeScale;

   695                 xs.iParams[EAlfTransformParamScaleX] = iX;

   696                 xs.iParams[EAlfTransformParamScaleY] = iY;

   697                 xs.iParams[EAlfTransformParamScaleZ] = iZ;

   698                 iTransformation.ReplaceStep(iStep,xs);

   699                 }

   700             else

   701                 {

   702                 iTransformation.Scale(iX, iY, iZ);

   703                 }

   704             break;

   705 

   706         case EAlfOpRotate:

   707             if(iStep != EStepNone)

   708                 {

   709                 CAlfTransformation::TTransform xs = iTransformation.Step(iStep);

   710                 xs.iType = CAlfTransformation::ETypeRotate;

   711                 xs.iParams[EAlfTransformParamRotateAngle] = iAngle;

   712                 xs.iParams[EAlfTransformParamRotateAxisX] = iX;

   713                 xs.iParams[EAlfTransformParamRotateAxisY] = iY;

   714                 xs.iParams[EAlfTransformParamRotateAxisZ] = iZ;

   715                 iTransformation.ReplaceStep(iStep,xs);

   716                 }

   717             else

   718                 {

   719                 TAlfTimedValue unsuspended;

   720                 unsuspended = iX;

   721                 TReal32 x = unsuspended.ValueNow();

   722                 unsuspended = iY;

   723                 TReal32 y = unsuspended.ValueNow();

   724                 unsuspended = iZ;

   725                 TReal32 z = unsuspended.ValueNow();

   726                 iTransformation.Rotate(iAngle, x, y, z);

   727                 }

   728             break;

   729             

   730         case EAlfOpReplaceStep:

   731             {

   732             if(iStep != EStepNone)

   733                 {

   734                 CAlfTransformation::TTransform xs = iTransformation.Step(iStep);

   735                 xs.iParams[EAlfTransformParamRotateAngle] = iAngle;

   736                 xs.iParams[EAlfTransformParamRotateAxisX] = iX;

   737                 xs.iParams[EAlfTransformParamRotateAxisY] = iY;

   738                 xs.iParams[EAlfTransformParamRotateAxisZ] = iZ;

   739                 iTransformation.ReplaceStep(iStep,xs);

   740                 }

   741             break;

   742             }

   743 

   744         default:

   745             __ALFLOGSTRING1( "TAlfTransformationCommand::ExecuteL Unknown operation %d", Operation() )

   746             break;

   747         }

   748     }

   749 

   750 

   751 EXPORT_C TInt TAlfTransformationCommand::Size() const

   752     {

   753     return sizeof(*this);

   754     }

   755 

   756 

   757 EXPORT_C CAlfTransformation& TAlfTransformationCommand::Transformation() const

   758     {

   759     return iTransformation;

   760     }

   761 

   762 

   763 EXPORT_C TInt TAlfTransformationCommand::Step() const

   764     {

   765     return iStep;

   766     }

   767 

   768 

   769 EXPORT_C void TAlfTransformationCommand::SetX(const TAlfTimedValue& aValue)

   770     {

   771     iX = aValue;

   772     //iX.Suspend();

   773     }

   774 

   775 

   776 EXPORT_C void TAlfTransformationCommand::SetY(const TAlfTimedValue& aValue)

   777     {

   778     iY = aValue;

   779     //iY.Suspend();

   780     }

   781 

   782 

   783 EXPORT_C void TAlfTransformationCommand::SetZ(const TAlfTimedValue& aValue)

   784     {

   785     iZ = aValue;

   786     //iZ.Suspend();

   787     }

   788 

   789 

   790 EXPORT_C void TAlfTransformationCommand::SetAngle(const TAlfTimedValue& aValue)

   791     {

   792     iAngle = aValue;

   793     //iAngle.Suspend();

   794     }

   795     

   796 EXPORT_C void TAlfTransformationCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   797     {

   798     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   799     }

   800 

   801 // MARKER COMMAND

   802 

   803 EXPORT_C TAlfMarkerCommand::TAlfMarkerCommand(TInt aId)

   804         : TAlfCommand(TAlfCommandType(EAlfCommandTypeMarkerFirst + aId))

   805     {

   806     }

   807 

   808 

   809 EXPORT_C void TAlfMarkerCommand::ExecuteL(CAlfEnv& /*aEnv*/) const

   810     {

   811     __ALFLOGSTRING1( "TAlfMarkerCommand::ExecuteL - Marker %d reached.", Id() )

   812     }

   813 

   814 

   815 EXPORT_C TInt TAlfMarkerCommand::Size() const

   816     {

   817     return sizeof(*this);

   818     }

   819 

   820 

   821 EXPORT_C TInt TAlfMarkerCommand::Id() const

   822     {

   823     return Type() - EAlfCommandTypeMarkerFirst;

   824     }

   825 

   826 EXPORT_C void TAlfMarkerCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   827     {

   828     TAlfCommand::CommandExtension( aExtensionUid, aExtensionParams );

   829     }

   830 

   831 // CUSTOM EVENT

   832 

   833 EXPORT_C TAlfCustomEventCommand::TAlfCustomEventCommand(

   834     TInt aEventParam, MAlfEventHandler* aRecipient, TInt aEventData)

   835         : TAlfObjectCommand(EAlfCommandTypeCustomEvent, aRecipient, EAlfOpNone),

   836           iEventParam(aEventParam),

   837           iEventData(aEventData)

   838     {

   839     }

   840  

   841 

   842 EXPORT_C void TAlfCustomEventCommand::ExecuteL(CAlfEnv& aEnv) const

   843     {

   844     TAlfEvent customEvent(iEventParam, iEventData);

   845 

   846     if(Recipient())

   847         {

   848         Recipient()->OfferEventL(customEvent);

   849         }

   850     else

   851         {

   852         aEnv.BroadcastEventL(customEvent);

   853         }

   854     }

   855 

   856 

   857 EXPORT_C TInt TAlfCustomEventCommand::Size() const

   858     {

   859     return sizeof(*this);

   860     }

   861 

   862 

   863 EXPORT_C MAlfEventHandler* TAlfCustomEventCommand::Recipient() const

   864     {

   865     return (MAlfEventHandler*) Object();

   866     }

   867 

   868 EXPORT_C TInt TAlfCustomEventCommand::Param() const

   869     {

   870     return iEventParam;

   871     }

   872     

   873 EXPORT_C TInt TAlfCustomEventCommand::EventData() const

   874     {

   875     return iEventData;

   876     }

   877 

   878 EXPORT_C void TAlfCustomEventCommand::CommandExtension(const TUid& aExtensionUid, TAny** aExtensionParams)

   879     {

   880     TAlfObjectCommand::CommandExtension( aExtensionUid, aExtensionParams );

   881     }

   882