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 alfbrushhandlers.h

    15  *

    16 */

    17 

    18 

    19 // [INCLUDE FILES]

    20 #include "testalfext.h"

    21 #include "testalfbrushhandlers.h"

    22 

    23 

    24 // ============================ MEMBER FUNCTIONS =========================

    25 

    26 

    27 // --------------------------------------------------------------------------

    28 // CTestAlfExt::TestBrushHandlerConstructL

    29 // --------------------------------------------------------------------------

    30 //

    31 TInt CTestAlfExt::TestBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    32     {

    33     _LIT(Kctestalfext, "CTestAlfExt");

    34     _LIT(Ktestcalfbrushhandlercalfbrushhandler, "In TestCAlfBrushHandlerCAlfBrushHandler");

    35     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfbrushhandlercalfbrushhandler);

    36     iLog->Log(Ktestcalfbrushhandlercalfbrushhandler);

    37     

    38     CTestCAlfBrushHandler* handler = new ( ELeave ) 

    39         CTestCAlfBrushHandler( *iInterface );

    40     CleanupStack::PushL( handler );

    41     

    42     CleanupStack::PopAndDestroy( handler );

    43     

    44     return KErrNone;

    45     }

    46 

    47 

    48 // --------------------------------------------------------------------------

    49 // CTestAlfExt::TestBrushHandlerForMAlfExtensionL

    50 // --------------------------------------------------------------------------

    51 //

    52 TInt CTestAlfExt::TestBrushHandlerForMAlfExtensionL( CStifItemParser& aItem )

    53     {

    54     _LIT(Kctestalfext, "CTestAlfExt");

    55     _LIT(Ktestcalfbrushhandlerrelease, "In TestCAlfBrushHandlerRelease");

    56     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfbrushhandlerrelease);

    57     iLog->Log(Ktestcalfbrushhandlerrelease);

    58 

    59     CTestCAlfBrushHandler* handler = new ( ELeave ) 

    60         CTestCAlfBrushHandler( *iInterface );

    61     CleanupStack::PushL( handler );

    62     handler->ConstructL();

    63     handler->TestBrushHandlerForMAlfExtensionL( aItem );

    64     CleanupStack::Pop( handler );

    65 

    66     return KErrNone;

    67     }

    68 

    69 // --------------------------------------------------------------------------

    70 // CTestAlfExt::TestBrushHandlerForOthersL

    71 // --------------------------------------------------------------------------

    72 //

    73 TInt CTestAlfExt::TestBrushHandlerForOthersL( CStifItemParser& aItem )

    74     {

    75     _LIT(Kctestalfext, "CTestAlfExt");

    76     _LIT(Ktestcalfbrushhandlergetinterface, "In TestCAlfBrushHandlerGetInterface");

    77     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfbrushhandlergetinterface);

    78     iLog->Log(Ktestcalfbrushhandlergetinterface);

    79 

    80     CTestCAlfBrushHandler* handler = new ( ELeave ) 

    81         CTestCAlfBrushHandler( *iInterface );

    82     CleanupStack::PushL( handler );

    83     handler->ConstructL();

    84     handler->SetOwnership( EFalse );

    85     handler->TestBrushHandlerForOthers( aItem );

    86     CleanupStack::PopAndDestroy( handler );

    87 

    88     return KErrNone;

    89     }

    90 

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

    92 // CTestAlfExt::TestBorderBrushHandlerConstructL

    93 // --------------------------------------------------------------------------

    94 //

    95 TInt CTestAlfExt::TestBorderBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

    96     {

    97     _LIT(Kctestalfext, "CTestAlfExt");

    98     _LIT(Ktestcalfborderbrushhandlernewl1, "In TestCAlfBorderBrushHandlerNewL1");

    99     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfborderbrushhandlernewl1);

   100     iLog->Log(Ktestcalfborderbrushhandlernewl1);

   101 

   102     TAlfXYMetric thickness;

   103     TAlfXYMetric edgeOffset;

   104     

   105     MAlfExtension* temp = CAlfBorderBrushHandler::NewL( *iInterface, 

   106             thickness, edgeOffset );

   107     CAlfBorderBrushHandler* handler = static_cast<CAlfBorderBrushHandler*>

   108         ( temp );

   109     CleanupStack::PushL( handler );

   110     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   111     CleanupStack::PushL( brush );

   112     handler->ConstructL( brush, thickness, edgeOffset );

   113     CleanupStack::Pop( brush );

   114     CleanupStack::PopAndDestroy( handler );

   115     

   116     handler = NULL;

   117     handler = static_cast<CAlfBorderBrushHandler*>

   118         (CAlfBorderBrushHandler::NewL( *iInterface, 1, 1, 1, 1 ) );

   119     CleanupStack::PushL( handler );

   120     CHuiBorderBrush* brush2 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   121     CleanupStack::PushL( brush2 );

   122     handler->ConstructL( brush2, 1, 1, 1, 1 );

   123     CleanupStack::Pop( brush2 );

   124     CleanupStack::PopAndDestroy( handler );

   125 

   126     return KErrNone;

   127     }

   128 

   129 // --------------------------------------------------------------------------

   130 // CTestAlfExt::TestBorderBrushHandlerProtectedL

   131 // --------------------------------------------------------------------------

   132 //

   133 TInt CTestAlfExt::TestBorderBrushHandlerProtectedL( CStifItemParser& aItem )

   134     {

   135     _LIT(Kctestalfext, "CTestAlfExt");

   136     _LIT(Ktestcalfborderbrushhandlernewl2, "In TestCAlfBorderBrushHandlerNewL2");

   137     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfborderbrushhandlernewl2);

   138     iLog->Log(Ktestcalfborderbrushhandlernewl2);

   139 

   140     CTestCAlfBorderBrushHandler* handler = new ( ELeave ) 

   141         CTestCAlfBorderBrushHandler ( *iInterface);

   142     CleanupStack::PushL( handler );

   143     TAlfXYMetric thickness;

   144     TAlfXYMetric edgeOffset;

   145     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   146     CleanupStack::PushL( brush );

   147     handler->ConstructL( brush, thickness, edgeOffset );

   148     CleanupStack::Pop( brush );

   149     handler->TestProtectedL( aItem );

   150     CleanupStack::Pop( handler );

   151 

   152     return KErrNone;

   153     }

   154 

   155 // --------------------------------------------------------------------------

   156 // CTestAlfExt::TestImageBrushHandlerConstructL

   157 // --------------------------------------------------------------------------

   158 //

   159 TInt CTestAlfExt::TestImageBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

   160     {

   161     _LIT(Kctestalfext, "CTestAlfExt");

   162     _LIT(Ktestcalfimagebrushhandlernewl, "In TestCAlfImageBrushHandlerNewL");

   163     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlernewl);

   164     iLog->Log(Ktestcalfimagebrushhandlernewl);

   165 

   166     THuiImage image;

   167     MAlfExtension* temp = CAlfImageBrushHandler::NewL( *iInterface, image );

   168     CAlfImageBrushHandler* handler = static_cast<CAlfImageBrushHandler*>

   169         ( temp );

   170     CleanupStack::PushL( handler );

   171     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   172     CleanupStack::PushL( brush );

   173     handler->ConstructL( brush, image );

   174     CleanupStack::Pop( brush );

   175     CleanupStack::PopAndDestroy( handler );

   176     

   177     return KErrNone;

   178     }

   179 

   180 // --------------------------------------------------------------------------

   181 // CTestAlfExt::TestImageBrushHandlerProtectedL

   182 // --------------------------------------------------------------------------

   183 //

   184 TInt CTestAlfExt::TestImageBrushHandlerProtectedL( CStifItemParser& aItem )

   185     {

   186     _LIT(Kctestalfext, "CTestAlfExt");

   187     _LIT(Ktestcalfimagebrushhandlercalfimagebrushhandler, "In TestCAlfImageBrushHandlerCAlfImageBrushHandler");

   188     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlercalfimagebrushhandler);

   189     iLog->Log(Ktestcalfimagebrushhandlercalfimagebrushhandler);

   190 

   191     CTestCAlfImageBrushHandler* handler = new ( ELeave ) 

   192         CTestCAlfImageBrushHandler( *iInterface );

   193     CleanupStack::PushL( handler );

   194     THuiImage image;

   195     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   196     CleanupStack::PushL( brush );

   197     handler->ConstructL( brush, image );

   198     CleanupStack::Pop( brush );

   199     handler->TestProtectedL( aItem );

   200     CleanupStack::Pop( handler );

   201 

   202     return KErrNone;

   203     }

   204 

   205 // --------------------------------------------------------------------------

   206 // CTestAlfExt::TestShadowBorderBrushHandlerConstructL

   207 // --------------------------------------------------------------------------

   208 //

   209 TInt CTestAlfExt::TestShadowBorderBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

   210     {

   211     _LIT(Kctestalfext, "CTestAlfExt");

   212     _LIT(Ktestcalfimagebrushhandlerconstructl, "In TestCAlfImageBrushHandlerConstructL");

   213     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerconstructl);

   214     iLog->Log(Ktestcalfimagebrushhandlerconstructl);

   215 

   216     CAlfShadowBorderBrushHandler* handler = 

   217         static_cast<CAlfShadowBorderBrushHandler*>

   218         (CAlfShadowBorderBrushHandler::NewL( *iInterface, 1 ) );

   219     CleanupStack::PushL( handler );

   220     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   221     CleanupStack::PushL( brush );

   222     handler->ConstructL( brush, 1 );

   223     CleanupStack::Pop( brush );

   224     CleanupStack::PopAndDestroy( handler );

   225     handler = NULL;

   226     TAlfMetric metric;

   227     handler = static_cast<CAlfShadowBorderBrushHandler*>

   228             (CAlfShadowBorderBrushHandler::NewL( *iInterface, metric ) );

   229     CleanupStack::PushL( handler );

   230     CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   231     CleanupStack::PushL( brush1 );

   232     handler->ConstructL( brush1, metric );

   233     CleanupStack::Pop( brush1 );

   234     CleanupStack::PopAndDestroy( handler );

   235     

   236     handler = NULL;

   237     handler = new ( ELeave )CAlfShadowBorderBrushHandler( *iInterface);

   238     CleanupStack::PushL( handler );

   239     CleanupStack::PopAndDestroy( handler );

   240     

   241     

   242     return KErrNone;

   243     }

   244 

   245 // --------------------------------------------------------------------------

   246 // CTestAlfExt::TestShadowBorderBrushHandlerProtectedL

   247 // --------------------------------------------------------------------------

   248 //

   249 TInt CTestAlfExt::TestShadowBorderBrushHandlerProtectedL( CStifItemParser& aItem )

   250     {

   251     _LIT(Kctestalfext, "CTestAlfExt");

   252     _LIT(Ktestcalfimagebrushhandlerrelease, "In TestCAlfImageBrushHandlerRelease");

   253     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerrelease);

   254     iLog->Log(Ktestcalfimagebrushhandlerrelease);

   255 

   256     CTestCAlfShadowBorderBrushHandler* handler = new ( ELeave ) 

   257         CTestCAlfShadowBorderBrushHandler ( *iInterface );

   258     CleanupStack::PushL( handler );

   259     CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   260     CleanupStack::PushL( brush1 );

   261     TAlfMetric metric;

   262     handler->ConstructL( brush1, metric );

   263     CleanupStack::Pop( brush1 );

   264     handler->TestProtectedL( aItem );

   265     CleanupStack::Pop( handler );

   266 

   267     return KErrNone;

   268     }

   269 

   270 // --------------------------------------------------------------------------

   271 // CTestAlfExt::TestDropShadowBrushHandlerConstructL

   272 // --------------------------------------------------------------------------

   273 //

   274 TInt CTestAlfExt::TestDropShadowBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

   275     {

   276     _LIT(Kctestalfext, "CTestAlfExt");

   277     _LIT(Ktestcalfimagebrushhandlergetinterface, "In TestCAlfImageBrushHandlerGetInterface");

   278     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlergetinterface);

   279     iLog->Log(Ktestcalfimagebrushhandlergetinterface);

   280 

   281     CAlfDropShadowBrushHandler* handler = 

   282             static_cast<CAlfDropShadowBrushHandler*>

   283             (CAlfDropShadowBrushHandler::NewL( *iInterface, 1 ) );

   284     CleanupStack::PushL( handler );

   285     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   286     CleanupStack::PushL( brush );

   287     handler->ConstructL( brush, 1 );

   288     CleanupStack::Pop( brush );

   289     CleanupStack::PopAndDestroy( handler );

   290     handler = NULL;

   291     TAlfMetric metric;

   292     handler = static_cast<CAlfDropShadowBrushHandler*>

   293             (CAlfDropShadowBrushHandler::NewL( *iInterface, metric ) );

   294     CleanupStack::PushL( handler );

   295     CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   296     CleanupStack::PushL( brush );

   297     handler->ConstructL( brush1, metric );

   298     CleanupStack::Pop( brush1 );

   299     CleanupStack::PopAndDestroy( handler );

   300 

   301     return KErrNone;

   302     }

   303 

   304 // --------------------------------------------------------------------------

   305 // CTestAlfExt::TestDropShadowBrushHandlerProtectedL

   306 // --------------------------------------------------------------------------

   307 //

   308 TInt CTestAlfExt::TestDropShadowBrushHandlerProtectedL( CStifItemParser& aItem )

   309     {

   310     _LIT(Kctestalfext, "CTestAlfExt");

   311     _LIT(Ktestcalfimagebrushhandlerhandlecmdl, "In TestCAlfImageBrushHandlerHandleCmdL");

   312     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerhandlecmdl);

   313     iLog->Log(Ktestcalfimagebrushhandlerhandlecmdl);

   314 

   315     CTestCAlfDropShadowBrushHandler* handler = new ( ELeave ) 

   316             CTestCAlfDropShadowBrushHandler( *iInterface );

   317     CleanupStack::PushL( handler );

   318     TAlfMetric metric;

   319     CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   320     CleanupStack::PushL( brush1 );

   321     handler->ConstructL( brush1, metric );

   322     CleanupStack::Pop( brush1 );

   323     handler->TestProtectedL( aItem );

   324     CleanupStack::Pop( handler );

   325 

   326     return KErrNone;

   327     }

   328 

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

   330 // CTestAlfExt::TestGradientBrushHandlerConstructL

   331 // --------------------------------------------------------------------------

   332 //

   333 TInt CTestAlfExt::TestGradientBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

   334     {

   335     _LIT(Kctestalfext, "CTestAlfExt");

   336     _LIT(Ktestcalfimagebrushhandlerbrushhandlerextension, "In TestCAlfImageBrushHandlerBrushHandlerExtension");

   337     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfimagebrushhandlerbrushhandlerextension);

   338     iLog->Log(Ktestcalfimagebrushhandlerbrushhandlerextension);

   339 

   340     CAlfGradientBrushHandler* handler = static_cast<CAlfGradientBrushHandler*>

   341         ( CAlfGradientBrushHandler::NewL( *iInterface ) );

   342     CleanupStack::PushL( handler );

   343     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   344     CleanupStack::PushL( brush );

   345     handler->ConstructL( brush );

   346     CleanupStack::Pop( brush );

   347     CleanupStack::PopAndDestroy( handler );

   348     handler = NULL;

   349     handler = new ( ELeave ) CAlfGradientBrushHandler( *iInterface );

   350     CleanupStack::PushL( handler );

   351     CleanupStack::PopAndDestroy( handler );

   352 

   353     return KErrNone;

   354     }

   355 

   356 // --------------------------------------------------------------------------

   357 // CTestAlfExt::TestGradientBrushHandlerProtectedL

   358 // --------------------------------------------------------------------------

   359 //

   360 TInt CTestAlfExt::TestGradientBrushHandlerProtectedL( CStifItemParser& aItem )

   361     {

   362     _LIT(Kctestalfext, "CTestAlfExt");

   363     _LIT(Ktestcalfshadowborderbrushhandlernewl1, "In TestCAlfShadowBorderBrushHandlerNewL1");

   364     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfshadowborderbrushhandlernewl1);

   365     iLog->Log(Ktestcalfshadowborderbrushhandlernewl1);

   366 

   367     CTestCAlfGradientBrushHandler* handler = new ( ELeave ) 

   368             CTestCAlfGradientBrushHandler( *iInterface );

   369     CleanupStack::PushL( handler );

   370     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   371     CleanupStack::PushL( brush );

   372     handler->ConstructL( brush );

   373     CleanupStack::Pop( brush );

   374     handler->TestProtectedL( aItem );

   375     CleanupStack::Pop( handler );

   376 

   377     return KErrNone;

   378     }

   379 

   380 // --------------------------------------------------------------------------

   381 // CTestAlfExt::TestFrameBrushHandlerConstructL

   382 // --------------------------------------------------------------------------

   383 //

   384 TInt CTestAlfExt::TestFrameBrushHandlerConstructL( CStifItemParser& /*aItem*/ )

   385     {

   386     _LIT(Kctestalfext, "CTestAlfExt");

   387     _LIT(Ktestcalfshadowborderbrushhandlernewl2, "In TestCAlfShadowBorderBrushHandlerNewL2");

   388     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfshadowborderbrushhandlernewl2);

   389     iLog->Log(Ktestcalfshadowborderbrushhandlernewl2);

   390     

   391     TAknsItemID id;

   392     TAlfXYMetric edgeOffset;

   393     CAlfFrameBrushHandler* handler = static_cast<CAlfFrameBrushHandler*>

   394         ( CAlfFrameBrushHandler::NewL( *iInterface, id, edgeOffset ) );

   395     CleanupStack::PushL( handler );

   396     CHuiBorderBrush* brush = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   397     CleanupStack::PushL( brush );

   398     handler->ConstructL( brush, id, edgeOffset );

   399     CleanupStack::Pop( brush );

   400     CleanupStack::PopAndDestroy( handler );

   401     handler = NULL;

   402     handler = static_cast<CAlfFrameBrushHandler*>

   403             ( CAlfFrameBrushHandler::NewL( *iInterface, id, 1, 1 ) );

   404     CleanupStack::PushL( handler );

   405     CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   406     CleanupStack::PushL( brush1 );

   407     handler->ConstructL( brush1, id, 1, 1 );

   408     CleanupStack::Pop( brush1 );

   409     CleanupStack::PopAndDestroy( handler );

   410     handler = NULL;

   411     THuiImage image;

   412     handler = static_cast<CAlfFrameBrushHandler*>

   413             ( CAlfFrameBrushHandler::NewL( *iInterface, image, edgeOffset ) );

   414     CleanupStack::PushL( handler );

   415     CHuiBorderBrush* brush2 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   416     CleanupStack::PushL( brush2 );

   417     handler->ConstructL( brush2, image, edgeOffset );

   418     CleanupStack::Pop( brush2 );

   419     CleanupStack::PopAndDestroy( handler );

   420 

   421     return KErrNone;

   422     }

   423 

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

   425 // CTestAlfExt::TestFrameBrushHandlerProtectedL

   426 // --------------------------------------------------------------------------

   427 //

   428 TInt CTestAlfExt::TestFrameBrushHandlerProtectedL( CStifItemParser& aItem )

   429     {

   430     _LIT(Kctestalfext, "CTestAlfExt");

   431     _LIT(Ktestcalfshadowborderbrushhandlercalfshadowborderbrushhandler, "In TestCAlfShadowBorderBrushHandlerCAlfShadowBorderBrushHandler");

   432     TestModuleIf().Printf(0, Kctestalfext, Ktestcalfshadowborderbrushhandlercalfshadowborderbrushhandler);

   433     iLog->Log(Ktestcalfshadowborderbrushhandlercalfshadowborderbrushhandler);

   434 

   435     CTestCAlfFrameBrushHandler* handler = new ( ELeave ) 

   436         CTestCAlfFrameBrushHandler( *iInterface );

   437     CleanupStack::PushL( handler );

   438     TAknsItemID id;

   439     CHuiBorderBrush* brush1 = CHuiBorderBrush::NewL( 1, 1, 1, 1 );

   440     CleanupStack::PushL( brush1 );

   441     handler->ConstructL( brush1, id, 1, 1 );

   442     CleanupStack::Pop( brush1 );

   443     handler->TestProtectedL( aItem );

   444     CleanupStack::Pop( handler );

   445 

   446     return KErrNone;

   447     }

   448 

   449 // End of file

   450 

   451