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 EIKLABEL.H

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES]

    21 

    22 #include <eikfnlab.h>

    23 #include <eiklabel.h>

    24 #include <avkon.hrh>

    25 #include <gdi.h>

    26 #include <barsread.h>

    27 #include <coeaui.h>

    28 #include <aknsconstants.h>

    29 #include <eikappui.h>

    30 #include <eikenv.h>

    31 #include <aknpictographinterface.h> 

    32 #include <s32mem.h>

    33 #include <testsdklabels.rsg>

    34 

    35 #include "testsdklabelslabel.h"

    36 #include "testsdklabelssubaknpictographcallback.h"

    37 #include "testsdklabels.h"

    38 

    39 const TInt KTextLength = 20;

    40 // ============================ MEMBER FUNCTIONS ===============================

    41 

    42 // -----------------------------------------------------------------------------

    43 // CTestSDKLabels::TestLabelDeconstructorL

    44 // -----------------------------------------------------------------------------

    45 //

    46 TInt CTestSDKLabels::TestLabelDeconstructorL( CStifItemParser& /*aItem*/ )

    47     {

    48     CEikLabel* label = new (ELeave) CEikLabel;

    49     CleanupStack::PushL( label );

    50     

    51     STIF_ASSERT_NOT_NULL( label );

    52     

    53     CleanupStack::Pop( label );

    54     delete label;

    55     

    56     return KErrNone;

    57     

    58     }

    59 

    60 // -----------------------------------------------------------------------------

    61 // CTestSDKLabels::TestLabelCEikLabelL

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

    63 //

    64 TInt CTestSDKLabels::TestLabelCEikLabelL( CStifItemParser& /*aItem*/ )

    65     {

    66     CEikLabel* label = new (ELeave) CEikLabel;

    67     CleanupStack::PushL( label );

    68     

    69     STIF_ASSERT_NOT_NULL( label );

    70     

    71     TResourceReader reader;

    72     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

    73     label->ConstructFromResourceL( reader );

    74     CleanupStack::PopAndDestroy();

    75     

    76     STIF_ASSERT_EQUALS( label->Font(), CCoeEnv::Static()->NormalFont() );

    77     

    78     CleanupStack::PopAndDestroy( label );

    79     

    80     return KErrNone;

    81     

    82     }

    83 

    84 // -----------------------------------------------------------------------------

    85 // CTestSDKLabels::TestLabelSetLabelAlignmentL

    86 // -----------------------------------------------------------------------------

    87 //

    88 TInt CTestSDKLabels::TestLabelSetLabelAlignmentL( CStifItemParser& /*aItem*/ )

    89     {

    90     CEikLabel* label = new (ELeave) CEikLabel;

    91     CleanupStack::PushL( label );

    92     

    93     STIF_ASSERT_NOT_NULL( label );

    94     

    95     TResourceReader reader;

    96     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

    97     label->ConstructFromResourceL( reader );

    98     CleanupStack::PopAndDestroy();

    99     

   100     label->SetLabelAlignment( ELayoutAlignCenter );

   101     CleanupStack::PopAndDestroy( label );

   102     

   103     return KErrNone;

   104     

   105     }

   106 

   107 // -----------------------------------------------------------------------------

   108 // CTestSDKLabels::TestLabelSetBrushStyleL

   109 // -----------------------------------------------------------------------------

   110 //

   111 TInt CTestSDKLabels::TestLabelSetBrushStyleL( CStifItemParser& /*aItem*/ )

   112     {

   113     CEikLabel* label = new (ELeave) CEikLabel;

   114     CleanupStack::PushL( label );

   115     

   116     STIF_ASSERT_NOT_NULL( label );

   117     

   118     TResourceReader reader;

   119     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   120     label->ConstructFromResourceL( reader );

   121     CleanupStack::PopAndDestroy();

   122     

   123     label->SetBrushStyle( CWindowGc::ESolidBrush );

   124     

   125     CleanupStack::PopAndDestroy( label );

   126     

   127     return KErrNone;

   128     

   129     }

   130 

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

   132 // CTestSDKLabels::TestLabelSetBrushStyleFromContextL

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

   134 //

   135 TInt CTestSDKLabels::TestLabelSetBrushStyleFromContextL( CStifItemParser& /*aItem*/ )

   136     {

   137     CEikLabel* label = new (ELeave) CEikLabel;

   138     CleanupStack::PushL( label );

   139     

   140     STIF_ASSERT_NOT_NULL( label );

   141     

   142     TResourceReader reader;

   143     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   144     label->ConstructFromResourceL( reader );

   145     CleanupStack::PopAndDestroy();

   146     

   147     label->SetBrushStyleFromContext();

   148     

   149     CleanupStack::PopAndDestroy( label );

   150     

   151     return KErrNone;

   152     

   153     }

   154 

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

   156 // CTestSDKLabels::TestLabelMinimumSizeL

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

   158 //

   159 TInt CTestSDKLabels::TestLabelMinimumSizeL( CStifItemParser& /*aItem*/ )

   160     {

   161     CEikLabel* label = new (ELeave) CEikLabel;

   162     CleanupStack::PushL( label );

   163     

   164     STIF_ASSERT_NOT_NULL( label );

   165 

   166     TResourceReader reader;

   167     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   168     label->ConstructFromResourceL( reader );

   169     CleanupStack::PopAndDestroy();

   170     

   171     TSize minsize = label->MinimumSize();

   172     TPoint point( minsize.AsPoint() );

   173     

   174     STIF_ASSERT_NOT_EQUALS( 0, point.iX );

   175     STIF_ASSERT_NOT_EQUALS( 0, point.iY );

   176     

   177     CleanupStack::PopAndDestroy( label );

   178     

   179     return KErrNone;

   180     

   181     }

   182 

   183 // -----------------------------------------------------------------------------

   184 // CTestSDKLabels::TestLabelConstructFromResourceL

   185 // -----------------------------------------------------------------------------

   186 //

   187 TInt CTestSDKLabels::TestLabelConstructFromResourceL( CStifItemParser& /*aItem*/ )

   188     {

   189     CEikLabel* label = new (ELeave) CEikLabel;

   190     CleanupStack::PushL( label );

   191     

   192     STIF_ASSERT_NOT_NULL( label );

   193     

   194     TResourceReader reader;

   195     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   196     label->ConstructFromResourceL( reader );

   197     CleanupStack::PopAndDestroy();

   198     

   199     _LIT( KText, "TestSDKLabels" );

   200     TBuf<KTextLength> text;

   201     text = *( label->Text() );

   202     STIF_ASSERT_EQUALS( 0, text.Compare( KText ) );

   203     

   204     CleanupStack::PopAndDestroy( label );

   205     

   206     return KErrNone;

   207     

   208     }

   209 

   210 // -----------------------------------------------------------------------------

   211 // CTestSDKLabels::TestLabelGetColorUseListL

   212 // -----------------------------------------------------------------------------

   213 //

   214 TInt CTestSDKLabels::TestLabelGetColorUseListL( CStifItemParser& /*aItem*/ )

   215     {

   216     CEikLabel* label = new (ELeave) CEikLabel;

   217     CleanupStack::PushL( label );

   218     

   219     STIF_ASSERT_NOT_NULL( label );

   220     

   221     TResourceReader reader;

   222     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   223     label->ConstructFromResourceL( reader );

   224     CleanupStack::PopAndDestroy();

   225     

   226     CArrayFix<TCoeColorUse>* colorUseList = new (ELeave) CArrayFixFlat<TCoeColorUse> ( 1 );

   227     CleanupStack::PushL( colorUseList );

   228     label->GetColorUseListL( *colorUseList );

   229     STIF_ASSERT_NOT_NULL( colorUseList );

   230     

   231     CleanupStack::PopAndDestroy( colorUseList );

   232     CleanupStack::PopAndDestroy( label );

   233     

   234     return KErrNone;

   235     

   236     }

   237 

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

   239 // CTestSDKLabels::TestLabelHandleResourceChangeL

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

   241 //

   242 TInt CTestSDKLabels::TestLabelHandleResourceChangeL( CStifItemParser& /*aItem*/ )

   243     {

   244     CEikLabel* label = new (ELeave) CEikLabel;

   245     CleanupStack::PushL( label );

   246     

   247     STIF_ASSERT_NOT_NULL( label );

   248     

   249     TResourceReader reader;

   250     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   251     label->ConstructFromResourceL( reader );

   252     CleanupStack::PopAndDestroy();

   253     

   254     label->HandleResourceChange( KAknsMessageSkinChange );

   255     

   256     CleanupStack::PopAndDestroy( label );

   257     

   258     return KErrNone;

   259     

   260     }

   261 

   262 // -----------------------------------------------------------------------------

   263 // CTestSDKLabels::TestLabelDrawL

   264 // -----------------------------------------------------------------------------

   265 //

   266 TInt CTestSDKLabels::TestLabelDrawL( CStifItemParser& /*aItem*/ )

   267     {

   268     CEikLabel* label = new (ELeave) CEikLabel;

   269     CleanupStack::PushL( label );

   270     

   271     STIF_ASSERT_NOT_NULL( label );

   272     

   273     TResourceReader reader;

   274     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   275     label->ConstructFromResourceL( reader );

   276     CleanupStack::PopAndDestroy();

   277     

   278     label->DrawNow();

   279     

   280     CleanupStack::PopAndDestroy( label );

   281     

   282     return KErrNone;

   283     

   284     }

   285 

   286 // -----------------------------------------------------------------------------

   287 // CTestSDKLabels::TestLabelSetTextL

   288 // -----------------------------------------------------------------------------

   289 //

   290 TInt CTestSDKLabels::TestLabelSetTextL( CStifItemParser& /*aItem*/ )

   291     {

   292     CEikLabel* label = new (ELeave) CEikLabel;

   293     CleanupStack::PushL( label );

   294     

   295     STIF_ASSERT_NOT_NULL( label );

   296     

   297     TResourceReader reader;

   298     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   299     label->ConstructFromResourceL( reader );

   300     CleanupStack::PopAndDestroy();

   301     

   302     _LIT( KText, "Labels" );

   303     STIF_ASSERT_NOT_LEAVES( label->SetTextL( KText ) );

   304     TBuf<KTextLength> text;

   305     text = *( label->Text() );

   306     STIF_ASSERT_EQUALS( 0, text.Compare( KText ) );

   307     

   308     CleanupStack::PopAndDestroy( label );

   309     

   310     return KErrNone;

   311     

   312     }

   313 

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

   315 // CTestSDKLabels::TestLabelTextL

   316 // -----------------------------------------------------------------------------

   317 //

   318 TInt CTestSDKLabels::TestLabelTextL( CStifItemParser& /*aItem*/ )

   319     {

   320     CEikLabel* label = new (ELeave) CEikLabel;

   321     CleanupStack::PushL( label );

   322     

   323     STIF_ASSERT_NOT_NULL( label );

   324     

   325     TResourceReader reader;

   326     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   327     label->ConstructFromResourceL( reader );

   328     CleanupStack::PopAndDestroy();

   329     

   330     const TInt KLength = 20;

   331     label->CropText();

   332     _LIT( KText, "TestSDKLabels" );

   333     TBuf<KLength> text;

   334     text = *( label->Text() );

   335     STIF_ASSERT_EQUALS( 0, text.Compare( KText ) );

   336     

   337     CleanupStack::PopAndDestroy( label );

   338     

   339     return KErrNone;

   340     

   341     }

   342 

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

   344 // CTestSDKLabels::TestLabelCropTextL

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

   346 //

   347 TInt CTestSDKLabels::TestLabelCropTextL( CStifItemParser& /*aItem*/ )

   348     {

   349     CEikLabel* label = new (ELeave) CEikLabel;

   350     CleanupStack::PushL( label );

   351     

   352     STIF_ASSERT_NOT_NULL( label );

   353     

   354     TResourceReader reader;

   355     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   356     label->ConstructFromResourceL( reader );

   357     CleanupStack::PopAndDestroy();

   358     

   359     const TInt KLength = 20;

   360     label->CropText();

   361     _LIT( KText, "TestSDKLabels" );

   362     TBuf<KLength> text;

   363     text = *( label->Text() );

   364     STIF_ASSERT_EQUALS( 0, text.Compare( KText ) );

   365     

   366     CleanupStack::PopAndDestroy( label );

   367     

   368     return KErrNone;

   369     

   370     }

   371 

   372 // -----------------------------------------------------------------------------

   373 // CTestSDKLabels::TestLabelSetBufferReserveLengthL

   374 // -----------------------------------------------------------------------------

   375 //

   376 TInt CTestSDKLabels::TestLabelSetBufferReserveLengthL( CStifItemParser& /*aItem*/ )

   377     {

   378     CEikLabel* label = new (ELeave) CEikLabel;

   379     CleanupStack::PushL( label );

   380     

   381     STIF_ASSERT_NOT_NULL( label );

   382     

   383     TResourceReader reader;

   384     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   385     label->ConstructFromResourceL( reader );

   386     CleanupStack::PopAndDestroy();

   387     

   388     const TInt KLength = 20;

   389     label->SetBufferReserveLengthL( KLength );

   390     TBuf<KLength> text;

   391     text = *( label->Text() );

   392     TInt length = text.MaxLength();

   393     STIF_ASSERT_EQUALS( length, KLength );

   394     

   395     _LIT( KText, "TestSDKLabels" );

   396     STIF_ASSERT_EQUALS( 0, text.Compare( KText ) );

   397     

   398     CleanupStack::PopAndDestroy( label );

   399     

   400     return KErrNone;

   401     

   402     }

   403 

   404 // -----------------------------------------------------------------------------

   405 // CTestSDKLabels::TestLabelSetFontL

   406 // -----------------------------------------------------------------------------

   407 //

   408 TInt CTestSDKLabels::TestLabelSetFontL( CStifItemParser& /*aItem*/ )

   409     {

   410     CEikLabel* label = new (ELeave) CEikLabel;

   411     CleanupStack::PushL( label );

   412     

   413     STIF_ASSERT_NOT_NULL( label );

   414     

   415     TResourceReader reader;

   416     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   417     label->ConstructFromResourceL( reader );

   418     CleanupStack::PopAndDestroy();

   419     

   420     const CFont* font = CEikonEnv::Static()->LegendFont();

   421     label->SetFont( font );

   422     

   423     const CFont* fontGet = label->Font();

   424     STIF_ASSERT_TRUE( font == fontGet );

   425     

   426     CleanupStack::PopAndDestroy( label );

   427     

   428     return KErrNone;

   429     

   430     }

   431 

   432 // -----------------------------------------------------------------------------

   433 // CTestSDKLabels::TestLabelFontL

   434 // -----------------------------------------------------------------------------

   435 //

   436 TInt CTestSDKLabels::TestLabelFontL( CStifItemParser& /*aItem*/ )

   437     {

   438     CEikLabel* label = new (ELeave) CEikLabel;

   439     CleanupStack::PushL( label );

   440     

   441     STIF_ASSERT_NOT_NULL( label );

   442     

   443     TResourceReader reader;

   444     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   445     label->ConstructFromResourceL( reader );

   446     CleanupStack::PopAndDestroy();

   447     

   448     const CFont* font = CEikonEnv::Static()->LegendFont();

   449     label->SetFont( font );

   450     

   451     const CFont* fontGet = label->Font();

   452     STIF_ASSERT_TRUE( font == fontGet );

   453     

   454     CleanupStack::PopAndDestroy( label );

   455     

   456     return KErrNone;

   457     

   458     }

   459 

   460 // -----------------------------------------------------------------------------

   461 // CTestSDKLabels::TestLabelSetEmphasisL

   462 // -----------------------------------------------------------------------------

   463 //

   464 TInt CTestSDKLabels::TestLabelSetEmphasisL( CStifItemParser& /*aItem*/ )

   465     {

   466     CEikLabel* label = new (ELeave) CEikLabel;

   467     CleanupStack::PushL( label );

   468     

   469     STIF_ASSERT_NOT_NULL( label );

   470     

   471     TResourceReader reader;

   472     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   473     label->ConstructFromResourceL( reader );

   474     CleanupStack::PopAndDestroy();

   475     

   476     label->SetEmphasis( CEikLabel::TTextEmphasis( 0 ));

   477     

   478     CleanupStack::PopAndDestroy( label );

   479     

   480     return KErrNone;

   481     

   482     }

   483 

   484 // -----------------------------------------------------------------------------

   485 // CTestSDKLabels::TestLabelSetPixelGapBetweenLinesL

   486 // -----------------------------------------------------------------------------

   487 //

   488 TInt CTestSDKLabels::TestLabelSetPixelGapBetweenLinesL( CStifItemParser& /*aItem*/ )

   489     {

   490     CEikLabel* label = new (ELeave) CEikLabel;

   491     CleanupStack::PushL( label );

   492     

   493     STIF_ASSERT_NOT_NULL( label );

   494     

   495     TResourceReader reader;

   496     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   497     label->ConstructFromResourceL( reader );

   498     CleanupStack::PopAndDestroy();

   499     

   500     label->SetPixelGapBetweenLines( 2 );

   501     TInt pixelGap = label->PixelGapBetweenLines();

   502     STIF_ASSERT_EQUALS( 2, pixelGap );

   503     

   504     CleanupStack::PopAndDestroy( label );

   505     

   506     return KErrNone;

   507     

   508     }

   509 

   510 // -----------------------------------------------------------------------------

   511 // CTestSDKLabels::TestLabelPixelGapBetweenLinesL

   512 // -----------------------------------------------------------------------------

   513 //

   514 TInt CTestSDKLabels::TestLabelPixelGapBetweenLinesL( CStifItemParser& /*aItem*/ )

   515     {

   516     CEikLabel* label = new (ELeave) CEikLabel;

   517     CleanupStack::PushL( label );

   518     

   519     STIF_ASSERT_NOT_NULL( label );

   520     

   521     TResourceReader reader;

   522     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   523     label->ConstructFromResourceL( reader );

   524     CleanupStack::PopAndDestroy();

   525     

   526     TInt pixelGap = label->PixelGapBetweenLines();

   527     label->SetPixelGapBetweenLines( pixelGap );

   528     

   529     CleanupStack::PopAndDestroy( label );

   530     

   531     return KErrNone;

   532     

   533     }

   534 

   535 // -----------------------------------------------------------------------------

   536 // CTestSDKLabels::TestLabelIsUnderlinedL

   537 // -----------------------------------------------------------------------------

   538 //

   539 TInt CTestSDKLabels::TestLabelIsUnderlinedL( CStifItemParser& /*aItem*/ )

   540     {

   541     CEikLabel* label = new (ELeave) CEikLabel;

   542     CleanupStack::PushL( label );

   543     

   544     STIF_ASSERT_NOT_NULL( label );

   545     

   546     TResourceReader reader;

   547     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   548     label->ConstructFromResourceL( reader );

   549     CleanupStack::PopAndDestroy();

   550     

   551     label->SetUnderlining( ETrue );

   552     TBool underline = label->IsUnderlined();

   553     STIF_ASSERT_TRUE( underline );

   554     

   555     CleanupStack::PopAndDestroy( label );

   556     

   557     return KErrNone;

   558     

   559     }

   560 

   561 // -----------------------------------------------------------------------------

   562 // CTestSDKLabels::TestLabelSetUnderliningL

   563 // -----------------------------------------------------------------------------

   564 //

   565 TInt CTestSDKLabels::TestLabelSetUnderliningL( CStifItemParser& /*aItem*/ )

   566     {

   567     CEikLabel* label = new (ELeave) CEikLabel;

   568     CleanupStack::PushL( label );

   569     

   570     STIF_ASSERT_NOT_NULL( label );

   571     

   572     TResourceReader reader;

   573     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   574     label->ConstructFromResourceL( reader );

   575     CleanupStack::PopAndDestroy();

   576     

   577     label->SetUnderlining( ETrue );

   578     TBool underline = label->IsUnderlined();

   579     STIF_ASSERT_TRUE( underline );

   580     

   581     CleanupStack::PopAndDestroy( label );

   582     

   583     return KErrNone;

   584     

   585     }

   586 

   587 // -----------------------------------------------------------------------------

   588 // CTestSDKLabels::TestLabelIsStrikethroughL

   589 // -----------------------------------------------------------------------------

   590 //

   591 TInt CTestSDKLabels::TestLabelIsStrikethroughL( CStifItemParser& /*aItem*/ )

   592     {

   593     CEikLabel* label = new (ELeave) CEikLabel;

   594     CleanupStack::PushL( label );

   595     

   596     STIF_ASSERT_NOT_NULL( label );

   597     

   598     TResourceReader reader;

   599     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   600     label->ConstructFromResourceL( reader );

   601     CleanupStack::PopAndDestroy();

   602     

   603     label->SetStrikethrough( ETrue );

   604     TBool strikethrough = label->IsStrikethrough();

   605     STIF_ASSERT_TRUE( strikethrough );

   606     

   607     CleanupStack::PopAndDestroy( label );

   608     

   609     return KErrNone;

   610     

   611     }

   612 

   613 // -----------------------------------------------------------------------------

   614 // CTestSDKLabels::TestLabelSetStrikethroughL

   615 // -----------------------------------------------------------------------------

   616 //

   617 TInt CTestSDKLabels::TestLabelSetStrikethroughL( CStifItemParser& /*aItem*/ )

   618     {

   619     CEikLabel* label = new (ELeave) CEikLabel;

   620     CleanupStack::PushL( label );

   621     

   622     STIF_ASSERT_NOT_NULL( label );

   623     

   624     TResourceReader reader;

   625     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   626     label->ConstructFromResourceL( reader );

   627     CleanupStack::PopAndDestroy();

   628     

   629     label->SetStrikethrough( ETrue );

   630     TBool strikethrough = label->IsStrikethrough();

   631     STIF_ASSERT_TRUE( strikethrough );

   632     

   633     CleanupStack::PopAndDestroy( label );

   634     

   635     return KErrNone;

   636     

   637     }

   638 

   639 // -----------------------------------------------------------------------------

   640 // CTestSDKLabels::TestLabelCalcMinimumSizeL

   641 // -----------------------------------------------------------------------------

   642 //

   643 TInt CTestSDKLabels::TestLabelCalcMinimumSizeL( CStifItemParser& /*aItem*/ )

   644     {

   645     CEikLabel* label = new (ELeave) CEikLabel;

   646     CleanupStack::PushL( label );

   647     

   648     STIF_ASSERT_NOT_NULL( label );

   649     

   650     TResourceReader reader;

   651     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   652     label->ConstructFromResourceL( reader );

   653     CleanupStack::PopAndDestroy();

   654     

   655     _LIT( KText, "CalcMinimumSize" );

   656     TPtrC text( KText );

   657     TSize size = label->CalcMinimumSize( text );

   658     TPoint point( size.AsPoint() );

   659     

   660     STIF_ASSERT_NOT_EQUALS( 0, point.iX );

   661     STIF_ASSERT_NOT_EQUALS( 0, point.iY );

   662     

   663     CleanupStack::PopAndDestroy( label );

   664     

   665     return KErrNone;

   666     

   667     }

   668 

   669 // -----------------------------------------------------------------------------

   670 // CTestSDKLabels::TestLabelNumberOfLinesL

   671 // -----------------------------------------------------------------------------

   672 //

   673 TInt CTestSDKLabels::TestLabelNumberOfLinesL( CStifItemParser& /*aItem*/ )

   674     {

   675     CEikLabel* label = new (ELeave) CEikLabel;

   676     CleanupStack::PushL( label );

   677     

   678     STIF_ASSERT_NOT_NULL( label );

   679     

   680     TResourceReader reader;

   681     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   682     label->ConstructFromResourceL( reader );

   683     CleanupStack::PopAndDestroy();

   684     

   685     TUint8 numberOfLinea = label->NumberOfLines();

   686     STIF_ASSERT_FALSE( 0 == numberOfLinea );

   687     

   688     CleanupStack::PopAndDestroy( label );

   689     

   690     return KErrNone;

   691     

   692     }

   693 

   694 // -----------------------------------------------------------------------------

   695 // CTestSDKLabels::TestLabelBufferReserveLengthL

   696 // -----------------------------------------------------------------------------

   697 //

   698 TInt CTestSDKLabels::TestLabelBufferReserveLengthL( CStifItemParser& /*aItem*/ )

   699     {

   700     CEikLabel* label = new (ELeave) CEikLabel;

   701     CleanupStack::PushL( label );

   702     

   703     STIF_ASSERT_NOT_NULL( label );

   704     

   705     TResourceReader reader;

   706     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   707     label->ConstructFromResourceL( reader );

   708     CleanupStack::PopAndDestroy();

   709     

   710     const TInt KLength = 20;

   711     label->SetBufferReserveLengthL( KLength );

   712     TInt reserveLength = label->BufferReserveLength();

   713     STIF_ASSERT_EQUALS( KLength, reserveLength);

   714     

   715     CleanupStack::PopAndDestroy( label );

   716     

   717     return KErrNone;

   718     

   719     }

   720 

   721 // -----------------------------------------------------------------------------

   722 // CTestSDKLabels::TestLabelUseLogicalToVisualConversionL

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

   724 //

   725 TInt CTestSDKLabels::TestLabelUseLogicalToVisualConversionL( CStifItemParser& /*aItem*/ )

   726     {

   727     CEikLabel* label = new (ELeave) CEikLabel;

   728     CleanupStack::PushL( label );

   729     

   730     STIF_ASSERT_NOT_NULL( label );

   731     

   732     TResourceReader reader;

   733     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   734     label->ConstructFromResourceL( reader );

   735     CleanupStack::PopAndDestroy();

   736     

   737     label->UseLogicalToVisualConversion( EFalse );

   738     TBool visualConversion= label->LogicalToVisualConversionUsed();

   739     STIF_ASSERT_FALSE( visualConversion );

   740     

   741     CleanupStack::PopAndDestroy( label );

   742     

   743     return KErrNone;

   744     

   745     }

   746 

   747 // -----------------------------------------------------------------------------

   748 // CTestSDKLabels::TestLabelLogicalToVisualConversionUsedL

   749 // -----------------------------------------------------------------------------

   750 //

   751 TInt CTestSDKLabels::TestLabelLogicalToVisualConversionUsedL( CStifItemParser& /*aItem*/ )

   752     {

   753     CEikLabel* label = new (ELeave) CEikLabel;

   754     CleanupStack::PushL( label );

   755     

   756     STIF_ASSERT_NOT_NULL( label );

   757     

   758     TResourceReader reader;

   759     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   760     label->ConstructFromResourceL( reader );

   761     CleanupStack::PopAndDestroy();

   762     

   763     TBool visualConversion = label->LogicalToVisualConversionUsed();

   764     STIF_ASSERT_TRUE( visualConversion );

   765     

   766     CleanupStack::PopAndDestroy( label );

   767     

   768     return KErrNone;

   769     

   770     }

   771 

   772 // -----------------------------------------------------------------------------

   773 // CTestSDKLabels::TestLabelEnablePictographsL

   774 // -----------------------------------------------------------------------------

   775 //

   776 TInt CTestSDKLabels::TestLabelEnablePictographsL( CStifItemParser& /*aItem*/ )

   777     {

   778     CEikLabel* label = new (ELeave) CEikLabel;

   779     CleanupStack::PushL( label );

   780     

   781     STIF_ASSERT_NOT_NULL( label );

   782     

   783     TResourceReader reader;

   784     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   785     label->ConstructFromResourceL( reader );

   786     CleanupStack::PopAndDestroy();

   787     

   788     CTestSDKLabelsSubAknPictographCallBack *subCallBack = CTestSDKLabelsSubAknPictographCallBack::NewLC();

   789     CAknPictographInterface* interface = subCallBack->Interface();

   790     

   791     label->EnablePictographsL( *interface );

   792     

   793     CleanupStack::PopAndDestroy( 2 );

   794     

   795     return KErrNone;

   796     

   797     }

   798 

   799 // -----------------------------------------------------------------------------

   800 // CTestSDKLabels::TestLabelDisablePictographsL

   801 // -----------------------------------------------------------------------------

   802 //

   803 TInt CTestSDKLabels::TestLabelDisablePictographsL( CStifItemParser& /*aItem*/ )

   804     {

   805     CEikLabel* label = new (ELeave) CEikLabel;

   806     CleanupStack::PushL( label );

   807     

   808     STIF_ASSERT_NOT_NULL( label );

   809     

   810     TResourceReader reader;

   811     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   812     label->ConstructFromResourceL( reader );

   813     CleanupStack::PopAndDestroy();

   814     

   815     label->DisablePictographs();

   816     

   817     CTestSDKLabelsSubAknPictographCallBack *subCallBack = CTestSDKLabelsSubAknPictographCallBack::NewLC();

   818     CAknPictographInterface* interface = subCallBack->Interface();

   819     label->EnablePictographsL( *interface );

   820     

   821     label->DisablePictographs();

   822     

   823     CleanupStack::PopAndDestroy( 2 );

   824     

   825     return KErrNone;

   826     

   827     }

   828 

   829 // -----------------------------------------------------------------------------

   830 // CTestSDKLabels::TestLabelHandlePointerEventL

   831 // -----------------------------------------------------------------------------

   832 //

   833 TInt CTestSDKLabels::TestLabelHandlePointerEventL( CStifItemParser& /*aItem*/ )

   834     {

   835     CEikLabel* label = new (ELeave) CEikLabel;

   836     CleanupStack::PushL( label );

   837     

   838     STIF_ASSERT_NOT_NULL( label );

   839     

   840     TResourceReader reader;

   841     CCoeEnv::Static()->CreateResourceReaderLC( reader, R_TEST_LABELS );

   842     label->ConstructFromResourceL( reader );

   843     CleanupStack::PopAndDestroy();

   844     

   845     TPointerEvent event;

   846     event.iType = TPointerEvent::EButton1Down;

   847     event.iModifiers = 0;

   848     TPoint eventPos( 10, 30 );

   849     event.iPosition = eventPos;

   850     event.iParentPosition = eventPos;

   851 

   852     STIF_ASSERT_NOT_LEAVES( label->HandlePointerEventL( event ) );

   853     

   854     CleanupStack::PopAndDestroy( label );

   855     

   856     return KErrNone;

   857     

   858     }

   859 

   860 // -----------------------------------------------------------------------------

   861 // CTestSDKLabels::TestLabelWriteInternalStateL

   862 // -----------------------------------------------------------------------------

   863 //

   864 TInt CTestSDKLabels::TestLabelWriteInternalStateL( CStifItemParser& /*aItem*/ )

   865     {

   866     CTestSDKLabelsLabel* label = CTestSDKLabelsLabel::NewLC();

   867     STIF_ASSERT_NOT_NULL( label );

   868     

   869     const TInt KLength = 200;

   870     CBufFlat* buf = CBufFlat::NewL( KLength );

   871     CleanupStack::PushL( buf );

   872     RBufWriteStream writeStream;

   873     CleanupClosePushL( writeStream );

   874     writeStream.Open( *buf );

   875     

   876     STIF_ASSERT_NOT_LEAVES( label->WriteInternalStateL( writeStream ) );

   877     STIF_ASSERT_NOT_NULL( buf );

   878     STIF_ASSERT_NOT_NULL( &writeStream );

   879     

   880     CleanupStack::PopAndDestroy( &writeStream );

   881     CleanupStack::PopAndDestroy( buf );

   882     CleanupStack::PopAndDestroy( label );

   883     

   884     return KErrNone;

   885     

   886     }

   887 

   888 //  [End of File]