/*

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

*

*

*/

#include <eikfrlbd.h>

#include <aknlists.h>

#include <AknMarqueeControl.h>

#include <centralrepository.h>

#include <gulicon.h>

#include <eikslbd.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <aknphysics.h>

#include <AknUtils.h> 

#include <AknFontId.h>

#include <AknLayoutFont.h>

#include "ccappcommlaunchercustomlistboxdata.h"

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfxinternal.h>

#endif //RD_UI_TRANSITION_EFFECTS_LIST

#include <touchfeedback.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(CCCAppCommLauncherCustomListBoxDataExtension) : 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:

	CCCAppCommLauncherCustomListBoxDataExtension();

	void ConstructL(CCCAppCommLauncherCustomListBoxData* aListBoxData,

			const TAknsItemID& aAnimationIID);

	~CCCAppCommLauncherCustomListBoxDataExtension();

	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 DrawPressedDownEffectL(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

	CCCAppCommLauncherCustomListBoxData* 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.

 */

CCCAppCommLauncherCustomListBoxDataExtension::CCCAppCommLauncherCustomListBoxDataExtension() :

	CActive(EPriorityHigh)

	{

	}

void CCCAppCommLauncherCustomListBoxDataExtension::ConstructL(

		CCCAppCommLauncherCustomListBoxData* aListBoxData,

		const TAknsItemID& aAnimationIID)

	{

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

	}

CCCAppCommLauncherCustomListBoxDataExtension::~CCCAppCommLauncherCustomListBoxDataExtension()

	{

	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;

	}

void CCCAppCommLauncherCustomListBoxDataExtension::AddRowAndSubCellL(TInt aRow,

		TInt aSubCell)

	{

	SRowAndSubCell subcell;

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

	subcell.iFont = NULL;

	TKeyArrayFix key(0, ECmpTInt32);

	iRowAndSubCellArray->InsertIsqL(subcell, key);

	}

CCCAppCommLauncherCustomListBoxDataExtension::SRowAndSubCell&

CCCAppCommLauncherCustomListBoxDataExtension::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 CCCAppCommLauncherCustomListBoxDataExtension::SRowAndSubCell&

CCCAppCommLauncherCustomListBoxDataExtension::At(TInt aArrayIndex) const

	{

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

	return (iRowAndSubCellArray->At(aArrayIndex));

	}

TInt CCCAppCommLauncherCustomListBoxDataExtension::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 CCCAppCommLauncherCustomListBoxDataExtension::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 CCCAppCommLauncherCustomListBoxDataExtension::AddSLSubCellL(TInt 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);

	}

CCCAppCommLauncherCustomListBoxDataExtension::SSLSubCell&

CCCAppCommLauncherCustomListBoxDataExtension::AtSL(TInt aArrayIndex)

	{

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

	return (iSLSubCellArray->At(aArrayIndex));

	}

const CCCAppCommLauncherCustomListBoxDataExtension::SSLSubCell&

CCCAppCommLauncherCustomListBoxDataExtension::AtSL(TInt aArrayIndex) const

	{

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

	return (iSLSubCellArray->At(aArrayIndex));

	}

TInt CCCAppCommLauncherCustomListBoxDataExtension::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 CCCAppCommLauncherCustomListBoxDataExtension::FindSLSubCellIndexOrAddL(

		TInt& aArrayIndex, TInt aSubCell)

	{

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

		{

		AddSLSubCellL(aSubCell);

		FindSLSubCellIndex(aArrayIndex, aSubCell);

		}

	}

void CCCAppCommLauncherCustomListBoxDataExtension::ResetSLSubCellArray()

	{

	iSLSubCellArray->Reset();

	iRowAndSubCellArray->Reset();

	}

void CCCAppCommLauncherCustomListBoxDataExtension::CreatePictographInterfaceL()

	{

	if (!iPictoInterface)

		{

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

		}

	}

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

// CCCAppCommLauncherCustomListBoxDataExtension::NoAnimIfError

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

//

inline void CCCAppCommLauncherCustomListBoxDataExtension::NoAnimIfError(

		TInt aError)

	{

	if (KErrNone != aError)

		{

		DeleteAnim();

		}

	}

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

// CCCAppCommLauncherCustomListBoxDataExtension::TryCreateAnimation

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

//

void CCCAppCommLauncherCustomListBoxDataExtension::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);

		}

	}

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

// CCCAppCommLauncherCustomListBoxDataExtension::SyncAnim

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

//

TBool CCCAppCommLauncherCustomListBoxDataExtension::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 ) ) );