/*

* Copyright (c) 2002-2009 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 <eikfrlbd.h>

#include <aknlists.h>

#include <AknMarqueeControl.h>

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <AknsEffectAnim.h>

#include <AknsListBoxBackgroundControlContext.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknPanic.h>

#include <AknBidiTextUtils.h>

#include <centralrepository.h>

#include <AvkonInternalCRKeys.h>

#include <gulicon.h>

#include <eikslbd.h>

#include "AknDebug.h"

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.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"

// there are 17(!) subcells in qdial grid (0 ... 16)

const TInt KMaxSubCellIndex = 16 + 1;

// colored tick marks support

const TInt KColorIconFlag = -1;

const TInt KColorIconIdx  =  0;

/**

* This class needs to be in .cpp file so that we do not accidentally make it

* derivable; that would destroy all the binary compability advantages this

* class has..

*

* 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(CFormattedCellListBoxDataExtension) :

    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

        {

        EAknSLGraphic,

        EAknSLText,

        EAknSLNumeric

        };

public:

    CFormattedCellListBoxDataExtension();

    void ConstructL( CFormattedCellListBoxData* aListBoxData,

                     const TAknsItemID& aAnimationIID );

    ~CFormattedCellListBoxDataExtension();

    void CreatePictographInterfaceL();

    void CreateMarqueeControlL();

    static TInt RedrawEvent(TAny* aControl);    // Marquee draw callback

    TBool IsMarqueeOn();

    struct SRowAndSubCell

        {

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

        const CFont* iFont;

        //TBool iUnderline;

        //TBool iStrikethrough;

        };

    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

        };

    SRowAndSubCell& At(TInt aArrayIndex);

    const SRowAndSubCell& At(TInt aArrayIndex) const;

    void AddRowAndSubCellL(TInt aRow,TInt aSubCell);

    TInt FindRowAndSubCellIndex(TInt& aArrayIndex,TInt aRow,TInt aSubCell) const;

    void FindRowAndSubCellIndexOrAddL(TInt& aArrayIndex,TInt aRow,TInt aSubCell);

    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();

    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( TSize aSize );

    void CreateColorBitmapsL();

    TBool DrawPressedDownEffect( MAknsSkinInstance* aSkin, 

                                 CWindowGc& aGc, 

                                 const TRect& aOutRect, 

                                 const TRect& aInnerRect ) const;

private: // New internal methods

    TBool DrawHighlightBackground( CFbsBitGc& aGc );

    void PostDeleteAnimation();

    void CreateAnimationL();

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

public:

    struct TSubCellExt

        { 

        TInt iSubCell; // Must be first entry 

        TBool iLayoutAlign;         

        };

    TInt AddSubCellExtL(TInt aSubCell);

    void FindSubCellExtIndexOrAddL( TInt& aArrayIndex,TInt aSubCell);

    void SetSubCellLayoutAlignmentL( TInt aSubCellIndex );        

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

    TBool SubCellLayoutAlignment(TInt aSubCellIndex) const;        

private: // From MAknPictographAnimatorCallBack

    void DrawPictographArea();

public:

    CCoeControl *iControl; // not owned

    CFormattedCellListBoxData* iListBoxData; // Not owned

    CAknsListBoxBackgroundControlContext* iSkinControlContext;

    TBool iSkinEnabled;

    const TAknsItemID *iSkinHighlightFrameId;

    const TAknsItemID *iSkinHighlightFrameCenterId;

    TBool iRespectFocus;

// not used ?    HBufC *iTempTextBuffer;

    TRect iSkinPopupInnerRect;

    TRect iSkinPopupOuterRect;

    CAknsFrameBackgroundControlContext* iPopupFrame;

    TBool iUseLogicalToVisualConversion;

    TInt16 iFirstWordWrappedSubcellIndex;

    TInt16 iSecondWordWrappedSubcellIndex;

    CAknPictographInterface* iPictoInterface;

    CAknMarqueeControl* iMarquee;

    CAknMarqueeControl* i2ndLineMarquee;

    TInt iCurrentItem; // Current list item index that marquee draws/has drawn.

    TInt iCurrentRow; // Current list row being drawn.  // not true - cache of currentitemindex 

    TInt iCurrentlyDrawnItemIndex;

    CArrayFix<SRowAndSubCell>* iRowAndSubCellArray;

    CArrayFix<SSLSubCell>* iSLSubCellArray;

    TBool iDrawBackground;   // Determines if background should be drawn (transparency)

    TSize iSubCellIconSize[KMaxSubCellIndex]; // Store icon sizes for each subcell

    TAknSeparatorLinePosition iSeparatorLinePosition;

    CAknsEffectAnim* iAnimation;

    TBitFlags32 iAnimFlags;

    TRgb iHighlightedTextColor;

    TRgb iTextColor;

    TBool iDrawScrollbarBackground;

    TBool iSimpleList;

    TBool       iUnderlineFlagSet;  // underlining support for more than

    TBitFlags32 iUnderlineFlags;    // one text subcell

    TBool iHideSecondRow;

    TBool iSubCellsMightIntersect;

    TBool iStretchingEnabled;

    TAknsItemID iAnimIID;

    MListBoxAnimBackgroundDrawer* iHighlightBgDrawer;

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

    // Drop shadows can be toggled on/off in

    // "transparent" lists (eg. transparent camera setting page).

    TBool iUseDropShadows;

    // highlight color skinning for setstyle lists - to be deprecated once correct color skinning is available

    TBool iUseHighligthIconSwapping;

    // colorskin highlight icons

    CFbsBitmap* iColorBmp;

    CFbsBitmap* iHiliBmp;

    TRgb        iIconColor;

    TRgb        iHiliIconColor;

    TInt        iConditionalCells;

    // which columns of highlighted item have clipped text ?

    TUint32     iClippedSubcells;

    TUint32     iClippedByWrap;

    TBool       iUseClippedByWrap;

    CArrayFix<TSubCellExt>* iSubCellExtArray; //for subcell alignment

    TRect iMarginRect;    

    TBool iKineticScrolling;

    };

/**

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

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

*/

CFormattedCellListBoxDataExtension::CFormattedCellListBoxDataExtension():

    CActive( EPriorityHigh )

    {}

void CFormattedCellListBoxDataExtension::ConstructL(

    CFormattedCellListBoxData* aListBoxData,

    const TAknsItemID& aAnimationIID )

    {

    _AKNTRACE_FUNC_ENTER;

    iListBoxData = aListBoxData;

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

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

    iSubCellExtArray = new(ELeave) CArrayFixFlat<TSubCellExt>(4);

    // bi-di algorithm support (NON_LEAVING_VERSION)

// not used ?    iTempTextBuffer = HBufC::NewL(256);

    iUseLogicalToVisualConversion = ETrue;

    iFirstWordWrappedSubcellIndex = -1;

    iSecondWordWrappedSubcellIndex = -1;

    iDrawBackground = ETrue;

    iSeparatorLinePosition = ENoLine;

    iAnimIID = aAnimationIID;

    CActiveScheduler::Add( this );

    TryCreateAnimation(); // Animations are created by default

    iTextColor = NULL; // just in case

    iHighlightedTextColor = NULL; // just in case

    iDrawScrollbarBackground = ETrue;

#ifdef RD_LIST_STRETCH

    // check list stretching from cenrep

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

    cenRep->Get( KAknAutomaticListStretching, iStretchingEnabled );

    delete cenRep;

#endif

    iKineticScrolling = CAknPhysics::FeatureEnabled();

    _AKNTRACE_FUNC_EXIT;

    }

CFormattedCellListBoxDataExtension::~CFormattedCellListBoxDataExtension()

    {

    _AKNTRACE_FUNC_ENTER;

    Cancel();

    // Stop receiving foreground events

    CCoeEnv* env = CCoeEnv::Static();

    env->RemoveForegroundObserver( *this );

    delete iRowAndSubCellArray;

    iRowAndSubCellArray = NULL;

    delete iSLSubCellArray;

    iSLSubCellArray = NULL;

    delete iSubCellExtArray;

    iSubCellExtArray = NULL;

    delete iPopupFrame;

    delete iSkinControlContext;

// not used ?    delete iTempTextBuffer;

    delete iPictoInterface;

    delete iMarquee;

    delete i2ndLineMarquee;

    delete iAnimation;

    delete iColorBmp;

    delete iHiliBmp;

    _AKNTRACE_FUNC_EXIT;

    }

void 

CFormattedCellListBoxDataExtension::AddRowAndSubCellL(TInt aRow,TInt aSubCell)

    {

    _AKNTRACE("CFormattedCellListBoxDataExtension::AddRowAndSubCellL aRow = %d, aSubCell=%d",

            aRow, aSubCell);

    SRowAndSubCell subcell;

    subcell.iIndex = (aRow << 8) | (aSubCell & 0xff);

    subcell.iFont=NULL;

    TKeyArrayFix key(0,ECmpTInt32);

    iRowAndSubCellArray->InsertIsqL(subcell,key);

    }

CFormattedCellListBoxDataExtension::SRowAndSubCell& 

CFormattedCellListBoxDataExtension::At(TInt aArrayIndex)

    {

/*    SRowAndSubCell subcell;

    for (int a=0;a<iRowAndSubCellArray->Count();a++)

        subcell = iRowAndSubCellArray->At(a); */

    __ASSERT_DEBUG(aArrayIndex>=0 && aArrayIndex<iRowAndSubCellArray->Count(),Panic(EAknPanicOutOfRange));

    return(iRowAndSubCellArray->At(aArrayIndex));

    }

const CFormattedCellListBoxDataExtension::SRowAndSubCell& 

CFormattedCellListBoxDataExtension::At(TInt aArrayIndex) const

    {

    __ASSERT_DEBUG(aArrayIndex>=0 && aArrayIndex<iRowAndSubCellArray->Count(),Panic(EAknPanicOutOfRange));

    return(iRowAndSubCellArray->At(aArrayIndex));

    }

TInt CFormattedCellListBoxDataExtension::FindRowAndSubCellIndex(TInt& aArrayIndex,

                                                                TInt aRow,

                                                                TInt aSubCell) const

    {

    if (iRowAndSubCellArray->Count()==0)

        return(KErrNotFound);

    TKeyArrayFix key(0,ECmpTInt32);

    SRowAndSubCell rowAndSubcell;

    rowAndSubcell.iIndex = (aRow << 8) | (aSubCell & 0xff);

    return(iRowAndSubCellArray->FindIsq(rowAndSubcell,key,aArrayIndex));

    }

void CFormattedCellListBoxDataExtension::FindRowAndSubCellIndexOrAddL(TInt& aArrayIndex,

                                                                      TInt aRow,

                                                                      TInt aSubCell)

    {

    if (FindRowAndSubCellIndex(aArrayIndex,aRow,aSubCell)!=0) //==KErrNotFound)

        {

        AddRowAndSubCellL(aRow,aSubCell);

        FindRowAndSubCellIndex(aArrayIndex,aRow,aSubCell);

        }

/*       SRowAndSubCell rowAndSubcell;

    rowAndSubcell = iRowAndSubCellArray->At(aArrayIndex); */

    }

void 

CFormattedCellListBoxDataExtension::AddSLSubCellL(TInt aSubCell)

    {

    _AKNTRACE("CFormattedCellListBoxDataExtension::AddSLSubCellL aSubCell = %d",

            aSubCell);

    SSLSubCell subcell;

    subcell.iSubCell = aSubCell;

    subcell.iTextLayout = NULL;

    subcell.iGraphicLayout = NULL;

    subcell.iSubCellType = 0;

    subcell.iConditionValue = -1;

    TKeyArrayFix key(0,ECmpTInt32);

    iSLSubCellArray->InsertIsqL(subcell,key);

    }

CFormattedCellListBoxDataExtension::SSLSubCell& 

CFormattedCellListBoxDataExtension::AtSL(TInt aArrayIndex)

    {

    __ASSERT_DEBUG(aArrayIndex>=0 && aArrayIndex<iSLSubCellArray->Count(),Panic(EAknPanicOutOfRange));

    return(iSLSubCellArray->At(aArrayIndex));

    }

const CFormattedCellListBoxDataExtension::SSLSubCell& 

CFormattedCellListBoxDataExtension::AtSL(TInt aArrayIndex) const

    {

    __ASSERT_DEBUG(aArrayIndex>=0 && aArrayIndex<iSLSubCellArray->Count(),Panic(EAknPanicOutOfRange));

    return(iSLSubCellArray->At(aArrayIndex));

    }

TInt CFormattedCellListBoxDataExtension::FindSLSubCellIndex(TInt& aArrayIndex,

                                                            TInt aSubCell) const

    {

    if (iSLSubCellArray->Count()==0)

        return(KErrNotFound);

    TKeyArrayFix key(0,ECmpTInt32);

    SSLSubCell SLSubCell;

    SLSubCell.iSubCell = aSubCell;

    return(iSLSubCellArray->FindIsq(SLSubCell,key,aArrayIndex));

    }

void CFormattedCellListBoxDataExtension::FindSLSubCellIndexOrAddL(TInt& aArrayIndex,

                                                                  TInt aSubCell)

    {

    if (FindSLSubCellIndex(aArrayIndex, aSubCell)!=0) //==KErrNotFound)

        {

        AddSLSubCellL(aSubCell);

        FindSLSubCellIndex(aArrayIndex,aSubCell);

        }

    }

void CFormattedCellListBoxDataExtension::ResetSLSubCellArray()

    {

    iSLSubCellArray->Reset();

    iRowAndSubCellArray->Reset();

    }

void CFormattedCellListBoxDataExtension::CreatePictographInterfaceL()

    {

    if ( !iPictoInterface )

        {

        iPictoInterface = CAknPictographInterface::NewL( *iControl, *this );

        }

    }

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

// CFormattedCellListBoxDataExtension::NoAnimIfError

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

//

inline void CFormattedCellListBoxDataExtension::NoAnimIfError( TInt aError )

    {

    if( KErrNone != aError )

        {

        DeleteAnim();

        }

    }

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

// CFormattedCellListBoxDataExtension::TryCreateAnimation

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

//

void CFormattedCellListBoxDataExtension::TryCreateAnimation()

    {

    _AKNTRACE_FUNC_ENTER;

    if( !iControl )

        {

        _AKNTRACE("CFormattedCellListBoxDataExtension::TryCreateAnimation iControl==NULL");

        _AKNTRACE_FUNC_EXIT;

        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 );

        }

    _AKNTRACE_FUNC_EXIT;

    }

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

// CFormattedCellListBoxDataExtension::SyncAnim

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

//

TBool CFormattedCellListBoxDataExtension::SyncAnim( const TSize& aSize )

    {

    _AKNTRACE_FUNC_ENTER;