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 in aknutils.h

    15 *

    16 */

    17 

    18 

    19 

    20 // [INCLUDE FILES]

    21 #include <e32svr.h>

    22 #include <stifparser.h>

    23 #include <stiftestinterface.h>

    24 #include <testsdkuifwutil.rsg>

    25 #include <eikclb.h>

    26 #include <eikfrlbd.h>

    27 #include <e32const.h>

    28 #include <akndialog.h>

    29 #include <aknlists.h>

    30 #include <eikclbd.h>

    31 #include <aknsfld.h>

    32 #include <aknlayout2def.h>

    33 #include <aknlayout2scalabledef.h>

    34 #include <eikmfne.h>

    35 #include <eikseced.h>

    36 #include <aknfontspecification.h>

    37 #include <akniconutils.h>

    38 #include <avkon.mbg>

    39 #include <gulfont.h>

    40 

    41 #include "testsdkuifwutil.h"

    42 

    43 // CONSTANTS

    44 const TInt KArraySize = 10;

    45 const TInt KBufSize = 64;

    46 const TInt KGeneralWidth = 50;

    47 const TInt KSearchFieldMaxLength = 20;

    48 _LIT( KTextExample, "textexample" );

    49 _LIT( KBitmapFile, "Z:\\resource\\apps\\avkon2.mbm" );

    50 

    51 // FORWARD DECLARATIONS

    52 // This class only for test, not any value.

    53 class CScrollBarObserver : public CBase, public MEikScrollBarObserver

    54     {

    55 public:

    56     // From MEikScrollBarObserver

    57     void HandleScrollEventL( CEikScrollBar* /*aScrollBar*/, TEikScrollEvent /*aEventType*/ ){}

    58     };

    59 

    60 // This class only for test, not any value.

    61 class CControlObserver : public CBase, public MCoeControlObserver

    62     {

    63 public:

    64     // From MCoeControlObserver

    65     void HandleControlEventL( CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/ ){}

    66     };

    67 // ============================ MEMBER FUNCTIONS ===============================

    68 

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

    70 // CTestSDKUiFwUtil::TestAknTextUtilsClipToFitL

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

    72 //

    73 TInt CTestSDKUiFwUtil::TestAknTextUtilsClipToFitL( CStifItemParser& aItem )

    74     {

    75     TInt num = 0;

    76     TInt err = aItem.GetNextInt( num );

    77     if ( err != KErrNone )

    78         {

    79         return err;

    80         }

    81     const CFont& font = *(iEnv->TitleFont());

    82     TBool result;

    83     TBuf<KBufSize> buf( KTextExample );

    84     switch ( num )

    85         {

    86         case ECaseZero:

    87             {

    88             result = AknTextUtils::ClipToFit( buf, font, KGeneralWidth);

    89             break;

    90             }

    91         case ECaseOne:

    92             {

    93             TInt itemindex = 0;   

    94             TInt columnnumber = 0;

    95             CEikColumnListBox* collist = new ( ELeave ) CAknSingleStyleListBox;

    96             CleanupStack::PushL( collist );

    97             collist->SetContainerWindowL( *iContainer );

    98             iContainer->SetComponentControlL( collist );

    99             TResourceReader reader;

   100             iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   101             collist->ConstructFromResourceL( reader );

   102             CleanupStack::PopAndDestroy();

   103             CColumnListBoxData *data = collist->ItemDrawer()->ColumnData();

   104             data->SetColumnFontL( columnnumber, &font );

   105             result = AknTextUtils::ClipToFit( buf, AknTextUtils::EClipFromEnd, collist,

   106                     itemindex, columnnumber );

   107             CleanupStack::PopAndDestroy( collist );

   108             break;

   109             }

   110         case ECaseTwo:

   111             {

   112             TInt itemindex = 0;   

   113             TInt subcellnumber = 0;

   114             CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

   115             CleanupStack::PushL( celllist );

   116             celllist->SetContainerWindowL( * iContainer );

   117             

   118             TResourceReader reader;

   119             iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   120             celllist->ConstructFromResourceL( reader );

   121             CleanupStack::PopAndDestroy();

   122             CFormattedCellListBoxData* formatData = celllist->ItemDrawer()->FormattedCellData();

   123             formatData->SetSubCellFontL( subcellnumber, &font );

   124             result = AknTextUtils::ClipToFit( buf, AknTextUtils::EClipFromEnd, celllist,

   125                     itemindex, subcellnumber );

   126             CleanupStack::PopAndDestroy( celllist );

   127             break;

   128             }

   129         default:

   130             {

   131             return KErrNotSupported;

   132             }

   133         }

   134     STIF_ASSERT_TRUE( result );

   135     

   136     return KErrNone;

   137     }

   138 

   139 // -----------------------------------------------------------------------------

   140 // CTestSDKUiFwUtil::TestAKnTextUtilsWrapToArrayL

   141 // -----------------------------------------------------------------------------

   142 //

   143 TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToArrayL( CStifItemParser& aItem )

   144     {

   145     TInt num = 0;

   146     TInt err = aItem.GetNextInt( num );

   147     if ( err != KErrNone )

   148         {

   149         return err;

   150         }

   151     TBuf<KBufSize> buf( KTextExample );

   152     CArrayFix<TPtrC>* wraparray = new ( ELeave ) CArrayFixFlat<TPtrC>( KArraySize );

   153     CleanupStack::PushL( wraparray );

   154     const CFont& font = *(iEnv->TitleFont());

   155     switch ( num )

   156         {

   157         case ECaseZero:

   158             {

   159             AknTextUtils::WrapToArrayL( buf, KGeneralWidth, font, *wraparray );

   160             break;

   161             }

   162         case ECaseOne:

   163             {

   164             CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

   165             CleanupStack::PushL( widtharray );

   166             AknTextUtils::WrapToArrayL( buf, *widtharray, font, *wraparray );

   167             CleanupStack::PopAndDestroy( widtharray );

   168             break;

   169             }

   170         default:

   171             {

   172             CleanupStack::PopAndDestroy( wraparray );

   173             return KErrNotSupported;

   174             }

   175         }

   176     

   177     CleanupStack::PopAndDestroy( wraparray );

   178     

   179     return KErrNone;

   180     }

   181 

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

   183 // CTestSDKUiFwUtil::TestAknTextUtilsWrapToArrayAndClipL

   184 // -----------------------------------------------------------------------------

   185 //

   186 TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToArrayAndClipL( CStifItemParser& /*aItem*/ )

   187     {

   188     TBuf<KBufSize> buf( KTextExample );

   189     CArrayFix<TPtrC>* wraparray = new ( ELeave ) CArrayFixFlat<TPtrC>( KArraySize );

   190     CleanupStack::PushL( wraparray );

   191     const CFont& font = *(iEnv->TitleFont());

   192     CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

   193     CleanupStack::PushL( widtharray );

   194     AknTextUtils::WrapToArrayAndClipL( buf, *widtharray, font, *wraparray );

   195     

   196     CleanupStack::PopAndDestroy( widtharray );

   197     CleanupStack::PopAndDestroy( wraparray );

   198     

   199     return KErrNone;

   200     }

   201 

   202 // -----------------------------------------------------------------------------

   203 // CTestSDKUiFwUtil::TestAknTextUtilsChopToArrayAndClipL

   204 // -----------------------------------------------------------------------------

   205 //

   206 TInt CTestSDKUiFwUtil::TestAknTextUtilsChopToArrayAndClipL( CStifItemParser& aItem )

   207     {

   208     TInt num = 0;

   209     TInt err = aItem.GetNextInt( num );

   210     if ( err != KErrNone )

   211         {

   212         return err;

   213         }

   214     TBuf<KBufSize> buf( KTextExample );

   215     CArrayFix<TPtrC>* wraparray = new ( ELeave ) CArrayFixFlat<TPtrC>( KArraySize );

   216     CleanupStack::PushL( wraparray );

   217     const CFont& font = *(iEnv->TitleFont());

   218     switch ( num )

   219         {

   220         case ECaseZero:

   221             {

   222             AknTextUtils::ChopToArrayAndClipL( buf, KGeneralWidth, font, *wraparray );

   223             break;

   224             }

   225         case ECaseOne:

   226             {

   227             CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

   228             CleanupStack::PushL( widtharray );

   229             AknTextUtils::ChopToArrayAndClipL( buf, *widtharray, font, *wraparray );

   230             CleanupStack::PopAndDestroy( widtharray );

   231             break;

   232             }

   233         default:

   234             {

   235             CleanupStack::PopAndDestroy( wraparray );

   236             return KErrNotSupported;

   237             }

   238         }

   239     

   240     CleanupStack::PopAndDestroy( wraparray );

   241     

   242     return KErrNone;

   243     }

   244 

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

   246 // CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringL

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

   248 //

   249 TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringL( CStifItemParser& /*aItem*/ )

   250     {

   251     TBuf<KBufSize> buf( KTextExample );

   252     TBuf<KBufSize> wrapbuf;

   253     const CFont& font = *(iEnv->TitleFont());

   254     CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

   255     CleanupStack::PushL( widtharray );

   256     AknTextUtils::WrapToStringL( buf, *widtharray, font, wrapbuf );

   257     

   258     CleanupStack::PopAndDestroy( widtharray );

   259     

   260     return KErrNone;

   261     }

   262 

   263 // -----------------------------------------------------------------------------

   264 // CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringAndClipL

   265 // -----------------------------------------------------------------------------

   266 //

   267 TInt CTestSDKUiFwUtil::TestAknTextUtilsWrapToStringAndClipL( CStifItemParser& /*aItem*/ )

   268     {

   269     TBuf<KBufSize> buf( KTextExample );

   270     TBuf<KBufSize> wrapbuf;

   271     const CFont& font = *(iEnv->TitleFont());

   272     CArrayFix<TInt>* widtharray = new ( ELeave ) CArrayFixFlat<TInt>( KArraySize );

   273     CleanupStack::PushL( widtharray );

   274     AknTextUtils::WrapToStringAndClipL( buf, *widtharray, font, wrapbuf );

   275     

   276     CleanupStack::PopAndDestroy(widtharray);

   277     

   278     return KErrNone;

   279     }

   280 

   281 // -----------------------------------------------------------------------------

   282 // CTestSDKUiFwUtil::TestAknTextUtilsProcessCharacters

   283 // -----------------------------------------------------------------------------

   284 //

   285 TInt CTestSDKUiFwUtil::TestAknTextUtilsProcessCharacters( CStifItemParser& aItem )

   286     {

   287     TInt num = 0;

   288     TInt err = aItem.GetNextInt( num );

   289     if ( err != KErrNone )

   290         {

   291         return err;

   292         }

   293     TBuf<KBufSize> buf( KTextExample );

   294     TBuf<KBufSize> charactor;

   295     charactor.FillZ();

   296     charactor.Append( ' ' );

   297     TChar replacechar( 'a' );

   298     switch ( num )

   299         {

   300         case ECaseZero:

   301             {

   302             AknTextUtils::StripCharacters( buf, charactor );

   303             break;

   304             }

   305         case ECaseOne:

   306             {

   307             AknTextUtils::ReplaceCharacters( buf, charactor, replacechar );

   308             break;

   309             }

   310         case ECaseTwo:

   311             {

   312             AknTextUtils::PackWhiteSpaces( buf, charactor );

   313             break;

   314             }

   315         default:

   316             {

   317             return KErrNotSupported;

   318             }

   319         }

   320     

   321     return KErrNone;

   322     }

   323 

   324 // -----------------------------------------------------------------------------

   325 // CTestSDKUiFwUtil::TestAknTextUtilsLanguageSpecificNumberConversion

   326 // -----------------------------------------------------------------------------

   327 //

   328 TInt CTestSDKUiFwUtil::TestAknTextUtilsLanguageSpecificNumberConversion( CStifItemParser& /*aItem*/ )

   329     {

   330     TBuf<KBufSize> buf( KTextExample );

   331     AknTextUtils::LanguageSpecificNumberConversion( buf );

   332     

   333     return KErrNone;

   334     }

   335 

   336 // -----------------------------------------------------------------------------

   337 // CTestSDKUiFwUtil::TestAknTextUtilsConvertDigitsTo

   338 // -----------------------------------------------------------------------------

   339 //

   340 TInt CTestSDKUiFwUtil::TestAknTextUtilsConvertDigitsTo( CStifItemParser& /*aItem*/ )

   341     {

   342     TBuf<KBufSize> buf( KTextExample );

   343     AknTextUtils::ConvertDigitsTo( buf, EDigitTypeAllTypes );

   344     

   345     return KErrNone;

   346     }

   347 

   348 // -----------------------------------------------------------------------------

   349 // CTestSDKUiFwUtil::TestAknTextUtilsCurrentScriptDirectionality

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

   351 //

   352 TInt CTestSDKUiFwUtil::TestAknTextUtilsCurrentScriptDirectionality( CStifItemParser& /*aItem*/ )

   353     {

   354     TBuf<KBufSize> buf( KTextExample );

   355     AknTextUtils::CurrentScriptDirectionality();

   356     

   357     return KErrNone;

   358     }

   359 

   360 // -----------------------------------------------------------------------------

   361 // CTestSDKUiFwUtil::TestAknTextUtilsNumericEditorDigitType

   362 // -----------------------------------------------------------------------------

   363 //

   364 TInt CTestSDKUiFwUtil::TestAknTextUtilsNumericEditorDigitType( CStifItemParser& /*aItem*/ )

   365     {

   366     AknTextUtils::NumericEditorDigitType();

   367     

   368     return KErrNone;

   369     }

   370 

   371 // -----------------------------------------------------------------------------

   372 // CTestSDKUiFwUtil::TestAknTextUtilsDisplayTextLanguageSpecificNumberConversion

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

   374 //

   375 TInt CTestSDKUiFwUtil::TestAknTextUtilsDisplayTextLanguageSpecificNumberConversion( CStifItemParser& /*aItem*/ )

   376     {

   377     TBuf<KBufSize> buf( KTextExample );

   378     AknTextUtils::DisplayTextLanguageSpecificNumberConversion( buf );

   379     

   380     return KErrNone;

   381     }

   382 

   383 // -----------------------------------------------------------------------------

   384 // CTestSDKUiFwUtil::TestAknTextUtilsTextEditorDigitType

   385 // -----------------------------------------------------------------------------

   386 //

   387 TInt CTestSDKUiFwUtil::TestAknTextUtilsTextEditorDigitType( CStifItemParser& /*aItem*/ )

   388     {

   389     AknTextUtils::TextEditorDigitType();

   390     

   391     return KErrNone;

   392     }

   393 

   394 // -----------------------------------------------------------------------------

   395 // CTestSDKUiFwUtil::TestAknTextUtilsDigitModeQuery

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

   397 //

   398 TInt CTestSDKUiFwUtil::TestAknTextUtilsDigitModeQuery( CStifItemParser& /*aItem*/ )

   399     {

   400     AknTextUtils::DigitModeQuery( AknTextUtils::EDigitModeNumberEditor );

   401     

   402     return KErrNone;

   403     }

   404 

   405 // -----------------------------------------------------------------------------

   406 // CTestSDKUiFwUtil::TestAknTextUtilsConvertFileNameL

   407 // -----------------------------------------------------------------------------

   408 //

   409 TInt CTestSDKUiFwUtil::TestAknTextUtilsConvertFileNameL( CStifItemParser& /*aItem*/ )

   410     {

   411     TBuf<KBufSize> buf( KTextExample );

   412     AknTextUtils::ConvertFileNameL( buf );

   413     

   414     return KErrNone;

   415     }

   416 

   417 // -----------------------------------------------------------------------------

   418 // CTestSDKUiFwUtil::TestAknTextUtilsLoadTextL

   419 // -----------------------------------------------------------------------------

   420 //

   421 TInt CTestSDKUiFwUtil::TestAknTextUtilsLoadTextL( CStifItemParser& /*aItem*/ )

   422     {

   423     TBuf<64> buf;

   424     AknTextUtils::LoadScalableText( *(CCoeEnv::Static()), 

   425         R_AKNTEXTUTILS_BUFZERO, buf );

   426     AknTextUtils::LoadScalableTextL( *(CCoeEnv::Static()), R_AKNTEXTUTILS_BUF );

   427     AknTextUtils::LoadScalableTextLC( *(CCoeEnv::Static()), R_AKNTEXTUTILS_BUF );

   428     CleanupStack::PopAndDestroy();

   429     

   430     return KErrNone;

   431     }

   432 

   433 // -----------------------------------------------------------------------------

   434 // CTestSDKUiFwUtil::TestAknTextUtilsClipAccordingScreenOrientationLCL

   435 // -----------------------------------------------------------------------------

   436 //

   437 TInt CTestSDKUiFwUtil::TestAknTextUtilsClipAccordingScreenOrientationLCL( CStifItemParser& /*aItem*/ )

   438     {

   439     TBuf<KBufSize> buf( KTextExample );

   440     HBufC* hbuf = HBufC::NewL( KBufSize );

   441     *hbuf = buf;    

   442     AknTextUtils::ClipAccordingScreenOrientationLC( *(CCoeEnv::Static()), hbuf );

   443     CleanupStack::PopAndDestroy();

   444     

   445     return KErrNone;

   446     }

   447 

   448 // -----------------------------------------------------------------------------

   449 // CTestSDKUiFwUtil::TestAknTextUtilsChooseScalableText

   450 // -----------------------------------------------------------------------------

   451 //

   452 TInt CTestSDKUiFwUtil::TestAknTextUtilsChooseScalableText( CStifItemParser& /*aItem*/ )

   453     {

   454     TBuf<KBufSize> buf( KTextExample );

   455     const CFont& font = *(iEnv->TitleFont());

   456     AknTextUtils::ChooseScalableText( buf, font, KGeneralWidth );

   457     

   458     return KErrNone;

   459     }

   460 

   461 // -----------------------------------------------------------------------------

   462 // CTestSDKUiFwUtil::TestAknSelectServHandleSelectionListProcessCommandL

   463 // -----------------------------------------------------------------------------

   464 //

   465 TInt CTestSDKUiFwUtil::TestAknSelectServHandleSelectionListProcessCommandL( CStifItemParser& /*aItem*/ )

   466     {

   467     CEikListBox* list = new ( ELeave ) CEikListBox;

   468     CleanupStack::PushL( list );

   469     AknSelectionService::HandleSelectionListProcessCommandL( 0, list );

   470     CleanupStack::PopAndDestroy( list );

   471     

   472     return KErrNone;

   473     }

   474 

   475 // -----------------------------------------------------------------------------

   476 // CTestSDKUiFwUtil::TestAknSelectServHandleMultiselectionListProcessCommandL

   477 // -----------------------------------------------------------------------------

   478 //

   479 TInt CTestSDKUiFwUtil::TestAknSelectServHandleMultiselectionListProcessCommandL( CStifItemParser& /*aItem*/ )

   480     {

   481     CEikListBox* list = new ( ELeave ) CEikListBox;

   482     CleanupStack::PushL( list );

   483     AknSelectionService::HandleMultiselectionListProcessCommandL( 0, list );

   484     CleanupStack::PopAndDestroy( list );

   485     

   486     return KErrNone;

   487     }

   488 

   489 // -----------------------------------------------------------------------------

   490 // CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListProcessCommandL

   491 // -----------------------------------------------------------------------------

   492 //

   493 TInt CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListProcessCommandL( CStifItemParser& /*aItem*/ )

   494     {

   495     CEikListBox* list = new ( ELeave ) CEikListBox;

   496     CleanupStack::PushL( list );

   497     AknSelectionService::HandleMarkableListProcessCommandL( 0, list );

   498     CleanupStack::PopAndDestroy( list );

   499     

   500     return KErrNone;

   501     }

   502 

   503 // -----------------------------------------------------------------------------

   504 // CTestSDKUiFwUtil::TestAknSelectServHandleMenuListOfferKeyEventL

   505 // -----------------------------------------------------------------------------

   506 //

   507 TInt CTestSDKUiFwUtil::TestAknSelectServHandleMenuListOfferKeyEventL( CStifItemParser& /*aItem*/ )

   508     {

   509     CEikListBox* list = new ( ELeave ) CAknSingleStyleListBox;

   510     CleanupStack::PushL( list );

   511     list->SetContainerWindowL( *iContainer );

   512     iContainer->SetComponentControlL( list );

   513     TResourceReader reader;

   514     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   515     list->ConstructFromResourceL( reader );

   516     CleanupStack::PopAndDestroy();

   517     TKeyEvent keyevent = { EKeyLeftShift, 0, 0, 0 };

   518     AknSelectionService::HandleMenuListOfferKeyEventL( keyevent, EEventKey, list );

   519     CleanupStack::PopAndDestroy( list );

   520     

   521     return KErrNone;

   522     }

   523 

   524 // -----------------------------------------------------------------------------

   525 // CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListDynInitMenuPaneL

   526 // -----------------------------------------------------------------------------

   527 //

   528 TInt CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListDynInitMenuPaneL( CStifItemParser& /*aItem*/ )

   529     {

   530     CAknDialog* dlg = new( ELeave ) CAknDialog();

   531     CleanupStack::PushL( dlg );

   532     CEikMenuPane* menuPane = new( ELeave ) CEikMenuPane( dlg );

   533     CleanupStack::PushL( menuPane );

   534     CEikListBox* list = new ( ELeave ) CEikListBox;

   535     CleanupStack::PushL( list );

   536     list->SetContainerWindowL( *iContainer );

   537     iContainer->SetComponentControlL( list );

   538     TResourceReader reader;

   539     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   540     list->ConstructFromResourceL( reader );

   541     CleanupStack::PopAndDestroy();

   542     AknSelectionService::HandleMarkableListDynInitMenuPane(

   543             R_AKNSELECTIONSERVICE_MENUPANE, menuPane, list );

   544     CleanupStack::PopAndDestroy( 3 );

   545     

   546     return KErrNone;

   547     }

   548 

   549 // -----------------------------------------------------------------------------

   550 // CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListDynInitMenuItemL

   551 // -----------------------------------------------------------------------------

   552 //

   553 TInt CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListDynInitMenuItemL( CStifItemParser& /*aItem*/ )

   554     {

   555     CAknDialog* dlg = new( ELeave ) CAknDialog();

   556     CleanupStack::PushL( dlg );

   557     CEikMenuPane* menuPane = new( ELeave ) CEikMenuPane( dlg );

   558     CleanupStack::PushL( menuPane );

   559     menuPane->ConstructL( NULL, dlg );

   560     CEikMenuPaneItem::SData item;

   561     item.iCommandId = 0;

   562     item.iCascadeId = 0;

   563     item.iFlags = 0;

   564     item.iText.Copy( KTextExample );

   565         

   566     menuPane->AddMenuItemL( item );

   567     CEikListBox* list = new ( ELeave ) CEikListBox;

   568     CleanupStack::PushL( list );

   569     TResourceReader reader;

   570     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   571     list->ConstructFromResourceL( reader );

   572     CleanupStack::PopAndDestroy();

   573     AknSelectionService::HandleMarkableListDynInitMenuItem(

   574             menuPane, list, 0, ETrue );

   575     CleanupStack::PopAndDestroy( 3 );

   576     

   577     return KErrNone;

   578     }

   579 

   580 // -----------------------------------------------------------------------------

   581 // CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListUpdateAfterCommandExecutionL

   582 // -----------------------------------------------------------------------------

   583 //

   584 TInt CTestSDKUiFwUtil::TestAknSelectServHandleMarkableListUpdateAfterCommandExecutionL( CStifItemParser& /*aItem*/ )

   585     {

   586     CEikListBox* list = new ( ELeave ) CAknSingleNumberStyleListBox;

   587     CleanupStack::PushL( list );

   588     list->SetContainerWindowL( *iContainer );

   589     iContainer->SetComponentControlL( list );

   590     TResourceReader reader;

   591     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   592     list->ConstructFromResourceL( reader );

   593     CleanupStack::PopAndDestroy();

   594     AknSelectionService::HandleMarkableListUpdateAfterCommandExecution( list );

   595     CleanupStack::PopAndDestroy( list );

   596     // these two methods fail for no view.

   597     return KErrNone;

   598     }

   599 

   600 // -----------------------------------------------------------------------------

   601 // CTestSDKUiFwUtil::TestAknSelectServHandleItemRemovalAndPositionHighlightL

   602 // -----------------------------------------------------------------------------

   603 // 

   604 TInt CTestSDKUiFwUtil::TestAknSelectServHandleItemRemovalAndPositionHighlightL( CStifItemParser& /*aItem*/ )

   605     {//!!! crash

   606     CAknDoubleLargeStyleListBox* list = new ( ELeave ) CAknDoubleLargeStyleListBox;

   607     CleanupStack::PushL( list );

   608     list->SetContainerWindowL( *iContainer );

   609     TResourceReader reader;

   610     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   611     list->ConstructFromResourceL( reader );

   612     CleanupStack::PopAndDestroy();

   613     list->SetCurrentItemIndex( 0 );

   614     CArrayFixFlat<TInt>* indexArray = new( ELeave ) CArrayFixFlat<TInt>( 2 );

   615     CleanupStack::PushL( indexArray );

   616     indexArray->AppendL( 0 );

   617     list->SetTopItemIndex( 1 );

   618     CDesCArray* textArray = static_cast<CDesCArray*>( list->Model()->ItemTextArray() );

   619     TInt num = textArray->Count();

   620     textArray->Delete( 0 );

   621     AknSelectionService::HandleItemRemovalAndPositionHighlightL( list, 0, ETrue );

   622     list->HandleItemAdditionL();

   623     list->SetTopItemIndex( 1 );

   624     AknSelectionService::HandleItemRemovalAndPositionHighlightL( list, 0, *indexArray );

   625     CleanupStack::PopAndDestroy( indexArray );

   626     CleanupStack::PopAndDestroy( list );

   627     return KErrNone;

   628     }

   629 

   630 // -----------------------------------------------------------------------------

   631 // CTestSDKUiFwUtil::TestAknFindHandleFindPopupProcessCommandL

   632 // -----------------------------------------------------------------------------

   633 //

   634 TInt CTestSDKUiFwUtil::TestAknFindHandleFindPopupProcessCommandL( CStifItemParser& /*aItem*/ )

   635     {

   636     TInt cmd = 0;

   637     CEikListBox* list = new ( ELeave ) CAknSingleStyleListBox;

   638     CleanupStack::PushL( list );

   639     list->SetContainerWindowL( *iContainer );

   640     iContainer->SetComponentControlL( list );

   641     TResourceReader reader;

   642     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   643     list->ConstructFromResourceL( reader );

   644     CleanupStack::PopAndDestroy();

   645     CAknSearchField* searchfield = CAknSearchField::NewL( *iContainer, 

   646             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

   647     CleanupStack::PushL( searchfield );

   648     AknFind::HandleFindPopupProcessCommandL( cmd, list, searchfield, iContainer );

   649     

   650     CleanupStack::PopAndDestroy( 2 );

   651     

   652     return KErrNone;

   653     }

   654 

   655 // -----------------------------------------------------------------------------

   656 // CTestSDKUiFwUtil::TestAknFindHandleFindOfferKeyEventL

   657 // -----------------------------------------------------------------------------

   658 //

   659 TInt CTestSDKUiFwUtil::TestAknFindHandleFindOfferKeyEventL( CStifItemParser& /*aItem*/ )

   660     {

   661     TBool reflash = ETrue;

   662     TKeyEvent keyevent = { 'a', 'b', 1, 0 };

   663     CEikListBox* list = new ( ELeave ) CAknSingleStyleListBox;

   664     CleanupStack::PushL( list );

   665     list->SetContainerWindowL( *iContainer );

   666     iContainer->SetComponentControlL( list );

   667     TResourceReader reader;

   668     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   669     list->ConstructFromResourceL( reader );

   670     CleanupStack::PopAndDestroy();

   671     AknFind::HandleFindOfferKeyEventL( keyevent, EEventKey, iContainer, list, NULL, ETrue, reflash );

   672     

   673     CleanupStack::PopAndDestroy( list );

   674     

   675     return KErrNone;

   676     }

   677 

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

   679 // CTestSDKUiFwUtil::TestAknFindHandleSizeChangeL

   680 // -----------------------------------------------------------------------------

   681 //

   682 TInt CTestSDKUiFwUtil::TestAknFindHandleSizeChangeL( CStifItemParser& /*aItem*/ )

   683     {

   684     CEikListBox* list = new ( ELeave ) CAknSingleStyleListBox;

   685     CleanupStack::PushL( list );

   686     list->SetContainerWindowL( *iContainer );

   687     iContainer->SetComponentControlL( list );

   688     TResourceReader reader;

   689     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   690     list->ConstructFromResourceL( reader );

   691     CleanupStack::PopAndDestroy();

   692     AknFind::HandleFindSizeChanged( iContainer, list, NULL );

   693     CAknColumnListBox* listbox = static_cast<CAknColumnListBox*>( list );

   694     AknFind::HandleFixedFindSizeChanged( iContainer, listbox, NULL );

   695     AknFind::HandlePopupFindSizeChanged( iContainer, list, NULL );

   696     TAknWindowLineLayout findarea;

   697     TAknWindowLineLayout listarea;

   698     TAknWindowLineLayout paraentarea;

   699     AknFind::HandleFindSizeChangedLayouts( iContainer, list, NULL, findarea, listarea, EFalse, paraentarea );

   700     

   701     CleanupStack::PopAndDestroy( list );

   702     

   703     return KErrNone;

   704     }

   705 

   706 // -----------------------------------------------------------------------------

   707 // CTestSDKUiFwUtil::TestAknFindProcessStrL

   708 // -----------------------------------------------------------------------------

   709 //

   710 TInt CTestSDKUiFwUtil::TestAknFindProcessStrL( CStifItemParser& /*aItem*/ )

   711     {

   712     TBuf<KBufSize> itembuf( KTextExample );

   713     TBuf<KBufSize> searchbuf( KTextExample );

   714     HBufC* hbuf = HBufC::NewL( KBufSize );

   715     CleanupStack::PushL( hbuf );

   716     *hbuf = itembuf;

   717     TChar ch( 'a' );

   718     AknFind::IsFindMatch( itembuf, searchbuf );

   719     AknFind::IsFindWordSeparator( ch );

   720     AknFind::IsAdaptiveFindMatch( itembuf, searchbuf, hbuf );

   721     AknFind::UpdateNextCharsFromString( hbuf,itembuf );

   722     AknFind::UpdateItemTextAccordingToFlag( itembuf, 0, searchbuf );

   723     CleanupStack::PopAndDestroy( hbuf );

   724     

   725     return KErrNone;

   726     }

   727 

   728 // -----------------------------------------------------------------------------

   729 // CTestSDKUiFwUtil::TestAknFindConstructEditingL

   730 // -----------------------------------------------------------------------------

   731 //

   732 TInt CTestSDKUiFwUtil::TestAknFindConstructEditingL( CStifItemParser& /*aItem*/ )

   733     {

   734     CEikEdwin* edwin = new( ELeave ) CEikEdwin;

   735     CleanupStack::PushL( edwin );

   736     AknEditUtils::ConstructEditingL( edwin, R_AKNEDITUTILS_EDWIN );

   737     CleanupStack::PopAndDestroy( edwin );

   738     edwin = NULL;

   739     edwin = new( ELeave ) CEikEdwin;

   740     CleanupStack::PushL( edwin );

   741     TResourceReader reader;

   742     iEnv->CreateResourceReaderLC( reader, R_AKNEDITUTILS_EDWIN );

   743     AknEditUtils::ConstructEditingL( edwin, reader );

   744     CleanupStack::PopAndDestroy( 2 );

   745     edwin = NULL;

   746     edwin = new( ELeave ) CEikEdwin;

   747     CleanupStack::PushL( edwin );

   748     AknEditUtils::SAknEditorParameters para;

   749     para.iEditingSpace = 1;

   750     para.iEditingWindow = 1;

   751     para.iCharacterCase = 1;

   752     para.iJustification = 1;

   753     para.iAllowedToMoveInsertionPoint = ETrue;

   754     para.iCursorYesNo = ETrue;

   755     para.iOverflowYesNo = ETrue;

   756     AknEditUtils::ConstructEditingL( edwin, para );

   757     CleanupStack::PopAndDestroy( edwin );

   758     edwin = NULL;

   759     edwin = new( ELeave ) CEikEdwin;

   760     CleanupStack::PushL( edwin );

   761     AknEditUtils::ConstructEditingL( edwin, 1, 1, 1, 1, ETrue, ETrue, ETrue );

   762     CleanupStack::PopAndDestroy( edwin );

   763     edwin = NULL;

   764     edwin = new( ELeave ) CEikEdwin;

   765     CleanupStack::PushL( edwin );

   766     AknEditUtils::ConstructEditingL( edwin, 1, 1, 1, 1, ETrue, ETrue, ETrue, EFalse );

   767     CleanupStack::PopAndDestroy( edwin );

   768     

   769     return KErrNone;

   770     }

   771 

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

   773 // CTestSDKUiFwUtil::TestCListBoxNumbersL

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

   775 //

   776 TInt CTestSDKUiFwUtil::TestCListBoxNumbersL( CStifItemParser& /*aItem*/ )

   777     {

   778     CEikColumnListBox* collist = new ( ELeave ) CAknSingleStyleListBox;

   779     CleanupStack::PushL( collist );

   780     collist->SetContainerWindowL( *iContainer );

   781     iContainer->SetComponentControlL( collist );

   782     TResourceReader reader;

   783     iEnv->CreateResourceReaderLC( reader, R_SINGLE_LISTBOX );

   784     collist->ConstructFromResourceL( reader );

   785     CleanupStack::PopAndDestroy();

   786     CListBoxNumbers* numberlist = new ( ELeave ) CListBoxNumbers( collist );

   787     CleanupStack::PushL( numberlist );

   788     numberlist->ConstructL();

   789     numberlist->UpdateL();

   790     CleanupStack::PopAndDestroy( numberlist );

   791     CleanupStack::PopAndDestroy( collist );

   792     

   793     return KErrNone;

   794     }

   795 

   796 // -----------------------------------------------------------------------------

   797 // CTestSDKUiFwUtil::TestFilterTextListBoxModelProcessFilterL

   798 // -----------------------------------------------------------------------------

   799 //

   800 TInt CTestSDKUiFwUtil::TestFilterTextListBoxModelProcessFilterL( CStifItemParser& /*aItem*/ )

   801     {

   802     CEikListBox* celllist = new ( ELeave ) CAknSingleNumberStyleListBox;

   803     CleanupStack::PushL( celllist );

   804     celllist->SetContainerWindowL( * iContainer );

   805     TResourceReader reader;

   806     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   807     celllist->ConstructFromResourceL( reader );

   808     CleanupStack::PopAndDestroy();

   809     CAknSearchField* search = CAknSearchField::NewL( *iContainer,

   810         CAknSearchField::ESearch, NULL, 10 );

   811     CleanupStack::PushL( search );

   812     CAknFilteredTextListBoxModel* model = 

   813         static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

   814     model->CreateFilterL( celllist, search );

   815     model->Filter();

   816     model->RemoveFilter();

   817     CleanupStack::PopAndDestroy( search );

   818     CleanupStack::PopAndDestroy( celllist );

   819     

   820     return KErrNone;

   821     }

   822 

   823 

   824 // -----------------------------------------------------------------------------

   825 // CTestSDKUiFwUtil::TestFilterTextListBoxModelParaInfoL

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

   827 //

   828 TInt CTestSDKUiFwUtil::TestFilterTextListBoxModelParaInfoL( CStifItemParser& /*aItem*/ )

   829     {

   830     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

   831     CleanupStack::PushL( celllist );

   832     celllist->SetContainerWindowL( * iContainer );

   833     

   834     TResourceReader reader;

   835     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   836     celllist->ConstructFromResourceL( reader );

   837     CleanupStack::PopAndDestroy();

   838     

   839     CAknFilteredTextListBoxModel* model = 

   840         static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

   841     model->ItemText( 0 );

   842     model->NumberOfItems();

   843     model->MatchableTextArray();

   844     

   845     CleanupStack::PopAndDestroy( celllist );

   846     

   847     return KErrNone;

   848     }

   849 

   850 // -----------------------------------------------------------------------------

   851 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsConstructorL

   852 // -----------------------------------------------------------------------------

   853 //

   854 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsConstructorL( CStifItemParser& /*aItem*/ )

   855     {

   856     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

   857     CleanupStack::PushL( celllist );

   858     celllist->SetContainerWindowL( *iContainer );

   859     TResourceReader reader;

   860     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   861     celllist->ConstructFromResourceL( reader );

   862     CleanupStack::PopAndDestroy();

   863     

   864     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

   865             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

   866     CleanupStack::PushL( search );

   867     

   868     CAknFilteredTextListBoxModel* model = 

   869             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

   870             

   871     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

   872             celllist, search, model, celllist->View() );

   873     CleanupStack::PushL( item );

   874     

   875     STIF_ASSERT_NOT_NULL( item );

   876     

   877     CleanupStack::PopAndDestroy( 3 );

   878     return KErrNone;

   879     }

   880 

   881 

   882 

   883 // -----------------------------------------------------------------------------

   884 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsConstructL

   885 // -----------------------------------------------------------------------------

   886 //

   887 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsConstructL( CStifItemParser& /*aItem*/ )

   888     {

   889     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

   890     CleanupStack::PushL( celllist );

   891     celllist->SetContainerWindowL( * iContainer );

   892     TResourceReader reader;

   893     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   894     celllist->ConstructFromResourceL( reader );

   895     CleanupStack::PopAndDestroy();

   896     

   897     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

   898             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

   899     CleanupStack::PushL( search );

   900     

   901     CAknFilteredTextListBoxModel* model = 

   902             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

   903             

   904     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

   905             celllist, search, model, celllist->View() );

   906     CleanupStack::PushL( item );

   907     

   908     item->ConstructL();

   909     

   910     CleanupStack::PopAndDestroy( 3 );

   911     return KErrNone;

   912     }

   913 

   914 // -----------------------------------------------------------------------------

   915 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsResetFilteringL

   916 // -----------------------------------------------------------------------------

   917 //

   918 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsResetFilteringL( CStifItemParser& /*aItem*/ )

   919     {

   920     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

   921     CleanupStack::PushL( celllist );

   922     celllist->SetContainerWindowL( * iContainer );

   923     TResourceReader reader;

   924     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   925     celllist->ConstructFromResourceL( reader );

   926     CleanupStack::PopAndDestroy();

   927     

   928     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

   929             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

   930     CleanupStack::PushL( search );

   931     

   932     CAknFilteredTextListBoxModel* model = 

   933             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

   934             

   935     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

   936             celllist, search, model, celllist->View() );

   937     CleanupStack::PushL( item );

   938     item->ConstructL();

   939     item->ResetFilteringL();

   940     

   941     CleanupStack::PopAndDestroy( 3 );

   942     return KErrNone;

   943     }

   944 

   945 

   946 // -----------------------------------------------------------------------------

   947 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsUpdateCachedDataL

   948 // -----------------------------------------------------------------------------

   949 //

   950 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsUpdateCachedDataL( CStifItemParser& /*aItem*/ )

   951     {

   952     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

   953     CleanupStack::PushL( celllist );

   954     celllist->SetContainerWindowL( * iContainer );

   955     TResourceReader reader;

   956     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   957     celllist->ConstructFromResourceL( reader );

   958     CleanupStack::PopAndDestroy();

   959     

   960     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

   961             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

   962     CleanupStack::PushL( search );

   963     

   964     CAknFilteredTextListBoxModel* model = 

   965             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

   966             

   967     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

   968             celllist, search, model, celllist->View() );

   969     CleanupStack::PushL( item );

   970     item->ConstructL();

   971     item->UpdateCachedDataL();

   972     

   973     CleanupStack::PopAndDestroy( 3 );

   974     return KErrNone;

   975     }

   976 

   977 

   978 // -----------------------------------------------------------------------------

   979 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsProcessSelectionIndexL

   980 // -----------------------------------------------------------------------------

   981 //

   982 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsProcessSelectionIndexL( CStifItemParser& /*aItem*/ )

   983     {

   984     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

   985     CleanupStack::PushL( celllist );

   986     celllist->SetContainerWindowL( * iContainer );

   987     TResourceReader reader;

   988     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

   989     celllist->ConstructFromResourceL( reader );

   990     CleanupStack::PopAndDestroy();

   991     

   992     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

   993             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

   994     CleanupStack::PushL( search );

   995     

   996     CAknFilteredTextListBoxModel* model = 

   997             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

   998             

   999     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

  1000             celllist, search, model, celllist->View() );

  1001     CleanupStack::PushL( item );

  1002     item->SetParentControl( iContainer );

  1003     item->ConstructL();

  1004     item->SelectionIndexes();

  1005     item->UpdateSelectionIndexesL();

  1006     item->UpdateSelectionIndexL( 0 );

  1007     

  1008     CleanupStack::PopAndDestroy( 3 );

  1009     return KErrNone;

  1010     }

  1011 

  1012 // -----------------------------------------------------------------------------

  1013 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsFilteredItemL

  1014 // -----------------------------------------------------------------------------

  1015 //

  1016 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsFilteredItemL( CStifItemParser& /*aItem*/ )

  1017     {

  1018     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

  1019     CleanupStack::PushL( celllist );

  1020     celllist->SetContainerWindowL( * iContainer );

  1021     TResourceReader reader;

  1022     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

  1023     celllist->ConstructFromResourceL( reader );

  1024     CleanupStack::PopAndDestroy();

  1025     

  1026     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

  1027             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

  1028     CleanupStack::PushL( search );

  1029     

  1030     CAknFilteredTextListBoxModel* model = 

  1031             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

  1032             

  1033     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

  1034             celllist, search, model, celllist->View() );

  1035     CleanupStack::PushL( item );

  1036     item->SetParentControl( iContainer );

  1037     item->ConstructL();

  1038     item->FilteredNumberOfItems();

  1039     item->FilteredItemIndex( 0 );

  1040     item->NonFilteredNumberOfItems();

  1041     item->VisibleItemIndex( 0 );

  1042     TBufC<KBufSize> buf( KTextExample );

  1043     TPtrC ptrc( buf );

  1044     item->DefaultMatchableItemFromItem( ptrc );

  1045     CleanupStack::PopAndDestroy( 3 );

  1046     

  1047     return KErrNone;

  1048     }

  1049 

  1050 

  1051 // -----------------------------------------------------------------------------

  1052 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsHandleOfferkeyEventL

  1053 // -----------------------------------------------------------------------------

  1054 //

  1055 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsHandleOfferkeyEventL( CStifItemParser& /*aItem*/ )

  1056     {

  1057     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

  1058     CleanupStack::PushL( celllist );

  1059     celllist->SetContainerWindowL( * iContainer );

  1060     TResourceReader reader;

  1061     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

  1062     celllist->ConstructFromResourceL( reader );

  1063     CleanupStack::PopAndDestroy();

  1064     

  1065     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

  1066             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

  1067     CleanupStack::PushL( search );

  1068     

  1069     CAknFilteredTextListBoxModel* model = 

  1070             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

  1071             

  1072     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

  1073             celllist, search, model, celllist->View() );

  1074     CleanupStack::PushL( item );

  1075     item->SetParentControl( iContainer );

  1076     item->ConstructL();

  1077     item->HandleOfferkeyEventL();

  1078     

  1079     CleanupStack::PopAndDestroy( 3 );

  1080     

  1081     return KErrNone;

  1082     }

  1083 

  1084 // -----------------------------------------------------------------------------

  1085 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsHandleItemArrayChangeL

  1086 // -----------------------------------------------------------------------------

  1087 //

  1088 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsHandleItemArrayChangeL( CStifItemParser& /*aItem*/ )

  1089     {

  1090     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

  1091     CleanupStack::PushL( celllist );

  1092     celllist->SetContainerWindowL( * iContainer );

  1093     TResourceReader reader;

  1094     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

  1095     celllist->ConstructFromResourceL( reader );

  1096     CleanupStack::PopAndDestroy();

  1097     

  1098     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

  1099             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

  1100     CleanupStack::PushL( search );

  1101     

  1102     CAknFilteredTextListBoxModel* model = 

  1103             static_cast<CAknFilteredTextListBoxModel*>( celllist->Model() );

  1104             

  1105     CAknListBoxFilterItems* item = new( ELeave ) CAknListBoxFilterItems(

  1106             celllist, search, model, celllist->View() );

  1107     CleanupStack::PushL( item );

  1108     item->SetParentControl( iContainer );

  1109     item->ConstructL();

  1110     item->HandleItemArrayChangeL();

  1111     

  1112     CleanupStack::PopAndDestroy( 3 );

  1113     

  1114     return KErrNone;

  1115     }

  1116 

  1117 // -----------------------------------------------------------------------------

  1118 // CTestSDKUiFwUtil::TestCAknListBoxFilterItemsDoObserverFuncL

  1119 // -----------------------------------------------------------------------------

  1120 //

  1121 TInt CTestSDKUiFwUtil::TestCAknListBoxFilterItemsDoObserverFuncL( CStifItemParser& /*aItem*/ )

  1122     {

  1123     CEikFormattedCellListBox* celllist = new ( ELeave ) CEikFormattedCellListBox;

  1124     CleanupStack::PushL( celllist );

  1125     celllist->SetContainerWindowL( * iContainer );

  1126     TResourceReader reader;

  1127     iEnv->CreateResourceReaderLC( reader, R_DOUBLE_LISTBOX );

  1128     celllist->ConstructFromResourceL( reader );

  1129     CleanupStack::PopAndDestroy();

  1130     

  1131     CAknSearchField* search = CAknSearchField::NewL( *iContainer, 

  1132             CAknSearchField::ESearch, NULL, KSearchFieldMaxLength );

  1133     CleanupStack::PushL( search );

  1134