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

    15 *

    16 */

    17 

    18 #include <akntreelist.h>

    19 #include <aknsinglestyletreelist.h>

    20 #include <akniconutils.h>

    21 #include <avkon.mbg>

    22 #include <aknsconstants.h>

    23 

    24 #include "testsdkhierarchicallists.h"

    25 #include "testsdkhierarchicallistsordering.h"

    26 

    27 // ============================ MEMBER FUNCTIONS ===============================

    28 // -----------------------------------------------------------------------------

    29 // CTestSDKHierarchicalLists::TestHLTLSetFlagsL

    30 // -----------------------------------------------------------------------------

    31 TInt CTestSDKHierarchicalLists::TestHLTLSetFlagsL( CStifItemParser& /*aItem*/ )

    32     {

    33     CAknTreeList* treeList = CAknSingleStyleTreeList::NewLC();

    34     STIF_ASSERT_NOT_NULL( treeList );

    35     

    36     treeList->SetFlags( KAknTreeListLooping );

    37     TUint32 flag = treeList->Flags();

    38     STIF_ASSERT_TRUE( flag == KAknTreeListLooping );

    39     

    40     CleanupStack::PopAndDestroy( treeList );

    41     

    42     return KErrNone;

    43     

    44     }

    45 

    46 // -----------------------------------------------------------------------------

    47 // CTestSDKHierarchicalLists::TestHLTLFlagsL

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

    49 TInt CTestSDKHierarchicalLists::TestHLTLFlagsL( CStifItemParser& aItem )

    50     {

    51     return TestHLTLSetFlagsL( aItem );

    52     

    53     }

    54 

    55 // -----------------------------------------------------------------------------

    56 // CTestSDKHierarchicalLists::TestHLTLMoveItemL

    57 // -----------------------------------------------------------------------------

    58 TInt CTestSDKHierarchicalLists::TestHLTLMoveItemL( CStifItemParser& /*aItem*/ )

    59     {

    60     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

    61     STIF_ASSERT_NOT_NULL( treeList );

    62     

    63     _LIT( KTextNode, "AddNode" );

    64     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

    65     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

    66     STIF_ASSERT_NOT_EQUALS( 0, idNode );

    67     

    68     _LIT( KTextLeaf, "AddLeaf" );

    69     TAknTreeItemID idLeaf = treeList->AddLeafL( KAknTreeIIDRoot, KTextLeaf, flags, ETrue );

    70     STIF_ASSERT_NOT_EQUALS( 0, idLeaf );

    71     

    72     CAknTreeList* list = treeList;

    73     list->MoveItemL( idLeaf, idNode, ETrue );

    74     

    75     CleanupStack::PopAndDestroy( treeList );

    76     

    77     return KErrNone;

    78     

    79     }

    80 

    81 // -----------------------------------------------------------------------------

    82 // CTestSDKHierarchicalLists::TestHLTLRemoveItemL

    83 // -----------------------------------------------------------------------------

    84 TInt CTestSDKHierarchicalLists::TestHLTLRemoveItemL( CStifItemParser& /*aItem*/ )

    85     {

    86     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

    87     STIF_ASSERT_NOT_NULL( treeList );

    88     

    89     _LIT( KTextNode, "AddNode" );

    90     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

    91     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

    92     STIF_ASSERT_NOT_EQUALS( 0, idNode );

    93     

    94     _LIT( KTextLeaf, "AddLeaf" );

    95     TAknTreeItemID idLeaf = treeList->AddLeafL( KAknTreeIIDRoot, KTextLeaf, flags, ETrue );

    96     STIF_ASSERT_NOT_EQUALS( 0, idLeaf );

    97     

    98     CAknTreeList* list = treeList;

    99     list->MoveItemL( idLeaf, idNode, ETrue );

   100     

   101     list->RemoveItem( idNode, ETrue );

   102     

   103     CleanupStack::PopAndDestroy( treeList );

   104     

   105     return KErrNone;

   106     

   107     }

   108 

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

   110 // CTestSDKHierarchicalLists::TestHLTLExpandNodeL

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

   112 TInt CTestSDKHierarchicalLists::TestHLTLExpandNodeL( CStifItemParser& /*aItem*/ )

   113     {

   114     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   115     STIF_ASSERT_NOT_NULL( treeList );

   116     

   117     _LIT( KTextNode, "AddNode" );

   118     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   119     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   120     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   121     

   122     CAknTreeList* list = treeList;

   123     

   124     list->ExpandNode( idNode, ETrue );

   125     STIF_ASSERT_TRUE( list->IsExpanded( idNode ) );

   126     

   127     CleanupStack::PopAndDestroy( treeList );

   128     

   129     return KErrNone;

   130     

   131     }

   132 

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

   134 // CTestSDKHierarchicalLists::TestHLTLCollapseNodeL

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

   136 TInt CTestSDKHierarchicalLists::TestHLTLCollapseNodeL( CStifItemParser& /*aItem*/ )

   137     {

   138     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   139     STIF_ASSERT_NOT_NULL( treeList );

   140     

   141     _LIT( KTextNode, "AddNode" );

   142     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   143     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   144     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   145     

   146     CAknTreeList* list = treeList;

   147     

   148     list->ExpandNode( idNode, ETrue );

   149     list->CollapseNode( idNode, ETrue );

   150     

   151     CleanupStack::PopAndDestroy( treeList );

   152     

   153     return KErrNone;

   154     

   155     }

   156 

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

   158 // CTestSDKHierarchicalLists::TestHLTLIsExpandedL

   159 // -----------------------------------------------------------------------------

   160 TInt CTestSDKHierarchicalLists::TestHLTLIsExpandedL( CStifItemParser& aItem )

   161     {

   162     return TestHLTLExpandNodeL( aItem );

   163     

   164     }

   165 

   166 // -----------------------------------------------------------------------------

   167 // CTestSDKHierarchicalLists::TestHLTLFocusedItemL

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

   169 TInt CTestSDKHierarchicalLists::TestHLTLFocusedItemL( CStifItemParser& /*aItem*/ )

   170     {

   171     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   172     STIF_ASSERT_NOT_NULL( treeList );

   173     

   174     _LIT( KTextNode, "AddNode" );

   175     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   176     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   177     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   178     

   179     CAknTreeList* list = treeList;

   180     

   181     list->SetFocusedItem( idNode );

   182     STIF_ASSERT_TRUE( idNode == list->FocusedItem() );

   183     

   184     CleanupStack::PopAndDestroy( treeList );

   185     

   186     return KErrNone;

   187     

   188     }

   189 

   190 // -----------------------------------------------------------------------------

   191 // CTestSDKHierarchicalLists::TestHLTLSetFocusedItemL

   192 // -----------------------------------------------------------------------------

   193 TInt CTestSDKHierarchicalLists::TestHLTLSetFocusedItemL( CStifItemParser& aItem )

   194     {

   195     return TestHLTLFocusedItemL( aItem );

   196     

   197     }

   198 

   199 // -----------------------------------------------------------------------------

   200 // CTestSDKHierarchicalLists::TestHLTLHighlightRectL

   201 // -----------------------------------------------------------------------------

   202 TInt CTestSDKHierarchicalLists::TestHLTLHighlightRectL( CStifItemParser& /*aItem*/ )

   203     {

   204     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   205     STIF_ASSERT_NOT_NULL( treeList );

   206     

   207     _LIT( KTextNode, "AddNode" );

   208     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   209     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   210     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   211     

   212     CAknTreeList* list = treeList;

   213     

   214     TRect rect = list->HighlightRect();

   215     TPoint point = rect.Size().AsPoint();

   216     STIF_ASSERT_EQUALS( 0, point.iX );

   217     STIF_ASSERT_EQUALS( 0, point.iY );

   218     

   219     CleanupStack::PopAndDestroy( treeList );

   220     

   221     return KErrNone;

   222     

   223     }

   224 

   225 // -----------------------------------------------------------------------------

   226 // CTestSDKHierarchicalLists::TestHLTLAddIconL

   227 // -----------------------------------------------------------------------------

   228 TInt CTestSDKHierarchicalLists::TestHLTLAddIconL( CStifItemParser& /*aItem*/ )

   229     {

   230     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   231     STIF_ASSERT_NOT_NULL( treeList );

   232     

   233     _LIT( KTextNode, "AddNode" );

   234     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   235     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   236     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   237     

   238     CAknTreeList* list = treeList;

   239     

   240     TInt icon = list->AddIconL( KAknsIIDQgnPropHlFolderOpen, 

   241                                 AknIconUtils::AvkonIconFileName(),

   242                                 EMbmAvkonQgn_prop_hl_folder_open, 

   243                                 EMbmAvkonQgn_prop_hl_folder_open_mask, 

   244                                 EAspectRatioPreserved );

   245     STIF_ASSERT_NOT_EQUALS( 0, icon );

   246     

   247     CleanupStack::PopAndDestroy( treeList );

   248     

   249     return KErrNone;

   250     

   251     }

   252 

   253 // -----------------------------------------------------------------------------

   254 // CTestSDKHierarchicalLists::TestHLTLAddIIconL

   255 // -----------------------------------------------------------------------------

   256 TInt CTestSDKHierarchicalLists::TestHLTLAddIIconL( CStifItemParser& /*aItem*/ )

   257     {

   258     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   259     STIF_ASSERT_NOT_NULL( treeList );

   260     

   261     _LIT( KTextNode, "AddNode" );

   262     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   263     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   264     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   265     

   266     CAknTreeList* list = treeList;

   267     

   268     _LIT( KBitmapFile, "z:\\resource\\apps\\avkon2.mbm" );

   269     CFbsBitmap* bitmap = NULL;

   270     CFbsBitmap* mask = NULL;

   271     AknIconUtils::CreateIconL( bitmap, mask, KBitmapFile, EMbmAvkonQgn_indi_mic,

   272                                EMbmAvkonQgn_indi_mic_mask );

   273     CleanupStack::PushL( bitmap );

   274     CleanupStack::PushL( mask );

   275     TInt icon = list->AddIconL( bitmap, mask, ETrue, EAspectRatioPreserved );

   276     STIF_ASSERT_NOT_EQUALS( 0, icon );

   277     CleanupStack::Pop( mask );

   278     CleanupStack::Pop( bitmap );

   279     

   280     CleanupStack::PopAndDestroy( treeList );

   281     

   282     return KErrNone;

   283     

   284     }

   285 

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

   287 // CTestSDKHierarchicalLists::TestHLTLAddColorIconL

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

   289 TInt CTestSDKHierarchicalLists::TestHLTLAddColorIconL( CStifItemParser& /*aItem*/ )

   290     {

   291     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   292     STIF_ASSERT_NOT_NULL( treeList );

   293     

   294     _LIT( KTextNode, "AddNode" );

   295     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   296     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   297     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   298     

   299     CAknTreeList* list = treeList;

   300     

   301     TInt icon = list->AddColorIconL( KAknsIIDQgnPropHlFolder, 

   302                                      KAknsIIDQsnTextColors, 

   303                                      EAknsCIQsnTextColorsCG10, 

   304                                      AknIconUtils::AvkonIconFileName(),

   305                                      EMbmAvkonQgn_prop_hl_folder,

   306                                      EMbmAvkonQgn_prop_hl_folder_mask,

   307                                      KRgbWhite,

   308                                      EAspectRatioPreserved );

   309     STIF_ASSERT_NOT_EQUALS( 0, icon );

   310     

   311     CleanupStack::PopAndDestroy( treeList );

   312     

   313     return KErrNone;

   314     

   315     }

   316 

   317 // -----------------------------------------------------------------------------

   318 // CTestSDKHierarchicalLists::TestHLTLAssignIconL

   319 // -----------------------------------------------------------------------------

   320 TInt CTestSDKHierarchicalLists::TestHLTLAssignIconL( CStifItemParser& /*aItem*/ )

   321     {

   322     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   323     STIF_ASSERT_NOT_NULL( treeList );

   324     

   325     _LIT( KTextNode, "AddNode" );

   326     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   327     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   328     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   329     

   330     CAknTreeList* list = treeList;

   331     

   332     _LIT( KBitmapFile, "z:\\resource\\apps\\avkon2.mbm" );

   333     CFbsBitmap* bitmap = NULL;

   334     CFbsBitmap* mask = NULL;

   335     AknIconUtils::CreateIconL( bitmap, mask, KBitmapFile, EMbmAvkonQgn_indi_mic,

   336                                EMbmAvkonQgn_indi_mic_mask );

   337     CleanupStack::PushL( bitmap );

   338     CleanupStack::PushL( mask );

   339     TInt icon = list->AddIconL( bitmap, mask, ETrue, EAspectRatioPreserved );

   340     STIF_ASSERT_NOT_EQUALS( 0, icon );

   341     CleanupStack::Pop( mask );

   342     CleanupStack::Pop( bitmap );

   343     

   344     list->AssignIconL( icon, 

   345                        KAknsIIDQgnPropHlFolderOpen, 

   346                        AknIconUtils::AvkonIconFileName(),

   347                        EMbmAvkonQgn_prop_hl_folder_open, 

   348                        EMbmAvkonQgn_prop_hl_folder_open_mask, 

   349                        EAspectRatioPreserved );

   350     

   351     CleanupStack::PopAndDestroy( treeList );

   352     

   353     return KErrNone;

   354     

   355     }

   356 

   357 // -----------------------------------------------------------------------------

   358 // CTestSDKHierarchicalLists::TestHLTLAssignIIconL

   359 // -----------------------------------------------------------------------------

   360 TInt CTestSDKHierarchicalLists::TestHLTLAssignIIconL( CStifItemParser& /*aItem*/ )

   361     {

   362     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   363     STIF_ASSERT_NOT_NULL( treeList );

   364     

   365     _LIT( KTextNode, "AddNode" );

   366     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   367     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   368     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   369     

   370     CAknTreeList* list = treeList;

   371     

   372     _LIT( KBitmapFile, "z:\\resource\\apps\\avkon2.mbm" );

   373     CFbsBitmap* bitmap = NULL;

   374     CFbsBitmap* mask = NULL;

   375     AknIconUtils::CreateIconL( bitmap, mask, KBitmapFile, EMbmAvkonQgn_indi_mic,

   376                                EMbmAvkonQgn_indi_mic_mask );

   377     CleanupStack::PushL( bitmap );

   378     CleanupStack::PushL( mask );

   379     TInt icon = list->AddIconL( bitmap, mask, ETrue, EAspectRatioPreserved );

   380     STIF_ASSERT_NOT_EQUALS( 0, icon );

   381     

   382     CleanupStack::Pop( mask );

   383     CleanupStack::Pop( bitmap );

   384     

   385     CFbsBitmap* bitmapAssign = NULL;

   386     CFbsBitmap* maskAssign = NULL;

   387     

   388     AknIconUtils::CreateIconL( bitmap, mask, KBitmapFile, EMbmAvkonQgn_indi_level_back,

   389                                EMbmAvkonQgn_indi_level_back_mask );

   390     CleanupStack::PushL( bitmapAssign );

   391     CleanupStack::PushL( maskAssign );

   392     list->AssignIconL( icon, bitmap, mask, ETrue, EAspectRatioPreserved );

   393     CleanupStack::Pop( maskAssign );

   394     CleanupStack::Pop( bitmapAssign );

   395     

   396     CleanupStack::PopAndDestroy( treeList );

   397     

   398     return KErrNone;

   399     

   400     }

   401 

   402 // -----------------------------------------------------------------------------

   403 // CTestSDKHierarchicalLists::TestHLTLAssignColorIconL

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

   405 TInt CTestSDKHierarchicalLists::TestHLTLAssignColorIconL( CStifItemParser& /*aItem*/ )

   406     {

   407     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   408     STIF_ASSERT_NOT_NULL( treeList );

   409     

   410     _LIT( KTextNode, "AddNode" );

   411     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   412     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   413     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   414     

   415     CAknTreeList* list = treeList;

   416 

   417     TInt icon = list->AddColorIconL( KAknsIIDQgnPropHlFolder, 

   418                                      KAknsIIDQsnTextColors, 

   419                                      EAknsCIQsnTextColorsCG10, 

   420                                      AknIconUtils::AvkonIconFileName(),

   421                                      EMbmAvkonQgn_prop_hl_folder,

   422                                      EMbmAvkonQgn_prop_hl_folder_mask,

   423                                      KRgbWhite,

   424                                      EAspectRatioPreserved );

   425     STIF_ASSERT_NOT_EQUALS( 0, icon );

   426     

   427     list->AssignColorIconL( icon,

   428                             KAknsIIDQgnIndiHlLineBranch,

   429                             KAknsIIDQsnTextColors, 

   430                             EAknsCIQsnTextColorsCG10, 

   431                             AknIconUtils::AvkonIconFileName(),

   432                             EMbmAvkonQgn_indi_hl_line_branch,

   433                             EMbmAvkonQgn_indi_hl_line_branch_mask,

   434                             KRgbWhite,

   435                             EAspectRatioPreserved );

   436     

   437     CleanupStack::PopAndDestroy( treeList );

   438     

   439     return KErrNone;

   440     

   441     }

   442 

   443 // -----------------------------------------------------------------------------

   444 // CTestSDKHierarchicalLists::TestHLTLRemoveIconL

   445 // -----------------------------------------------------------------------------

   446 TInt CTestSDKHierarchicalLists::TestHLTLRemoveIconL( CStifItemParser& /*aItem*/ )

   447     {

   448     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   449     STIF_ASSERT_NOT_NULL( treeList );

   450     

   451     _LIT( KTextNode, "AddNode" );

   452     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   453     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   454     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   455     

   456     CAknTreeList* list = treeList;

   457     

   458     _LIT( KBitmapFile, "z:\\resource\\apps\\avkon2.mbm" );

   459     CFbsBitmap* bitmap = NULL;

   460     CFbsBitmap* mask = NULL;

   461     AknIconUtils::CreateIconL( bitmap, mask, KBitmapFile, EMbmAvkonQgn_indi_mic,

   462                                EMbmAvkonQgn_indi_mic_mask );

   463     CleanupStack::PushL( bitmap );

   464     CleanupStack::PushL( mask );

   465     TInt icon = list->AddIconL( bitmap, mask, ETrue, EAspectRatioPreserved );

   466     STIF_ASSERT_NOT_EQUALS( 0, icon );

   467     list->RemoveIconL( icon );

   468     

   469     CleanupStack::Pop( mask );

   470     CleanupStack::Pop( bitmap );

   471     

   472     CleanupStack::PopAndDestroy( treeList );

   473     

   474     return KErrNone;

   475     

   476     }

   477 

   478 // -----------------------------------------------------------------------------

   479 // CTestSDKHierarchicalLists::TestHLTLChildCountL

   480 // -----------------------------------------------------------------------------

   481 TInt CTestSDKHierarchicalLists::TestHLTLChildCountL( CStifItemParser& /*aItem*/ )

   482     {

   483     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   484     STIF_ASSERT_NOT_NULL( treeList );

   485     

   486     _LIT( KTextNode, "AddNode" );

   487     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   488     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   489     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   490     

   491     CAknTreeList* list = treeList;

   492     

   493     TInt count = list->ChildCount( idNode );

   494     STIF_ASSERT_EQUALS( 0, count );

   495     

   496     CleanupStack::PopAndDestroy( treeList );

   497     

   498     return KErrNone;

   499     

   500     }

   501 

   502 // -----------------------------------------------------------------------------

   503 // CTestSDKHierarchicalLists::TestHLTLChildL

   504 // -----------------------------------------------------------------------------

   505 TInt CTestSDKHierarchicalLists::TestHLTLChildL( CStifItemParser& /*aItem*/ )

   506     {

   507     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   508     STIF_ASSERT_NOT_NULL( treeList );

   509     

   510     _LIT( KTextNode, "AddNode" );

   511     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   512     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   513     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   514     

   515     _LIT( KTextChild, "AddChild" );

   516     TAknTreeItemID idChild =treeList->AddNodeL( idNode, KTextChild, flags, ETrue );

   517     

   518     CAknTreeList* list = treeList;

   519     

   520     STIF_ASSERT_TRUE( idChild == list->Child( idNode, 0 ) );

   521     

   522     CleanupStack::PopAndDestroy( treeList );

   523     

   524     return KErrNone;

   525     

   526     }

   527 

   528 // -----------------------------------------------------------------------------

   529 // CTestSDKHierarchicalLists::TestHLTLParentL

   530 // -----------------------------------------------------------------------------

   531 TInt CTestSDKHierarchicalLists::TestHLTLParentL( CStifItemParser& /*aItem*/ )

   532     {

   533     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   534     STIF_ASSERT_NOT_NULL( treeList );

   535     

   536     _LIT( KTextNode, "AddNode" );

   537     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   538     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   539     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   540     

   541     _LIT( KTextChild, "AddChild" );

   542     TAknTreeItemID idChild =treeList->AddNodeL( idNode, KTextChild, flags, ETrue );

   543     

   544     CAknTreeList* list = treeList;

   545     

   546     STIF_ASSERT_TRUE( idNode == list->Parent( idChild ) );

   547     

   548     CleanupStack::PopAndDestroy( treeList );

   549     

   550     return KErrNone;

   551     

   552     }

   553 

   554 // -----------------------------------------------------------------------------

   555 // CTestSDKHierarchicalLists::TestHLTLContainsL

   556 // -----------------------------------------------------------------------------

   557 TInt CTestSDKHierarchicalLists::TestHLTLContainsL( CStifItemParser& /*aItem*/ )

   558     {

   559     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   560     STIF_ASSERT_NOT_NULL( treeList );

   561     

   562     _LIT( KTextNode, "AddNode" );

   563     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   564     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   565     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   566     

   567     _LIT( KTextChild, "AddChild" );

   568     TAknTreeItemID idChild =treeList->AddNodeL( idNode, KTextChild, flags, ETrue );

   569     

   570     CAknTreeList* list = treeList;

   571     

   572     STIF_ASSERT_TRUE( list->Contains( idNode ) );

   573     STIF_ASSERT_TRUE( list->Contains( idChild ) );

   574     

   575     CleanupStack::PopAndDestroy( treeList );

   576     

   577     return KErrNone;

   578     

   579     }

   580 

   581 // -----------------------------------------------------------------------------

   582 // CTestSDKHierarchicalLists::TestHLTLIsNodeL

   583 // -----------------------------------------------------------------------------

   584 TInt CTestSDKHierarchicalLists::TestHLTLIsNodeL( CStifItemParser& /*aItem*/ )

   585     {

   586     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   587     STIF_ASSERT_NOT_NULL( treeList );

   588     

   589     _LIT( KTextNode, "AddNode" );

   590     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   591     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   592     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   593     

   594     _LIT( KTextChild, "AddChild" );

   595     TAknTreeItemID idChild =treeList->AddNodeL( idNode, KTextChild, flags, ETrue );

   596     

   597     CAknTreeList* list = treeList;

   598     

   599     STIF_ASSERT_TRUE( list->IsNode( idNode ) );

   600     STIF_ASSERT_TRUE( list->IsNode( idChild ) );

   601     

   602     CleanupStack::PopAndDestroy( treeList );

   603     

   604     return KErrNone;

   605     

   606     }

   607 

   608 // -----------------------------------------------------------------------------

   609 // CTestSDKHierarchicalLists::TestHLTLIsLeafL

   610 // -----------------------------------------------------------------------------

   611 TInt CTestSDKHierarchicalLists::TestHLTLIsLeafL( CStifItemParser& /*aItem*/ )

   612     {

   613     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   614     STIF_ASSERT_NOT_NULL( treeList );

   615     

   616     _LIT( KTextNode, "AddNode" );

   617     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   618     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   619     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   620     

   621     _LIT( KTextLeaf, "AddLeaf" );

   622     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   623     

   624     CAknTreeList* list = treeList;

   625     

   626     STIF_ASSERT_FALSE( list->IsLeaf( idNode ) );

   627     STIF_ASSERT_TRUE( list->IsLeaf( idLeaf ) );

   628     

   629     CleanupStack::PopAndDestroy( treeList );

   630     

   631     return KErrNone;

   632     

   633     }

   634 

   635 // -----------------------------------------------------------------------------

   636 // CTestSDKHierarchicalLists::TestHLTLIsMarkedL

   637 // -----------------------------------------------------------------------------

   638 TInt CTestSDKHierarchicalLists::TestHLTLIsMarkedL( CStifItemParser& /*aItem*/ )

   639     {

   640     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   641     STIF_ASSERT_NOT_NULL( treeList );

   642     

   643     _LIT( KTextNode, "AddNode" );

   644     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   645     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   646     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   647     

   648     _LIT( KTextLeaf, "AddLeaf" );

   649     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   650     

   651     CAknTreeList* list = treeList;

   652     

   653     list->SetMarked( idNode, ETrue, ETrue );

   654     STIF_ASSERT_TRUE( list->IsMarked( idNode ) );

   655     

   656     CleanupStack::PopAndDestroy( treeList );

   657     

   658     return KErrNone;

   659     

   660     }

   661 

   662 // -----------------------------------------------------------------------------

   663 // CTestSDKHierarchicalLists::TestHLTLSetMarkedL

   664 // -----------------------------------------------------------------------------

   665 TInt CTestSDKHierarchicalLists::TestHLTLSetMarkedL( CStifItemParser& aItem )

   666     {

   667     return TestHLTLIsMarkedL( aItem );

   668     

   669     }

   670 

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

   672 // CTestSDKHierarchicalLists::TestHLTLEnableMarkingL

   673 // -----------------------------------------------------------------------------

   674 TInt CTestSDKHierarchicalLists::TestHLTLEnableMarkingL( CStifItemParser& /*aItem*/ )

   675     {

   676     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   677     STIF_ASSERT_NOT_NULL( treeList );

   678     

   679     _LIT( KTextNode, "AddNode" );

   680     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   681     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   682     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   683     

   684     _LIT( KTextLeaf, "AddLeaf" );

   685     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   686     

   687     CAknTreeList* list = treeList;

   688     

   689     list->EnableMarking( idNode, ETrue );

   690     

   691     CleanupStack::PopAndDestroy( treeList );

   692     

   693     return KErrNone;

   694     

   695     }

   696 

   697 // -----------------------------------------------------------------------------

   698 // CTestSDKHierarchicalLists::TestHLTLGetMarkedRItemsL

   699 // -----------------------------------------------------------------------------

   700 TInt CTestSDKHierarchicalLists::TestHLTLGetMarkedRItemsL( CStifItemParser& /*aItem*/ )

   701     {

   702     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   703     STIF_ASSERT_NOT_NULL( treeList );

   704     

   705     _LIT( KTextNode, "AddNode" );

   706     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   707     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   708     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   709     

   710     _LIT( KTextLeaf, "AddLeaf" );

   711     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   712     

   713     CAknTreeList* list = treeList;

   714     

   715     RArray<TAknTreeItemID> array;

   716     CleanupClosePushL( array );

   717     

   718     const TInt count = 2;

   719     list->SetMarked( idNode, ETrue, ETrue );

   720     list->SetMarked( idLeaf, ETrue, ETrue );

   721     list->GetMarkedItemsL( array );

   722     STIF_ASSERT_EQUALS( count, array.Count() );

   723     

   724     CleanupStack::PopAndDestroy( &array );

   725     CleanupStack::PopAndDestroy( treeList );

   726     

   727     return KErrNone;

   728     

   729     }

   730 

   731 // -----------------------------------------------------------------------------

   732 // CTestSDKHierarchicalLists::TestHLTLGetMarkedItemsL

   733 // -----------------------------------------------------------------------------

   734 TInt CTestSDKHierarchicalLists::TestHLTLGetMarkedItemsL( CStifItemParser& /*aItem*/ )

   735     {

   736     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   737     STIF_ASSERT_NOT_NULL( treeList );

   738     

   739     _LIT( KTextNode, "AddNode" );

   740     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   741     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   742     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   743     

   744     _LIT( KTextLeaf, "AddLeaf" );

   745     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   746     

   747     CAknTreeList* list = treeList;

   748     

   749     RArray<TAknTreeItemID> array;

   750     CleanupClosePushL( array );

   751     

   752     const TInt count = 1;

   753     list->SetMarked( idNode, ETrue, ETrue );

   754     list->SetMarked( idLeaf, ETrue, ETrue );

   755     list->GetMarkedItemsL( idNode, array );

   756     STIF_ASSERT_EQUALS( count, array.Count() );

   757     

   758     CleanupStack::PopAndDestroy( &array );

   759     CleanupStack::PopAndDestroy( treeList );

   760     

   761     return KErrNone;

   762     

   763     }

   764 

   765 // -----------------------------------------------------------------------------

   766 // CTestSDKHierarchicalLists::TestHLTLIsEmptyL

   767 // -----------------------------------------------------------------------------

   768 TInt CTestSDKHierarchicalLists::TestHLTLIsEmptyL( CStifItemParser& /*aItem*/ )

   769     {

   770     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   771     STIF_ASSERT_NOT_NULL( treeList );

   772     

   773     _LIT( KTextNode, "AddNode" );

   774     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   775     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   776     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   777     

   778     _LIT( KTextLeaf, "AddLeaf" );

   779     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   780     

   781     CAknTreeList* list = treeList;

   782     

   783     STIF_ASSERT_FALSE( list->IsEmpty( idNode ) );

   784     

   785     CleanupStack::PopAndDestroy( treeList );

   786     

   787     return KErrNone;

   788     

   789     }

   790 

   791 // -----------------------------------------------------------------------------

   792 // CTestSDKHierarchicalLists::TestHLTLSetNonEmptyL

   793 // -----------------------------------------------------------------------------

   794 TInt CTestSDKHierarchicalLists::TestHLTLSetNonEmptyL( CStifItemParser& /*aItem*/ )

   795     {

   796     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   797     STIF_ASSERT_NOT_NULL( treeList );

   798     

   799     _LIT( KTextNode, "AddNode" );

   800     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   801     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   802     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   803     

   804     _LIT( KTextLeaf, "AddLeaf" );

   805     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   806     

   807     CAknTreeList* list = treeList;

   808     

   809     list->SetNonEmpty( idNode, EFalse, ETrue );

   810     

   811     CleanupStack::PopAndDestroy( treeList );

   812     

   813     return KErrNone;

   814     

   815     }

   816 

   817 // -----------------------------------------------------------------------------

   818 // CTestSDKHierarchicalLists::TestHLTLIsPersistentL

   819 // -----------------------------------------------------------------------------

   820 TInt CTestSDKHierarchicalLists::TestHLTLIsPersistentL( CStifItemParser& /*aItem*/ )

   821     {

   822     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   823     STIF_ASSERT_NOT_NULL( treeList );

   824     

   825     _LIT( KTextNode, "AddNode" );

   826     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   827     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   828     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   829     

   830     _LIT( KTextLeaf, "AddLeaf" );

   831     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   832     

   833     CAknTreeList* list = treeList;

   834     

   835     list->SetPersistent( idNode, ETrue );

   836     STIF_ASSERT_TRUE( list->IsPersistent( idNode ) );

   837     

   838     CleanupStack::PopAndDestroy( treeList );

   839     

   840     return KErrNone;

   841     

   842     }

   843 

   844 // -----------------------------------------------------------------------------

   845 // CTestSDKHierarchicalLists::TestHLTLSetPersistentL

   846 // -----------------------------------------------------------------------------

   847 TInt CTestSDKHierarchicalLists::TestHLTLSetPersistentL( CStifItemParser& aItem )

   848     {

   849     return TestHLTLIsPersistentL( aItem );

   850     

   851     }

   852 

   853 // -----------------------------------------------------------------------------

   854 // CTestSDKHierarchicalLists::TestHLTLSortL

   855 // -----------------------------------------------------------------------------

   856 TInt CTestSDKHierarchicalLists::TestHLTLSortL( CStifItemParser& /*aItem*/ )

   857     {

   858     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   859     STIF_ASSERT_NOT_NULL( treeList );

   860     

   861     _LIT( KTextNode, "AddNode" );

   862     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   863     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   864     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   865     

   866     _LIT( KTextLeaf, "AddLeaf" );

   867     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   868     

   869     CAknTreeList* list = treeList;

   870     

   871     CTestSDKOrdering* ordering = new (ELeave) CTestSDKOrdering;

   872     CleanupStack::PushL( ordering );

   873     STIF_ASSERT_NOT_NULL( ordering );

   874     

   875     list->Sort( ordering, ETrue );

   876     

   877     CleanupStack::PopAndDestroy( ordering );

   878     CleanupStack::PopAndDestroy( treeList );

   879     

   880     return KErrNone;

   881     

   882     }

   883 

   884 // -----------------------------------------------------------------------------

   885 // CTestSDKHierarchicalLists::TestHLTLNSortL

   886 // -----------------------------------------------------------------------------

   887 TInt CTestSDKHierarchicalLists::TestHLTLNSortL( CStifItemParser& /*aItem*/ )

   888     {

   889     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   890     STIF_ASSERT_NOT_NULL( treeList );

   891     

   892     _LIT( KTextNode, "AddNode" );

   893     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   894     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   895     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   896     

   897     _LIT( KTextLeaf, "AddLeaf" );

   898     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   899     

   900     CAknTreeList* list = treeList;

   901     

   902     list->Sort( idNode, ETrue, ETrue );

   903     

   904     CleanupStack::PopAndDestroy( treeList );

   905     

   906     return KErrNone;

   907     

   908     }

   909 

   910 // -----------------------------------------------------------------------------

   911 // CTestSDKHierarchicalLists::TestHLTLAddObserverL

   912 // -----------------------------------------------------------------------------

   913 TInt CTestSDKHierarchicalLists::TestHLTLAddObserverL( CStifItemParser& /*aItem*/ )

   914     {

   915     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   916     STIF_ASSERT_NOT_NULL( treeList );

   917     

   918     _LIT( KTextNode, "AddNode" );

   919     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   920     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   921     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   922     

   923     _LIT( KTextLeaf, "AddLeaf" );

   924     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   925     

   926     CAknTreeList* list = treeList;

   927     

   928     CTestSDKOrdering* ordering = new (ELeave) CTestSDKOrdering;

   929     CleanupStack::PushL( ordering );

   930     STIF_ASSERT_NOT_NULL( ordering );

   931     

   932     list->AddObserverL( ordering );

   933     list->RemoveObserver( ordering );

   934     

   935     CleanupStack::PopAndDestroy( ordering );

   936     CleanupStack::PopAndDestroy( treeList );

   937     

   938     return KErrNone;

   939     

   940     }

   941 

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

   943 // CTestSDKHierarchicalLists::TestHLTLRemoveObserverL

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

   945 TInt CTestSDKHierarchicalLists::TestHLTLRemoveObserverL( CStifItemParser& aItem )

   946     {

   947     return TestHLTLAddObserverL( aItem );

   948     

   949     }

   950 

   951 // -----------------------------------------------------------------------------

   952 // CTestSDKHierarchicalLists::TestHLTLTabModeFunctionIndicatorsL

   953 // -----------------------------------------------------------------------------

   954 TInt CTestSDKHierarchicalLists::TestHLTLTabModeFunctionIndicatorsL( CStifItemParser& /*aItem*/ )

   955     {

   956     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   957     STIF_ASSERT_NOT_NULL( treeList );

   958     

   959     _LIT( KTextNode, "AddNode" );

   960     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   961     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   962     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   963     

   964     _LIT( KTextLeaf, "AddLeaf" );

   965     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

   966     

   967     CAknTreeList* list = treeList;

   968     

   969     list->EnableTabModeFunctionIndicatorsL( ETrue );

   970     STIF_ASSERT_TRUE( list->TabModeFunctionIndicators() );

   971     

   972     CleanupStack::PopAndDestroy( treeList );

   973     

   974     return KErrNone;

   975     

   976     }

   977 

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

   979 // CTestSDKHierarchicalLists::TestHLTLEnableTabModeFunctionIndicatorsL

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

   981 TInt CTestSDKHierarchicalLists::TestHLTLEnableTabModeFunctionIndicatorsL( CStifItemParser& aItem )

   982     {

   983     return TestHLTLTabModeFunctionIndicatorsL( aItem );

   984     

   985     }

   986 

   987 // -----------------------------------------------------------------------------

   988 // CTestSDKHierarchicalLists::TestHLTLSetFocusedItemIDL

   989 // -----------------------------------------------------------------------------

   990 TInt CTestSDKHierarchicalLists::TestHLTLSetFocusedItemIDL( CStifItemParser& /*aItem*/ )

   991     {

   992     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

   993     STIF_ASSERT_NOT_NULL( treeList );

   994     

   995     _LIT( KTextNode, "AddNode" );

   996     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

   997     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

   998     STIF_ASSERT_NOT_EQUALS( 0, idNode );

   999     

  1000     _LIT( KTextLeaf, "AddLeaf" );

  1001     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

  1002     

  1003     CAknTreeList* list = treeList;

  1004     

  1005     list->SetFocusedItem( idNode );

  1006     

  1007     CleanupStack::PopAndDestroy( treeList );

  1008     

  1009     return KErrNone;

  1010     

  1011     }

  1012 

  1013 // -----------------------------------------------------------------------------

  1014 // CTestSDKHierarchicalLists::TestHLTLFocusedItemIndexL

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

  1016 TInt CTestSDKHierarchicalLists::TestHLTLFocusedItemIndexL( CStifItemParser& /*aItem*/ )

  1017     {

  1018     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

  1019     STIF_ASSERT_NOT_NULL( treeList );

  1020     

  1021     _LIT( KTextNode, "AddNode" );

  1022     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

  1023     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

  1024     STIF_ASSERT_NOT_EQUALS( 0, idNode );

  1025     

  1026     _LIT( KTextLeaf, "AddLeaf" );

  1027     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

  1028     

  1029     CAknTreeList* list = treeList;

  1030     

  1031     const TInt index = -1;

  1032     STIF_ASSERT_EQUALS( index, list->FocusedItemIndex() );

  1033     

  1034     CleanupStack::PopAndDestroy( treeList );

  1035     

  1036     return KErrNone;

  1037     

  1038     }

  1039 

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

  1041 // CTestSDKHierarchicalLists::TestHLTLVisibleItemIndexL

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

  1043 TInt CTestSDKHierarchicalLists::TestHLTLVisibleItemIndexL( CStifItemParser& /*aItem*/ )

  1044     {

  1045     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

  1046     STIF_ASSERT_NOT_NULL( treeList );

  1047     

  1048     _LIT( KTextNode, "AddNode" );

  1049     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

  1050     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

  1051     STIF_ASSERT_NOT_EQUALS( 0, idNode );

  1052     

  1053     _LIT( KTextLeaf, "AddLeaf" );

  1054     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

  1055     

  1056     CAknTreeList* list = treeList;

  1057     

  1058     const TInt index = 0;

  1059     STIF_ASSERT_EQUALS( index, list->VisibleItemIndex( idNode ) );

  1060     

  1061     CleanupStack::PopAndDestroy( treeList );

  1062     

  1063     return KErrNone;

  1064     

  1065     }

  1066 

  1067 // -----------------------------------------------------------------------------

  1068 // CTestSDKHierarchicalLists::TestHLTLOSortL

  1069 // -----------------------------------------------------------------------------

  1070 TInt CTestSDKHierarchicalLists::TestHLTLOSortL( CStifItemParser& /*aItem*/ )

  1071     {

  1072     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

  1073     STIF_ASSERT_NOT_NULL( treeList );

  1074     

  1075     _LIT( KTextNode, "AddNode" );

  1076     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

  1077     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

  1078     STIF_ASSERT_NOT_EQUALS( 0, idNode );

  1079     

  1080     _LIT( KTextLeaf, "AddLeaf" );

  1081     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

  1082     

  1083     CAknTreeList* list = treeList;

  1084     

  1085     CTestSDKOrdering* ordering = new (ELeave) CTestSDKOrdering;

  1086     CleanupStack::PushL( ordering );

  1087     STIF_ASSERT_NOT_NULL( ordering );

  1088     

  1089     list->Sort( ordering, CAknTreeList::ESaveFocus, ETrue );

  1090     

  1091     CleanupStack::PopAndDestroy( ordering );

  1092     CleanupStack::PopAndDestroy( treeList );

  1093     

  1094     return KErrNone;

  1095     

  1096     }

  1097 

  1098 // -----------------------------------------------------------------------------

  1099 // CTestSDKHierarchicalLists::TestHLTLFBSortL

  1100 // -----------------------------------------------------------------------------

  1101 TInt CTestSDKHierarchicalLists::TestHLTLFBSortL( CStifItemParser& /*aItem*/ )

  1102     {

  1103     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

  1104     STIF_ASSERT_NOT_NULL( treeList );

  1105     

  1106     _LIT( KTextNode, "AddNode" );

  1107     TUint32 flags = CAknSingleStyleTreeList::EPersistent;

  1108     TAknTreeItemID idNode = treeList->AddNodeL( KAknTreeIIDRoot, KTextNode, flags, ETrue );

  1109     STIF_ASSERT_NOT_EQUALS( 0, idNode );

  1110     

  1111     _LIT( KTextLeaf, "AddLeaf" );

  1112     TAknTreeItemID idLeaf = treeList->AddLeafL( idNode, KTextLeaf, flags, ETrue );

  1113     

  1114     CAknTreeList* list = treeList;

  1115     

  1116     list->Sort( idNode, CAknTreeList::ESaveFocus, ETrue, ETrue );

  1117 

  1118     CleanupStack::PopAndDestroy( treeList );

  1119     

  1120     return KErrNone;

  1121     

  1122     }

  1123 

  1124 // -----------------------------------------------------------------------------

  1125 // CTestSDKHierarchicalLists::TestHLTLSetEmptyTextL

  1126 // -----------------------------------------------------------------------------

  1127 TInt CTestSDKHierarchicalLists::TestHLTLSetEmptyTextL( CStifItemParser& /*aItem*/ )

  1128     {

  1129     CAknSingleStyleTreeList* treeList = CAknSingleStyleTreeList::NewLC();

  1130     STIF_ASSERT_NOT_NULL( treeList );

  1131     

  1132     CAknTreeList* list = treeList;

  1133     

  1134     _LIT( KText, "EmptyText" );