1 /*

     2 * Copyright (c) 2002 - 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:  test functions for alfvisual.h

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES]

    21 #include <alf/alfvisual.h>

    22 #include <alf/alfvisualfactory.h>

    23 #include <touchlogicalfeedback.h>

    24 #include <alf/alfpropertyowner.h>

    25 

    26 #include "testplatalfvisual.h"

    27 

    28 

    29 // CONSTANTS

    30 const TUint KRefFlag = 0;

    31 

    32 const TInt KNum10 = 10;

    33 const TInt KNum20 = 20;

    34 const TInt KNum30 = 30;

    35 const TInt KNum40 = 40;

    36 const TInt KNum50 = 50;

    37 const TInt KNum65 = 65;

    38 const TInt KNum88 = 88;

    39 const TInt KNum100 = 100;

    40 const TInt KNum120 = 120;

    41 const TInt KNum200 = 200;

    42 const TInt KNum300 = 300;

    43 

    44 const TReal32 KReal1 = 20.4;

    45 const TReal32 KReal2 = 30.3;

    46 const TReal32 KReal3 = 40.3;

    47 const TReal32 KReal4 = 50.4;

    48 const TReal32 KReal5 = 0.6;

    49 const TReal32 KReal6 = 0.3;

    50 const TReal32 KReal7 = 12.3;

    51 

    52 

    53 // FORWARD DECLARATION

    54 // class CTestAlfVisual for testing CAlfVisual

    55 class CTestAlfVisual : public CAlfVisual

    56     {

    57 public:

    58     // From CAlfVisual

    59     void PropertyOwnerExtension( const TUid& aExtensionUid, TAny** aExtensionParams )

    60         {

    61         CAlfVisual::PropertyOwnerExtension( aExtensionUid, aExtensionParams );

    62         }

    63     };

    64 

    65 

    66 // ============================ MEMBER FUNCTIONS ===============================

    67 

    68 // -----------------------------------------------------------------------------

    69 // CTestPlatAlfVisual::TestCAlfVCAlfVisualL

    70 // -----------------------------------------------------------------------------

    71 //

    72 TInt CTestPlatAlfVisual::TestCAlfVCAlfVisualL( CStifItemParser& /*aItem*/ )

    73     {

    74     // Print to UI

    75     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    76     _LIT( KTestCAlfVCAlfVisualL, "TestCAlfVCAlfVisualL" );

    77     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVCAlfVisualL );

    78     // Print to log file

    79     iLog->Log( KTestCAlfVCAlfVisualL );

    80     

    81     CAlfVisual* alfVisual = new ( ELeave ) CAlfVisual();

    82     CleanupStack::PushL( alfVisual );

    83     STIF_ASSERT_NOT_NULL( alfVisual );

    84     CleanupStack::PopAndDestroy( alfVisual );

    85     

    86     return KErrNone;

    87     }

    88 

    89 // -----------------------------------------------------------------------------

    90 // CTestPlatAlfVisual::TestCAlfVConstructL

    91 // -----------------------------------------------------------------------------

    92 //

    93 TInt CTestPlatAlfVisual::TestCAlfVConstructL( CStifItemParser& /*aItem*/ )

    94     {

    95     // Print to UI

    96     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

    97     _LIT( KTestCAlfVConstructL, "TestCAlfVConstructL" );

    98     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVConstructL );

    99     // Print to log file

   100     iLog->Log( KTestCAlfVConstructL );

   101     

   102     CAlfVisual* alfVisual = new ( ELeave ) CAlfVisual();

   103     CleanupStack::PushL( alfVisual );

   104     STIF_ASSERT_NOT_NULL( alfVisual );

   105     alfVisual->ConstructL( *iAlfCtl );

   106     CleanupStack::PopAndDestroy( alfVisual );

   107     

   108     return KErrNone;

   109     }

   110 

   111 // -----------------------------------------------------------------------------

   112 // CTestPlatAlfVisual::TestCAlfVRemoveAndDestroyAllDL

   113 // -----------------------------------------------------------------------------

   114 //

   115 TInt CTestPlatAlfVisual::TestCAlfVRemoveAndDestroyAllDL( CStifItemParser& /*aItem*/ )

   116     {

   117     // Print to UI

   118     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   119     _LIT( KTestCAlfVRemoveAndDestroyAllDL, "TestCAlfVRemoveAndDestroyAllDL" );

   120     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVRemoveAndDestroyAllDL );

   121     // Print to log file

   122     iLog->Log( KTestCAlfVRemoveAndDestroyAllDL );

   123     

   124     

   125     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   126             EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   127     STIF_ASSERT_NOT_NULL( alfVisual );

   128     alfVisual->RemoveAndDestroyAllD();

   129     

   130     return KErrNone;

   131     }

   132 

   133 // -----------------------------------------------------------------------------

   134 // CTestPlatAlfVisual::TestCAlfVIdentifierL

   135 // -----------------------------------------------------------------------------

   136 //

   137 TInt CTestPlatAlfVisual::TestCAlfVIdentifierL( CStifItemParser& /*aItem*/ )

   138     {

   139     // Print to UI

   140     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   141     _LIT( KTestCAlfVIdentifierL, "TestCAlfVIdentifierL" );

   142     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVIdentifierL );

   143     // Print to log file

   144     iLog->Log( KTestCAlfVIdentifierL );

   145     

   146     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   147                 EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   148     CleanupStack::PushL( alfVisual );

   149     STIF_ASSERT_NOT_NULL( alfVisual );

   150     STIF_ASSERT_NOT_EQUALS( 0, alfVisual->Identifier() );

   151     CleanupStack::PopAndDestroy( alfVisual );

   152     

   153     return KErrNone;

   154     }

   155 

   156 // -----------------------------------------------------------------------------

   157 // CTestPlatAlfVisual::TestCAlfVSetFlagL

   158 // -----------------------------------------------------------------------------

   159 //

   160 TInt CTestPlatAlfVisual::TestCAlfVSetFlagL( CStifItemParser& /*aItem*/ )

   161     {

   162     // Print to UI

   163     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   164     _LIT( KTestCAlfVSetFlagL, "TestCAlfVSetFlagL" );

   165     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetFlagL );

   166     // Print to log file

   167     iLog->Log( KTestCAlfVSetFlagL );

   168     

   169     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   170     CleanupStack::PushL( alfVisual );

   171     STIF_ASSERT_NOT_NULL( alfVisual );

   172     

   173     // Create layout parent for testing purposes

   174     CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

   175     CleanupStack::PushL( parentLayout );

   176     User::LeaveIfError( parentLayout->Append( alfVisual ) ); 

   177     parentLayout->SetFlag( EAlfVisualFlagManualLayout );

   178     parentLayout->SetPos( TAlfRealPoint( KNum40, KNum50 ) );

   179     parentLayout->SetSize( TAlfRealSize( KNum100, KNum120 ) );

   180     parentLayout->UpdateChildrenLayout();

   181     TAlfTimedPoint size = alfVisual->Size(); 

   182     STIF_ASSERT_EQUALS( KNum100+0.f, size.iX.Target() );

   183     STIF_ASSERT_EQUALS( KNum120+0.f, size.iY.Target() );

   184     TAlfTimedPoint pos = alfVisual->Pos(); 

   185     STIF_ASSERT_EQUALS( 0.f, pos.iX.Target() );

   186     STIF_ASSERT_EQUALS( 0.f, pos.iY.Target() );

   187     

   188     // 1# EAlfVisualFlagManualSize

   189     alfVisual->SetSize( TAlfRealSize( KNum10, KNum20 ) );   // 1. resize without the flag

   190     parentLayout->UpdateChildrenLayout();           // 2. relayout siblings

   191     size = alfVisual->Size();                       // 3. check that the visual still has the original size

   192     STIF_ASSERT_EQUALS( KNum100+0.f, size.iX.Target() );

   193     STIF_ASSERT_EQUALS( KNum120+0.f, size.iY.Target() );

   194     alfVisual->SetFlag( EAlfVisualFlagManualSize ); // 4. set the manual size flag

   195     alfVisual->SetSize( TAlfRealSize( KNum10, KNum20 ) );   // 5. resize again

   196     parentLayout->UpdateChildrenLayout();           // 6. relayout siblings

   197     size = alfVisual->Size();                       // 7. check the the new size is still valid

   198     STIF_ASSERT_EQUALS( KNum10+0.f, size.iX.Target() );

   199     STIF_ASSERT_EQUALS( KNum20+0.f, size.iY.Target() );

   200     

   201     // 2# EAlfVisualFlagManualPosition

   202     alfVisual->SetPos( TAlfRealPoint( KNum10, KNum20 ) );   // 1. replace without the flag

   203     parentLayout->UpdateChildrenLayout();           // 2. relayout siblings

   204     pos = alfVisual->Pos();                         // 3. check that the visual still has the original position

   205     STIF_ASSERT_EQUALS( 0.f, pos.iX.Target() );

   206     STIF_ASSERT_EQUALS( 0.f, pos.iY.Target() );

   207     alfVisual->SetFlag( EAlfVisualFlagManualPosition );// 4. set the manual position flag

   208     alfVisual->SetPos( TAlfRealPoint( KNum10, KNum20 ) );      // 5. replace again

   209     parentLayout->UpdateChildrenLayout();              // 6. relayout siblings

   210     pos = alfVisual->Pos();                            // 7. check the the new posotion is still valid

   211     STIF_ASSERT_EQUALS( KNum10+0.f, pos.iX.Target() );

   212     STIF_ASSERT_EQUALS( KNum20+0.f, pos.iY.Target() );

   213     

   214     // 3# AlfVisualFlagClipping

   215     alfVisual->SetFlag( AlfVisualFlagClipping );

   216     

   217     // 4# EAlfVisualFlagLayoutUpdateNotification

   218     parentLayout->UpdateChildrenLayout();

   219     

   220     // 5# EAlfVisualFlag3DProjection

   221     alfVisual->SetFlag( EAlfVisualFlag3DProjection );

   222     

   223     // 6# EAlfVisualFlagNoDepthOcclusion

   224     alfVisual->SetFlag( EAlfVisualFlagNoDepthOcclusion );

   225     

   226     // 7# EAlfVisualFlagLocalHorizon

   227     alfVisual->SetFlag( EAlfVisualFlagLocalHorizon );

   228     

   229     // 8# EAlfVisualFlagClipping

   230     alfVisual->SetFlag( EAlfVisualFlagClipping );

   231     

   232     // 8# EAlfVisualFlagHOriginCenter

   233     alfVisual->SetFlag( EAlfVisualFlagHOriginCenter );

   234     

   235     // 8# EAlfVisualFlagHOriginRight

   236     alfVisual->SetFlag( EAlfVisualFlagHOriginRight );

   237     

   238     // 8# EAlfVisualFlagVOriginCenter

   239     alfVisual->SetFlag( EAlfVisualFlagVOriginCenter );

   240     

   241     // 8# EAlfVisualFlagVOriginBottom

   242     alfVisual->SetFlag( EAlfVisualFlagVOriginBottom );

   243     

   244     CleanupStack::Pop( parentLayout );

   245     CleanupStack::Pop( alfVisual );

   246     

   247     return KErrNone;

   248     }

   249 

   250 // -----------------------------------------------------------------------------

   251 // CTestPlatAlfVisual::TestCAlfVSetFlagsL

   252 // -----------------------------------------------------------------------------

   253 //

   254 TInt CTestPlatAlfVisual::TestCAlfVSetFlagsL( CStifItemParser& /*aItem*/ )

   255     {

   256     // Print to UI

   257     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   258     _LIT( KTestCAlfVSetFlagsL, "TestCAlfVSetFlagsL" );

   259     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetFlagsL );

   260     // Print to log file

   261     iLog->Log( KTestCAlfVSetFlagsL );

   262     

   263     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   264                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   265     CleanupStack::PushL( alfVisual );

   266     STIF_ASSERT_NOT_NULL( alfVisual );

   267     TUint flags = EAlfVisualFlagVOriginCenter +

   268                   EAlfVisualFlagNoDepthOcclusion +

   269                   EAlfVisualFlagClipping;

   270     alfVisual->SetFlags( flags );

   271     TUint retFlags = alfVisual->Flags();

   272     STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagVOriginCenter ) );

   273     STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

   274     STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagClipping ) );

   275     CleanupStack::PopAndDestroy( alfVisual );

   276     

   277     return KErrNone;

   278     }

   279 

   280 // -----------------------------------------------------------------------------

   281 // CTestPlatAlfVisual::TestCAlfVClearFlagL

   282 // -----------------------------------------------------------------------------

   283 //

   284 TInt CTestPlatAlfVisual::TestCAlfVClearFlagL( CStifItemParser& /*aItem*/ )

   285     {

   286     // Print to UI

   287     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   288     _LIT( KTestCAlfVClearFlagL, "TestCAlfVClearFlagL" );

   289     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVClearFlagL );

   290     // Print to log file

   291     iLog->Log( KTestCAlfVClearFlagL );

   292     

   293     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   294                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   295     CleanupStack::PushL( alfVisual );

   296     STIF_ASSERT_NOT_NULL( alfVisual );

   297     TUint flags = EAlfVisualFlagVOriginCenter +

   298                   EAlfVisualFlagNoDepthOcclusion +

   299                   EAlfVisualFlagClipping;

   300     alfVisual->SetFlags( flags );

   301     alfVisual->ClearFlag( EAlfVisualFlagNoDepthOcclusion );

   302     alfVisual->ClearFlag( EAlfVisualFlagClipping );

   303     TUint retFlags = alfVisual->Flags();

   304     STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagVOriginCenter ) );

   305     STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

   306     STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagClipping ) );

   307     CleanupStack::PopAndDestroy( alfVisual );

   308     

   309     return KErrNone;

   310     }

   311 

   312 // -----------------------------------------------------------------------------

   313 // CTestPlatAlfVisual::TestCAlfVClearFlagsL

   314 // -----------------------------------------------------------------------------

   315 //

   316 TInt CTestPlatAlfVisual::TestCAlfVClearFlagsL( CStifItemParser& /*aItem*/ )

   317     {

   318     // Print to UI

   319     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   320     _LIT( KTestCAlfVClearFlagsL, "TestCAlfVClearFlagsL" );

   321     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVClearFlagsL );

   322     // Print to log file

   323     iLog->Log( KTestCAlfVClearFlagsL );

   324     

   325     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   326                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   327     CleanupStack::PushL( alfVisual );

   328     STIF_ASSERT_NOT_NULL( alfVisual );

   329     TUint flags = EAlfVisualFlagVOriginCenter +

   330                   EAlfVisualFlagNoDepthOcclusion +

   331                   EAlfVisualFlagClipping;

   332     alfVisual->SetFlags( flags );

   333     alfVisual->ClearFlags( EAlfVisualFlagNoDepthOcclusion + EAlfVisualFlagClipping );

   334     TUint retFlags = alfVisual->Flags();

   335     STIF_ASSERT_NOT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagVOriginCenter ) );

   336     STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

   337     STIF_ASSERT_EQUALS( KRefFlag, ( retFlags & EAlfVisualFlagClipping ) );

   338     CleanupStack::PopAndDestroy( alfVisual );

   339     

   340     return KErrNone;

   341     }

   342 

   343 // -----------------------------------------------------------------------------

   344 // CTestPlatAlfVisual::TestCAlfVFlagsL

   345 // -----------------------------------------------------------------------------

   346 //

   347 TInt CTestPlatAlfVisual::TestCAlfVFlagsL( CStifItemParser& /*aItem*/ )

   348     {

   349     // Print to UI

   350     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   351     _LIT( KTestCAlfVFlagsL, "TestCAlfVFlagsL" );

   352     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVFlagsL );

   353     // Print to log file

   354     iLog->Log( KTestCAlfVFlagsL );

   355     

   356     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   357                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   358     CleanupStack::PushL( alfVisual );

   359     STIF_ASSERT_NOT_NULL( alfVisual );

   360     

   361     alfVisual->SetFlag( EAlfVisualFlagVOriginCenter );

   362     TUint retFlags = alfVisual->Flags();

   363     STIF_ASSERT_NOT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagVOriginCenter ) );

   364     

   365     alfVisual->SetFlag( EAlfVisualFlagNoDepthOcclusion );

   366     retFlags = alfVisual->Flags();

   367     STIF_ASSERT_NOT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

   368     

   369     alfVisual->SetFlag( EAlfVisualFlagClipping );

   370     retFlags = alfVisual->Flags();

   371     STIF_ASSERT_NOT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagClipping ) );

   372     

   373     alfVisual->ClearFlag( EAlfVisualFlagNoDepthOcclusion );

   374     retFlags = alfVisual->Flags();

   375     STIF_ASSERT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagNoDepthOcclusion ) );

   376     

   377     alfVisual->ClearFlag( EAlfVisualFlagVOriginCenter );

   378     retFlags = alfVisual->Flags();

   379     STIF_ASSERT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagVOriginCenter ) );

   380     

   381     alfVisual->ClearFlag( EAlfVisualFlagClipping );

   382     retFlags = alfVisual->Flags();

   383     STIF_ASSERT_EQUALS( KRefFlag , ( retFlags & EAlfVisualFlagClipping ) );

   384     

   385     CleanupStack::PopAndDestroy( alfVisual );

   386     

   387     return KErrNone;

   388     }

   389 

   390 // -----------------------------------------------------------------------------

   391 // CTestPlatAlfVisual::TestCAlfVLayoutL

   392 // -----------------------------------------------------------------------------

   393 //

   394 TInt CTestPlatAlfVisual::TestCAlfVLayoutL( CStifItemParser& /*aItem*/ )

   395     {

   396     // Print to UI

   397     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   398     _LIT( KTestCAlfVLayoutL, "TestCAlfVLayoutL" );

   399     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVLayoutL );

   400     // Print to log file

   401     iLog->Log( KTestCAlfVLayoutL );

   402     

   403     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   404     CleanupStack::PushL( alfVisual );

   405     STIF_ASSERT_NOT_NULL( alfVisual );

   406     

   407     STIF_ASSERT_NULL( alfVisual->Layout() );

   408     

   409     CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

   410     CleanupStack::PushL( parentLayout );

   411     STIF_ASSERT_NOT_NULL( parentLayout );

   412     User::LeaveIfError( parentLayout->Append( alfVisual ) ); // calls SetLayout()

   413     

   414     STIF_ASSERT_EQUALS( parentLayout, alfVisual->Layout() );

   415     

   416     CleanupStack::Pop( parentLayout );

   417     CleanupStack::Pop( alfVisual );

   418     

   419     return KErrNone;

   420     }

   421 

   422 // -----------------------------------------------------------------------------

   423 // CTestPlatAlfVisual::TestCAlfVPosL

   424 // -----------------------------------------------------------------------------

   425 //

   426 TInt CTestPlatAlfVisual::TestCAlfVPosL( CStifItemParser& /*aItem*/ )

   427     {

   428     // Print to UI

   429     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   430     _LIT( KTestCAlfVPosL, "TestCAlfVPosL" );

   431     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVPosL );

   432     // Print to log file

   433     iLog->Log( KTestCAlfVPosL );

   434     

   435     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   436                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   437     CleanupStack::PushL( alfVisual );

   438     STIF_ASSERT_NOT_NULL( alfVisual );

   439     

   440     TAlfRealPoint pos( KNum20, KNum30 );

   441     alfVisual->SetPos( pos );

   442     

   443     TAlfTimedPoint result = alfVisual->Pos();

   444     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.ValueNow() );

   445     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.ValueNow() );

   446     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.Target() );

   447     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.Target() );

   448     

   449     CleanupStack::PopAndDestroy( alfVisual );

   450     

   451     return KErrNone;

   452     }

   453 

   454 // -----------------------------------------------------------------------------

   455 // CTestPlatAlfVisual::TestCAlfVSetPosL

   456 // -----------------------------------------------------------------------------

   457 //

   458 TInt CTestPlatAlfVisual::TestCAlfVSetPosL( CStifItemParser& /*aItem*/ )

   459     {

   460     // Print to UI

   461     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   462     _LIT( KTestCAlfVSetPosL, "TestCAlfVSetPosL" );

   463     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetPosL );

   464     // Print to log file

   465     iLog->Log( KTestCAlfVSetPosL );

   466     

   467     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   468                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   469     CleanupStack::PushL( alfVisual );

   470     STIF_ASSERT_NOT_NULL( alfVisual );

   471     

   472     TAlfRealPoint pos( KNum20, KNum30 );

   473     alfVisual->SetPos( pos );

   474     

   475     TAlfTimedPoint result = alfVisual->Pos();

   476     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.ValueNow() );

   477     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.ValueNow() );

   478     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.Target() );

   479     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.Target() );

   480     

   481     pos = TAlfRealPoint( KNum40, KNum50 );

   482     alfVisual->SetPos( pos, KNum10);

   483     

   484     result = alfVisual->Pos();

   485     STIF_ASSERT_NOT_EQUALS( KNum40+0.f, result.iX.ValueNow() );

   486     STIF_ASSERT_NOT_EQUALS( KNum50+0.f, result.iY.ValueNow() );

   487     STIF_ASSERT_EQUALS( KNum40+0.f, result.iX.Target() );

   488     STIF_ASSERT_EQUALS( KNum50+0.f, result.iY.Target() );

   489     

   490     CleanupStack::PopAndDestroy( alfVisual );

   491     

   492     return KErrNone;

   493     }

   494 

   495 // -----------------------------------------------------------------------------

   496 // CTestPlatAlfVisual::TestCAlfVSizeL

   497 // -----------------------------------------------------------------------------

   498 //

   499 TInt CTestPlatAlfVisual::TestCAlfVSizeL( CStifItemParser& /*aItem*/ )

   500     {

   501     // Print to UI

   502     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   503     _LIT( KTestCAlfVSizeL, "TestCAlfVSizeL" );

   504     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSizeL );

   505     // Print to log file

   506     iLog->Log( KTestCAlfVSizeL );

   507     

   508     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   509                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   510     CleanupStack::PushL( alfVisual );

   511     STIF_ASSERT_NOT_NULL( alfVisual );

   512     

   513     TAlfRealSize size( KNum20, KNum30 );

   514     alfVisual->SetSize( size );

   515     

   516     TAlfTimedPoint result = alfVisual->Size();

   517     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.ValueNow() );

   518     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.ValueNow() );

   519     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.Target() );

   520     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.Target() );

   521     

   522     CleanupStack::PopAndDestroy( alfVisual );

   523     

   524     return KErrNone;

   525     }

   526 

   527 // -----------------------------------------------------------------------------

   528 // CTestPlatAlfVisual::TestCAlfVSetSizeL

   529 // -----------------------------------------------------------------------------

   530 //

   531 TInt CTestPlatAlfVisual::TestCAlfVSetSizeL( CStifItemParser& /*aItem*/ )

   532     {

   533     // Print to UI

   534     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   535     _LIT( KTestCAlfVSetSizeL, "TestCAlfVSetSizeL" );

   536     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetSizeL );

   537     // Print to log file

   538     iLog->Log( KTestCAlfVSetSizeL );

   539     

   540     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   541                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   542     CleanupStack::PushL( alfVisual );

   543     STIF_ASSERT_NOT_NULL( alfVisual );

   544     

   545     TAlfRealSize size( KNum20, KNum30 );

   546     alfVisual->SetSize( size );

   547     

   548     TAlfTimedPoint result = alfVisual->Size();

   549     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.ValueNow() );

   550     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.ValueNow() );

   551     STIF_ASSERT_EQUALS( KNum20+0.f, result.iX.Target() );

   552     STIF_ASSERT_EQUALS( KNum30+0.f, result.iY.Target() );

   553     

   554     size = TAlfRealSize( KNum40, KNum50 );

   555     alfVisual->SetSize( size, KNum10);

   556     

   557     result = alfVisual->Size();

   558     STIF_ASSERT_NOT_EQUALS( KNum40+0.f, result.iX.ValueNow() );

   559     STIF_ASSERT_NOT_EQUALS( KNum50+0.f, result.iY.ValueNow() );

   560     STIF_ASSERT_EQUALS( KNum40+0.f, result.iX.Target() );

   561     STIF_ASSERT_EQUALS( KNum50+0.f, result.iY.Target() );

   562     

   563     CleanupStack::PopAndDestroy( alfVisual );

   564     

   565     return KErrNone;

   566     }

   567 

   568 // -----------------------------------------------------------------------------

   569 // CTestPlatAlfVisual::TestCAlfVOpacityL

   570 // -----------------------------------------------------------------------------

   571 //

   572 TInt CTestPlatAlfVisual::TestCAlfVOpacityL( CStifItemParser& /*aItem*/ )

   573     {

   574     // Print to UI

   575     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   576     _LIT( KTestCAlfVOpacityL, "TestCAlfVOpacityL" );

   577     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVOpacityL );

   578     // Print to log file

   579     iLog->Log( KTestCAlfVOpacityL );

   580     

   581     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   582                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   583     CleanupStack::PushL( alfVisual );

   584     STIF_ASSERT_NOT_NULL( alfVisual );

   585     TAlfTimedValue opacity = alfVisual->Opacity();

   586     STIF_ASSERT_EQUALS( 1.f, opacity.ValueNow() );

   587     STIF_ASSERT_EQUALS( 1.f, opacity.Target() );

   588     CleanupStack::PopAndDestroy( alfVisual );

   589     

   590     return KErrNone;

   591     }

   592 

   593 // -----------------------------------------------------------------------------

   594 // CTestPlatAlfVisual::TestCAlfVSetOpacityL

   595 // -----------------------------------------------------------------------------

   596 //

   597 TInt CTestPlatAlfVisual::TestCAlfVSetOpacityL( CStifItemParser& /*aItem*/ )

   598     {

   599     // Print to UI

   600     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   601     _LIT( KTestCAlfVSetOpacityL, "TestCAlfVSetOpacityL" );

   602     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetOpacityL );

   603     // Print to log file

   604     iLog->Log( KTestCAlfVSetOpacityL );

   605     

   606     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   607                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   608     CleanupStack::PushL( alfVisual );

   609     STIF_ASSERT_NOT_NULL( alfVisual );

   610     

   611     TAlfTimedValue opacity;

   612     opacity.SetValueNow( 0.2 );

   613     alfVisual->SetOpacity( opacity );

   614     

   615     TAlfTimedValue result = alfVisual->Opacity();

   616     STIF_ASSERT_EQUALS( 0.2f, result.ValueNow() );

   617     STIF_ASSERT_EQUALS( 0.2f, result.Target() );

   618     

   619     opacity.SetTarget( KReal5, KNum10 );

   620     alfVisual->SetOpacity( opacity );

   621     

   622     result = alfVisual->Opacity();

   623     STIF_ASSERT_NOT_EQUALS( KReal5, result.ValueNow() );

   624     STIF_ASSERT_EQUALS( KReal5, result.Target() );

   625     

   626     CleanupStack::PopAndDestroy( alfVisual );

   627     

   628     return KErrNone;

   629     }

   630 

   631 // -----------------------------------------------------------------------------

   632 // CTestPlatAlfVisual::TestCAlfVEnvL

   633 // -----------------------------------------------------------------------------

   634 //

   635 TInt CTestPlatAlfVisual::TestCAlfVEnvL( CStifItemParser& /*aItem*/ )

   636     {

   637     // Print to UI

   638     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   639     _LIT( KTestCAlfVEnvL, "TestCAlfVEnvL" );

   640     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVEnvL );

   641     // Print to log file

   642     iLog->Log( KTestCAlfVEnvL );

   643     

   644     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   645                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   646     CleanupStack::PushL( alfVisual );

   647     STIF_ASSERT_NOT_NULL( alfVisual );

   648     STIF_ASSERT_EQUALS( iAlfEnv, &alfVisual->Env() );

   649     CleanupStack::PopAndDestroy( alfVisual );

   650     

   651     return KErrNone;

   652     }

   653 

   654 // -----------------------------------------------------------------------------

   655 // CTestPlatAlfVisual::TestCAlfVDisplayL

   656 // -----------------------------------------------------------------------------

   657 //

   658 TInt CTestPlatAlfVisual::TestCAlfVDisplayL( CStifItemParser& /*aItem*/ )

   659     {

   660     // Print to UI

   661     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   662     _LIT( KTestCAlfVDisplayL, "TestCAlfVDisplayL" );

   663     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVDisplayL );

   664     // Print to log file

   665     iLog->Log( KTestCAlfVDisplayL );

   666     

   667     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   668     CleanupStack::PushL( alfVisual );

   669     STIF_ASSERT_NOT_NULL( alfVisual );

   670     alfVisual->Display();

   671     CleanupStack::Pop( alfVisual );

   672     

   673     return KErrNone;

   674     }

   675 

   676 // -----------------------------------------------------------------------------

   677 // CTestPlatAlfVisual::TestCAlfVTagL

   678 // -----------------------------------------------------------------------------

   679 //

   680 TInt CTestPlatAlfVisual::TestCAlfVTagL( CStifItemParser& /*aItem*/ )

   681     {

   682     // Print to UI

   683     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   684     _LIT( KTestCAlfVTagL, "TestCAlfVTagL" );

   685     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVTagL );

   686     // Print to log file

   687     iLog->Log( KTestCAlfVTagL );

   688     

   689     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   690                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   691     CleanupStack::PushL( alfVisual );

   692     STIF_ASSERT_NOT_NULL( alfVisual );

   693     const TDesC8& tag = alfVisual->Tag();

   694     STIF_ASSERT_EQUALS( 0, tag.Length() );

   695     CleanupStack::PopAndDestroy( alfVisual );

   696     

   697     return KErrNone;

   698     }

   699 

   700 // -----------------------------------------------------------------------------

   701 // CTestPlatAlfVisual::TestCAlfVUpdateChildrenLayoutL

   702 // -----------------------------------------------------------------------------

   703 //

   704 TInt CTestPlatAlfVisual::TestCAlfVUpdateChildrenLayoutL( CStifItemParser& /*aItem*/ )

   705     {

   706     // Print to UI

   707     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   708     _LIT( KTestCAlfVUpdateChildrenLayoutL, "TestCAlfVUpdateChildrenLayoutL" );

   709     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVUpdateChildrenLayoutL );

   710     // Print to log file

   711     iLog->Log( KTestCAlfVUpdateChildrenLayoutL );

   712     

   713     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   714                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   715     CleanupStack::PushL( alfVisual );

   716     STIF_ASSERT_NOT_NULL( alfVisual );

   717     alfVisual->UpdateChildrenLayout();

   718     CleanupStack::PopAndDestroy( alfVisual );

   719     

   720     return KErrNone;

   721     }

   722 

   723 // -----------------------------------------------------------------------------

   724 // CTestPlatAlfVisual::TestCAlfVDisplayRectTargetL

   725 // -----------------------------------------------------------------------------

   726 //

   727 TInt CTestPlatAlfVisual::TestCAlfVDisplayRectTargetL( CStifItemParser& /*aItem*/ )

   728     {

   729     // Print to UI

   730     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   731     _LIT( KTestCAlfVDisplayRectTargetL, "TestCAlfVDisplayRectTargetL" );

   732     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVDisplayRectTargetL );

   733     // Print to log file

   734     iLog->Log( KTestCAlfVDisplayRectTargetL );

   735     

   736     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   737     CleanupStack::PushL( alfVisual );

   738     STIF_ASSERT_NOT_NULL( alfVisual );

   739     

   740     // Create layout parent for testing purposes

   741     CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

   742     CleanupStack::PushL( parentLayout );

   743     STIF_ASSERT_NOT_NULL( parentLayout );

   744     User::LeaveIfError( parentLayout->Append( alfVisual ) );

   745     parentLayout->SetFlag( EAlfVisualFlagManualLayout );

   746     parentLayout->SetPos( TAlfRealPoint( KNum40, KNum50 ) );

   747     parentLayout->SetSize( TAlfRealSize( KNum100, KNum120 ) );

   748     parentLayout->UpdateChildrenLayout();

   749     

   750     alfVisual->DisplayRectTarget();

   751     

   752     CleanupStack::Pop( parentLayout );

   753     CleanupStack::Pop( alfVisual );

   754     

   755     return KErrNone;

   756     }

   757 

   758 // -----------------------------------------------------------------------------

   759 // CTestPlatAlfVisual::TestCAlfVLocalToDisplayL

   760 // -----------------------------------------------------------------------------

   761 //

   762 TInt CTestPlatAlfVisual::TestCAlfVLocalToDisplayL( CStifItemParser& /*aItem*/ )

   763     {

   764     // Print to UI

   765     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   766     _LIT( KTestCAlfVLocalToDisplayL, "TestCAlfVLocalToDisplayL" );

   767     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVLocalToDisplayL );

   768     // Print to log file

   769     iLog->Log( KTestCAlfVLocalToDisplayL );

   770     

   771     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   772     CleanupStack::PushL( alfVisual );

   773     STIF_ASSERT_NOT_NULL( alfVisual );

   774     

   775     // Create layout parent for testing purposes

   776     CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

   777     CleanupStack::PushL( parentLayout );

   778     STIF_ASSERT_NOT_NULL( parentLayout );

   779     User::LeaveIfError( parentLayout->Append( alfVisual ) );

   780     parentLayout->SetFlag( EAlfVisualFlagManualLayout );

   781     parentLayout->SetPos( TAlfRealPoint( KNum40, KNum50 ) );

   782     parentLayout->SetSize( TAlfRealSize( KNum100, KNum120 ) );

   783     parentLayout->UpdateChildrenLayout();

   784     

   785     iAlfDisplay->Roster().ShowL( *iAlfCtrlGroup );

   786     

   787     TAlfRealPoint result = alfVisual->LocalToDisplay( TPoint( KNum65, KNum88 ) );

   788     

   789     STIF_ASSERT_EQUALS( result.iX, KNum65+KNum40+0.f );

   790     STIF_ASSERT_EQUALS( result.iY, KNum88+KNum50+0.f );

   791 

   792     iAlfDisplay->Roster().Hide( *iAlfCtrlGroup );

   793     

   794     CleanupStack::Pop( parentLayout );

   795     CleanupStack::Pop( alfVisual );

   796     

   797     return KErrNone;

   798     }

   799 

   800 // -----------------------------------------------------------------------------

   801 // CTestPlatAlfVisual::TestCAlfVLocalToDisplayWithRealPointL

   802 // -----------------------------------------------------------------------------

   803 //

   804 TInt CTestPlatAlfVisual::TestCAlfVLocalToDisplayWithRealPointL( CStifItemParser& /*aItem*/ )

   805     {

   806     // Print to UI

   807     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   808     _LIT( KTestCAlfVLocalToDisplayWithRealPointL, "TestCAlfVLocalToDisplayWithRealPointL" );

   809     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVLocalToDisplayWithRealPointL );

   810     // Print to log file

   811     iLog->Log( KTestCAlfVLocalToDisplayWithRealPointL );

   812     

   813     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   814     CleanupStack::PushL( alfVisual );

   815     STIF_ASSERT_NOT_NULL( alfVisual );

   816     

   817     // Create layout parent for testing purposes

   818     CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

   819     CleanupStack::PushL( parentLayout );

   820     STIF_ASSERT_NOT_NULL( parentLayout );

   821     User::LeaveIfError( parentLayout->Append( alfVisual ) );

   822     parentLayout->SetFlag( EAlfVisualFlagManualLayout );

   823     parentLayout->SetPos( TAlfRealPoint( KNum40, KNum50 ) );

   824     parentLayout->SetSize( TAlfRealSize( KNum100, KNum120 ) );

   825     parentLayout->UpdateChildrenLayout();

   826     

   827     TAlfRealPoint result = alfVisual->LocalToDisplay( TAlfRealPoint( KNum65, KNum88 ) );

   828     

   829     STIF_ASSERT_EQUALS( result.iX, KNum65+KNum40+0.f );

   830     STIF_ASSERT_EQUALS( result.iY, KNum88+KNum50+0.f );

   831     

   832     CleanupStack::Pop( parentLayout );

   833     CleanupStack::Pop( alfVisual );

   834     

   835     return KErrNone;

   836     }

   837 

   838 // -----------------------------------------------------------------------------

   839 // CTestPlatAlfVisual::TestCAlfVDisplayToLocalL

   840 // -----------------------------------------------------------------------------

   841 //

   842 TInt CTestPlatAlfVisual::TestCAlfVDisplayToLocalL( CStifItemParser& /*aItem*/ )

   843     {

   844     // Print to UI

   845     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   846     _LIT( KTestCAlfVDisplayToLocalL, "TestCAlfVDisplayToLocalL" );

   847     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVDisplayToLocalL );

   848     // Print to log file

   849     iLog->Log( KTestCAlfVDisplayToLocalL );

   850     

   851     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   852     CleanupStack::PushL( alfVisual );

   853     STIF_ASSERT_NOT_NULL( alfVisual );

   854     

   855     // Create layout parent for testing purposes

   856     CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

   857     CleanupStack::PushL( parentLayout );

   858     STIF_ASSERT_NOT_NULL( parentLayout );

   859     User::LeaveIfError( parentLayout->Append( alfVisual ) );

   860     parentLayout->SetFlag( EAlfVisualFlagManualLayout );

   861     parentLayout->SetPos( TAlfRealPoint( KNum40, KNum50 ) );

   862     parentLayout->SetSize( TAlfRealSize( KNum100, KNum120 ) );

   863     parentLayout->UpdateChildrenLayout();

   864     

   865     iAlfDisplay->Roster().ShowL( *iAlfCtrlGroup );

   866     

   867     TPoint result = alfVisual->DisplayToLocal( TPoint( KNum10, KNum20 ) );

   868     

   869     STIF_ASSERT_EQUALS( result.iX, KNum10-KNum40 );

   870     STIF_ASSERT_EQUALS( result.iY, KNum20-KNum50 );

   871     

   872     iAlfDisplay->Roster().Hide( *iAlfCtrlGroup );

   873     

   874     CleanupStack::Pop( parentLayout );

   875     CleanupStack::Pop( alfVisual );

   876     

   877     return KErrNone;

   878     }

   879 

   880 // -----------------------------------------------------------------------------

   881 // CTestPlatAlfVisual::TestCAlfVDisplayToLocalWithRealPointL

   882 // -----------------------------------------------------------------------------

   883 //

   884 TInt CTestPlatAlfVisual::TestCAlfVDisplayToLocalWithRealPointL( CStifItemParser& /*aItem*/ )

   885     {

   886     // Print to UI

   887     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   888     _LIT( KTestCAlfVDisplayToLocalWithRealPointL, "TestCAlfVDisplayToLocalWithRealPointL" );

   889     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVDisplayToLocalWithRealPointL );

   890     // Print to log file

   891     iLog->Log( KTestCAlfVDisplayToLocalWithRealPointL );

   892     

   893     CAlfVisual* alfVisual = iAlfCtl->AppendVisualL( EAlfVisualTypeVisual );

   894     CleanupStack::PushL( alfVisual );

   895     STIF_ASSERT_NOT_NULL( alfVisual );

   896     

   897     // Create layout parent for testing purposes

   898     CAlfLayout* parentLayout = iAlfCtl->AppendLayoutL( EAlfLayoutTypeDeck );

   899     CleanupStack::PushL( parentLayout );

   900     STIF_ASSERT_NOT_NULL( parentLayout );

   901     User::LeaveIfError( parentLayout->Append( alfVisual ) );

   902     parentLayout->SetFlag( EAlfVisualFlagManualLayout );

   903     parentLayout->SetPos( TAlfRealPoint( KNum40, KNum50 ) );

   904     parentLayout->SetSize( TAlfRealSize( KNum100, KNum120 ) );

   905     parentLayout->UpdateChildrenLayout();

   906     

   907     TAlfRealPoint result = alfVisual->DisplayToLocal( TAlfRealPoint( KNum10, KNum20 ) );

   908     

   909     STIF_ASSERT_EQUALS( result.iX, KNum10-KNum40+0.f );

   910     STIF_ASSERT_EQUALS( result.iY, KNum20-KNum50+0.f );

   911     

   912     CleanupStack::Pop( parentLayout );

   913     CleanupStack::Pop( alfVisual );

   914     

   915     return KErrNone;

   916     }

   917 

   918 // -----------------------------------------------------------------------------

   919 // CTestPlatAlfVisual::TestCAlfVEnableBrushesL

   920 // -----------------------------------------------------------------------------

   921 //

   922 TInt CTestPlatAlfVisual::TestCAlfVEnableBrushesL( CStifItemParser& /*aItem*/ )

   923     {

   924     // Print to UI

   925     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   926     _LIT( KTestCAlfVEnableBrushesL, "TestCAlfVEnableBrushesL" );

   927     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVEnableBrushesL );

   928     // Print to log file

   929     iLog->Log( KTestCAlfVEnableBrushesL );

   930     

   931     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   932                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   933     CleanupStack::PushL( alfVisual );

   934     STIF_ASSERT_NOT_NULL( alfVisual );

   935     alfVisual->EnableBrushesL();

   936     alfVisual->EnableBrushesL( EFalse );

   937     CleanupStack::PopAndDestroy( alfVisual );

   938     

   939     return KErrNone;

   940     }

   941 

   942 // -----------------------------------------------------------------------------

   943 // CTestPlatAlfVisual::TestCAlfVBrushesL

   944 // -----------------------------------------------------------------------------

   945 //

   946 TInt CTestPlatAlfVisual::TestCAlfVBrushesL( CStifItemParser& /*aItem*/ )

   947     {

   948     // Print to UI

   949     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   950     _LIT( KTestCAlfVBrushesL, "TestCAlfVBrushesL" );

   951     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVBrushesL );

   952     // Print to log file

   953     iLog->Log( KTestCAlfVBrushesL );

   954     

   955     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   956                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   957     CleanupStack::PushL( alfVisual );

   958     STIF_ASSERT_NOT_NULL( alfVisual );

   959     alfVisual->EnableBrushesL( EFalse );

   960     STIF_ASSERT_NULL( alfVisual->Brushes() );

   961     alfVisual->EnableBrushesL( ETrue );

   962     STIF_ASSERT_NOT_NULL( alfVisual->Brushes() );

   963     alfVisual->EnableBrushesL( EFalse );

   964     CleanupStack::PopAndDestroy( alfVisual );

   965     

   966     return KErrNone;

   967     }

   968 

   969 // -----------------------------------------------------------------------------

   970 // CTestPlatAlfVisual::TestCAlfVMoveToFrontL

   971 // -----------------------------------------------------------------------------

   972 //

   973 TInt CTestPlatAlfVisual::TestCAlfVMoveToFrontL( CStifItemParser& /*aItem*/ )

   974     {

   975     // Print to UI

   976     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

   977     _LIT( KTestCAlfVMoveToFrontL, "TestCAlfVMoveToFrontL" );

   978     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVMoveToFrontL );

   979     // Print to log file

   980     iLog->Log( KTestCAlfVMoveToFrontL );

   981     

   982     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

   983                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

   984     CleanupStack::PushL( alfVisual );

   985     STIF_ASSERT_NOT_NULL( alfVisual );

   986     alfVisual->MoveToFront();

   987     CleanupStack::PopAndDestroy( alfVisual );

   988     

   989     return KErrNone;

   990     }

   991 

   992 // -----------------------------------------------------------------------------

   993 // CTestPlatAlfVisual::TestCAlfVEnableTransformationL

   994 // -----------------------------------------------------------------------------

   995 //

   996 TInt CTestPlatAlfVisual::TestCAlfVEnableTransformationL( CStifItemParser& /*aItem*/ )

   997     {

   998     // Print to UI

   999     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

  1000     _LIT( KTestCAlfVEnableTransformationL, "TestCAlfVEnableTransformationL" );

  1001     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVEnableTransformationL );

  1002     // Print to log file

  1003     iLog->Log( KTestCAlfVEnableTransformationL );

  1004     

  1005     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

  1006                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

  1007     CleanupStack::PushL( alfVisual );

  1008     STIF_ASSERT_NOT_NULL( alfVisual );

  1009     alfVisual->EnableTransformationL();

  1010     CleanupStack::PopAndDestroy( alfVisual );

  1011     

  1012     return KErrNone;

  1013     }

  1014 

  1015 // -----------------------------------------------------------------------------

  1016 // CTestPlatAlfVisual::TestCAlfVTransformationL

  1017 // -----------------------------------------------------------------------------

  1018 //

  1019 TInt CTestPlatAlfVisual::TestCAlfVTransformationL( CStifItemParser& /*aItem*/ )

  1020     {

  1021     // Print to UI

  1022     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

  1023     _LIT( KTestCAlfVTransformationL, "TestCAlfVTransformationL" );

  1024     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVTransformationL );

  1025     // Print to log file

  1026     iLog->Log( KTestCAlfVTransformationL );

  1027     

  1028     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

  1029                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

  1030     CleanupStack::PushL( alfVisual );

  1031     STIF_ASSERT_NOT_NULL( alfVisual );

  1032     alfVisual->EnableTransformationL();

  1033     alfVisual->Transformation();

  1034     alfVisual->EnableTransformationL( EFalse );

  1035     CleanupStack::PopAndDestroy( alfVisual );

  1036     

  1037     return KErrNone;

  1038     }

  1039 

  1040 // -----------------------------------------------------------------------------

  1041 // CTestPlatAlfVisual::TestCAlfVSetPaddingL

  1042 // -----------------------------------------------------------------------------

  1043 //

  1044 TInt CTestPlatAlfVisual::TestCAlfVSetPaddingL( CStifItemParser& /*aItem*/ )

  1045     {

  1046     // Print to UI

  1047     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

  1048     _LIT( KTestCAlfVSetPaddingL, "TestCAlfVSetPaddingL" );

  1049     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetPaddingL );

  1050     // Print to log file

  1051     iLog->Log( KTestCAlfVSetPaddingL );

  1052     

  1053     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

  1054                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

  1055     CleanupStack::PushL( alfVisual );

  1056     STIF_ASSERT_NOT_NULL( alfVisual );

  1057     alfVisual->SetPadding( KNum100 );

  1058     CleanupStack::PopAndDestroy( alfVisual );

  1059     

  1060     return KErrNone;

  1061     }

  1062 

  1063 // -----------------------------------------------------------------------------

  1064 // CTestPlatAlfVisual::TestCAlfVSetPaddingWithPointL

  1065 // -----------------------------------------------------------------------------

  1066 //

  1067 TInt CTestPlatAlfVisual::TestCAlfVSetPaddingWithPointL( CStifItemParser& /*aItem*/ )

  1068     {

  1069     // Print to UI

  1070     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

  1071     _LIT( KTestCAlfVSetPaddingWithPointL, "TestCAlfVSetPaddingWithPointL" );

  1072     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetPaddingWithPointL );

  1073     // Print to log file

  1074     iLog->Log( KTestCAlfVSetPaddingWithPointL );

  1075     

  1076     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

  1077                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

  1078     CleanupStack::PushL( alfVisual );

  1079     STIF_ASSERT_NOT_NULL( alfVisual );

  1080     TPoint point( KNum100, KNum50 );

  1081     alfVisual->SetPadding( point );

  1082     CleanupStack::PopAndDestroy( alfVisual );

  1083     

  1084     return KErrNone;

  1085     }

  1086 

  1087 // -----------------------------------------------------------------------------

  1088 // CTestPlatAlfVisual::TestCAlfVSetPaddingWithMetricL

  1089 // -----------------------------------------------------------------------------

  1090 //

  1091 TInt CTestPlatAlfVisual::TestCAlfVSetPaddingWithMetricL( CStifItemParser& /*aItem*/ )

  1092     {

  1093     // Print to UI

  1094     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

  1095     _LIT( KTestCAlfVSetPaddingWithMetricL, "TestCAlfVSetPaddingWithMetricL" );

  1096     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVSetPaddingWithMetricL );

  1097     // Print to log file

  1098     iLog->Log( KTestCAlfVSetPaddingWithMetricL );

  1099     

  1100     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

  1101                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

  1102     CleanupStack::PushL( alfVisual );

  1103     STIF_ASSERT_NOT_NULL( alfVisual );

  1104     TAlfBoxMetric boxMetric;

  1105     alfVisual->SetPadding( boxMetric );

  1106     CleanupStack::PopAndDestroy( alfVisual );

  1107     

  1108     return KErrNone;

  1109     }

  1110 

  1111 // -----------------------------------------------------------------------------

  1112 // CTestPlatAlfVisual::TestCAlfVPaddingInPixelsL

  1113 // -----------------------------------------------------------------------------

  1114 //

  1115 TInt CTestPlatAlfVisual::TestCAlfVPaddingInPixelsL( CStifItemParser& /*aItem*/ )

  1116     {

  1117     // Print to UI

  1118     _LIT( KTestPlatAlfVisual, "TestPlatAlfVisual" );

  1119     _LIT( KTestCAlfVPaddingInPixelsL, "TestCAlfVPaddingInPixelsL" );

  1120     TestModuleIf().Printf( 0, KTestPlatAlfVisual, KTestCAlfVPaddingInPixelsL );

  1121     // Print to log file

  1122     iLog->Log( KTestCAlfVPaddingInPixelsL );

  1123     

  1124     CAlfVisual* alfVisual = AlfVisualFactory::NewVisualL(

  1125                     EAlfVisualTypeVisual, NULL, *iAlfCtl, *iAlfEnv );

  1126     CleanupStack::PushL( alfVisual );

  1127     STIF_ASSERT_NOT_NULL( alfVisual );

  1128     TAlfBoxMetric boxMetric;

  1129     alfVisual->PaddingInPixels();

  1130     CleanupStack::PopAndDestroy( alfVisual );

  1131     

  1132     return KErrNone;

  1133     }

  1134 

  1135 // -----------------------------------------------------------------------------