1 /*

     2 * Copyright (c) 2006 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:   definitions of alf built-in visual support

    15 *

    16 */

    17 

    18 

    19 

    20 #include "alf/alfvisualhandlers.h"

    21 #include "alftextstylehandlers.h"

    22 #include "alf/alfconstants.h"

    23 #include <uiacceltk/HuiTextVisual.h>

    24 #include <uiacceltk/HuiGridLayout.h>

    25 #include <uiacceltk/HuiImageVisual.h>

    26 #include "alf/alfbrushhandlers.h"

    27 #include <alf/alfvisual.h>

    28 #include <alf/alftextvisual.h>

    29 #include <uiacceltk/HuiLineVisual.h>

    30 #include <uiacceltk/HuiMeshVisual.h>

    31 #include <uiacceltk/huiproceduralmesh.h>

    32 #include <uiacceltk/huim3gmesh.h>

    33 #include <uiacceltk/HuiUtil.h>

    34 #include <alf/alfmaterial.h>

    35 #include "alf/alfserverutils.h"

    36 #include "alfsrvvisualowner.h"

    37 #include <AknsConstants.h>

    38 #include "alf/alfappui.h"

    39 #include "alfsrvdropshadowhandler.h"

    40 #include <AknFontSpecification.h> // @todo mka

    41 #include <gdi.h> // @todo mka

    42 #include <uiacceltk/HuiCanvasVisual.h>

    43 

    44 // Remove when EAlfVisualEnableTransformation handing is fixed

    45 #include "alfappsrvsession.h"

    46 #include "alfsrvsubsessionbase.h"

    47 #include "alfsrvtransformationsubsession.h"

    48 

    49 #ifdef RD_ALF_IN_PLATFORM

    50 #include <aknlayout2hierarchy.h>

    51 #endif

    52 

    53 #include <avkon.hrh> //     ELayoutAlignNone, etc

    54 

    55 #include "HuiFxEngine.h"

    56 #include "HuiFxEffect.h"

    57 struct CAlfVisualHandler::TPrivateData

    58     {

    59     CAlfSrvVisualOwner* iVisualOwner;

    60     };

    61 

    62 //----------------------------

    63 // Visual base

    64 //----------------------------

    65 EXPORT_C MAlfExtension* CAlfVisualHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)

    66     {

    67     CAlfVisualHandler* me = new (ELeave) CAlfVisualHandler(aResolver);

    68     CleanupStack::PushL(me);

    69     me->ConstructL(NULL, *aOwner, aParentLayout);

    70     CleanupStack::Pop();

    71     return me;

    72     }

    73 

    74 EXPORT_C CAlfVisualHandler::CAlfVisualHandler(MAlfInterfaceProvider& aResolver):iResolver(aResolver)

    75     {

    76     }

    77 

    78 

    79 EXPORT_C void CAlfVisualHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)

    80     {

    81     if (!aVisual)

    82         {

    83         iVisual = CHuiVisual::AddNewL(aOwner, aParentLayout);          

    84         }

    85     else 

    86         {

    87         iVisual = aVisual;    

    88         }

    89         

    90     iPrivateData = new (ELeave) TPrivateData;

    91     iPrivateData->iVisualOwner = NULL;

    92     

    93     }

    94 

    95 

    96 EXPORT_C CAlfVisualHandler::~CAlfVisualHandler()

    97     {

    98     if ( iPrivateData )

    99         {

   100         if ( iPrivateData->iVisualOwner )

   101             {

   102             if ( iVisual ) // If the visual has not been deleted already

   103                 {

   104                 iVisual->SetOwner( *iPrivateData->iVisualOwner->RealOwner() );

   105                 }

   106             delete iPrivateData->iVisualOwner;

   107             iPrivateData->iVisualOwner = NULL;

   108             }

   109         }

   110     delete iPrivateData;

   111     iPrivateData = NULL;

   112     

   113     iVisual = NULL;

   114     }

   115 

   116 EXPORT_C void CAlfVisualHandler::Release()

   117     {

   118     delete this;

   119     }

   120 

   121 

   122 EXPORT_C TAny* CAlfVisualHandler::GetInterface(const THuiInterfaceSupport& aInterface)

   123     {

   124     switch (aInterface)

   125         {

   126         case EHuiObjectTypeVisual:

   127             return iVisual;

   128         case EAlfVisualHandler:

   129             return this;

   130         default:

   131             return 0;

   132                     

   133         }

   134 

   135     }

   136 

   137 void NullChildVisualHandlerPointers(

   138     CHuiVisual& iVisual, 

   139     const RPointerArray<CAlfSrvSubSessionBase>& aArray)

   140     {

   141     for(TInt i = iVisual.Count() - 1; i >= 0; --i)

   142         {

   143         NullChildVisualHandlerPointers( iVisual.Visual(i), aArray );

   144         }

   145         

   146     for ( TInt h = 0 ; h < aArray.Count(); h++ )

   147         {

   148         if ( aArray[h]->AsHuiVisual() == &iVisual )

   149             {

   150             CAlfVisualHandler* visualHandler = static_cast<CAlfVisualHandler*>( aArray[h]->AsCommandHandler() );

   151             visualHandler->HuiVisualAboutToTerminate();

   152             }

   153         }

   154    

   155     }

   156 

   157 void CAlfVisualHandler::HuiVisualAboutToTerminate()

   158     {

   159     iVisual = NULL;

   160     }

   161 

   162 

   163 EXPORT_C void CAlfVisualHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)

   164     {

   165     switch (aCommandId)

   166         {

   167         case EAlfVisualRemoveAndDestroyAll:

   168             {

   169             // we need to NULL all the child visual handlers

   170             CHuiVisual* tmp = iVisual;

   171             

   172             CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

   173             RPointerArray<CAlfSrvSubSessionBase> array;

   174             TRAP_IGNORE( session.GetSubsessionsByTypeL( array, EAlfVisualHandler ) );

   175             NullChildVisualHandlerPointers(*iVisual, array);

   176             array.Close();

   177             

   178             tmp->RemoveAndDestroyAllD();

   179             tmp = NULL;

   180             break;                

   181             }

   182         

   183         case EAlfVisualUpdateChildrenLayout:

   184             {

   185             TInt* transitionTime = (TInt*) aInputBuffer.Ptr();

   186             iVisual->UpdateChildrenLayout( *transitionTime >= 0 ? *transitionTime : CHuiStatic::LayoutTransitionTime() );

   187             break;

   188             }

   189                 

   190         case  EAlfVisualSetOpacity:

   191             {

   192             TAlfTimedValue* opacity = (TAlfTimedValue*) aInputBuffer.Ptr() ;

   193             AlfTimedValueUtility::CopyTimedValue(*opacity, iVisual->iOpacity, iResolver);

   194             break;    

   195             }

   196         

   197         case EAlfVisualGetOpacity:

   198             {

   199             TAlfTimedValue opacity;

   200             AlfTimedValueUtility::CopyTimedValue(iVisual->iOpacity, opacity);

   201             TPckg<TAlfTimedValue> resultPckg(opacity);

   202             

   203             aResponse = resultPckg; // awkward     

   204             break;

   205             }

   206         

   207         case  EAlfVisualLocalToDisplay:

   208             {

   209             TAlfRealPoint* alfPoint = (TAlfRealPoint*) aInputBuffer.Ptr();

   210             const THuiRealPoint realPoint( alfPoint->iX, alfPoint->iY );

   211             

   212             THuiRealPoint result = iVisual->LocalToDisplay( realPoint );

   213 

   214             // if the visual is showing, the container layout rect is included

   215             // in the LocalToDisplay calculations

   216             if ( iVisual->Display() )

   217                 {

   218                 // if not showing, we need to add the display rect offset.

   219                 CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

   220                 result -= session.ClientDrawingArea().iTl;

   221                 }

   222             

   223             TAlfRealPoint alf_point(result.iX, result.iY);

   224             TPckg<TAlfRealPoint> resultPckg(alf_point);            

   225             

   226             aResponse = resultPckg; // awkward 

   227             break;     

   228             }

   229         

   230         case  EAlfVisualDisplayToLocal:

   231             {

   232             TAlfRealPoint* alfPoint = (TAlfRealPoint*) aInputBuffer.Ptr();

   233             THuiRealPoint realPoint( alfPoint->iX, alfPoint->iY );

   234             

   235             // if the visual is showing, the container layout rect is included

   236             // in the DisplayToLocal calculations

   237             if ( iVisual->Display() )

   238                 {

   239                 // if not showing, we need to reduce the display rect offset

   240                 // from the comparision value.

   241                 CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

   242                 realPoint += session.ClientDrawingArea().iTl;

   243                 }

   244             

   245             THuiRealPoint result = iVisual->DisplayToLocal( realPoint );

   246                         

   247             TAlfRealPoint alf_point(result.iX, result.iY);

   248             TPckg<TAlfRealPoint> resultPckg(alf_point);            

   249 

   250             aResponse = resultPckg; // awkward 

   251             break;     

   252             }

   253         

   254         case  EAlfVisualDisplayRectTarget:

   255             {

   256             THuiRealRect huiResult = iVisual->DisplayRectTarget();

   257             

   258             if ( iVisual->Display() )

   259                 {

   260                 CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

   261                 huiResult.Move( -session.ClientDrawingArea().iTl.iX, -session.ClientDrawingArea().iTl.iY ); 

   262                 }

   263             

   264             TAlfRealRect alfResult;

   265             alfResult.iTl.iX = huiResult.iTl.iX;

   266             alfResult.iTl.iY = huiResult.iTl.iY;

   267             alfResult.iBr.iX = huiResult.iBr.iX;

   268             alfResult.iBr.iY = huiResult.iBr.iY;

   269             TPckg<TAlfRealRect> resultPckg(alfResult);

   270             

   271             aResponse = resultPckg; // awkward 

   272             break;            

   273             }

   274         

   275         case  EAlfVisualPos:

   276             {

   277             TAlfTimedPoint result;

   278             AlfTimedPointUtility::CopyTimedPoint(iVisual->Pos(), result);             

   279             

   280             TPckg<TAlfTimedPoint> resultPckg(result);

   281 

   282             aResponse = resultPckg; // awkward 

   283             break;            

   284             }

   285         

   286         case  EAlfVisualSetPos:

   287             {

   288             TAlfVisualPos* pos = (TAlfVisualPos*) aInputBuffer.Ptr();

   289             

   290             THuiRealPoint huiPoint( pos->iPoint.iX, pos->iPoint.iY );

   291             

   292             iVisual->SetPos(huiPoint, pos->iTime);

   293             break;            

   294             }

   295             

   296         

   297         case EAlfVisualMoveToFront:

   298             { 

   299             iVisual->MoveToFront();

   300             break;            

   301             }

   302         

   303         case EAlfVisualSize:

   304             {

   305             TAlfTimedPoint a_size;

   306             AlfTimedPointUtility::CopyTimedPoint(iVisual->Size(), a_size);             

   307 

   308             TPckg<TAlfTimedPoint> sizePckg(a_size);

   309             

   310             aResponse = sizePckg; // awkward 

   311             break;            

   312             }

   313         

   314         case EAlfVisualSetSize:

   315             {

   316             TAlfVisualSize* size = (TAlfVisualSize*) aInputBuffer.Ptr();

   317             iVisual->SetSize(THuiRealSize( size->iSize.iWidth,size->iSize.iHeight ) , size->iTime);

   318 

   319             break;            

   320             }

   321             

   322         case EAlfVisualBrushArrayReset:

   323             {

   324             if ( iVisual ) // during destruction the iVisual is already deleted

   325                 {

   326                 iVisual->EnableBrushesL( EFalse );

   327                 }

   328             break;

   329             }

   330             

   331 

   332         case EAlfVisualBrushArrayAppend:

   333             {

   334             TInt2* params = (TInt2*) aInputBuffer.Ptr();

   335             

   336             const THuiOwnership ownership = (THuiOwnership)params->iInt2;

   337             

   338             CHuiBrush* brush = (CHuiBrush*)iResolver.GetInterfaceL(EHuiObjectTypeBrush, params->iInt1);

   339             iVisual->EnableBrushesL();

   340             iVisual->Brushes()->AppendL(brush,ownership);

   341             CAlfBrushHandler* holder = (CAlfBrushHandler*) iResolver.GetInterfaceL(EAlfBrushHandler, params->iInt1);

   342             

   343             // If the brush array is taking the ownership...

   344             if ( ownership == EHuiHasOwnership )

   345                 {

   346                 // ... the brush holder cannot have it anymore

   347                 holder->SetOwnership(EFalse);

   348                 }

   349             break;

   350             }

   351         case EAlfVisualBrushArrayInsert:

   352             {

   353             TInt3* params = (TInt3*) aInputBuffer.Ptr();

   354             

   355             CHuiBrush* brush = (CHuiBrush*)iResolver.GetInterfaceL(EHuiObjectTypeBrush, params->iInt1);

   356             iVisual->EnableBrushesL();

   357             iVisual->Brushes()->InsertL(params->iInt3, brush,(THuiOwnership)params->iInt2);

   358             CAlfBrushHandler* holder = (CAlfBrushHandler*) iResolver.GetInterfaceL(EAlfBrushHandler, params->iInt1);

   359             holder->SetOwnership(!params->iInt2); // THuiOwnership matches boolean 

   360             break;

   361             }

   362         case EAlfVisualBrushArrayRemove:

   363             {

   364             if ( iVisual ) // iVisual is NULL:led i.e. deleted

   365                 {

   366                 TInt* params = (TInt*) aInputBuffer.Ptr();

   367                 iVisual->EnableBrushesL();

   368                 iVisual->Brushes()->Remove(*params);

   369                 }

   370             break;

   371             }

   372             

   373         case EAlfVisualSetFlag:

   374             {

   375             THuiVisualFlags* params = (THuiVisualFlags*) aInputBuffer.Ptr();

   376             iVisual->SetFlag( *params );

   377             break;

   378             }

   379             

   380         case EAlfVisualSetFlags:

   381             {

   382             TUint* params = (TUint*) aInputBuffer.Ptr();

   383             iVisual->SetFlags( *params );

   384             break;

   385             }

   386             

   387         case EAlfVisualClearFlag:

   388             {

   389             THuiVisualFlags* params = (THuiVisualFlags*) aInputBuffer.Ptr();

   390             iVisual->ClearFlag( *params );

   391             break;

   392             }

   393             

   394         case EAlfVisualClearFlags:

   395             {

   396             TUint* params = (TUint*) aInputBuffer.Ptr();

   397             iVisual->ClearFlags( *params );

   398             break;

   399             }

   400             

   401         case EAlfVisualFlags:

   402             {

   403             const TUint flags = iVisual->Flags();

   404             TPckg<TUint> flagsPckg(flags);

   405             aResponse = flagsPckg; // awkward 

   406             break;

   407             }

   408             

   409         case EAlfVisualSetPaddingInt:

   410             {

   411             TInt* params = (TInt*) aInputBuffer.Ptr();

   412             iVisual->SetPadding( *params );

   413             break;

   414             }

   415             

   416         case EAlfVisualSetPaddingPoint:

   417             {

   418             TPoint* params = (TPoint*) aInputBuffer.Ptr();

   419             iVisual->SetPadding( *params );

   420             break;

   421             }

   422             

   423         case EAlfVisualSetPaddingBox:

   424             {

   425             TAlfBoxMetric* metric = (TAlfBoxMetric*) aInputBuffer.Ptr();

   426                     

   427             THuiMetric newMetricLeft(metric->iLeft.iMagnitude, metric->iLeft.iUnit, metric->iLeft.iReferenceTextStyleId);

   428             THuiMetric newMetricRight(metric->iRight.iMagnitude, metric->iRight.iUnit, metric->iRight.iReferenceTextStyleId);

   429             THuiMetric newMetricTop(metric->iTop.iMagnitude, metric->iTop.iUnit, metric->iTop.iReferenceTextStyleId);

   430             THuiMetric newMetricBottom(metric->iBottom.iMagnitude, metric->iBottom.iUnit, metric->iBottom.iReferenceTextStyleId);

   431             

   432             THuiBoxMetric newBoxMetric(newMetricLeft, newMetricRight, newMetricTop, newMetricBottom);

   433             iVisual->SetPadding(newBoxMetric);

   434             break;

   435             }

   436             

   437         case EAlfVisualPaddingInPixels:

   438             {

   439             const THuiRealRect huiResult = iVisual->PaddingInPixels();  

   440             

   441             TAlfRealRect alfResult;

   442             alfResult.iTl.iX = huiResult.iTl.iX;

   443             alfResult.iTl.iY = huiResult.iTl.iY;

   444             alfResult.iBr.iX = huiResult.iBr.iX;

   445             alfResult.iBr.iY = huiResult.iBr.iY;

   446             

   447             TPckg<TAlfRealRect> resultPckg(alfResult);           

   448             aResponse = resultPckg; // awkward 

   449             break;    

   450         }

   451         

   452         case EAlfVisualEnableTransformation:

   453             {

   454             TInt2* params = (TInt2*) aInputBuffer.Ptr();

   455             

   456             const TBool isTransformed = params->iInt2;

   457             const TInt transHandle = params->iInt1;

   458             

   459             

   460             // @todo: nasty hack

   461             CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

   462             CAlfSrvSubSessionBase& transSubSession = session.SubSession( transHandle );

   463             CAlfSrvTransformationSubSession& transformationSubSession = 

   464                 static_cast<CAlfSrvTransformationSubSession&>(transSubSession);

   465             

   466             // Enable transformation

   467             iVisual->EnableTransformationL( isTransformed );

   468             CHuiTransformation* transformation = NULL;

   469             if ( isTransformed )

   470                 {

   471                 transformation = &iVisual->Transformation();

   472                 }

   473                 

   474             transformationSubSession.SetTransformation( transformation );

   475             break;

   476             }

   477 

   478         case EAlfVisualDepthOffset:

   479             {

   480             TAlfTimedValue value;

   481             AlfTimedValueUtility::CopyTimedValue(iVisual->iDepthOffset, value);             

   482 

   483             TPckg<TAlfTimedValue> resultPckg(value);            

   484             aResponse = resultPckg; // awkward                 

   485             break;    

   486             }

   487 

   488         case EAlfVisualSetDepthOffset:

   489             {

   490             TAlfTimedValue* params = (TAlfTimedValue*) aInputBuffer.Ptr();            

   491             AlfTimedValueUtility::CopyTimedValue(*params, iVisual->iDepthOffset, iResolver);

   492             break;    

   493             }

   494 

   495         case EAlfVisualSetMinSize:

   496             {

   497             TSize* params = (TSize*) aInputBuffer.Ptr();

   498             iVisual->SetMinSize( *params );            

   499             break;    

   500             }

   501 

   502         case EAlfVisualGetMinSize:

   503             {

   504             TSize result = iVisual->MinSize();            

   505             TPckg<TSize> resultPckg(result);

   506             aResponse = resultPckg; // awkward 

   507             break;    

   508             }

   509 

   510         case EAlfVisualSetMinSizeInBaseUnits:

   511             {

   512             TAlfRealSize* params = (TAlfRealSize*) aInputBuffer.Ptr();

   513             const THuiRealSize minSize(params->iWidth, params->iHeight);

   514             iVisual->SetMinSize( minSize );            

   515             break;    

   516             }

   517 

   518         case EAlfVisualGetMinSizeInBaseUnits:

   519             {

   520             THuiRealSize result = iVisual->MinSizeInBaseUnits(); 

   521             TAlfRealSize alfResult(result.iWidth, result.iHeight);  

   522             TPckg<TAlfRealSize> resultPckg(alfResult);

   523             aResponse = resultPckg; // awkward 

   524             break;    

   525             }

   526 

   527         case EAlfVisualSetMaxSize:

   528             {            

   529             TSize* params = (TSize*) aInputBuffer.Ptr();

   530             iVisual->SetMaxSize( *params );            

   531             break;    

   532             }

   533 

   534         case EAlfVisualGetMaxSize:

   535             {

   536             TSize result = iVisual->MaxSize();            

   537             TPckg<TSize> resultPckg(result);

   538             aResponse = resultPckg; // awkward 

   539             break;    

   540             }

   541 

   542         case EAlfVisualSetMaxSizeInBaseUnits:

   543             {            

   544             TAlfRealSize* params = (TAlfRealSize*) aInputBuffer.Ptr();

   545             const THuiRealSize maxSize(params->iWidth, params->iHeight);

   546             iVisual->SetMaxSize( maxSize );            

   547             break;    

   548             }

   549 

   550         case EAlfVisualGetMaxSizeInBaseUnits:

   551             {

   552             THuiRealSize result = iVisual->MaxSizeInBaseUnits(); 

   553             TAlfRealSize alfResult(result.iWidth, result.iHeight);  

   554             TPckg<TAlfRealSize> resultPckg(alfResult);

   555             aResponse = resultPckg; // awkward 

   556             break;    

   557             }

   558 

   559         case EAlfVisualMove:

   560             {            

   561             TAlfVisualPos* pos = (TAlfVisualPos*) aInputBuffer.Ptr();           

   562             const THuiRealPoint huiPoint(pos->iPoint.iX, pos->iPoint.iY);

   563             iVisual->Move(huiPoint, pos->iTime);

   564             break;            

   565             }

   566 

   567        case EAlfVisualSetCenteredPosAndSize:

   568             {            

   569             TAlfVisualPosSize* posAndSize = (TAlfVisualPosSize*) aInputBuffer.Ptr();            

   570             const THuiRealPoint huiPoint(posAndSize->iPoint.iX, posAndSize->iPoint.iY);

   571             const THuiRealSize huiSize(posAndSize->iSize.iWidth, posAndSize->iSize.iHeight);

   572             iVisual->SetCenteredPosAndSize(huiPoint, huiSize, posAndSize->iTime);

   573             break;            

   574             }

   575 

   576         case EAlfVisualDisplayRect:

   577             {          

   578             THuiRealRect huiResult = iVisual->DisplayRect();

   579             

   580             if ( iVisual->Display() )

   581                 {

   582                 CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

   583                 huiResult.Move( -session.ClientDrawingArea().iTl.iX, -session.ClientDrawingArea().iTl.iY );

   584                 }

   585             

   586             TAlfRealRect alfResult;

   587             alfResult.iTl.iX = huiResult.iTl.iX;

   588             alfResult.iTl.iY = huiResult.iTl.iY;

   589             alfResult.iBr.iX = huiResult.iBr.iX;

   590             alfResult.iBr.iY = huiResult.iBr.iY;

   591             

   592             TPckg<TAlfRealRect> resultPckg(alfResult);           

   593             aResponse = resultPckg; // awkward 

   594             break;    

   595             }

   596 

   597         case EAlfVisualEffectiveOpacity:

   598             {

   599             TReal32 value = iVisual->EffectiveOpacity();

   600             TPckg<TReal32> resultPckg(value);            

   601             aResponse = resultPckg; // awkward                 

   602             break;    

   603             }

   604         case EAlfVisualSetPosTimed:

   605             {

   606             TAlfTimedPoint* params = (TAlfTimedPoint*) aInputBuffer.Ptr();                        

   607             AlfTimedValueUtility::CopyTimedValue(params->iX, iVisual->Pos().iX, iResolver);

   608             AlfTimedValueUtility::CopyTimedValue(params->iY, iVisual->Pos().iY, iResolver);

   609             break;        

   610             }            

   611         case EAlfVisualSetSizeTimed:            

   612             {

   613             TAlfTimedPoint* params = (TAlfTimedPoint*) aInputBuffer.Ptr();                        

   614             AlfTimedValueUtility::CopyTimedValue(params->iX, iVisual->Size().iX, iResolver);

   615             AlfTimedValueUtility::CopyTimedValue(params->iY, iVisual->Size().iY, iResolver);

   616             break;        

   617             }

   618             

   619         case EAlfVisualLayoutUpdatedNotification:

   620             {

   621             if ( !iPrivateData->iVisualOwner )

   622                 {

   623                 // @todo: nasty hack

   624                 CAlfAppSrvSessionBase& session = static_cast<CAlfAppSrvSessionBase&>( iResolver );

   625                 iPrivateData->iVisualOwner = CAlfSrvVisualOwner::NewL( session, &iVisual->Owner() );

   626                 iVisual->SetOwner( *iPrivateData->iVisualOwner );

   627                 }

   628             

   629             TInt commandId = iResolver.HandleCurrentCommanndAsynch();

   630             iPrivateData->iVisualOwner->SetVisualLayoutUpdatedNotificationId( commandId );

   631             break;

   632             }

   633         case EAlfSubSCancelAsynchRequest:

   634             {

   635             TInt2* inptr =  (TInt2*) aInputBuffer.Ptr();

   636             if (inptr->iInt2 != EAlfVisualLayoutUpdatedNotification )

   637                 { 

   638                 // strange one, someone tries to cancel something we don't support

   639                 // we shouldn't leave on cancel though

   640                 break;

   641                 }

   642             // else let fall through    

   643             }

   644         case EAlfVisualLayoutUpdatedNotificationCancel:

   645             {

   646             if ( iPrivateData->iVisualOwner )

   647                 {

   648                 if ( iVisual ) // If the visual has not been deleted already

   649                     {

   650                     iVisual->SetOwner( *iPrivateData->iVisualOwner->RealOwner() );

   651                     }

   652                 delete iPrivateData->iVisualOwner;

   653                 iPrivateData->iVisualOwner = NULL;

   654                 }    

   655             break;

   656             }

   657 

   658         case EAlfVisualCopyValuesFromOtherVisual:

   659             {

   660             TInt3* inptr =  (TInt3*) aInputBuffer.Ptr();

   661             CHuiVisual* sourceVisual = (CHuiVisual*) iResolver.GetInterfaceL( EHuiObjectTypeVisual, inptr->iInt1 );

   662             if (inptr->iInt2&AlfVisualProperties::ESize)

   663                 {

   664                 THuiRealPoint gotThePoint = sourceVisual->Size().RealTarget(); 

   665                 THuiRealSize rs(gotThePoint.iX, gotThePoint.iY);

   666                 iVisual->SetSize(rs, inptr->iInt3 );

   667                 }

   668             if (inptr->iInt2&AlfVisualProperties::EPosition)

   669                 { 

   670                 THuiRealPoint gotThePoint = sourceVisual->Pos().RealTarget(); 

   671                 THuiRealPoint rPoint(gotThePoint.iX, gotThePoint.iY);

   672                 iVisual->SetPos(rPoint, inptr->iInt3);

   673                 }

   674             if (inptr->iInt2&AlfVisualProperties::EOpacity)

   675                 {

   676                 iVisual->iOpacity.Set(sourceVisual->iOpacity.Target(), inptr->iInt3); 

   677                 }

   678             if (inptr->iInt2&AlfVisualProperties::EDepthOffset)

   679                 {

   680                 iVisual->iDepthOffset.Set( sourceVisual->iDepthOffset.Target(), inptr->iInt3);

   681                 }

   682             break;

   683             }

   684 

   685         case EAlfVisualPauseProperties:

   686             {

   687             TInt* inptr =  (TInt*) aInputBuffer.Ptr();

   688             if (*inptr&AlfVisualProperties::ESize)

   689                 {

   690                 iVisual->Size().iX.Suspend(); 

   691                 iVisual->Size().iY.Suspend(); 

   692                 }

   693             if (*inptr&AlfVisualProperties::EPosition)

   694                 { 

   695                 iVisual->Pos().iX.Suspend(); 

   696                 iVisual->Pos().iY.Suspend(); 

   697                 }

   698             if (*inptr&AlfVisualProperties::EOpacity)

   699                 {

   700                 iVisual->iOpacity.Suspend(); 

   701                 }

   702             if (*inptr&AlfVisualProperties::EDepthOffset)

   703                 {

   704                 iVisual->iDepthOffset.Suspend();

   705                 }

   706             break;

   707             }

   708 

   709         case EAlfVisualResumeProperties:

   710             {

   711             TInt* inptr =  (TInt*) aInputBuffer.Ptr();

   712             if (*inptr&AlfVisualProperties::ESize)

   713                 {

   714                 iVisual->Size().iX.Suspend(EFalse); 

   715                 iVisual->Size().iY.Suspend(EFalse); 

   716                 }

   717             if (*inptr&AlfVisualProperties::EPosition)

   718                 { 

   719                 iVisual->Pos().iX.Suspend(EFalse); 

   720                 iVisual->Pos().iY.Suspend(EFalse); 

   721                 }

   722             if (*inptr&AlfVisualProperties::EOpacity)

   723                 {

   724                 iVisual->iOpacity.Suspend(EFalse); 

   725                 }

   726             if (*inptr&AlfVisualProperties::EDepthOffset)

   727                 {

   728                 iVisual->iDepthOffset.Suspend(EFalse);

   729                 }

   730             break;

   731             }

   732             

   733         case EAlfVisualSetTactileFeedback:

   734             {

   735             TInt2* value = (TInt2*) aInputBuffer.Ptr();

   736             iVisual->SetTactileFeedbackL( value->iInt1, value->iInt2 );

   737             }

   738             break;

   739             

   740         case EAlfVisualHasTactileFeedback:

   741             {

   742             TInt* value = (TInt*) aInputBuffer.Ptr();

   743             TBool answer = iVisual->HasTactileFeedback( *value );

   744             TPckg<TBool> resultPckg(answer);           

   745             aResponse = resultPckg;

   746             }

   747             break;

   748             

   749         case EAlfVisualRemoveTactileFeedback:

   750             {

   751             TInt* value = (TInt*) aInputBuffer.Ptr();

   752             iVisual->RemoveTactileFeedback( *value );

   753             }

   754             break;

   755             

   756         case EAlfVisualEnableDropShadow:

   757             {

   758             const TBool* const enable = (TBool*) aInputBuffer.Ptr();

   759             iVisual->EnableDropShadowL( *enable );

   760             }

   761             break;

   762             

   763         case EAlfVisualSetEffect:

   764             {

   765             // TODO: handle errors more gracefully

   766             // TODO: effect merging

   767             TAlfVisualEffectParams* params = (TAlfVisualEffectParams*)aInputBuffer.Ptr();

   768             CHuiFxEngine* engine = iVisual->Env().EffectsEngine();

   769             if (engine)

   770                 {

   771                 CHuiFxEffect* effect = NULL;

   772                 engine->LoadEffectL( params->iFileName, effect, iVisual->Effectable() );

   773                 // The effect will be automatically set to the visual if parsing succeeds

   774                 }

   775             break;

   776             }

   777         case EAlfVisualSetGroupEffect:

   778             {

   779             TAlfVisualEffectParams* params = (TAlfVisualEffectParams*)aInputBuffer.Ptr();

   780             TInt groupHandle = params->iGroupHandle;

   781             CHuiFxEngine* engine = iVisual->Env().EffectsEngine();

   782             if (engine)

   783                 {

   784                 CHuiFxEffect* effect = NULL;

   785                 // this will add the group, if it does not exist already

   786                 // Begin and End group events are supposed to come through GfxTransEffect API.

   787                 engine->BeginGroupEffect(groupHandle); 

   788                 engine->LoadGroupEffectL( params->iFileName, effect, iVisual->Effectable(),groupHandle );

   789                 // The effect will be automatically set to the visual if parsing succeeds

   790                 }

   791             break;

   792             }            

   793         case EAlfVisualRemoveEffect:

   794             {

   795             iVisual->SetEffect(NULL);

   796             break;

   797             }

   798 

   799         default:

   800             

   801             if ( AlfSrvDropShadowHandler::CanHandleCommand( aCommandId ) )

   802                 {

   803                 CHuiDropShadow* shadow = iVisual->DropShadowHandler();

   804                 

   805                 // Drop shadow should be enabled first

   806                 __ASSERT_DEBUG( shadow , User::Leave( KErrGeneral ) );

   807                 

   808                 if ( !shadow )

   809                     {

   810                     iVisual->EnableDropShadowL( ETrue );

   811                     shadow = iVisual->DropShadowHandler();

   812                     }

   813                 

   814                 AlfSrvDropShadowHandler::HandleCommandL( *shadow, aCommandId, aInputBuffer, aResponse );

   815                 break;

   816                 }

   817         

   818             User::Leave(KErrNotSupported);

   819         }

   820     }

   821 

   822 EXPORT_C void CAlfVisualHandler::VisualHandlerExtension(const TUid& /*aExtensionUid*/, TAny** /*aExtensionParameters*/)

   823     {

   824     }

   825 

   826 //----------------------------

   827 // TextVisual

   828 //----------------------------

   829 EXPORT_C MAlfExtension* CAlfTextVisualHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)

   830     {

   831     CAlfTextVisualHandler* me = new (ELeave) CAlfTextVisualHandler(aResolver);

   832     CleanupStack::PushL(me);

   833     me->ConstructL(NULL, *aOwner, aParentLayout);

   834     CleanupStack::Pop();

   835     return me;

   836     }

   837 

   838 

   839 EXPORT_C CAlfTextVisualHandler::CAlfTextVisualHandler(MAlfInterfaceProvider& aResolver):CAlfVisualHandler(aResolver)

   840     {

   841     }

   842 

   843 

   844 EXPORT_C void CAlfTextVisualHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)

   845     {

   846     if (!aVisual)

   847         {

   848         CHuiTextVisual* textVisual = CHuiTextVisual::AddNewL(aOwner, aParentLayout); 

   849         CAlfVisualHandler::ConstructL(textVisual, aOwner, aParentLayout);

   850         }

   851     else 

   852         {

   853         CAlfVisualHandler::ConstructL(aVisual, aOwner, aParentLayout);

   854         }

   855     }

   856 

   857 

   858 EXPORT_C CAlfTextVisualHandler::~CAlfTextVisualHandler()

   859     {

   860     }

   861 

   862 EXPORT_C void CAlfTextVisualHandler::Release()

   863     {

   864     delete this;

   865     }

   866 

   867 

   868 EXPORT_C TAny* CAlfTextVisualHandler::GetInterface(const THuiInterfaceSupport& aInterface)

   869     {

   870     return CAlfVisualHandler::GetInterface(aInterface);

   871     }

   872 

   873 

   874 EXPORT_C void CAlfTextVisualHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)

   875     {

   876     CHuiTextVisual* visual = static_cast<CHuiTextVisual*>(iVisual);

   877     

   878     switch (aCommandId)

   879         {

   880         case  EAlfTextVisualSetText:           

   881             {

   882             TPtrC text((const TUint16*)aInputBuffer.Ptr(), aInputBuffer.Length()/2);                        

   883             visual->SetTextL(text);

   884             break;                

   885             }

   886         

   887         case  EAlfTextVisualSetStyle:

   888             {      

   889             TInt2* params = (TInt2*) aInputBuffer.Ptr();

   890             visual->SetStyle( (THuiPreconfiguredTextStyle)params->iInt1,(THuiBackgroundType)params->iInt2 );

   891             break;    

   892             }

   893         

   894         case  EAlfTextVisualSetTextStyle:

   895             {

   896     		// Convert text style id to server domain

   897             TInt* value = (TInt*) aInputBuffer.Ptr();            	

   898     		TAlfTextStyleHandler* textStyleHandler = static_cast<TAlfTextStyleHandler*>(iResolver.GetInterfaceL(EAlfTextStyleHandler, *value));    		

   899             visual->SetTextStyle(textStyleHandler->TextStyleId());

   900             break;    

   901             }

   902         

   903         case  EAlfTextVisualSetEffects:

   904             {

   905             // This is for future expansion, unimplemented.

   906             break;    

   907             }

   908         

   909         case EAlfTextVisualSetAlign:

   910             {

   911             TInt2* params = (TInt2*) aInputBuffer.Ptr();

   912             visual->SetAlign( (THuiAlignHorizontal)params->iInt1,(THuiAlignVertical)params->iInt2 );

   913             break;

   914             }

   915             

   916         case EAlfTextVisualSetLineSpacing:

   917             {

   918             TInt2* params = (TInt2*) aInputBuffer.Ptr();

   919             visual->SetLineSpacing( params->iInt1, (CHuiTextVisual::TLineSpacingUnits)params->iInt2 );

   920             break;

   921             }

   922             

   923         case EAlfTextVisualTextExtents:

   924             {

   925             const TSize size = visual->TextExtents();

   926             TPckg<TSize> resultPckg(size);            

   927             aResponse = resultPckg; // awkward 

   928             break;

   929             }

   930             

   931         case EAlfTextVisualSubstringExtents:

   932             {

   933             TInt2* params = (TInt2*) aInputBuffer.Ptr();            

   934             const TRect size = visual->SubstringExtents(params->iInt1, params->iInt2);

   935             TPckg<TRect> resultPckg(size);            

   936             aResponse = resultPckg; // awkward 

   937             break;

   938             }

   939                         

   940         case EAlfTextVisualStyle:

   941             {

   942             const TInt2 result( 

   943                 visual->Style(),

   944                 visual->BackgroundType() );

   945             

   946             

   947             TPckg<TInt2> resultPckg(result);            

   948             aResponse = resultPckg; // awkward 

   949             break;

   950             }

   951                                             

   952         case EAlfTextVisualSetMaxLineCount:

   953             {

   954             TInt* value = (TInt*) aInputBuffer.Ptr();

   955             visual->SetMaxLineCount(*value);

   956             break;

   957             }

   958 

   959         case EAlfTextVisualMaxLineCount:

   960             {

   961             const TInt value = visual->MaxLineCount();

   962             TPckg<TInt> resultPckg(value);            

   963             aResponse = resultPckg; // awkward 

   964             break;

   965             }

   966 

   967         case EAlfTextVisualWrapping:

   968             {

   969             // Client side uses CAlfTextVisual::TLineWrap, should be compatible.

   970             CHuiTextVisual::TLineWrap value = visual->Wrapping();

   971             TPckg<CHuiTextVisual::TLineWrap> resultPckg(value);            

   972             aResponse = resultPckg; // awkward 

   973             break;

   974             }

   975 

   976         case EAlfTextVisualSetWrapping:

   977             {

   978             CHuiTextVisual::TLineWrap* value = (CHuiTextVisual::TLineWrap*) aInputBuffer.Ptr();

   979             visual->SetWrapping(*value);

   980             break;

   981             }

   982 

   983         /* deprecated

   984         case EAlfTextVisualShadowOpacity:

   985         case EAlfTextVisualSetShadowOpacity:        

   986         */

   987             

   988         case EAlfTextVisualSetColor:        

   989             {

   990             TAlfTextVisualFontColorParams* value = (TAlfTextVisualFontColorParams*) aInputBuffer.Ptr();

   991             if (value->iId == KAknsIIDNone)

   992                 {

   993                 visual->SetColor(value->iColor);                        

   994                 }

   995             else

   996                 {

   997                 visual->SetColor(value->iId, value->iIndex);                                            

   998                 }    

   999             break;

  1000             }

  1001             

  1002         case EAlfTextVisualOffset:        

  1003             {

  1004             TAlfTimedPoint value;

  1005             AlfTimedPointUtility::CopyTimedPoint(visual->Offset(), value);

  1006             TPckg<TAlfTimedPoint> resultPckg(value);            

  1007             aResponse = resultPckg; // awkward 

  1008             break;

  1009             }            

  1010         case EAlfTextVisualSetOffset:

  1011             {

  1012             TAlfTimedPoint* value = (TAlfTimedPoint*) aInputBuffer.Ptr();

  1013             AlfTimedPointUtility::CopyTimedPoint(*value, visual->Offset(), iResolver);

  1014             break;

  1015             }

  1016         case EAlfTextVisualSetHighlightRange:

  1017         	{

  1018 			TAlfTextVisualSetHighlightRangeParams* value = (TAlfTextVisualSetHighlightRangeParams*) aInputBuffer.Ptr();        	

  1019 			visual->SetHighlightRange(value->iStart, value->iEnd, value->iHighlightColor, value->iHighlightTextColor);

  1020 			break;

  1021         	}    

  1022 

  1023         /* deprecated

  1024         case EAlfTextVisualEnableShadow:        

  1025         */       

  1026         case EAlfTextVisualSetRasterizedMesh:

  1027             {

  1028         	visual->UpdateMeshL(aInputBuffer);

  1029         	break;

  1030             }

  1031         	

  1032         case EAlfVisualCopyValuesFromOtherVisual:

  1033         case EAlfVisualPauseProperties:

  1034         case EAlfVisualResumeProperties:        

  1035             {

  1036             if (aCommandId == EAlfVisualCopyValuesFromOtherVisual)

  1037                 {

  1038                 TInt3* inptr =  (TInt3*) aInputBuffer.Ptr();

  1039                 CHuiTextVisual* sourceVisual = (CHuiTextVisual*) iResolver.GetInterfaceL( EHuiObjectTypeVisual, inptr->iInt1 );

  1040                 if (inptr->iInt2&AlfVisualProperties::ETextVisShadowOpacity)

  1041                     {

  1042                     visual->iShadow.Set(sourceVisual->iShadow.Target(), inptr->iInt3 );

  1043                     }

  1044                 }

  1045             else if (aCommandId == EAlfVisualPauseProperties)

  1046                 {

  1047                 TInt* inptr =  (TInt*) aInputBuffer.Ptr();

  1048                 if (*inptr&AlfVisualProperties::ETextVisShadowOpacity)

  1049                     {

  1050                     visual->iShadow.Suspend();

  1051                     }

  1052                 }

  1053             else  // AlfVisualResumeProperties

  1054                 {

  1055                 TInt* inptr =  (TInt*) aInputBuffer.Ptr();

  1056                 if (*inptr&AlfVisualProperties::ETextVisShadowOpacity)

  1057                     {

  1058                     visual->iShadow.Suspend(EFalse);

  1059                     }

  1060                 }

  1061             } // FALL THROUGH !!

  1062         default:

  1063             CAlfVisualHandler::HandleCmdL(aCommandId, aInputBuffer, aResponse);

  1064         }

  1065     }

  1066 

  1067 EXPORT_C void CAlfTextVisualHandler::VisualHandlerExtension(const TUid& aExtensionUid, TAny** aExtensionParameters)

  1068     {

  1069     CAlfVisualHandler::VisualHandlerExtension(aExtensionUid,aExtensionParameters);

  1070     }

  1071 

  1072  

  1073 //----------------------------

  1074 // LCTTextVisual

  1075 //----------------------------

  1076 EXPORT_C MAlfExtension* CAlfLCTTextVisualHandler::NewL(MAlfInterfaceProvider& aResolver, CHuiControl* aOwner, CHuiLayout* aParentLayout)

  1077     {

  1078     CAlfLCTTextVisualHandler* me = new (ELeave) CAlfLCTTextVisualHandler(aResolver);

  1079     CleanupStack::PushL(me);

  1080     me->ConstructL(NULL, *aOwner, aParentLayout);

  1081     CleanupStack::Pop();

  1082     return me;

  1083     }

  1084 

  1085 

  1086 EXPORT_C CAlfLCTTextVisualHandler::CAlfLCTTextVisualHandler(MAlfInterfaceProvider& aResolver):CAlfTextVisualHandler(aResolver)

  1087     {

  1088     }

  1089 

  1090 

  1091 EXPORT_C void CAlfLCTTextVisualHandler::ConstructL(CHuiVisual* aVisual, CHuiControl& aOwner, CHuiLayout* aParentLayout)

  1092     {

  1093     if (!aVisual)

  1094         {

  1095         CHuiTextVisual* textVisual = CHuiTextVisual::AddNewL(aOwner, aParentLayout); 

  1096         CAlfVisualHandler::ConstructL(textVisual, aOwner, aParentLayout);

  1097         }

  1098     else 

  1099         {

  1100         CAlfVisualHandler::ConstructL(aVisual, aOwner, aParentLayout);

  1101         }

  1102     }

  1103 

  1104 

  1105 EXPORT_C CAlfLCTTextVisualHandler::~CAlfLCTTextVisualHandler()

  1106     {

  1107     }

  1108 

  1109 

  1110 EXPORT_C void CAlfLCTTextVisualHandler::Release()

  1111     {

  1112     delete this;

  1113     }

  1114 

  1115 

  1116 EXPORT_C TAny* CAlfLCTTextVisualHandler::GetInterface(const THuiInterfaceSupport& aInterface)

  1117     {

  1118     return CAlfTextVisualHandler::GetInterface(aInterface);

  1119     }

  1120 

  1121 

  1122 EXPORT_C void CAlfLCTTextVisualHandler::HandleCmdL(TInt aCommandId, const TDesC8& aInputBuffer, TDes8& aResponse)

  1123     {

  1124     switch (aCommandId)

  1125         {

  1126         case  EAlfLCTTextVisualSetTextPane:

  1127             {

  1128 #ifdef RD_ALF_IN_PLATFORM

  1129             CHuiTextVisual* visual = static_cast<CHuiTextVisual*>(iVisual);

  1130             TAlfLCTTextVisualSetTextPaneParams* params = (TAlfLCTTextVisualSetTextPaneParams*)aInputBuffer.Ptr();

  1131 

  1132             TAknLayoutHierarchyComponentHandle handle;

  1133             handle.SetApiId(params->iApiId);

  1134             handle.SetComponentId(params->iComponentId);