/*

* Copyright (c) 1997-2010 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:

*

*/

#include <eikclbd.h>

#include <aknlists.h>

#include <AknsEffectAnim.h>

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <centralrepository.h>

#include <AvkonInternalCRKeys.h>

#include <AknsListBoxBackgroundControlContext.h>

#include <AknMarqueeControl.h>

#include <eikpanic.h>

#include <eikcoctlpanic.h>

#include <gulicon.h>

#include <AknBidiTextUtils.h>

#include <skinlayout.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <aknphysics.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfxinternal.h>

#endif //RD_UI_TRANSITION_EFFECTS_LIST

#include <touchfeedback.h>

#include "akntrace.h"

const TInt KColumnListBoxGranularity=4;

const TInt KNoActualColumnFont=-1;

const TInt KMaxColumn = 6;

// colored tick marks support

const TInt KColorIconFlag = -1;

const TInt KColorIconIdx  =  0;

/**

* About animation usage:

* All animation usage is implemented in this class. Animation is eye candy and

* low priority when it comes to resources -> on resource failures animation

* fails fast to release resources for more critical functionality. Also, no

* attempt to (re)construct failed animation is made.

*

* User inactivity is not being observed. Only one animation is used. Extension

* is CActive to make it possible to postpone animation deletion on animation

* failure.

*/

NONSHARABLE_CLASS(CColumnListBoxDataExtension) :

    public CActive,

    public MAknPictographAnimatorCallBack,

    public MCoeForegroundObserver,

    public MAknsEffectAnimObserver,

    public MListBoxItemChangeObserver

    {

public:

    enum TFlag

        {

        // Set if current item background should be copied to animation as

        // input layer.

        EFlagUpdateBg      = 0,

        // Set if animation has been resized at least once

        EFlagHasLayers     = 1,

        // Set if foreground has been gained.

        EFlagHasForeground = 2

        };

    enum TSubCellType

        {

        EEikSLGraphic,

        EEikSLText,

        EEikSLNumeric

        };

public:

    CColumnListBoxDataExtension();

    void ConstructL( CColumnListBoxData* aListBoxData,

                     const TAknsItemID& aAnimationIID );

    ~CColumnListBoxDataExtension();

    static TInt RedrawEvent(TAny* aControl);

    TBool IsMarqueeOn();

    struct SRowAndColumn

        {

        TInt iIndex; // 24 bits for row and 8 bits for column

        const CFont* iFont;

        };

    SRowAndColumn& At(TInt aArrayIndex);

    const SRowAndColumn& At(TInt aArrayIndex) const;

    void AddRowAndColumnL(TInt aRow,TInt aColumn);

    TInt FindRowAndColumnIndex(TInt& aArrayIndex,TInt aRow,TInt aColumn) const;

    void FindRowAndColumnIndexOrAddL(TInt& aArrayIndex,TInt aRow,TInt aColumn);

    inline void NoAnimIfError( TInt aError );

    void TryCreateAnimation();

    TBool SyncAnim( const TSize& aSize );

    TBool SyncAndDrawAnim( CBitmapContext& aGc, const TRect& aRect );

    MAknsControlContext* SkinBackgroundContext() const;

    void DeleteAnim();

    void FocusGained();

    void FocusLost();

    void SkinChanged();

    void SetControl( CCoeControl* aControl );

    // Implementation of MCoeForegroundObserver

    void HandleGainingForeground();

    void HandleLosingForeground();

    // Implementation of MAknsEffectAnimObserver

    void AnimFrameReady( TInt aError, TInt );

    // Implementation of MListBoxItemChangeObserver

    void ListBoxItemsChanged(CEikListBox* aListBox);

    // Overloads CActive::DoCancel

    void DoCancel();

    // Overloads CActive::RunL

    void RunL();

    void Play();

    void CreateColorBitmapsL();

    TBool DrawPressedDownEffectL( MAknsSkinInstance* aInstance, 

                                 CWindowGc& aGc, 

                                 const TRect& aOutRect, 

                                 const TRect& aInnerRect ) const;

public: //for handling column alignment

    struct TColumnExt

        {

        TInt    iColumn; // Must be first entry 

        TBool   iLayoutAlign;//is layout alignment or Set by client 

        };    

    TInt  AddColumnExtL(TInt aColumn);        

    void  FindColumnExtIndexOrAddL(TInt& aArrayIndex,TInt aColumn);  

    void  SetColumnLayoutAlignmentL(TInt aColumn);  

    TBool FindColumnExtIndex(TInt& aArrayIndex,TInt aColumn) const; 

    TBool ColumnLayoutAlignment(TInt aColumn) const;  

public: // new list layout system

    struct SRowAndSubCell

        {

        TInt iIndex; // 24 bits for row and 8 bits for subcell

        const CFont* iFont;

        };

    struct SSLSubCell

        {

        TInt iSubCell; // Must be first entry

        TAknTextLineLayout iTextLayout;

        TAknWindowLineLayout iGraphicLayout;

        TInt iSubCellType;

        TInt iConditionValue; // used with conditional layouts for not always drawn subcells

        };

    SSLSubCell& AtSL(TInt aArrayIndex);

    const SSLSubCell& AtSL(TInt aArrayIndex) const;

    void AddSLSubCellL(TInt aSubCell);

    TInt FindSLSubCellIndex(TInt& aArrayIndex, TInt aSubCell) const;

    void FindSLSubCellIndexOrAddL(TInt& aArrayIndex, TInt aSubCell);

    void ResetSLSubCellArray();

private: // New internal methods

    TBool DrawHighlightBackground( CFbsBitGc& aGc );

    void PostDeleteAnimation();

    void CreateAnimationL();

    void DoResizeL( const TSize& aHighlightSize, TBool aAboutToStart );

private: // from MAknPictographAnimatorCallback

    void DrawPictographArea();

public:

    CArrayPtr<CGulIcon>* iIconArray;

    CCoeControl *iControl; // not owned

    CAknsListBoxBackgroundControlContext* iSkinControlContext;

    const TAknsItemID *iSkinHighlightFrameId;

    const TAknsItemID *iSkinHighlightFrameCenterId;

    TBool iSkinEnabled;

    CAknPictographInterface* iPictoInterface;

    CAknMarqueeControl*   iMarquee;

    CAknMarqueeControl*   i2ndLineMarquee;

    TInt                  iCurrentItem; // Marquee:

    TInt iCurrentRow; // Current list row being drawn.

    CArrayFix<SRowAndColumn>* iRowAndColumnArray;

    TSize iSubCellIconSize[6]; // Store icon sizes for each column

    TAknSeparatorLinePosition iSeparatorLinePosition;

    CAknsEffectAnim* iAnimation;

    /**

    * Stored flags are explained in enumeration TFlags.

    */

    TBitFlags32 iAnimFlags;

    CColumnListBoxData* iListBoxData;

    TRgb iHighlightedTextColor;

    TRgb iTextColor;

    TAknsItemID iAnimIID;

    MColumnListBoxAnimBackgroundDrawer* iHighlightBgDrawer;

    TSize iAnimSize; // TODO Deprecating old style anim API and removing this

    TBool       iUnderlineFlagSet;  // underlining support for more than

    TBitFlags32 iUnderlineFlags;    // one text subcell

    TBool iUseLayoutData;

    TBool iStretchingEnabled;

    CArrayFix<SRowAndSubCell>* iRowAndSubCellArray;

    CArrayFix<SSLSubCell>* iSLSubCellArray;

    TBool iSubCellsMightIntersect;

    TRect iParent;  // parent for size calculations

    // colorskin highlight icons

    CFbsBitmap* iColorBmp;

    CFbsBitmap* iHiliBmp;

    TRgb        iIconColor;

    TRgb        iHiliIconColor;

    TInt        iConditionalCells;

    // which columns of highlighted item have clipped text ?

    TUint32     iClippedColumns;

    TBool iKineticScrolling;

    CArrayFix<TColumnExt>* iColumnExtArray; //for column alignment

    TRect iMarginRect;

    };

/**

* High priority is well argumented because running the active object will

* result in animation deletion -> results in freeing resources.

*/

CColumnListBoxDataExtension::CColumnListBoxDataExtension():

    CActive( EPriorityHigh )

    {}

void CColumnListBoxDataExtension::ConstructL(

    CColumnListBoxData* aListBoxData,

    const TAknsItemID& aAnimationIID )

    {

    _AKNTRACE_FUNC_ENTER;

    ASSERT( aListBoxData );

    iListBoxData = aListBoxData;

    iRowAndColumnArray=new(ELeave) CArrayFixFlat<SRowAndColumn>(4);

    iSeparatorLinePosition = ENoLine;

    iAnimIID = aAnimationIID;

    CActiveScheduler::Add( this );

    TryCreateAnimation(); // Animations are created by default

    // try to set ESS text colors here so that they will be set at least somewhere...

    iTextColor = NULL; // just in case

    iHighlightedTextColor = NULL; // just in case

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TRgb color;

    // set ESS text color

    TInt error = AknsUtils::GetCachedColor( skin,

                                            color,

                                            KAknsIIDQsnTextColors,

                                            EAknsCIQsnTextColorsCG6 );

    if ( !error )

        {

        iTextColor = color;

        }

    // set ESS highlighted text color

    error = AknsUtils::GetCachedColor( skin,

                                       color,

                                       KAknsIIDQsnTextColors,

                                       EAknsCIQsnTextColorsCG10 );

    if ( !error )

        {

        iHighlightedTextColor = color;

        }

    iRowAndSubCellArray=new(ELeave) CArrayFixFlat<SRowAndSubCell>(4);

    iSLSubCellArray=new(ELeave) CArrayFixFlat<SSLSubCell>(4);

    iColumnExtArray = new(ELeave) CArrayFixFlat<TColumnExt>(KColumnListBoxGranularity);

#ifdef RD_LIST_STRETCH

    // check list stretching from cenrep

    CRepository* cenRep = CRepository::NewL( KCRUidAvkon );

    cenRep->Get( KAknAutomaticListStretching, iStretchingEnabled );

    delete cenRep;

#endif // RD_LIST_STRETCH

    iKineticScrolling = CAknPhysics::FeatureEnabled();

    _AKNTRACE_FUNC_EXIT;

    }

CColumnListBoxDataExtension::~CColumnListBoxDataExtension()

    {

    Cancel();

    // Stop receiving foreground events

    CCoeEnv* env = CCoeEnv::Static();

    env->RemoveForegroundObserver( *this );

    delete iRowAndColumnArray;

    iRowAndColumnArray = NULL;

    delete iSkinControlContext;

    delete iPictoInterface;

    delete iMarquee;

    delete i2ndLineMarquee;

    delete iAnimation;

    delete iRowAndSubCellArray;

    delete iSLSubCellArray;

    delete iColorBmp;

    delete iHiliBmp;

    delete  iColumnExtArray;

    }

MAknsControlContext* CColumnListBoxDataExtension::SkinBackgroundContext() const

    {

    if ( iSkinEnabled )

        {

        return iSkinControlContext;

        }

    return NULL;

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::NoAnimIfError

// -----------------------------------------------------------------------------

//

inline void CColumnListBoxDataExtension::NoAnimIfError( TInt aError )

    {

    if( KErrNone != aError )

        {

        DeleteAnim();

        }

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::TryCreateAnimation

// -----------------------------------------------------------------------------

//

void CColumnListBoxDataExtension::TryCreateAnimation()

    {

    if( !iControl )

        {

        return;

        }

#ifdef RD_UI_TRANSITION_EFFECTS_LIST  

    CEikListBox* list = static_cast<CEikListBox*>( iControl );

    CListBoxView* view = list->View();

    if ( !view || !view->ItemDrawer() )

        {

        return;

        }

    CWindowGc* gc = view->ItemDrawer()->Gc();

    MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( gc );

    if ( transApi && transApi->VerifyKml() == KErrNone )

        {

        return;

        }

#endif //RD_UI_TRANSITION_EFFECTS_LIST      

    // Ideally we should not create animation if the list has zero items.

    // Unfortunately, this will cause problems elsewhere as setting item text

    // array to list requires not calling HandleItemAddition (or similar

    // method) -> in some situations animation would not be created at all as

    // we don't receive item change event. Fortunately, creating animation to

    // empty list doesn't carry much overhead as layer creation is delayed to

    // first render.

    if( !iAnimation )

        {

        // This must be the first call because animation does not exist.

        // Animation layers are created when the animation is rendered for the

        // first time.

        TRAPD( err, CreateAnimationL() );

        NoAnimIfError( err );

        }

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::SyncAnim

// -----------------------------------------------------------------------------

//

TBool CColumnListBoxDataExtension::SyncAnim( const TSize& aSize )

    {

    if( !iAnimation || aSize.iWidth <= 0 || aSize.iHeight <= 0 )

        {

        return EFalse;

        }

    if( iAnimation->Size() != aSize || iAnimation->NeedsInputLayer() )

        {

        // Resizing will update animation background

        iAnimFlags.Clear( EFlagUpdateBg );

        // Animation exists but its size is out of sync or input layers have

        // been released

        TRAPD( err, DoResizeL( aSize, iAnimFlags.IsSet( EFlagHasForeground ) ) );

        if( err )

            {

            DeleteAnim();

            return EFalse;

            }

        iAnimFlags.Set( EFlagHasLayers );

        }

    // Highlight animation background needs update (current item has changed)

    if( iAnimFlags.IsSet( EFlagUpdateBg ) )

        {

        iAnimFlags.Clear( EFlagUpdateBg );

        if( iAnimation->InputRgbGc() )

            {

            DrawHighlightBackground( *iAnimation->InputRgbGc() );

            // We need to update the output frame (otherwise the highlight

            // would drawn with the old output before the next new animation

            // frame).

            NoAnimIfError( iAnimation->UpdateOutput() );

            if( !iAnimation )

                {

                return EFalse;

                }

            }

        }

    return ETrue;

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::SyncAndDrawAnim

// -----------------------------------------------------------------------------

//

TBool CColumnListBoxDataExtension::SyncAndDrawAnim(

        CBitmapContext& aGc, const TRect& aRect )

    {

    if( iAnimation )

        {

        // When application loses foreground or has not yet gained foreground

        // animation is in stopped state and input layers are not present. It

        // is possible that list is repainted in this situation. Calling

        // SyncAnim will create the non-present layers -> WSERV flush ->

        // flicker. To prevent flickering we just render the existing frame.

        // This can lead to incorrect draw if the current item index is changed

        // when the app has no foreground (very unlikely). If EFlagHasLayers is

        // not set we need to do SyncAnim because it is the first call to draw

        // (and flicker is not an issue).

        if( EAknsAnimStateStopped == iAnimation->State() &&

            !iAnimFlags.IsSet( EFlagHasForeground ) &&

            iAnimFlags.IsSet( EFlagHasLayers )  &&

            !iAnimFlags.IsSet( EFlagUpdateBg ) )

            {

            return iAnimation->Render( aGc, aRect );

            }

        }

    if( SyncAnim( aRect.Size() ) )

        {

        return iAnimation->Render( aGc, aRect );

        }

    return EFalse;

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::DeleteAnim

// -----------------------------------------------------------------------------

//

void CColumnListBoxDataExtension::DeleteAnim()

    {

    // Stop receiving foreground events

    CCoeEnv* env = CCoeEnv::Static();

    env->RemoveForegroundObserver( *this );

    delete iAnimation;

    iAnimation = NULL;

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::FocusGained

// -----------------------------------------------------------------------------

//

void CColumnListBoxDataExtension::FocusGained()

    {

    Play();

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::FocusLost

// -----------------------------------------------------------------------------

//

void CColumnListBoxDataExtension::FocusLost()

    {

    if( iAnimation )

        {

        NoAnimIfError( iAnimation->Pause() );

        }

    }

// -----------------------------------------------------------------------------

// CColumnListBoxDataExtension::SkinChanged

// -----------------------------------------------------------------------------

//

void CColumnListBoxDataExtension::SkinChanged()

    {