1 /*

     2 * Copyright (c) 2007-2009 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:  Implementation for CAknSingleColumnStyleTreeList class.

    15 *

    16 */

    17 

    18 

    19 #include <AknDef.h>

    20 #include <AknUtils.h>

    21 #include <aknlayoutscalable_avkon.cdl.h>

    22 

    23 #include <AknTasHook.h> // for testability hooks

    24 #include "aknhlistlib.h"

    25 #include "akntree.h"

    26 #include "akntreelistview.h"

    27 #include "akntreelistinternalconstants.h"

    28 #include "aknsinglecolumnstylecoredatarow.h"

    29 #include "aknsinglecolumnstylesimpledatarow.h"

    30 #include "aknsinglecolumnstylesubtitlerow.h"

    31 #include "aknsinglecolumnstyletreelist.h"

    32 

    33 

    34 /** Set of flags that are always set on for hierarchical column list. */

    35 const TInt KMandatoryListFlags = NULL;

    36 

    37 /** Set of flags that cannot be set for hierarchical column list. */

    38 const TInt KRestrictedListFlags = NULL;

    39 

    40 /** Set of default flags for hieararchical column list. */

    41 const TInt KDefaultListFlags = KAknTreeListNoStructureLines;

    42 

    43 

    44 // ======== MEMBER FUNCTIONS ========

    45 

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

    47 // Two-phased constructor.

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

    49 //

    50 EXPORT_C CAknSingleColumnStyleTreeList* CAknSingleColumnStyleTreeList::NewL()

    51     {

    52     CAknSingleColumnStyleTreeList* self

    53         = CAknSingleColumnStyleTreeList::NewLC();

    54     CleanupStack::Pop( self );

    55     return self;

    56     }

    57 

    58 

    59 // ---------------------------------------------------------------------------

    60 // Two-phased constructor.

    61 // ---------------------------------------------------------------------------

    62 //

    63 EXPORT_C CAknSingleColumnStyleTreeList* CAknSingleColumnStyleTreeList::NewL(

    64     const CCoeControl& aContainer )

    65     {

    66     CAknSingleColumnStyleTreeList* self

    67         = CAknSingleColumnStyleTreeList::NewLC( aContainer );

    68     CleanupStack::Pop( self );

    69     return self;

    70     }

    71 

    72 

    73 // ---------------------------------------------------------------------------

    74 // Two-phased constructor.

    75 // ---------------------------------------------------------------------------

    76 //

    77 EXPORT_C CAknSingleColumnStyleTreeList* CAknSingleColumnStyleTreeList::NewLC()

    78     {

    79     CAknSingleColumnStyleTreeList* self =

    80         new( ELeave ) CAknSingleColumnStyleTreeList;

    81     CleanupStack::PushL( self );

    82     self->ConstructL();

    83     AKNTASHOOK_ADDL( self, "CAknSingleColumnStyleTreeList" );

    84     return self;

    85     }

    86 

    87 

    88 // ---------------------------------------------------------------------------

    89 // Two-phased constructor.

    90 // ---------------------------------------------------------------------------

    91 //

    92 EXPORT_C CAknSingleColumnStyleTreeList* CAknSingleColumnStyleTreeList::NewLC(

    93     const CCoeControl& aContainer )

    94     {

    95     CAknSingleColumnStyleTreeList* self =

    96         new( ELeave ) CAknSingleColumnStyleTreeList;

    97     CleanupStack::PushL( self );

    98     self->ConstructL( aContainer );

    99     AKNTASHOOK_ADDL( self, "CAknSingleColumnStyleTreeList" );

   100     return self;

   101     }

   102 

   103 

   104 // ---------------------------------------------------------------------------

   105 // Destructor.

   106 // ---------------------------------------------------------------------------

   107 //

   108 CAknSingleColumnStyleTreeList::~CAknSingleColumnStyleTreeList()

   109     {

   110     AKNTASHOOK_REMOVE();

   111     }

   112 

   113 

   114 // ---------------------------------------------------------------------------

   115 // Creates simple data row instance and adds it to the specified node.

   116 // ---------------------------------------------------------------------------

   117 //

   118 EXPORT_C TAknTreeItemID CAknSingleColumnStyleTreeList::AddSimpleDataRowL(

   119     TAknTreeItemID aParent, const TDesC& aText, TUint32 aFlags,

   120     TBool aDrawNow )

   121     {

   122     // Get flags relevant to simple data row.

   123     TUint32 flags = NULL;

   124     if ( aFlags & EPersistent )

   125         {

   126         flags |= CAknTreeLeaf::EPersistent;

   127         }

   128     if ( aFlags & EMarked )

   129         {

   130         flags |= CAknTreeLeaf::EMarked;

   131         }

   132     if ( aFlags & EMarkingDisabled )

   133         {

   134         flags |= CAknTreeLeaf::EMarkingDisabled;

   135         }

   136 

   137     CAknSingleColumnStyleSimpleDataRow* row =

   138         CAknSingleColumnStyleSimpleDataRow::NewLC( aText, flags );

   139     TAknTreeItemID id = Tree().AddItemL( row, aParent, aDrawNow );

   140     CleanupStack::Pop( row );

   141     return id;

   142     }

   143 

   144 

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

   146 // Creates core data row instance with two text columns and adds it to the

   147 // specified parent node.

   148 // ---------------------------------------------------------------------------

   149 //

   150 EXPORT_C TAknTreeItemID CAknSingleColumnStyleTreeList::AddCoreDataRowL(

   151     TAknTreeItemID aParent, const TDesC& aFirstColumn,

   152     const TDesC& aSecondColumn, TUint32 aFlags, TBool aDrawNow )

   153     {

   154     // Get flags relevant to core data row.

   155     TUint32 flags = NULL;

   156     if ( aFlags & EPersistent )

   157         {

   158         flags |= CAknTreeLeaf::EPersistent;

   159         }

   160     if ( aFlags & EMarked )

   161         {

   162         flags |= CAknTreeLeaf::EMarked;

   163         }

   164     if ( aFlags & EMarkingDisabled )

   165         {

   166         flags |= CAknTreeLeaf::EMarkingDisabled;

   167         }

   168     if ( aFlags & EEmphasis )

   169         {

   170         flags |= CAknSingleColumnStyleCoreDataRow::EEmphasis;

   171         }

   172 

   173     CAknSingleColumnStyleCoreDataRow* row =

   174         CAknSingleColumnStyleCoreDataRow::NewLC( aFirstColumn,

   175             aSecondColumn, flags );

   176     TAknTreeItemID id = Tree().AddItemL( row, aParent, aDrawNow );

   177     CleanupStack::Pop( row );

   178     return id;

   179     }

   180 

   181 

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

   183 // Creates core data row instance with three text columns and adds it to the

   184 // specified parent node.

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

   186 //

   187 EXPORT_C TAknTreeItemID CAknSingleColumnStyleTreeList::AddCoreDataRowL(

   188     TAknTreeItemID aParent, const TDesC& aFirstColumn,

   189     const TDesC& aSecondColumn, const TDesC& aThirdColumn, TUint32 aFlags,

   190     TBool aDrawNow )

   191     {

   192     // Get flags relevant to core data row.

   193     TUint32 flags = NULL;

   194     if ( aFlags & EPersistent )

   195         {

   196         flags |= CAknTreeLeaf::EPersistent;

   197         }

   198     if ( aFlags & EMarked )

   199         {

   200         flags |= CAknTreeLeaf::EMarked;

   201         }

   202     if ( aFlags & EMarkingDisabled )

   203         {

   204         flags |= CAknTreeLeaf::EMarkingDisabled;

   205         }

   206     if ( aFlags & EEmphasis )

   207         {

   208         flags |= CAknSingleColumnStyleCoreDataRow::EEmphasis;

   209         }

   210 

   211     CAknSingleColumnStyleCoreDataRow* row =

   212         CAknSingleColumnStyleCoreDataRow::NewLC( aFirstColumn,

   213             aSecondColumn, aThirdColumn, flags );

   214     TAknTreeItemID id = Tree().AddItemL( row, aParent, aDrawNow );

   215     CleanupStack::Pop( row );

   216     return id;

   217     }

   218 

   219 

   220 // ---------------------------------------------------------------------------

   221 // Creates subtitle row instance and adds it to the specified node.

   222 // ---------------------------------------------------------------------------

   223 //

   224 EXPORT_C TAknTreeItemID CAknSingleColumnStyleTreeList::AddSubtitleRowL(

   225     TAknTreeItemID aParent, const TDesC& aText, TUint32 aFlags,

   226     TBool aDrawNow )

   227     {

   228     // Get flags relevant to subtitle row.

   229     TUint32 flags = NULL;

   230     if ( aFlags & EPersistent )

   231         {

   232         flags |= CAknTreeNode::EPersistent;

   233         }

   234     if ( aFlags & EMarked )

   235         {

   236         flags |= CAknTreeNode::EMarked;

   237         }

   238     if ( aFlags & EMarkingDisabled )

   239         {

   240         flags |= CAknTreeNode::EMarkingDisabled;

   241         }

   242     if ( aFlags & EExpanded )

   243         {

   244         flags |= CAknTreeNode::EExpanded;

   245         }

   246     if ( aFlags & ENonEmpty )

   247         {

   248         flags |= CAknTreeNode::ENonEmpty;

   249         }

   250 

   251     CAknSingleColumnStyleSubtitleRow* row =

   252         CAknSingleColumnStyleSubtitleRow::NewLC( aText, flags );

   253     TAknTreeItemID id = Tree().AddItemL( row, aParent, aDrawNow );

   254     CleanupStack::Pop( row );

   255     return id;

   256     }

   257 

   258 

   259 // ---------------------------------------------------------------------------

   260 // Returns the text field of the specified list item.

   261 // ---------------------------------------------------------------------------

   262 //

   263 EXPORT_C const TDesC& CAknSingleColumnStyleTreeList::Text(

   264     TAknTreeItemID aItem ) const

   265     {

   266     return Text( aItem, 0 );

   267     }

   268     

   269 

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

   271 // Returns the specified text column of specified list item. Null descriptor

   272 // is returned if column with non-zero index is requested from simple data

   273 // row or subtitle row.

   274 // ---------------------------------------------------------------------------

   275 //

   276 EXPORT_C const TDesC& CAknSingleColumnStyleTreeList::Text(

   277     TAknTreeItemID aItem, TInt aColumnIndex ) const

   278     {

   279     CAknTreeItem* item = Tree().Item( aItem );

   280     TInt type = item->Type();

   281 

   282     if ( type == AknTreeList::KSingleColumnStyleCoreDataRow )

   283         {

   284         CAknSingleColumnStyleCoreDataRow* coreDataRow =

   285             static_cast<CAknSingleColumnStyleCoreDataRow*>( item );

   286         return coreDataRow->Text( aColumnIndex );

   287         }

   288 

   289     else if ( type == AknTreeList::KSingleColumnStyleSimpleDataRow &&

   290         !aColumnIndex )

   291         {

   292         CAknSingleColumnStyleSimpleDataRow* simpleDataRow =

   293             static_cast<CAknSingleColumnStyleSimpleDataRow*>( item );

   294         return simpleDataRow->Text();

   295         }

   296 

   297     else if ( type == AknTreeList::KSingleColumnStyleSubtitleRow &&

   298         !aColumnIndex )

   299         {

   300         CAknSingleColumnStyleSubtitleRow* subtitleRow = 

   301             static_cast<CAknSingleColumnStyleSubtitleRow*>( item );

   302         return subtitleRow->Text();

   303         }

   304 

   305     else

   306         {

   307         return KNullDesC;

   308         }

   309     }

   310 

   311 

   312 // ---------------------------------------------------------------------------

   313 // Set text for specified item.

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

   315 //

   316 EXPORT_C void CAknSingleColumnStyleTreeList::SetTextL( TAknTreeItemID aItem,

   317     const TDesC& aText, TBool aDrawNow )

   318     {

   319     SetTextL( aItem, aText, 0, aDrawNow );

   320     }

   321 

   322 

   323 // ---------------------------------------------------------------------------

   324 // Set text for specified column of specified list item.

   325 // ---------------------------------------------------------------------------

   326 //

   327 EXPORT_C void CAknSingleColumnStyleTreeList::SetTextL( TAknTreeItemID aItem,

   328     const TDesC& aText, TInt aColumnIndex, TBool aDrawNow )

   329     {

   330     CAknTreeItem* item = Tree().Item( aItem );

   331     TInt type = item->Type();

   332 

   333     if ( type == AknTreeList::KSingleColumnStyleCoreDataRow )

   334         {

   335         CAknSingleColumnStyleCoreDataRow* coreDataRow =

   336             static_cast<CAknSingleColumnStyleCoreDataRow*>( item );

   337         coreDataRow->SetTextL( aText, aColumnIndex, aDrawNow );

   338         }

   339 

   340     else if ( type == AknTreeList::KSingleColumnStyleSimpleDataRow )

   341         {

   342         if ( !aColumnIndex )

   343             {

   344             CAknSingleColumnStyleSimpleDataRow* simpleDataRow =

   345                 static_cast<CAknSingleColumnStyleSimpleDataRow*>( item );

   346             simpleDataRow->SetTextL( aText, aDrawNow );

   347             }

   348         else

   349             {

   350             User::Leave( KErrNotFound );

   351             }

   352         }

   353 

   354     else if ( type == AknTreeList::KSingleColumnStyleSubtitleRow )

   355         {

   356         if ( !aColumnIndex )

   357             {

   358             CAknSingleColumnStyleSubtitleRow* subtitleRow =

   359                 static_cast<CAknSingleColumnStyleSubtitleRow*>( item );

   360             subtitleRow->SetTextL( aText, aDrawNow );

   361             }

   362         else

   363             {

   364             User::Leave( KErrNotFound );

   365             }

   366         }

   367 

   368     else

   369         {

   370         // Invalid item type.

   371         Panic( EAknHListPanicInvalidItemType );

   372         }

   373     }

   374 

   375 

   376 // ---------------------------------------------------------------------------

   377 // Checks whether the specified core data row is emphasised.

   378 // ---------------------------------------------------------------------------

   379 //

   380 EXPORT_C TBool CAknSingleColumnStyleTreeList::IsEmphasised(

   381     TAknTreeItemID aItem ) const

   382     {

   383     TBool emphasis = EFalse;

   384     CAknTreeItem* item = Tree().Item( aItem );

   385     if ( item->Type() == AknTreeList::KSingleColumnStyleCoreDataRow )

   386         {

   387         CAknSingleColumnStyleCoreDataRow* coreDataRow =

   388             static_cast<CAknSingleColumnStyleCoreDataRow*>( item );

   389         emphasis = coreDataRow->IsEmphasised();

   390         }

   391     return emphasis;

   392     }

   393 

   394 

   395 // ---------------------------------------------------------------------------

   396 // Set emphasis for core data row.

   397 // ---------------------------------------------------------------------------

   398 //

   399 EXPORT_C void CAknSingleColumnStyleTreeList::SetEmphasis(

   400     TAknTreeItemID aItem, TBool aEmphasis, TBool aDrawNow )

   401     {

   402     CAknTreeItem* item = Tree().Item( aItem );

   403     if ( item->Type() == AknTreeList::KSingleColumnStyleCoreDataRow )

   404         {

   405         CAknSingleColumnStyleCoreDataRow* coreDataRow =

   406             static_cast<CAknSingleColumnStyleCoreDataRow*>( item );

   407         coreDataRow->SetEmphasis( aEmphasis, aDrawNow );

   408         }

   409     else

   410         {

   411         // Invalid item type. Set emphasis supported only for core data rows.

   412         Panic( EAknHListPanicInvalidItemType );

   413         }

   414     }

   415 

   416 

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

   418 // Checks whether the third text column is enabled.

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

   420 //

   421 EXPORT_C TBool CAknSingleColumnStyleTreeList::IsThirdColumnEnabled(

   422     TAknTreeItemID aItem ) const

   423     {

   424     TBool thirdColumn = EFalse;

   425     CAknTreeItem* item = Tree().Item( aItem );

   426     if ( item->Type() == AknTreeList::KSingleColumnStyleCoreDataRow )

   427         {

   428         CAknSingleColumnStyleCoreDataRow* coreDataRow =

   429             static_cast<CAknSingleColumnStyleCoreDataRow*>( item );

   430         thirdColumn = coreDataRow->IsThirdColumnEnabled();

   431         }

   432     return thirdColumn;

   433     }

   434 

   435 

   436 // ---------------------------------------------------------------------------

   437 // Enables or disables third text column for specified item.

   438 // ---------------------------------------------------------------------------

   439 //

   440 EXPORT_C void CAknSingleColumnStyleTreeList::EnableThirdColumn(

   441     TAknTreeItemID aItem, TBool aEnable, TBool aDrawNow )

   442     {

   443     CAknTreeItem* item = Tree().Item( aItem );

   444     if ( item->Type() == AknTreeList::KSingleColumnStyleCoreDataRow )

   445         {

   446         CAknSingleColumnStyleCoreDataRow* coreDataRow =

   447             static_cast<CAknSingleColumnStyleCoreDataRow*>( item );

   448         coreDataRow->EnableThirdColumn( aEnable, aDrawNow );

   449         }

   450     else

   451         {

   452         // Invalid item type.

   453         Panic( EAknHListPanicInvalidItemType );

   454         }

   455     }

   456 

   457 

   458 // ---------------------------------------------------------------------------

   459 // Get icon ID set for specified item.

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

   461 //

   462 EXPORT_C TInt CAknSingleColumnStyleTreeList::Icon( TAknTreeItemID aItem,

   463     TIconType aType ) const

   464     {

   465     CAknTreeItem* item = Tree().Item( aItem );

   466     if ( item->Type() == AknTreeList::KSingleColumnStyleCoreDataRow )

   467         {

   468         CAknSingleColumnStyleCoreDataRow::TIconType type;

   469         switch ( aType )

   470             {

   471             case ELeaf:

   472                 type = CAknSingleColumnStyleCoreDataRow::EIcon;

   473                 break;

   474             case EHighlightedLeaf:

   475                 type = CAknSingleColumnStyleCoreDataRow::EHighlightedIcon;

   476                 break;

   477             case EOptionalIcon1:

   478                 type = CAknSingleColumnStyleCoreDataRow::EOptIcon1;

   479                 break;

   480             case EHighlightedOptionalIcon1:

   481                 type = CAknSingleColumnStyleCoreDataRow::EHighlightedOptIcon1;

   482                 break;

   483             case EOptionalIcon2:

   484                 type = CAknSingleColumnStyleCoreDataRow::EOptIcon2;

   485                 break;

   486             case EHighlightedOptionalIcon2:

   487                 type = CAknSingleColumnStyleCoreDataRow::EHighlightedOptIcon2;

   488                 break;

   489             default:

   490                 // Invalid icon type for core data row.

   491                 return KErrNotFound;

   492             }

   493         return static_cast<CAknSingleColumnStyleCoreDataRow*>( item )->

   494             Icon( type );

   495         }

   496 

   497     else if ( item->Type() == AknTreeList::KSingleColumnStyleSimpleDataRow )

   498         {

   499         CAknSingleColumnStyleSimpleDataRow::TIconType type;

   500         switch ( aType )

   501             {

   502             case ELeaf:

   503                 type = CAknSingleColumnStyleSimpleDataRow::EIcon;

   504                 break;

   505             case EHighlightedLeaf:

   506                 type = CAknSingleColumnStyleSimpleDataRow::EHighlightedIcon;

   507                 break;

   508             case EOptionalIcon1:

   509                 type = CAknSingleColumnStyleSimpleDataRow::EOptIcon;

   510                 break;

   511             case EHighlightedOptionalIcon1:

   512                 type = CAknSingleColumnStyleSimpleDataRow::EHighlightedOptIcon;

   513                 break;

   514             default:

   515                 // Invalid icon type for simple data row.

   516                 return KErrNotFound;

   517             }

   518         return static_cast<CAknSingleColumnStyleSimpleDataRow*>( item )->

   519             Icon( type );

   520         }

   521 

   522     else if ( item->Type() == AknTreeList::KSingleColumnStyleSubtitleRow )

   523         {

   524         CAknSingleColumnStyleSubtitleRow::TIconType type;

   525         switch ( aType )

   526             {

   527             case EExpandedNode:

   528                 type = CAknSingleColumnStyleSubtitleRow::EExpandedIcon;

   529                 break;

   530             case EHighlightedExpandedNode:

   531                 type = CAknSingleColumnStyleSubtitleRow::EHighlightedExpandedIcon;

   532                 break;

   533             case ECollapsedNode:

   534                 type = CAknSingleColumnStyleSubtitleRow::ECollapsedIcon;

   535                 break;

   536             case EHighlightedCollapsedNode:

   537                 type = CAknSingleColumnStyleSubtitleRow::EHighlightedCollapsedIcon;

   538                 break;

   539             case EOptionalIcon1:

   540                 type = CAknSingleColumnStyleSubtitleRow::EOptIcon;

   541                 break;

   542             case EHighlightedOptionalIcon1:

   543                 type = CAknSingleColumnStyleSubtitleRow::EHighlightedOptIcon;

   544                 break;

   545             default:

   546                 // Invalid icon type for subtitle row.

   547                 return KErrNotFound;

   548             }

   549         return static_cast<CAknSingleColumnStyleSubtitleRow*>( item )->

   550             Icon( type );

   551         }

   552 

   553     else

   554         {

   555         return KErrNotFound;

   556         }

   557     }

   558 

   559 

   560 // ---------------------------------------------------------------------------

   561 // Set icon for specified item.

   562 // ---------------------------------------------------------------------------

   563 //

   564 EXPORT_C void CAknSingleColumnStyleTreeList::SetIcon(

   565     const TAknTreeItemID aItem, const TIconType aType, const TInt aIconId,

   566     const TBool aDrawNow )

   567     {

   568     CAknTreeItem* item = Tree().Item( aItem );

   569     if ( item->Type() == AknTreeList::KSingleColumnStyleCoreDataRow )

   570         {

   571         CAknSingleColumnStyleCoreDataRow::TIconType type

   572             = CAknSingleColumnStyleCoreDataRow::EIcon;

   573         switch ( aType )

   574             {

   575             case ELeaf:

   576                 type = CAknSingleColumnStyleCoreDataRow::EIcon;

   577                 break;

   578             case EHighlightedLeaf:

   579                 type = CAknSingleColumnStyleCoreDataRow::EHighlightedIcon;

   580                 break;

   581             case EOptionalIcon1:

   582                 type = CAknSingleColumnStyleCoreDataRow::EOptIcon1;

   583                 break;

   584             case EHighlightedOptionalIcon1:

   585                 type = CAknSingleColumnStyleCoreDataRow::EHighlightedOptIcon1;

   586                 break;

   587             case EOptionalIcon2:

   588                 type = CAknSingleColumnStyleCoreDataRow::EOptIcon2;

   589                 break;

   590             case EHighlightedOptionalIcon2:

   591                 type = CAknSingleColumnStyleCoreDataRow::EHighlightedOptIcon2;

   592                 break;

   593             default:

   594                 // Invalid icon type for core data row.

   595                 Panic( EAknHListPanicInvalidItemType );

   596                 break;

   597             }

   598         static_cast<CAknSingleColumnStyleCoreDataRow*>( item )->

   599             SetIcon( type, aIconId, aDrawNow );

   600         }

   601 

   602     else if ( item->Type() == AknTreeList::KSingleColumnStyleSimpleDataRow )

   603         {

   604         CAknSingleColumnStyleSimpleDataRow::TIconType type

   605             = CAknSingleColumnStyleSimpleDataRow::EIcon;

   606         switch ( aType )

   607             {

   608             case ELeaf:

   609                 type = CAknSingleColumnStyleSimpleDataRow::EIcon;

   610                 break;

   611             case EHighlightedLeaf:

   612                 type  = CAknSingleColumnStyleSimpleDataRow::EHighlightedIcon;

   613                 break;

   614             case EOptionalIcon1:

   615                 type = CAknSingleColumnStyleSimpleDataRow::EOptIcon;

   616                 break;

   617             case EHighlightedOptionalIcon1:

   618                 type = CAknSingleColumnStyleSimpleDataRow::EHighlightedOptIcon;

   619                 break;

   620             default:

   621                 // Invalid icon type for simple data row.

   622                 Panic( EAknHListPanicInvalidItemType );

   623                 break;

   624             }

   625         static_cast<CAknSingleColumnStyleSimpleDataRow*>( item )->

   626             SetIcon( type, aIconId, aDrawNow );

   627         }

   628 

   629     else if ( item->Type() == AknTreeList::KSingleColumnStyleSubtitleRow )

   630         {

   631         CAknSingleColumnStyleSubtitleRow::TIconType type

   632             = CAknSingleColumnStyleSubtitleRow::EExpandedIcon;

   633         switch ( aType )

   634             {

   635             case EExpandedNode:

   636                 type = CAknSingleColumnStyleSubtitleRow::EExpandedIcon;

   637                 break;

   638             case EHighlightedExpandedNode:

   639                 type = CAknSingleColumnStyleSubtitleRow::

   640                     EHighlightedExpandedIcon;

   641                 break;

   642             case ECollapsedNode:

   643                 type = CAknSingleColumnStyleSubtitleRow::ECollapsedIcon;

   644                 break;

   645             case EHighlightedCollapsedNode:

   646                 type = CAknSingleColumnStyleSubtitleRow::

   647                     EHighlightedCollapsedIcon;

   648                 break;

   649             case EOptionalIcon1:

   650                 type = CAknSingleColumnStyleSubtitleRow::EOptIcon;

   651                 break;

   652             case EHighlightedOptionalIcon1:

   653                 type = CAknSingleColumnStyleSubtitleRow::EHighlightedOptIcon;

   654                 break;

   655             default:

   656                 // Invalid icon type for subtitle row.

   657                 Panic( EAknHListPanicInvalidItemType );

   658                 break;

   659             }

   660         static_cast<CAknSingleColumnStyleSubtitleRow*>( item )->

   661             SetIcon( type, aIconId, aDrawNow );

   662         }

   663 

   664     else

   665         {

   666         // Invalid item type.

   667         Panic( EAknHListPanicInvalidItemType );

   668         }

   669     }

   670 

   671 

   672 // ---------------------------------------------------------------------------

   673 // Returns the type of the specified item.

   674 // ---------------------------------------------------------------------------

   675 //

   676 EXPORT_C CAknSingleColumnStyleTreeList::TItemType

   677     CAknSingleColumnStyleTreeList::ItemType( TAknTreeItemID aItem ) const

   678     {

   679     TItemType type = ENone;

   680     if ( aItem != KAknTreeIIDNone )

   681         {

   682         CAknTreeItem* item = Tree().Item( aItem );

   683         switch ( item->Type() )

   684             {

   685             case AknTreeList::KTree:

   686                 type = ETreeRoot;

   687                 break;

   688             case AknTreeList::KSingleColumnStyleSimpleDataRow:

   689                 type = ESimpleDataRow;

   690                 break;

   691             case AknTreeList::KSingleColumnStyleCoreDataRow:

   692                 type = ECoreDataRow;

   693                 break;

   694             case AknTreeList::KSingleColumnStyleSubtitleRow:

   695                 type = ESubtitleRow;

   696                 break;

   697             default:

   698                 break;

   699             }

   700         }

   701     return type;

   702     }

   703 

   704 

   705 // ---------------------------------------------------------------------------

   706 // From class CAknTreeList.

   707 // Sets flags for the list.

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

   709 //

   710 void CAknSingleColumnStyleTreeList::SetFlags( TUint32 aFlags )

   711     {

   712     TUint32 flags = ( aFlags | KMandatoryListFlags ) & ~KRestrictedListFlags;

   713     CAknTreeList::SetFlags( flags );

   714     }

   715 

   716 

   717 // ---------------------------------------------------------------------------

   718 // From class CAknTreeList.

   719 // Handles resource changes.

   720 // ---------------------------------------------------------------------------

   721 //

   722 void CAknSingleColumnStyleTreeList::HandleResourceChange( TInt aType )

   723     {

   724     if ( aType == KEikDynamicLayoutVariantSwitch )

   725         {

   726         UpdateIndention();

   727         }

   728     CAknTreeList::HandleResourceChange( aType );

   729     }

   730 

   731 

   732 

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

   734 // Default C++ constructor.

   735 // ---------------------------------------------------------------------------

   736 //

   737 CAknSingleColumnStyleTreeList::CAknSingleColumnStyleTreeList()

   738     {

   739     }

   740 

   741 

   742 // ---------------------------------------------------------------------------

   743 // Second phase constructor.

   744 // ---------------------------------------------------------------------------

   745 //

   746 void CAknSingleColumnStyleTreeList::ConstructL()

   747     {

   748     BaseConstructL();

   749     UpdateIndention();

   750 

   751     // Set default flags on.

   752     SetFlags( KDefaultListFlags );

   753     }

   754 

   755 // ---------------------------------------------------------------------------

   756 // Second phase constructor.

   757 // ---------------------------------------------------------------------------

   758 //

   759 void CAknSingleColumnStyleTreeList::ConstructL( const CCoeControl& aContainer )

   760     {

   761     BaseConstructL( aContainer );

   762     UpdateIndention();

   763 

   764     // Sets default flags on.

   765     SetFlags( KDefaultListFlags );

   766     }

   767 

   768 

   769 // ---------------------------------------------------------------------------

   770 // Updates the width of single indentation step.

   771 // ---------------------------------------------------------------------------

   772 //

   773 void CAknSingleColumnStyleTreeList::UpdateIndention()

   774     {

   775     TAknLayoutRect layoutRect;

   776     layoutRect.LayoutRect( Rect(),

   777         AknLayoutScalable_Avkon::aid_indentation_list_msg().LayoutLine() );

   778     TInt indentationWidth = layoutRect.Rect().Width();

   779     View().SetIndentionWidth( indentationWidth );

   780     }