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:  For test alf core toolkit api modules

    15 *

    16 */

    17 

    18 

    19 #include <uiacceltk/huiBrush.h>

    20 #include <uiacceltk/HuiBorderBrush.h>

    21 #include <uiacceltk/huiframebrush.h>

    22 #include <uiacceltk/HuiDisplayCoeControl.h>

    23 

    24 #include "testuiaifcoretoolkit.h"

    25 

    26 // FOR DECLARATION

    27 /**

    28  * This class is used to test huiBrush protected member.

    29  */

    30 class CTestHuiBrush : public CHuiBrush

    31     {

    32 public:

    33     /**

    34      * Test constructor

    35      */

    36     CTestHuiBrush() : CHuiBrush()

    37         {

    38         //do nothing.

    39         }

    40     ~CTestHuiBrush()

    41         {

    42         

    43         }

    44     /**

    45      * Test BrushExtension

    46      */

    47     void TestBrushExtension( const TUid& aExtensionUid, TAny** aExtensionParameters )

    48         {

    49         CHuiBrush::BrushExtension( aExtensionUid, aExtensionParameters );

    50         }

    51     };

    52 // -----------------------------------------------------------------------------

    53 // Ctestplatalfcoretoolkit::TestHuiBrushExpandVisualRectL

    54 // -----------------------------------------------------------------------------

    55 //

    56 TInt CTestUiAifCoreToolkit::TestHuiBrushExpandVisualRectL( CStifItemParser& /*aItem*/ )

    57     {

    58 

    59     // Print to UI

    60     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

    61     _LIT( KTestHuiBrushExpandVisualRectL, "TestHuiBrushExpandVisualRectL" );

    62     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushExpandVisualRectL );

    63     // Print to log file

    64     iLog->Log( KTestHuiBrushExpandVisualRectL );

    65 

    66     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

    67     CleanupStack::PushL( huiBrush );

    68     STIF_ASSERT_NOT_NULL( huiBrush );

    69     TRect rect(10, 10, 30, 20);

    70     huiBrush->ExpandVisualRect( rect );

    71     CleanupStack::PopAndDestroy( huiBrush );

    72     

    73     return KErrNone;

    74 

    75     }

    76 // -----------------------------------------------------------------------------

    77 // Ctestplatalfcoretoolkit::TestHuiBrushSetChangedL

    78 // -----------------------------------------------------------------------------

    79 //

    80 TInt CTestUiAifCoreToolkit::TestHuiBrushSetChangedL( CStifItemParser& /*aItem*/ )

    81     {

    82 

    83     // Print to UI

    84     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

    85     _LIT( KTestHuiBrushSetChangedL, "TestHuiBrushSetChangedL" );

    86     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushSetChangedL );

    87     // Print to log file

    88     iLog->Log( KTestHuiBrushSetChangedL );

    89 

    90     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

    91     CleanupStack::PushL( huiBrush );

    92     STIF_ASSERT_NOT_NULL( huiBrush );

    93     huiBrush->SetChanged();

    94     CleanupStack::PopAndDestroy( huiBrush );

    95     

    96     return KErrNone;

    97 

    98     }

    99 // -----------------------------------------------------------------------------

   100 // Ctestplatalfcoretoolkit::TestHuiBrushChangedL

   101 // -----------------------------------------------------------------------------

   102 //

   103 TInt CTestUiAifCoreToolkit::TestHuiBrushChangedL( CStifItemParser& /*aItem*/ )

   104     {

   105 

   106     // Print to UI

   107     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   108     _LIT( KTestHuiBrushChangedL, "TestHuiBrushChangedL" );

   109     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushChangedL );

   110     // Print to log file

   111     iLog->Log( KTestHuiBrushChangedL );

   112 

   113     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   114     CleanupStack::PushL( huiBrush );

   115     STIF_ASSERT_NOT_NULL( huiBrush );

   116     TBool isChange = huiBrush->Changed();

   117     CleanupStack::PopAndDestroy( huiBrush );

   118     

   119     return KErrNone;

   120 

   121     }

   122 // -----------------------------------------------------------------------------

   123 // Ctestplatalfcoretoolkit::TestHuiBrushClearChangedL

   124 // -----------------------------------------------------------------------------

   125 //

   126 TInt CTestUiAifCoreToolkit::TestHuiBrushClearChangedL( CStifItemParser& /*aItem*/ )

   127     {

   128 

   129     // Print to UI

   130     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   131     _LIT( KTestHuiBrushClearChangedL, "TestHuiBrushClearChangedL" );

   132     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushClearChangedL );

   133     // Print to log file

   134     iLog->Log( KTestHuiBrushClearChangedL );

   135 

   136     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   137     CleanupStack::PushL( huiBrush );

   138     STIF_ASSERT_NOT_NULL( huiBrush );

   139     huiBrush->ClearChanged();

   140     CleanupStack::PopAndDestroy( huiBrush );

   141     

   142     return KErrNone;

   143 

   144     }

   145 // -----------------------------------------------------------------------------

   146 // Ctestplatalfcoretoolkit::TestHuiBrushSetClipToVisualL

   147 // -----------------------------------------------------------------------------

   148 //

   149 TInt CTestUiAifCoreToolkit::TestHuiBrushSetClipToVisualL( CStifItemParser& /*aItem*/ )

   150     {

   151 

   152     // Print to UI

   153     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   154     _LIT( KTestHuiBrushSetClipToVisualL, "TestHuiBrushSetClipToVisualL" );

   155     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushSetClipToVisualL );

   156     // Print to log file

   157     iLog->Log( KTestHuiBrushSetClipToVisualL );

   158 

   159     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   160     CleanupStack::PushL( huiBrush );

   161     STIF_ASSERT_NOT_NULL( huiBrush );

   162     huiBrush->SetClipToVisual( EFalse );

   163     CleanupStack::PopAndDestroy( huiBrush );

   164     

   165     return KErrNone;

   166 

   167     }

   168 // -----------------------------------------------------------------------------

   169 // Ctestplatalfcoretoolkit::TestHuiBrushClipToVisualL

   170 // -----------------------------------------------------------------------------

   171 //

   172 TInt CTestUiAifCoreToolkit::TestHuiBrushClipToVisualL( CStifItemParser& /*aItem*/ )

   173     {

   174 

   175     // Print to UI

   176     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   177     _LIT( KTestHuiBrushClipToVisualL, "TestHuiBrushClipToVisualL" );

   178     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushClipToVisualL );

   179     // Print to log file

   180     iLog->Log( KTestHuiBrushClipToVisualL );

   181 

   182     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   183     CleanupStack::PushL( huiBrush );

   184     STIF_ASSERT_NOT_NULL( huiBrush );

   185     TBool isClipToVisual = huiBrush->ClipToVisual();

   186     CleanupStack::PopAndDestroy( huiBrush );

   187     

   188     return KErrNone;

   189 

   190     }

   191 // -----------------------------------------------------------------------------

   192 // Ctestplatalfcoretoolkit::TestHuiBrushSetLayerL

   193 // -----------------------------------------------------------------------------

   194 //

   195 TInt CTestUiAifCoreToolkit::TestHuiBrushSetLayerL( CStifItemParser& /*aItem*/ )

   196     {

   197 

   198     // Print to UI

   199     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   200     _LIT( KTestHuiBrushSetLayerL, "TestHuiBrushSetLayerL" );

   201     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushSetLayerL );

   202     // Print to log file

   203     iLog->Log( KTestHuiBrushSetLayerL );

   204 

   205     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   206     CleanupStack::PushL( huiBrush );

   207     STIF_ASSERT_NOT_NULL( huiBrush );

   208     THuiBrushLayer layer = EHuiBrushLayerBackground;

   209     huiBrush->SetLayer( layer );

   210     CleanupStack::PopAndDestroy( huiBrush );

   211     

   212     return KErrNone;

   213 

   214     }

   215 // -----------------------------------------------------------------------------

   216 // Ctestplatalfcoretoolkit::TestHuiBrushLayerL

   217 // -----------------------------------------------------------------------------

   218 //

   219 TInt CTestUiAifCoreToolkit::TestHuiBrushLayerL( CStifItemParser& /*aItem*/ )

   220     {

   221 

   222     // Print to UI

   223     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   224     _LIT( KTestHuiBrushLayerL, "TestHuiBrushLayerL" );

   225     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushLayerL );

   226     // Print to log file

   227     iLog->Log( KTestHuiBrushLayerL );

   228 

   229     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   230     CleanupStack::PushL( huiBrush );

   231     STIF_ASSERT_NOT_NULL( huiBrush );

   232     THuiBrushLayer layer = huiBrush->Layer();

   233     CleanupStack::PopAndDestroy( huiBrush );

   234     

   235     return KErrNone;

   236 

   237     }

   238 // -----------------------------------------------------------------------------

   239 // Ctestplatalfcoretoolkit::TestHuiBrushBeginDrawL

   240 // -----------------------------------------------------------------------------

   241 //

   242 TInt CTestUiAifCoreToolkit::TestHuiBrushBeginDrawL( CStifItemParser& /*aItem*/ )

   243     {

   244 

   245     // Print to UI

   246     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   247     _LIT( KTestHuiBrushBeginDrawL, "TestHuiBrushBeginDrawL" );

   248     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushBeginDrawL );

   249     // Print to log file

   250     iLog->Log( KTestHuiBrushBeginDrawL );

   251 

   252     TAknsItemID id;

   253     id.Set( TUid::Uid( 0 ), 0 );

   254     CHuiBrush* huiBrush = CHuiFrameBrush::NewL( id, 0, 0 );

   255     CleanupStack::PushL( huiBrush );

   256     STIF_ASSERT_NOT_NULL( huiBrush );

   257     TRect rect = CEikonEnv::Static()->AppUiFactory()->ClientRect();

   258     CHuiDisplayCoeControl* ctrl = CHuiDisplayCoeControl::NewL( *iHuiEnv, rect );

   259     CleanupStack::PushL( ctrl );

   260     CHuiEnv::RefreshCallBack( iHuiEnv );

   261     CHuiGc& huiGc = iHuiEnv->Skin().Context();

   262     huiBrush->BeginDraw( huiGc, *iHuiVisual );

   263     CleanupStack::PopAndDestroy( ctrl );

   264     CleanupStack::PopAndDestroy( huiBrush );

   265     

   266     return KErrNone;

   267 

   268     }

   269 // -----------------------------------------------------------------------------

   270 // Ctestplatalfcoretoolkit::TestHuiBrushDrawL

   271 // -----------------------------------------------------------------------------

   272 //

   273 TInt CTestUiAifCoreToolkit::TestHuiBrushDrawL( CStifItemParser& /*aItem*/ )

   274     {

   275 

   276     // Print to UI

   277     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   278     _LIT( KTestHuiBrushDrawL, "TestHuiBrushDrawL" );

   279     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushDrawL );

   280     // Print to log file

   281     iLog->Log( KTestHuiBrushDrawL );

   282 

   283     CTestHuiBrush* testHuiBrush = new( ELeave ) CTestHuiBrush;

   284     CleanupStack::PushL( testHuiBrush );

   285     STIF_ASSERT_NOT_NULL( testHuiBrush );

   286     TRect rect = CEikonEnv::Static()->AppUiFactory()->ClientRect();

   287     CHuiDisplayCoeControl* ctrl = CHuiDisplayCoeControl::NewL( *iHuiEnv, rect );

   288     CleanupStack::PushL( ctrl );

   289     CHuiEnv::RefreshCallBack( iHuiEnv );

   290     CHuiGc& huiGc = iHuiEnv->Skin().Context();

   291     testHuiBrush->Draw( huiGc, *iHuiVisual );

   292     CleanupStack::PopAndDestroy( ctrl );

   293     CleanupStack::PopAndDestroy( testHuiBrush );

   294     

   295     return KErrNone;

   296 

   297     }

   298 // -----------------------------------------------------------------------------

   299 // Ctestplatalfcoretoolkit::TestHuiBrushEndDrawL

   300 // -----------------------------------------------------------------------------

   301 //

   302 TInt CTestUiAifCoreToolkit::TestHuiBrushEndDrawL( CStifItemParser& /*aItem*/ )

   303     {

   304 

   305     // Print to UI

   306     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   307     _LIT( KTestHuiBrushEndDrawL, "TestHuiBrushEndDrawL" );

   308     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushEndDrawL );

   309     // Print to log file

   310     iLog->Log( KTestHuiBrushEndDrawL );

   311 

   312     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   313     CleanupStack::PushL( huiBrush );

   314     STIF_ASSERT_NOT_NULL( huiBrush );

   315     TRect rect = CEikonEnv::Static()->AppUiFactory()->ClientRect();

   316     CHuiDisplayCoeControl* ctrl = CHuiDisplayCoeControl::NewL( *iHuiEnv, rect );

   317     CleanupStack::PushL( ctrl );

   318     CHuiEnv::RefreshCallBack( iHuiEnv );

   319     CHuiGc& huiGc = iHuiEnv->Skin().Context();

   320     huiBrush->EndDraw( huiGc, *iHuiVisual );

   321     CleanupStack::PopAndDestroy( ctrl );

   322     CleanupStack::PopAndDestroy( huiBrush );

   323     

   324     return KErrNone;

   325 

   326     }

   327 // -----------------------------------------------------------------------------

   328 // Ctestplatalfcoretoolkit::TestHuiBrushTypeL

   329 // -----------------------------------------------------------------------------

   330 //

   331 TInt CTestUiAifCoreToolkit::TestHuiBrushTypeL( CStifItemParser& /*aItem*/ )

   332     {

   333 

   334     // Print to UI

   335     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   336     _LIT( KTestHuiBrushTypeL, "TestHuiBrushTypeL" );

   337     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushTypeL );

   338     // Print to log file

   339     iLog->Log( KTestHuiBrushTypeL );

   340 

   341     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   342     CleanupStack::PushL( huiBrush );

   343     STIF_ASSERT_NOT_NULL( huiBrush );

   344     huiBrush->Type();

   345     CleanupStack::PopAndDestroy( huiBrush );

   346     

   347     return KErrNone;

   348 

   349     }

   350 // -----------------------------------------------------------------------------

   351 // Ctestplatalfcoretoolkit::TestHuiBrushSessionIdL

   352 // -----------------------------------------------------------------------------

   353 //

   354 TInt CTestUiAifCoreToolkit::TestHuiBrushSessionIdL( CStifItemParser& /*aItem*/ )

   355     {

   356 

   357     // Print to UI

   358     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   359     _LIT( KTestHuiBrushSessionIdL, "TestHuiBrushSessionIdL" );

   360     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushSessionIdL );

   361     // Print to log file

   362     iLog->Log( KTestHuiBrushSessionIdL );

   363 

   364     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   365     CleanupStack::PushL( huiBrush );

   366     STIF_ASSERT_NOT_NULL( huiBrush );

   367     TInt id = huiBrush->SessionId();

   368     CleanupStack::PopAndDestroy( huiBrush );

   369     

   370     return KErrNone;

   371 

   372     }

   373 // -----------------------------------------------------------------------------

   374 // Ctestplatalfcoretoolkit::TestHuiBrushSetSessionIdL

   375 // -----------------------------------------------------------------------------

   376 //

   377 TInt CTestUiAifCoreToolkit::TestHuiBrushSetSessionIdL( CStifItemParser& /*aItem*/ )

   378     {

   379 

   380     // Print to UI

   381     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   382     _LIT( KTestHuiBrushSetSessionIdL, "TestHuiBrushSetSessionIdL" );

   383     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushSetSessionIdL );

   384     // Print to log file

   385     iLog->Log( KTestHuiBrushSetSessionIdL );

   386 

   387     CHuiBrush* huiBrush = CHuiBorderBrush::NewL( 0, 0, 0, 0 );

   388     CleanupStack::PushL( huiBrush );

   389     STIF_ASSERT_NOT_NULL( huiBrush );

   390     huiBrush->SetSessionId( 0 );

   391     CleanupStack::PopAndDestroy( huiBrush );

   392     

   393     return KErrNone;

   394 

   395     }

   396 // -----------------------------------------------------------------------------

   397 // Ctestplatalfcoretoolkit::TestHuiBrushCHuiBrushL

   398 // -----------------------------------------------------------------------------

   399 //

   400 TInt CTestUiAifCoreToolkit::TestHuiBrushCHuiBrushL( CStifItemParser& /*aItem*/ )

   401     {

   402 

   403     // Print to UI

   404     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   405     _LIT( KTestHuiBrushCHuiBrushL, "TestHuiBrushCHuiBrushL" );

   406     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushCHuiBrushL );

   407     // Print to log file

   408     iLog->Log( KTestHuiBrushCHuiBrushL );

   409 

   410     CTestHuiBrush* testHuiBrush = new( ELeave ) CTestHuiBrush;

   411     CleanupStack::PushL( testHuiBrush );

   412     STIF_ASSERT_NOT_NULL( testHuiBrush );

   413     CleanupStack::PopAndDestroy( testHuiBrush );

   414     

   415     return KErrNone;

   416 

   417     }

   418 // -----------------------------------------------------------------------------

   419 // Ctestplatalfcoretoolkit::TestHuiBrushBrushExtensionL

   420 // -----------------------------------------------------------------------------

   421 //

   422 TInt CTestUiAifCoreToolkit::TestHuiBrushBrushExtensionL( CStifItemParser& /*aItem*/ )

   423     {

   424 

   425     // Print to UI

   426     _LIT( Ktestplatalfcoretoolkit, "testplatalfcoretoolkit" );

   427     _LIT( KTestHuiBrushBrushExtensionL, "TestHuiBrushBrushExtensionL" );

   428     TestModuleIf().Printf( 0, Ktestplatalfcoretoolkit, KTestHuiBrushBrushExtensionL );

   429     // Print to log file

   430     iLog->Log( KTestHuiBrushBrushExtensionL );

   431 

   432     CTestHuiBrush* testHuiBrush = new( ELeave ) CTestHuiBrush;

   433     CleanupStack::PushL( testHuiBrush );

   434     STIF_ASSERT_NOT_NULL( testHuiBrush );

   435     testHuiBrush->TestBrushExtension( TUid::Uid( 0 ), NULL );

   436     CleanupStack::PopAndDestroy( testHuiBrush );

   437     

   438     return KErrNone;

   439 

   440     }

   441 

   442 //End of file.