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_*/