emailuis/uicomponents/inc/fstreenodevisualizerbase.h
branchRCL_3
changeset 25 3533d4323edc
equal deleted inserted replaced
24:d189ee25cf9d 25:3533d4323edc
       
     1 /*
       
     2 * Copyright (c) 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:  Base class of item visualizer.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 #ifndef FSTREENODEVISUALIZERBASE_H_
       
    21 #define FSTREENODEVISUALIZERBASE_H_
       
    22 
       
    23 
       
    24 #include <e32base.h>
       
    25 //<cmail> removed __FS_ALFRED_SUPPORT flag
       
    26 //#include <fsconfig.h>
       
    27 //</cmail> removed __FS_ALFRED_SUPPORT flag
       
    28 #include <gdi.h>
       
    29 // <cmail> SF
       
    30 #include <alf/alfeventhandler.h>
       
    31 // </cmail>
       
    32 #include "fstreenodevisualizer.h"
       
    33 
       
    34 class CAlfLayout;
       
    35 class CAlfTexture;
       
    36 class CAlfBrush;
       
    37 class CAlfTexture;
       
    38 class CAlfAnchorLayout;
       
    39 class CAlfControl;
       
    40 class CFsAlfTextStyleManager;
       
    41 class CAlfTextVisual;
       
    42 
       
    43 /**
       
    44  * CFsTreeNodeVisualizerBase is a base class implementing methods common for
       
    45  * all tree node visualizers.
       
    46  *
       
    47  * Thic class is a concrete implementation for the MFsTreeItemVisualizer 
       
    48  * interface.
       
    49  * 
       
    50  * @code
       
    51  *
       
    52  * @endcode
       
    53  *
       
    54  * @lib 
       
    55  */
       
    56 NONSHARABLE_CLASS(CFsTreeNodeVisualizerBase) : public CBase,
       
    57                                                public MFsTreeNodeVisualizer,
       
    58                                                public MAlfEventHandler
       
    59     {
       
    60     
       
    61 public:
       
    62 
       
    63     virtual ~CFsTreeNodeVisualizerBase();
       
    64     
       
    65     
       
    66 public: //from MFsTreeItemVisualizer
       
    67 
       
    68     /**
       
    69      * Returns the type of the item's visualizer.
       
    70      */
       
    71     virtual TFsTreeItemVisualizerType Type() const;
       
    72     
       
    73     /**
       
    74      * Sets horizontal alignment of the displayed plain text.
       
    75      * 
       
    76      * For AH layout EHuiAlignHLeft is internally converted to EHuiAlignHRight
       
    77      * and EHuiAlignHRight is converted to EHuiAlignHLeft.
       
    78      * 
       
    79      * EAlfAlignHLocale (default setting) - alignment set according to text directionality
       
    80      * 
       
    81      * @param aAlign Horizontal text alignment type.
       
    82      */
       
    83     virtual void SetTextAlign( const TAlfAlignHorizontal aAlign );
       
    84         
       
    85     /**
       
    86      * The function sets item's text color for the focused state.
       
    87      *
       
    88      * @param aColor New color to be set.
       
    89      */
       
    90     virtual void SetFocusedStateTextColor( const TRgb& aColor );
       
    91     
       
    92     /**
       
    93      * The function returns item's text color for the focused state.
       
    94      */
       
    95     virtual TRgb FocusedStateTextColor() const;
       
    96     
       
    97     /**
       
    98      * The function sets item's text color for the normal (unfocused) state.
       
    99      *
       
   100      * @param aColor New color to be set.
       
   101      */
       
   102     virtual void SetNormalStateTextColor( const TRgb& aColor );
       
   103     
       
   104     /**
       
   105      * The function returns item's text color for the normal (unfocused) state
       
   106      */
       
   107     virtual TRgb NormalStateTextColor() const;
       
   108         
       
   109     /**
       
   110      * The function sets the style of item's text.
       
   111      * 
       
   112      * @param aTextStyleId Text style ID provided by the text style manager.
       
   113      */
       
   114     virtual void SetTextStyleId ( const TInt aTextStyleId );
       
   115     
       
   116     /**
       
   117      * The function returns the style of item's text.
       
   118      * 
       
   119      * @return Text style ID provided by the text style manager.
       
   120      */
       
   121     virtual TInt TextStyleId () const;
       
   122     
       
   123     /**
       
   124      * From MFsTreeItemVisualizer.
       
   125      * Sets multiple flags for an item at one time.
       
   126      * 
       
   127      * @param aFlags Flags for item visualizer.
       
   128      */
       
   129     virtual void SetFlags( TUint32 aFlags );
       
   130     
       
   131     /**
       
   132      * From MFsTreeItemVisualizer.
       
   133      * Returns flags of the item visualizer.
       
   134      * 
       
   135      * @return Item visualizer's flags value.
       
   136      */
       
   137     virtual TUint32 Flags();
       
   138     
       
   139     /**
       
   140      * From MFsTreeItemVisualizer.
       
   141      * Sets visualized item's state to marked/unmarked.
       
   142      * 
       
   143      * @param aFlag ETrue to visualize item as marked.
       
   144      */
       
   145     virtual void SetMarked( TBool aFlag );
       
   146     
       
   147     /**
       
   148      * From MFsTreeItemVisualizer.
       
   149      * Returns mark/unmark state of the item's visualization.
       
   150      * 
       
   151      * @return ETrue if item is visualized as marked.
       
   152      */
       
   153     virtual TBool IsMarked() const;
       
   154      
       
   155     /**
       
   156      * From MFsTreeItemVisualizer.
       
   157      * Sets visualized item's state to dimmed/not dimmed.
       
   158      * 
       
   159      * @param aFlag ETrue to visualize item as dimmed.
       
   160      */
       
   161     virtual void SetDimmed( TBool aFlag );
       
   162     
       
   163     /**
       
   164      * From MFsTreeItemVisualizer.
       
   165      * Returns dimmed/not dimmed state of the item's visualization.
       
   166      * 
       
   167      * @return ETrue if item is visualized as dimmed.
       
   168      */
       
   169     virtual TBool IsDimmed() const;
       
   170     
       
   171     /**
       
   172      * From MFsTreeItemVisualizer.
       
   173      * Sets the size of the item visualization when item is not in expanded 
       
   174      * state. 
       
   175      * 
       
   176      * @param aSize Size in pixels of the an when it is not expanded.
       
   177      */
       
   178     virtual void SetSize( const TSize aSize );
       
   179     
       
   180     /**
       
   181      * From MFsTreeItemVisualizer.
       
   182      * Returns the size of an item in a normal (not extended) state.
       
   183      * 
       
   184      * @return Size in pixels of an item when it is not extended.
       
   185      */
       
   186     virtual TSize Size() const;     
       
   187     
       
   188     /**
       
   189      * From MFsTreeItemVisualizer.
       
   190      * Sets the item's visualization state to expanded. This state is used to
       
   191      * preview more data of an item.
       
   192      * 
       
   193      * @param aFlag ETrue to visualize item as expanded.
       
   194      */
       
   195     virtual void SetExtended( const TBool aFlag );
       
   196     
       
   197     /**
       
   198      * From MFsTreeItemVisualizer.
       
   199      * Returns expanded/not expanded state of the item visualization.
       
   200      * 
       
   201      * @return ETrue if item is visualized as expanded.
       
   202      */
       
   203     virtual TBool IsExtended() const;    
       
   204     
       
   205     /**
       
   206      * From MFsTreeItemVisualizer.
       
   207      * Sets if an item can be in expanded state or not.
       
   208      * 
       
   209      * @param aFlag ETrue if item can be in expanded state.
       
   210      */
       
   211     virtual void SetExtendable( TBool aFlag );
       
   212     
       
   213     /**
       
   214      * From MFsTreeItemVisualizer.
       
   215      * Returns an information if item can be in expanded state.
       
   216      * 
       
   217      * @return ETrue if item can be in expanded state.
       
   218      */
       
   219     virtual TBool IsExtendable( );
       
   220     
       
   221     /**
       
   222      * From MFsTreeItemVisualizer
       
   223      * Returns an information if item can be focused.
       
   224      * 
       
   225      * @return ETrue if item can be focused.
       
   226      */
       
   227     virtual TBool IsFocusable( ) const;
       
   228     
       
   229     /**
       
   230      * From MFsTreeItemVisualizer
       
   231      * Used to set/unset item's ability to receive focus.
       
   232      * 
       
   233      * @param aFlag ETrue if item can be focused.
       
   234      */
       
   235     virtual void SetFocusable( const TBool aFlag );
       
   236     
       
   237     /**
       
   238      * From MFsTreeItemVisualizer.
       
   239      * Sets the size of the item visualization area when item is in expanded 
       
   240      * state. 
       
   241      * 
       
   242      * @param aSize Size in pixels of the item when it is expanded.
       
   243      */
       
   244     virtual void SetExtendedSize( const TSize aSize );
       
   245     
       
   246     /**
       
   247      * From MFsTreeItemVisualizer.
       
   248      * Returns the size of an item in expanded state.
       
   249      * 
       
   250      * @return Size in pixels of the item when it is in expanded state.
       
   251      */
       
   252     virtual TSize ExtendedSize() const;
       
   253         
       
   254     /**
       
   255      * From MFsTreeItemVisualizer.
       
   256      * Sets visualized item's state to hidden/visible.
       
   257      * 
       
   258      * @param ETrue if item should be visualized as hidden.
       
   259      */
       
   260     virtual void SetHidden( TBool aFlag );
       
   261     
       
   262     /**
       
   263      * From MFsTreeItemVisualizer.
       
   264      * Returns an information if the item is hidden or not.
       
   265      * 
       
   266      * @return ETrue if item is hiddden, EFalse if item is visible.
       
   267      */
       
   268     virtual TBool IsHidden() ;
       
   269     
       
   270     /**
       
   271      * From MFsTreeItemVisualizer.
       
   272      * Enables or disables text shadow.
       
   273      * 
       
   274      * @param aShadowOn Pass ETrue if shadow should be enabled 
       
   275      * EFalse otherwise.
       
   276      */
       
   277     virtual void EnableTextShadow( const TBool aShadowOn = ETrue );
       
   278     
       
   279     /**
       
   280      * From MFsTreeItemVisualizer.
       
   281      * Sets text indentation.
       
   282      *
       
   283      * @param aIndentation Indentation in pixels.
       
   284      */
       
   285     virtual void SetIndentation( const TInt aIndentation = 0 );
       
   286     
       
   287     /**
       
   288      * From MFsTreeItemVisualizer.
       
   289      * Sets item background color.
       
   290      * 
       
   291      * @param aColor New background color.
       
   292      */
       
   293     virtual void SetBackgroundColor( const TRgb aColor );
       
   294     
       
   295     /**
       
   296      * From MFsTreeItemVisualizer.
       
   297      * Returns background color if it's set.
       
   298      * 
       
   299      * @param aColor Out parameter. Contains background color.
       
   300      * 
       
   301      * @return ETrue if background color is set, EFalse otherwise.
       
   302      */
       
   303     virtual TBool GetBackgroundColor( TRgb& aColor );
       
   304         
       
   305     /**
       
   306      * From MFsTreeItemVisualizer.
       
   307      * Sets item background texture.
       
   308      * 
       
   309      * @param aTexture New background texture.
       
   310      */
       
   311     virtual void SetBackgroundTexture( const CAlfTexture& aTexture );
       
   312 
       
   313     // <cmail>
       
   314     /**
       
   315      * From MFsTreeItemVisualizer.
       
   316      * Sets item background brush. Ownership not transfered.
       
   317      * 
       
   318      * @param aBrush New background brush.
       
   319      */
       
   320     virtual void SetBackgroundBrush( CAlfBrush* aBrush );
       
   321 
       
   322     /**
       
   323      * From MFsTreeItemVisualizer.
       
   324      * Returns item background brush.
       
   325      * 
       
   326      * @param aBrush Out parameter. Contains pointer to a background brush.
       
   327      *
       
   328      * @return ETrue if background brush is set, EFalse otherwise.
       
   329      */
       
   330     virtual TBool GetBackgroundBrush( CAlfBrush*& aBrush );
       
   331     // </cmail>
       
   332 
       
   333     /**
       
   334      * From MFsTreeItemVisualizer.
       
   335      * Returns background texture if it's set.
       
   336      * 
       
   337      * @param aTexture Out parameter. Contains pointer to a texture.
       
   338      * 
       
   339      * @return ETrue if background texture is set, EFalse otherwise.
       
   340      */
       
   341     virtual TBool GetBackgroundTexture( const CAlfTexture*& aTexture );
       
   342     
       
   343     /**
       
   344      * From MFsTreeItemVisualizer.
       
   345      * Clears item background.
       
   346      */
       
   347     virtual void ClearBackground( );
       
   348     
       
   349     /**
       
   350      * Sets menu for item
       
   351      * @param aMenu CTreeList object containing menu items
       
   352      */
       
   353     virtual void SetMenu( CFsTreeList* aMenu );
       
   354      
       
   355     /**
       
   356      * Returns CFsTreeList object contaning menu items
       
   357      * @return Menu for item.
       
   358      */
       
   359     virtual CFsTreeList* Menu() const;
       
   360     
       
   361     /**
       
   362      * This functions sets wether an item should always be in extended state.
       
   363      * 
       
   364      * @param ETrue if item should always be in extended state.
       
   365      */
       
   366     virtual void SetAlwaysExtended( TBool aAlwaysExtended );
       
   367     
       
   368     /**
       
   369      * This function returns wether an item is always in extended state.
       
   370      * 
       
   371      * @return ETrue if item is always in extended state.
       
   372      */
       
   373     virtual TBool IsAlwaysExtended( ) const;
       
   374     
       
   375     /**
       
   376      * Sets the text style manager for the item visualizer.
       
   377      * 
       
   378      * @param aManager Reference to the text style manager.
       
   379      */
       
   380     virtual void SetTextStyleManager( CFsAlfTextStyleManager& aManager );
       
   381     
       
   382     /**
       
   383      * Sets the text stroke weight for the item visualizer.
       
   384      * 
       
   385      * @param aIsBold ETrue if the text shoul be bold.
       
   386      */
       
   387     virtual void SetTextBold( const TBool aIsBold );
       
   388     
       
   389     /**
       
   390      * Gets the text stroke weight for the item visualizer.
       
   391      * 
       
   392      * @return ETrue if the text is be bold.
       
   393      */
       
   394     virtual TBool IsTextBold( ) const;
       
   395     
       
   396     
       
   397     /**
       
   398      * Method to set text font height in twips.
       
   399      * 
       
   400      * @param aHeightInTwips Text font height to be set.
       
   401      */
       
   402     virtual void SetFontHeight(const TInt aHeightInTwips);
       
   403     
       
   404     /**
       
   405      * Gets height of a text font in twips.
       
   406      * 
       
   407      * @return Height of the font in twips
       
   408      */
       
   409     virtual TInt FontHeight() const;
       
   410     
       
   411     /**
       
   412      * Method to set text font height in pixels.
       
   413      * 
       
   414      * @param aHeightInPixels Text font height to be set.
       
   415      */
       
   416     virtual void SetFontHeightInPixels(const TInt aHeightInPixels);
       
   417     
       
   418     /**
       
   419      * Gets height of a text font in pixels.
       
   420      * 
       
   421      * @return Height of the font in pixels.
       
   422      */
       
   423     virtual TInt FontHeightInPixels() const;
       
   424     
       
   425     /**
       
   426      * 
       
   427      */
       
   428     virtual CAlfLayout& Layout() const;
       
   429 
       
   430     /**
       
   431      * 
       
   432      */
       
   433     virtual void ShowL( CAlfLayout& aParentLayout,
       
   434             const TUint aTimeout = 0 );
       
   435     
       
   436     /**
       
   437      * 
       
   438      */
       
   439     virtual void UpdateL( const MFsTreeItemData& aData,
       
   440             TBool aFocused,
       
   441             const TUint aLevel,
       
   442             CAlfTexture*& aMarkIcon,
       
   443             CAlfTexture*& aMenuIcon,
       
   444             const TUint aTimeout = 0,
       
   445             TBool aUpdateData = ETrue);
       
   446 
       
   447     /**
       
   448      * 
       
   449      */
       
   450     virtual void Hide( const TInt aTimeout = 0 );
       
   451     
       
   452     /**
       
   453      * This method marquees the text in tree item if it is too long.
       
   454      * 
       
   455      * @param aMarqueeType Type of marquee.
       
   456      * @param aMarqueeSpeed Speed of marquee in pixels per second.
       
   457      * @param aMarqueeStartDelay Marquee's start delay in miliseconds.
       
   458      * @param aMarqueeCycleStartDelay Marquee cycle's start delay.
       
   459      * @param aMarqueeRepetitions Number of marquee's cycles.
       
   460      */
       
   461     virtual void MarqueeL(const TFsTextMarqueeType aMarqueeType,
       
   462                           const TUint aMarqueeSpeed,
       
   463                           const TInt aMarqueeStartDelay,
       
   464                           const TInt aMarqueeCycleStartDelay,
       
   465                           const TInt aMarqueeRepetitions);
       
   466     
       
   467     /**
       
   468      * 
       
   469      */
       
   470     virtual TBool OfferEventL(const TAlfEvent& aEvent);
       
   471     	        
       
   472 public: //from base class MFsTreeNodeVisualizer
       
   473 
       
   474     /**
       
   475      * From MFsTreeNodeVisualizer.
       
   476      * Sets visualized node's state to rolled/unrolled.
       
   477      * 
       
   478      * @param aFlag ETrue to visualize node as rolled (collapsed).
       
   479      */
       
   480     virtual void SetExpanded( TBool aFlag, const MFsTreeItemData* aData = 0 );
       
   481     
       
   482     /**
       
   483      * From MFsTreeNodeVisualizer.
       
   484      * Returns rolled/unrolled state of the node's visualization.
       
   485      * 
       
   486      * @return ETrue if node is visualized as rolled (collapsed).
       
   487      */
       
   488     virtual TBool IsExpanded() const;
       
   489     
       
   490     
       
   491 protected:
       
   492     
       
   493     /**
       
   494      * C++ constructor
       
   495      */
       
   496     CFsTreeNodeVisualizerBase(CAlfControl& aOwnerControl);
       
   497     
       
   498     /**
       
   499      * Second phase constructor
       
   500      *
       
   501      */
       
   502     void ConstructL( );
       
   503     
       
   504     
       
   505 protected:
       
   506 
       
   507     /**
       
   508      * Function gets text color for a focused item. The color is taken from 
       
   509      * the skin if skin support is on, if not then a default value is used.
       
   510      * 
       
   511      * @return aTextColor Text's color.
       
   512      */
       
   513     virtual TRgb FocusedStateTextSkinColor( );
       
   514     
       
   515     /**
       
   516      * Function gets text color for a non focused item. The color is taken 
       
   517      * from the skin if skin support is on, if not then a default value is 
       
   518      * used.
       
   519      * 
       
   520      * @return aTextColor Text's color.
       
   521      */
       
   522     virtual TRgb NormalStateTextSkinColor( );
       
   523         
       
   524     /**
       
   525      * Returns horizontal alignment of the displayed text in respect to
       
   526      * current layout.
       
   527      * 
       
   528      * For AH layout EAlfAlignHLeft is internally converted to EAlfAlignHRight
       
   529      * and EAlfAlignHRight is converted to EAlfAlignHLeft.
       
   530      * 
       
   531      * @param aAlign Horizontal text alignment type.
       
   532          */
       
   533     virtual TAlfAlignHorizontal CurrentTextAlignmentL( TAlfAlignHorizontal aAlignment,
       
   534                                                        TDesC* aText,
       
   535                                                        CAlfTextVisual* aVisual);
       
   536     /**
       
   537      * Returns text style id used in the node.
       
   538      */
       
   539     virtual TInt ModifiedStyleIdL( ) const;
       
   540     
       
   541 public:
       
   542     /*
       
   543      * Layouting hints for the visualizers. Hints are binary flags so they can be mixed.
       
   544      */
       
   545     enum TLayoutHint
       
   546         {
       
   547         ENormalLayout = 0,
       
   548         // Use folder layout for item visualizers
       
   549         EFolderLayout = (1<<0),
       
   550         // Item visualizers are in popup
       
   551         EPopupLayout = (1<<1)
       
   552         };    
       
   553     
       
   554     
       
   555 public:
       
   556     
       
   557     // Set layout hint(s). Given hints are ORed so previously set flags will remain.
       
   558     virtual void SetLayoutHints( const TUint aHints );
       
   559     
       
   560     /**
       
   561      * Check if given layout hint is set.
       
   562      */    
       
   563     virtual TBool IsLayoutHintSet( const TLayoutHint aHint ) const;    
       
   564     
       
   565 protected:
       
   566 
       
   567     enum TFsNodeBackgroundState
       
   568         {
       
   569         EFsNodeBackgroundNone,
       
   570         EFsNodeBackgroundColor,
       
   571         EFsNodeBackgroundTexture,
       
   572     // <cmail> this feature is waiting for title divider bg graphics
       
   573         EFsNodeBackgroundBrush       
       
   574     // </cmail>
       
   575         };
       
   576     
       
   577 protected:
       
   578 
       
   579     /*
       
   580      * A parent control for the tree visualizer.
       
   581      */
       
   582     CAlfControl& iOwnerControl;
       
   583     
       
   584     /*
       
   585      * Parent layout of the item layout, typically list layout.
       
   586      * Not own.
       
   587      */
       
   588     CAlfLayout* iParentLayout;
       
   589     
       
   590     /**
       
   591      * Main layout for the plain text item.
       
   592      * Own.
       
   593      */
       
   594     CAlfAnchorLayout* iLayout;
       
   595     
       
   596     /*
       
   597      * Visualizer's state flag.
       
   598      */
       
   599     TUint32 iFlags;
       
   600     
       
   601     /*
       
   602      * Horizontal text alignment in visual.
       
   603      */
       
   604     TAlfAlignHorizontal iTextAlign;
       
   605     
       
   606     /*
       
   607      * Item's size.
       
   608      */
       
   609     TSize iSize;
       
   610     
       
   611     /*
       
   612      * Item's extended size.
       
   613      */
       
   614     TSize iExtendedSize;
       
   615     
       
   616     /**
       
   617      * CFsTreeList containing menu for item
       
   618      */
       
   619     CFsTreeList* iMenu;
       
   620      
       
   621     /**
       
   622      * Text indetation in pixels.
       
   623      */
       
   624     TInt iTextIndentation;
       
   625     
       
   626     /**
       
   627      * Custom color set for a text in normal state. 
       
   628      * ETrue custom color set, EFalse use color from the skin. 
       
   629      */
       
   630     TBool iIsCustomTextNormalColor;
       
   631     
       
   632     /**
       
   633      * Text's color in normal (unfocused) state.
       
   634      */
       
   635     TRgb iNormalTextColor;
       
   636     
       
   637     /**
       
   638      * Custom color set for a text in focused state. 
       
   639      * ETrue custom color set, EFalse use color from the skin.
       
   640      */    
       
   641     TBool iIsCustomTextFocusedColor;
       
   642     
       
   643     /**
       
   644      * Text's color in focused state.
       
   645      */
       
   646     TRgb iFocusedTextColor;
       
   647     
       
   648     /**
       
   649      * Text's style. The id comes from CHuiTextStyleManager.
       
   650      */
       
   651     TInt iTextStyleId;
       
   652     
       
   653     /**
       
   654      * ETrue if custom text style is used. EFalse text style taken from layout manager.
       
   655      */
       
   656     TBool iIsCustomTextStyle;
       
   657     
       
   658     /**
       
   659      * Item's text style manager.
       
   660      */
       
   661     CFsAlfTextStyleManager* iTextStyleManager;
       
   662     
       
   663     /**
       
   664      * Font height
       
   665      */
       
   666     TInt iFontHeight;
       
   667     
       
   668     /**
       
   669      * State of the background: clear, color, texture.
       
   670      */
       
   671     TFsNodeBackgroundState iBackgroundState;
       
   672     
       
   673     /*
       
   674      * Background color.
       
   675      */
       
   676     TRgb iBackgroundColor;
       
   677     
       
   678     /**
       
   679      * Background texture.
       
   680      * Not own.
       
   681      */
       
   682     const CAlfTexture* iBackgroundTexture;
       
   683 
       
   684     /**
       
   685      * Background brush.
       
   686      * Not own.
       
   687      */
       
   688     CAlfBrush* iBackgroundBrush;
       
   689     
       
   690     /*
       
   691      * Layout hints.
       
   692      */
       
   693     TUint iLayoutHints;
       
   694     };
       
   695 
       
   696 
       
   697 #endif /*FSTREENODEVISUALIZERBASE_H_*/