/*

* Copyright (c) 2002-2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  

*

*/

//

// EIKFRLBD.H

//

// Copyright (c) 2001 Symbian Ltd.  All rights reserved.

//

#if !defined(__EIKFRLBD_H__)

#define __EIKFRLBD_H__

#include <e32base.h>

#include <gdi.h>

#include <eiklbd.h>

#include <eikfrlb.h>

#include <avkon.hrh>

#include <AknsDrawUtils.h> // for TAknsQsnTextColorsIndex

#include <babitflags.h>    // for TBitFlags32

class CWindowGc;

class CGulIcon;

class CFormattedCellListBoxDataExtension;

class MAknsControlContext;

class TAknsItemID;

class CAknLayoutData;

class CAknsEffectAnim;

class TAknTextLineLayout;

class TAknWindowLineLayout;

class TAknTextComponentLayout;

class TAknWindowComponentLayout;

/**

* A callback interface for overriding highlight animation input layer

* preparation in derived classes. Usually drawing the background under the

* highlight rect will yield the right kind of result. The size of the render

* target is equal to item cell size.

*

* @since 3.0

*/

class MListBoxAnimBackgroundDrawer

    {

    public:

    /**

     * @param aGc Bitmapped graphical context to draw to.

     * @return 

     */ 

        virtual TBool DrawHighlightAnimBackground( CFbsBitGc& aGc ) const = 0;

    };

/**

 * @c CFormattedCellListBoxData can draw list items.

 * This is similar class than @c CColumnListBoxData, but it can more freely

 * layout the list items; more parameters can be used to position the elements.

 * In particular, the position of the elements is free, and not tied to fixed

 * width columns.

 *

 * This class is used to draw most of the S60 list and grid layouts.

 *

 * It also handles truncation of the text elements, centering and cropping of

 * images, z-order/overlapping cells, bi-directional text drawing, backgrounds

 * for lists, highlight drawing, various text and image properties and finally

 * the parts of the separator lines that are inside list items.

 *

 * This is a very low level class. The less you use this class, the better.

 * Applications should be using @c CAknSelectionListDialog or

 * @c CAknMarkableListDialog or @c CAknListQueryDialog to use lists. There are

 * enough predefined list layouts available, so there should be no need for

 * applications to use this class. See Style Guide for more information. Use of

 * this class may cause your application to not look ok when properties of the

 * device change.

 *

 * @lib avkon

 */

class CFormattedCellListBoxData : public CListBoxData

    {

    friend class CFormattedCellListBoxDataExtension;

public:

    //INNER CLASS DECLARATION

    /*

     * A container class for storage of colour values.                           

     * Used by @c CFormattedCellListBoxData.

     */

    class TColors

        {

    public:

        /**

         * C++ default constructor.

         */

        IMPORT_C TColors();

    public:

        /** 

         * The text colour.

         */

        TRgb iText;

        /** 

         * The background colour.

         */

        TRgb iBack;

        /** 

         * The highlighted text colour.

         */

        TRgb iHighlightedText;

        /** 

         * The highlighted background colour.

         */

        TRgb iHighlightedBack;

        /** 

         * The separator line colour.

         *

         * @deprecated The separator line colour is no longer used because the

         *             separator lines are skinned.

         */

        TRgb iRightSeparatorColor;

        };

public:

    /**

     * Two-phased constructor.

     *

     * @return Pointer to a new formatted cell listbox data object.

     */

    IMPORT_C static CFormattedCellListBoxData* NewL();

    /**

     * Destructor.

     */

    IMPORT_C ~CFormattedCellListBoxData();

public:

    /**

     * Gets colours attached to the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Text and background colors.

     */

    IMPORT_C const TColors& SubCellColors(TInt aSubCellIndex) const;

    /**

     * Sets colours attached to the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aColors Text and background colors.

     */

    IMPORT_C void SetSubCellColorsL(TInt aSubCellIndex, const TColors &aColors);

    /**

     * Gets baseline position from top of the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Baseline y-position.

     */

    IMPORT_C TInt SubCellBaselinePos(TInt aSubCellIndex) const;

    /**

     * Sets baseline position from top of the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aPos Position which is set for the item.

     */

    IMPORT_C void SetSubCellBaselinePosL(TInt aSubCellIndex, TInt aPos);

    /**

     * Gets cell size in pixels.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Cell size.

     */

    IMPORT_C TSize SubCellSize(TInt aSubCellIndex) const;

    /**

     * Sets cell size in pixels.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aSize Cell size.

     */

    IMPORT_C void SetSubCellSizeL(TInt aSubCellIndex, TSize aSize);

    /**

     * Gets cell position inside an item.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Cell position.

     */

    IMPORT_C TPoint SubCellPosition(TInt aSubCellIndex) const;

    /**

     * Sets cell position inside an item.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aPosition New position for cell.

     */

    IMPORT_C void SetSubCellPositionL(TInt aSubCellIndex, TPoint aPosition);

    /**

     * Determines whether this cell can overlap with one of the previous cells.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return @c ETrue if cell overlaps another one, @c EFalse if cell allocates 

     *         area from other cells.

     */

    IMPORT_C TBool SubCellIsTransparent(TInt aSubCellIndex) const;

    /**

     * Modifies whether the cell can overlap with one of the previous cells.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aIsTransparent @c ETrue if transparent, @c EFalse if not.

     */

    IMPORT_C void SetTransparentSubCellL(TInt aSubCellIndex, 

                                         TBool aIsTransparent);

    /**

     * Checks whether drawing algorithm always draws the cell or whether empty 

     * string in list item can disable the drawing of the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return @c ETrue when empty string disables cell, 

     *         @c EFalse if always drawn.

     */

    IMPORT_C TBool SubCellIsNotAlwaysDrawn(TInt aSubCellIndex) const;

    /**

     * Sets whether drawing algorithm always draws the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aIsNotAlwaysDrawn If @c ETrue, empty string disables cell.

     */

    IMPORT_C void SetNotAlwaysDrawnSubCellL(TInt aSubCellIndex,

                                            TBool aIsNotAlwaysDrawn);

    /**

     * Gets margins used for the content inside the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Margins in pixels.

     */

    IMPORT_C TMargins SubCellMargins(TInt aSubCellIndex) const;

    /**

     * Sets margins for the content inside the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aMargins Margins for the content inside the cell.

     */

    IMPORT_C void SetSubCellMarginsL(TInt aSubCellIndex, TMargins aMargins);

    /**

     * Gets font attached to the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Handle to the attached font.

     */

    IMPORT_C const CFont* SubCellFont(TInt aSubCellIndex) const;

    /**

     * Sets the font attached to the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aFont Font to attach to the cell.

     */

    IMPORT_C void SetSubCellFontL(TInt aSubCellIndex, const CFont* aFont);

    /**

     * Gets the alignment attached to the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Alignment of the text.

     */

    IMPORT_C CGraphicsContext::TTextAlign SubCellAlignment(TInt aSubCellIndex)

        const;

    /**

     * Sets the alignment attached to the cell.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aAlign Alignment that is attached to the cell

     */

    IMPORT_C void SetSubCellAlignmentL(TInt aSubCellIndex,

                                       CGraphicsContext::TTextAlign aAlign);

    /**

     * Checks whetherdrawing algorithm considers the text

     * string in list item as unicode text string displayable on the screen,

     * or as string representation of an index to icon array.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return @c ETrue if graphics cell, @c EFalse if text cell.

     */

    IMPORT_C TBool SubCellIsGraphics(TInt aSubCellIndex) const;

    /**

     * Sets whether drawing algorithm considers the text string in list item as

     * unicode text string displayable on the screen, or as string 

     * representation of an index to icon array.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aIsGraphics @c ETrue if graphics cell, @c EFalse if text cell.

     */

    IMPORT_C void SetGraphicsSubCellL(TInt aSubCellIndex, TBool aIsGraphics);

    /**

     * Checks whether vertical line is drawn to the right side of the cell.

     *

     * @param aColumn Index number of the subcell.

     * @return Style of pen used to draw a line for the right side of the cell.

     */

    IMPORT_C CGraphicsContext::TPenStyle 

        SubCellRightSeparatorStyle(TInt aColumn) const;

    /**

     * Sets whether vertical line is drawn to the right side of the cell.

     *

     * @param aSubCell Index number of the subcell.

     * @param aStyle Style of a pen used to draw a line for the right side of 

     *        the cell.

     */

    IMPORT_C void SetSubCellRightSeparatorStyleL(TInt aSubCell,

                                            CGraphicsContext::TPenStyle aStyle);

    /**

     * Gets the amount of pixels text margins is grown if it is truncated. 

     * This is usually very small number used to make the layout look more 

     * balanced when text is truncated. (the glyph used for truncation is 

     * almost empty and on narrow text elements, it looks odd if the truncated

     * text element is exactly same size as non-truncated version.)

     *

     * @param aSubCellIndex Index number of the subcell.

     * @return Amount of pixels that are used for growing the text margins in 

     *         truncation.

     */

    IMPORT_C TInt SubCellTextClipGap(TInt aSubCellIndex) const;

    /**

     * Sets the amount of pixels truncation grows a text element.

     *

     * @param aSubCellIndex Index number of the subcell.

     * @param aGap The amount of pixels that are required for growing the text 

     *        element when it is truncated. 

     */

    IMPORT_C void SetSubCellTextClipGapL(TInt aSubCellIndex, TInt aGap);

    /**

     * SkinEnabled checks whether skins are enabled on this list.

     *

     * @since Symbian 2.0 

     * @return @c ETrue if enabled, @c EFalse if disabled.

     */

    IMPORT_C TBool SkinEnabled() const;

    /**

     * Sets whether skins are enabled on this list.

     * The default value is determined from global setting from @c CAknAppUi.

     *

     * @since Symbian 2.0

     * @param aEnabled If @c ETrue skins are set enabled. 

     *        If @c EFalse skins are set disabled.

     */

    IMPORT_C void SetSkinEnabledL(TBool aEnabled);

    /**

     * Checks whether the cell is used for numbers.

     *

     * @since Symbian 2.0

     * @param aSubCellIndex Index number of the subcell.

     * @return @c ETrue if enabled, @c EFalse if disabled.

     */

    IMPORT_C TBool SubCellIsNumberCell(TInt aSubCellIndex) const;

    /**

     * Sets whether the cell is used for numbers.

     *

     * @since Symbian 2.0

     * @param aSubCellIndex Index number of the subcell.

     * @param aIsNumberCell New value for the flag.

     */

    IMPORT_C void SetNumberCellL(TInt aSubCellIndex, TBool aIsNumberCell);

    /**

     * Gets the icon array used when drawing bitmaps for the listbox items.

     */

    IMPORT_C CArrayPtr<CGulIcon>* IconArray() const;

    /**

     * Sets the icon array used when drawing bitmaps.

     * The array can be modified (no need to call this method when modifying),

     * even in @c MdcaPoint() or @c MdcaCount() methods of @c MDesCArray class.

     * See also @c CTextListBoxModel::SetItemTextArray().

     * 

     * The most common way to crash a listbox is by forgetting to call this 

     * method, or the list item string for graphics cell is not an index of 

     * a bitmap.

     *

     * @param aArray Pointer to the icon array.

     */

    IMPORT_C void SetIconArrayL(CArrayPtr<CGulIcon>* aArray);

    /**

     * SetIconArray sets the icon array used when drawing bitmaps.

     * The array can be modified (no need to call this method when modifying),

     * even in @c MdcaPoint() or @c MdcaCount() methods of @c MDesCArray class.

     * See also @c CTextListBoxModel::SetItemTextArray().

     * 

     * The most common way to crash a listbox is by forgetting to call this

     * method, or the list item string for graphics cell is not an index of

     * a bitmap.

     *

     * @param aArray Pointer to the icon array.

     */

    IMPORT_C void SetIconArray(CArrayPtr<CGulIcon>* aArray);

    /**

     * Font access to the font used in subcell.

     *

     * @param aItemProperties Not used in code.

     * @param aSubCellIndex Index number of the subcell.

     * @return Font used in subcell.

     */

    IMPORT_C CFont* Font(const TListItemProperties& aItemProperties,

                         TInt aSubCellIndex) const;

    /**

     * From @c CListBoxData.

     *

     * @c Draw() is the most important method in 

     * @c CEikFormattedCellListBoxData.

     * This is the only method that needs to be implemented in this class and

     * it draws the whole list item.

     *

     * @param aProperties Properties attached to the list item.

     * @param aGc Graphics Context used for drawing the list item.

     * @param aText A text string describing the list item cells.

     * @param aRect The area of the screen for the whole list item.

     * @param aHighlight Whether the list item is selected.

     * @param aColors The colours used for drawing the item.

     */

    IMPORT_C virtual void Draw(TListItemProperties aProperties,

                               CWindowGc& aGc,

                               const TDesC* aText,

                               const TRect& aRect,

                               TBool aHighlight,

                               const TColors& aColors) const;

    /**

     * Indicates if sub cell is using its own colors rather than common colors.

     *

     * @param aSubCell Index number of the subcell.

     * @return Boolean indicating whether own colors enabled.

     *         @c ETrue enabled, @c EFalse disabled.

     */

    IMPORT_C TBool UseSubCellColors(TInt aSubCell) const;

    /**

     * Ability for a skin subsystem to access Mop chain through current 

     * listbox control.

     *

     * @since Symbian 2.0

     * @return Current listbox instance or NULL.

     */

    IMPORT_C CCoeControl* Control() const;

    /**

     * Ability for a skin subsystem to access mop chain through current listbox

     * control.

     *

     * @since Symbian 2.0

     * @param aControlOrNull Current listbox instance or NULL. Cannot be other

     *        control than the current listbox!

     */

    IMPORT_C void SetControl(CCoeControl* aControlOrNull);

    /**

     * Access to the background context of the listbox.

     *

     * @since Symbian 2.0

     * @return Skin background context.

     */

    IMPORT_C MAknsControlContext* SkinBackgroundContext() const;

    /**

     * Modify properties of the skin context (background).

     *

     * @since Symbian 2.0

     * @param aId Skin background identifier.

     * @param aRect Skin background rectangle.

     */

    IMPORT_C void SetBackgroundSkinStyle(const TAknsItemID *aId,

                                         const TRect &aRect);

    /**

     * Modify properties of the skin context (AB-column).

     *

     * @since Symbian 2.0

     * @param aId Skin background identifier.

     * @param aTileRect Skin background area from LAF.

     */

    IMPORT_C void SetSkinStyle(const TAknsItemID* aId, const TRect& aTileRect);

    /**

     * Modify position of the parent for list default context.

     *

     * @since Symbian 2.0

     * @param aPos The new position.

     */

    IMPORT_C void SetSkinParentPos(const TPoint& aPos);

    /**

     * Modify properties of the skin context (list ending)*

     * @since Symbian 2.0

     * @param listEndId List ending skin background identifier.

     * @param aRect List ending background area from LAF.

     */

    IMPORT_C void SetListEndSkinStyle(const TAknsItemID *listEndId,

                                      const TRect &aRect);

    /**

     * Gets RespectFocus flag.

     *

     * @return RespectFocus flag. @c ETrue if list item highlights are only 

     *         shown  when the list is has been focused on.

     */

    IMPORT_C TBool RespectFocus() const;

    /**

     * Sets RespectFocus flag.

     *

     * @param aBool Value of RespectFocus flag. @c ETrue means that the 

     *        list item highlight is only shown if list is focused on.

     */

    IMPORT_C void SetRespectFocus(TBool aBool);

    /**

     * Set list higlight skin style.

     *

     * @since Symbian 2.0

     * @param aFrameId The id for the frame.

     * @param aFrameCenterId The id for the frame center.

     */

    IMPORT_C void SetSkinHighlightFrame(const TAknsItemID* aFrameId,

                                        const TAknsItemID* aFrameCenterId);

    /**

     * Set popup skin style.

     *

     * @since Symbian 2.0

     * @param aFrameId The id for the frame.

     * @param aFrameCenterId The id for the frame center.

     */

    IMPORT_C void SetSkinPopupFrame(const TAknsItemID* aFrameId, 

                                    const TAknsItemID* aFrameCenterId);

    /**

     * Set popup skin frame position.

     *

     * @since Symbian 2.0

     * @param aOuterRect Outer position of the frame.

     * @param aInnerRect Inner position of the frame.

     */

    IMPORT_C void SetSkinPopupFramePosition(const TRect& aOuterRect,

                                            const TRect& aInnerRect);

    /**

     * Enable or disable logical to visual reordering in listbox data text

     * drawing. By default, it is enabled. This has any effect only when

     * bidirectional text is rendered.

     *

     * If you convert text to visual order prior to passing it to the listbox

     * (for example by wrapping text to lines with methods in

     * @c AknBidiTextUtils), then you should disable conversion in listbox by

     * calling this method.

     *

     * @since Symbian 2.0

     * @param aUseConversion Enable (@c ETrue) or disable 

     *        (@c EFalse) conversion.

     */

    IMPORT_C void UseLogicalToVisualConversion( TBool aUseConversion );

    /**

     * Enables or disables marquee.

     *

     * @param aEnable @c ETrue if On, @c EFalse if Off.

     */

    IMPORT_C void EnableMarqueeL(TBool aEnable);

    /**

     * Determines if marquee is on.

     *

     * @return Flag indicating if marquee is on (@c ETrue on, @c EFalse off)  

     */

#ifdef __WINS__

    IMPORT_C const TBool IsMarqueeOn();

#else

    IMPORT_C TBool IsMarqueeOn();

#endif // __WINS__

    /**

     * Function that is called when the owning control has gained the focus.

     * Causes that animation is continued because the control is visible and

     * focused.

     */

    void FocusGained();

    /**

     * Function that is called when the owning control has lost the focus.

     * Causes the animation to pause, even if the control is partially

     * visible.

     */

    void FocusLost();

    /**

     * Handles the skin change situation. Causes change of animation.

     *

     * @param aType Type of resource change.

     */

    void HandleResourceChange( TInt aType );

    /**

     * Gets animation used for drawing the list highlight.

     * May return NULL, in which case the normal skinned highlight should be

     * drawn. This pointer is valid only during the draw -> you should not

     * store it locally outside draw scope.

     *

     * @return Animation used for drawing the list highlight.

     */

    IMPORT_C const CAknsEffectAnim* HighlightAnim() const;

    /**

     * This method should be called before drawing animated highlight. It will

     * sync the animation with the background under the current highlight (only

     * when current item index has changed).

     */

    IMPORT_C void AboutToDrawHighlightAnim() const;

    /**

     * Sets the observer for overriding default highlight input layer drawing

     * functionality. Note that you should still call 

     * @c AboutToDrawHighlightAnim (it will call the observer if it is set).

     *

     * @param aDrawer Highlight animation drawer.

     */

    IMPORT_C void SetHighlightAnimBackgroundDrawer( 

                                       MListBoxAnimBackgroundDrawer* aDrawer );

    /**

     * Changes item cell size and resizes highlight animation. Called by list

     * when item cell size changes. If you are using non-standard highlight 

     * sizes make sure to sync the list item cell size.

     *

     * @param aSize New cell size.

     */

    IMPORT_C void SetItemCellSize( const TSize& aSize );

    /**

    * @return ETrue if highlight animation exists, EFalse otherwise.

    *

    * @since 3.1

    */

    IMPORT_C TBool HasHighlightAnim() const;

    /**

    * The preferred method for drawing highlight animation in derived classes.

    * Before calling this method you should check that highlight animation

    * exists by calling HasHighlightAnim. In case of draw failure you should

    * default to normal skinned highlight drawing. For example:

    *

    * TBool drawOk = EFalse;

    *

    * if( HasHighlightAnim() )

    *     {

    *     drawOk = DrawHighlightAnim( gc, rect );

    *     }

    *

    * if( !drawOk )

    *     {

    *     ...do normal skinned draw

    *     }

    *

    * @param aGc   Graphics context for blitting animation frame

    * @param aRect Target rect for blitting animation frame

    * @return The draw status, ETrue if drawing was ok, EFalse otherwise.

    *

    * @since 3.1

    */

    IMPORT_C TBool DrawHighlightAnim( CBitmapContext& aGc, const TRect& aRect ) const;

    /**

    * Creates pictograph interface.

    * Only effective in Japanese variant.

    * Called by the listbox.

    */

    void CreatePictographInterfaceL();

    /**

     * Creates marquee control.

     * Called by the listbox.

     */

    void CreateMarqueeControlL();

    /**

     * Resets the marquee animation data.

     */

    void ResetMarquee();

    /**

     * Gets the current list item index that is / was drawn by marquee.

     *

     * @return Index of the item that is / was drawn by marquee.

     */

    TInt CurrentMarqueeItemIndex();

    /**

     * Sets the current list item index that was drawn by marquee.

     *

     * @param aIndex Index of list item.

     */

    void SetCurrentMarqueeItemIndex(TInt aIndex);

    /**

     * Sets the current list item index (not for marquee). Since Symbian 3.0 

     * causes highlight animation to change its background (only if the current

     * item index changes). Don't call this method if the index is not the 

     * current item index.

     *

     * @param aIndex Index number of list item.

     */

    void SetCurrentItemIndex(TInt aIndex);

    // previous method was used both as current item index AND as currently

    // drawn item index. Not really good idea.

    void SetCurrentlyDrawnItemIndex( TInt aIndex );

    /**

     * Sets the font attached to the cell for each row separately.

     *

     * @param aRowIndex Row, which subcells are to be changed.

     * @param aSubCellIndex Index number of the subcell.

     * @param aFont Font to be used.

     */

    IMPORT_C void SetSubCellFontForRowL(TInt aRowIndex, 

                                        TInt aSubCellIndex, 

                                        const CFont* aFont);

    /**

     * Gets font attached to the row and cell.

     *

     * @param aRow Index number of the row.

     * @param aSubCellIndex Index number of the subcell.

     * @return Font handle.

     */

    IMPORT_C const CFont* RowAndSubCellFont(TInt aRow, 

                                            TInt aSubCellIndex) const;

    /**

     * Enables or disables transparency effect i.e. does the listbox draw its

     * own background or not.

     *

     * @param aDrawBackground @c EFalse enables transparency, @c ETrue disables.

     */ 

    IMPORT_C void SetDrawBackground(const TBool aDrawBackground);

    /**

     * Checks if the list is transparent and drawing the background 

     * that would fall behind it.

     * 

     * @return @c EFalse if transparent, @c ETrue otherwise.

     */ 

    TBool IsBackgroundDrawingEnabled() const;

    /**

     * Enables or disables drawing background after scrollbar.

     *

     * @param aDrawBackground Default is @c ETrue which means that Scrollbar

     *        is drawn first.

     */ 

    void SetDrawScrollbarBackground(const TBool aDrawBackground);

    /**

     * Is the listbox drawing the background behind the scrollbar or not.

     *

     * @return @c ETrue if background is drawn after scrollbar, @c EFalse

     *         otherwise. 

     */ 

    TBool IsScrollbarBackgroundDrawingEnabled() const;

    /**

     * Sets position of listbox separator line.

     *

     * @param aPosition Position in which separator line is placed.

     */

    IMPORT_C void SetSeparatorLinePosition(TAknSeparatorLinePosition aPosition);

    /**

     * Gets separator line position.

     *

     * @return Position of separator line.

     */

    IMPORT_C TAknSeparatorLinePosition SeparatorLinePosition() const;

    /**

     *

     * @deprecated

     *

     * Gets layout data needed for separator lines drawing.

     *

     * @return Layout data.

     */

    IMPORT_C CAknLayoutData* LayoutData() const;

    /**

     *

     * @deprecated

     *

     * Gets LayOutInit flag used for drawing separator lines in lists.

     *

     * @internal

     * @return LayOutInit flag.

     */

    IMPORT_C TBool LayoutInit() const;

    /**

     *

     * @deprecated

     *

     * Sets LayOutInit flag used for drawing separator lines in lists.

     *

     * @internal

     * @param aValue LayOutInit flag value.

     */

    IMPORT_C void SetLayoutInit(TBool aValue);

    /**

     * Enables or disables underlining per text subcell only if 

     * @c TListItemProperties also has underlining enabled. If this method is

     * not called and @c TListItemProperties has underlining enabled, drawing

     * will revert to old style where only first text subcell will be underlined.

     *

     * @since S60 3.1

     * @param aUnderlinedCells Bitmask of cells to be underlined.

     */    

    IMPORT_C void SetSubcellUnderlined( TBitFlags32 aUnderlinedCells );

    /**

    *

    * enables certain highlight skinning for

    * radibutton / checkbox set style lists

    *

    * should be used only by avkon internally

    *

    * @since S60 3.1

    * 

    */

    void UseHighlightIconSwapping( TBool aUse );

    TBool UseHighlightIconSwapping() const;

    // next methods are only used inside the drawing algorithm.

    // The set methods are also const because they do not change observable behavior of the system.

    TSize SubCellRealSize(TInt aSubCellIndex) const;

    void SetSubCellRealSize(TInt aSubCellIndex, TSize aRealSize) const;

    //

    TSize SubCellRealTextSize(TInt aSubCellIndex) const;

    void SetSubCellRealTextSize(TInt aSubCellIndex, TSize aRealSize) const;

    struct SSubCell

        {

        SSubCell() { }

        TInt iSubCell; // Must be first entry

        TInt iWidth;

        TMargins iMargin;

        const CFont* iBaseFont;

        TInt iActualFontIndex;

        TBool iGraphics;

        TBool iTransparent;

        TBool iNotAlwaysDrawn;

        CGraphicsContext::TTextAlign iAlign;

        CGraphicsContext::TPenStyle iRightSeparatorStyle;

        TPoint iPosition;

        TInt iBaseline;

        TSize iSize;

        TBool iUseSubCellColors; // this is set if someone calls SetSubCellColorsL()

        TColors iColors;

        TInt iTextClipGap;

        TBool iNumberCell;

        // the next ones change during drawing algorithm

        __MUTABLE TSize iRealSize;

        __MUTABLE TSize iRealTextSize;

        };

protected:

    /**

     * C++ default constructor.

     */

    IMPORT_C CFormattedCellListBoxData();

    /**

     * Second phase constructor. Highlight animation will be 

     * created by default (if it is provided by the skin).

     */

    IMPORT_C void ConstructLD();

    /**

     * Second phase constructor for subclasses that want to override highlight

     * animation creation.

     *

     * @param aAnimationIID Skin ItemID of the constructed animation. Passing

     *        @c KAknsIIDNone will disable highlight animation.

     */

    IMPORT_C void ConstructLD(const TAknsItemID& aAnimationIID);

    /**

     * Main drawing algorithm used for drawing S60 list item. 

     * @c Draw() method should call this method after clearing the list item

     * area and drawing the highlight.

     *

     * @param aProperties Properties attached to the list item.

     * @param aGc Graphics Context used for drawing the list item.

     * @param aText A text string describing the list item cells.

     * @param aRect The area of the screen for the whole list item.

     * @param aHighlight Whether the list item is selected.

     * @param aColors The colors used for drawing the item.

     * @panic EAknPanicFormattedCellListInvalidBitmapIndex The defined bitmap

     *        index is invalid.

     * @panic EAknPanicOutOfRange The defined index is out of the range. 

     */

    IMPORT_C void DrawFormatted(TListItemProperties aProperties,

                                CWindowGc& aGc,

                                const TDesC* aText,

                                const TRect& aRect,

                                TBool aHighlight,

                                const TColors& aColors) const;

    /**

    * Draws list items.

    *

    * @param aProperties Properties attached to the list item.

    * @param aGc Graphics Context used for drawing the list item.

    * @param aText A text string describing the list item cells.

    * @param aRect The area of the screen for the whole list item.

    * @param aHighlight Whether the list item is selected.

    * @param aColors The colors used for drawing the item.

    * @internal

    */

    void DrawFormattedSimple( TListItemProperties& aProperties,

                              CWindowGc& aGc,

                              const TDesC* aText,

                              const TRect& aRect,

                              TBool aHighlight,

                              const TColors& aColors ) const;

private:

    /**

    * @internal

    */

    void DrawFormattedOld( TListItemProperties& aProperties,

                           CWindowGc& aGc,

                           const TDesC* aText,

                           const TRect& aItemRect,

                           TBool aHighlight,

                           const TColors& aColors ) const;

    /**

    * @internal helper

    */

    void BitBltColored( CWindowGc&      aGc,

                        TBool           aHighlight,

                        const CGulIcon* aIcon,