/*

* Copyright (c) 1997-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 <badesca.h>

#include <gdi.h>

#include <w32std.h>

#include <eiklbx.pan>

#include <eiklbx.h>

#include <eiklbv.h>

#include <eiklbm.h>

#include <eiklbi.h>

#include <gulutil.h>

#include <eikenv.h>

#include <avkon.rsg>

#include <barsread.h>

#include <AknUtils.h>

#include <AknsDrawUtils.h>

#include <AknsControlContext.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistboxtfxinternal.h>

#include <aknlistloadertfx.h>

#endif

#include "laflbv.h"

#include "laflbx.h"

#include "akntrace.h"

#define ITEM_EXISTS_BEGIN TInt no_of_items__ = iModel->NumberOfItems()

#define ITEM_EXISTS(x) (((x) > -1) && ((x) < no_of_items__))

#define ITEM_EXISTS_ONCE(x) (((x) > -1) && ((x) < iModel->NumberOfItems()))

//

// class CListBoxView

//

CListBoxViewExtension* CListBoxViewExtension::NewL()

    {

    CListBoxViewExtension* self = new ( ELeave ) CListBoxViewExtension;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // self

    return self;

    }

CListBoxViewExtension::~CListBoxViewExtension()

    {

    }

void CListBoxViewExtension::ConstructL()

    {

    // Panning and flicking disabled by default

    iScrollingDisabled = ETrue;

    }

void CListBoxView::SetVisibilityObserver(MListVisibilityObserver* aObserver)

	{

	iVisibilityObserver=aObserver;

	}

EXPORT_C TBool CListBoxView::IsVisible() const

	{

	if(iVisibilityObserver)

		return(iVisibilityObserver->IsVisible());

	return ETrue;

	}

EXPORT_C void CListBoxView::SetListEmptyTextL(const TDesC& aText)

	{

	delete iListEmptyText;

	iListEmptyText = NULL;

	iListEmptyText= aText.AllocL();

	}

EXPORT_C CListBoxView::CListBoxView()

	{

	_AKNTRACE_FUNC_ENTER;

	iItemHeight = 20;

//	iBackColor = KDefaultLbxBackColor;

	iBackColor = CEikonEnv::Static()->Color(EColorControlBackground); //KDefaultLbxBackColor;

	iMatcherCursorColor = TRgb(177, 177, 177);		// light gray?

	iCurrentItemIndex = 0;

	iTopItemIndex = 0;

	iListEmptyText = 0;

	iVerticalOffset = 0;

	_AKNTRACE_FUNC_EXIT;

	}

EXPORT_C void CListBoxView::ConstructL(MListBoxModel* aList, CListItemDrawer* aItemDrawer, CWsScreenDevice* aScreen, RWindowGroup* aGroupWindow, RWindow* aWsWindow, const TRect& aDisplayArea, TInt aItemHeight)

	{

	_AKNTRACE_FUNC_ENTER;

	iExtension = CListBoxViewExtension::NewL();

	iModel = aList;

	iItemDrawer = aItemDrawer;

	iWin = aWsWindow;

	iGroupWin = aGroupWindow;

	// create a graphics context

    User::LeaveIfError(aScreen->CreateContext(iGc));

	iGc->Activate(*iWin);

	iItemDrawer->SetGc(iGc);

	iViewRect = aDisplayArea;

	iItemHeight = aItemHeight;

	iSelectionIndexes = new(ELeave) CArrayFixFlat<TInt>(5);

	//SetListEmptyTextL(_L("No Data"));

	TResourceReader rr;

	CEikonEnv::Static()->CreateResourceReaderLC(rr,R_AVKON_LISTBOX_DEFAULT_EMPTY_TEXT);

	TPtrC emptytext= rr.ReadTPtrC();

	SetListEmptyTextL(emptytext);

	CleanupStack::PopAndDestroy();

	_AKNTRACE_FUNC_EXIT;

	}

EXPORT_C CListBoxView::~CListBoxView()

	{

	_AKNTRACE_FUNC_ENTER;

	// Although my "item Drawer" is created by some other object, it is convenient

	// for me to destroy it here...

	delete iExtension;

	delete(iItemDrawer);

	delete iSelectionIndexes;

	delete(iGc);

	delete (iListEmptyText);

	_AKNTRACE_FUNC_EXIT;

	}

EXPORT_C TInt CListBoxView::TopItemIndex() const

	{

	_AKNTRACE( "iTopItemIndex = %d", iTopItemIndex );

	return iTopItemIndex;

	}

EXPORT_C TInt CListBoxView::BottomItemIndex() const

	{

	_AKNTRACE( "iBottomItemIndex = %d", iBottomItemIndex );

	return iBottomItemIndex;

	}

EXPORT_C TBool CListBoxView::ItemIsSelected(TInt aItemIndex) const

	{

	_AKNTRACE( "Item selected is %d", aItemIndex );

	TKeyArrayFix key(0, ECmpTInt);	

	TInt pos;

	if (iSelectionIndexes->Find(aItemIndex, key, pos))

		return(EFalse);

	return(ETrue);

	}

EXPORT_C void CListBoxView::ToggleItemL(TInt aItemIndex) 

	{

	_AKNTRACE_FUNC_ENTER;

	__ASSERT_DEBUG(iSelectionIndexes, Panic(EEikPanicListBoxNoSelIndexArray));

	if (iItemDrawer->Properties(aItemIndex).IsSelectionHidden()) { DeselectItem(aItemIndex); return; }

	TKeyArrayFix key(0, ECmpTInt);	

	TInt pos;

	if (iSelectionIndexes->Find(aItemIndex, key, pos))

		iSelectionIndexes->AppendL(aItemIndex);   

	else

		iSelectionIndexes->Delete(pos);

	DrawItem(aItemIndex);

	_AKNTRACE_FUNC_EXIT;

	}

EXPORT_C void CListBoxView::SelectItemL(TInt aItemIndex)

    {   

    // select the specified item; if already selected, do nothing

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "SelectItem is %d", aItemIndex );

    __ASSERT_DEBUG(iSelectionIndexes, Panic(EEikPanicListBoxNoSelIndexArray));

    if (iItemDrawer->Properties(aItemIndex).IsSelectionHidden()) 

        { 

        DeselectItem(aItemIndex); 

        _AKNTRACE_FUNC_EXIT;

        return; 

        }

    TKeyArrayFix key(0, ECmpTInt);  

    TInt pos;

    if (iSelectionIndexes->Find(aItemIndex, key, pos))

        {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

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

        if ( transApi )

            {

            transApi->Invalidate( MAknListBoxTfxInternal::EListItem, aItemIndex );

            }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

        iSelectionIndexes->AppendL(aItemIndex);

        DrawItem(aItemIndex);

        }

    _AKNTRACE_FUNC_EXIT;

    }  

EXPORT_C void CListBoxView::DeselectItem(TInt aItemIndex)

    {

    // deselect the specified item; if not currently selected, do nothing

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "DeselectItem is %d", aItemIndex );

    __ASSERT_DEBUG(iSelectionIndexes, Panic(EEikPanicListBoxNoSelIndexArray));

    TKeyArrayFix key(0, ECmpTInt);  

    TInt pos;

    if (!(iSelectionIndexes->Find(aItemIndex, key, pos)))

        {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

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

        if ( transApi )

            {

            transApi->Invalidate( MAknListBoxTfxInternal::EListItem, aItemIndex );

            }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

        iSelectionIndexes->Delete(pos);

        DrawItem(aItemIndex);

        }

    _AKNTRACE_FUNC_EXIT;

    }  

EXPORT_C void CListBoxView::GetSelectionIndexesL(CSelectionIndexArray *aSelectionArray) const

	{

	__ASSERT_DEBUG(aSelectionArray, Panic(EEikPanicListBoxInvalidSelIndexArraySpecified));

	__ASSERT_DEBUG(iSelectionIndexes, Panic(EEikPanicListBoxNoSelIndexArray));

	aSelectionArray->Reset();

	TInt selectionIndex;

	TInt numOfSelections = iSelectionIndexes->Count();

	for (TInt i = 0; i < numOfSelections; i++)

		{

		selectionIndex = (*(iSelectionIndexes))[i];

		aSelectionArray->AppendL(selectionIndex);

		}

	}

EXPORT_C void CListBoxView::SetSelectionIndexesL(const CSelectionIndexArray *aSelectionArray)

	{

	__ASSERT_DEBUG(aSelectionArray, Panic(EEikPanicListBoxInvalidSelIndexArraySpecified));

	ClearSelection();

	TInt numOfSelections = aSelectionArray->Count();

	TInt selectionIndex;

	for (TInt i = 0; i < numOfSelections; i++)

		{

		selectionIndex = (*aSelectionArray)[i];

        SelectItemL(selectionIndex);

		}

	}

EXPORT_C const CListBoxView::CSelectionIndexArray* CListBoxView::SelectionIndexes() const

	{

	return iSelectionIndexes;

	}

EXPORT_C void CListBoxView::ClearSelection()

	{

	_AKNTRACE_FUNC_ENTER;

	__ASSERT_DEBUG(iSelectionIndexes, Panic(EEikPanicListBoxNoSelIndexArray));

	TInt numSelectedItems = iSelectionIndexes->Count();

	TInt selectedItemIndex; 

	for	(TInt i = 0; i < numSelectedItems; i++)

		{

		selectedItemIndex = (*(iSelectionIndexes))[0];

        DeselectItem(selectedItemIndex);

		}

	ClearSelectionAnchorAndActiveIndex();

	_AKNTRACE_FUNC_EXIT;

	}

EXPORT_C void CListBoxView::ClearSelectionAnchorAndActiveIndex()

	{

	_AKNTRACE_FUNC_ENTER;

	iAnchorIndex = 0;

	iActiveEndIndex = 0;

	ClearFlags(EAnchorExists);

	ClearFlags(EMarkSelection);

	ClearFlags(EUnmarkSelection);

	_AKNTRACE_FUNC_EXIT;

	}

EXPORT_C void CListBoxView::SelectRangeL(TInt aItemIndex1, TInt aItemIndex2)

	{

	TInt startItem, endItem;

	startItem = Min(aItemIndex1, aItemIndex2);

	endItem = Max(aItemIndex1, aItemIndex2);

	for (TInt i = startItem; i <= endItem; i++)

        SelectItemL(i);

	}

EXPORT_C void CListBoxView::SetAnchor(TInt aItemIndex)

	{

    SetFlags(EAnchorExists);

	iAnchorIndex = aItemIndex;

	iActiveEndIndex = aItemIndex;

	}

EXPORT_C void CListBoxView::UpdateSelectionL(TSelectionMode aSelectionMode)

	{

	// assumes that iCurrentItemIndex has already been updated...

	_AKNTRACE_FUNC_ENTER;

	_AKNTRACE( "aSelectionMode is %d", aSelectionMode );

	if (iCurrentItemIndex == -1)   // i.e. no selection

		{

		ClearSelection();

		_AKNTRACE_FUNC_EXIT;

		return;

		}

	TInt newActiveEndIndex = iCurrentItemIndex;

	if ( Flags() & EPaintedSelection )

		{

		switch (aSelectionMode)

			{

		case ENoSelection:

			{

			ClearFlags(EAnchorExists);

			iActiveEndIndex = iCurrentItemIndex;

			DrawItem(iCurrentItemIndex);

			break;

			}

		case ESingleSelection:

			{

			TInt i = 0;

			iAnchorIndex = iCurrentItemIndex;

			iActiveEndIndex = iCurrentItemIndex;

			SetFlags(EAnchorExists);

			TInt selectedItemIndex; 

			while (i < iSelectionIndexes->Count())

				{

				selectedItemIndex = (*(iSelectionIndexes))[i];

                DeselectItem(selectedItemIndex);

				}

			//DrawItem(iActiveEndIndex);

            SelectItemL(newActiveEndIndex);

			}

			break;

		case EContiguousSelection:

			{

			if (newActiveEndIndex == iActiveEndIndex)

				break;

			if (!(iFlags & EAnchorExists))

				{

				iAnchorIndex = newActiveEndIndex;

				SetFlags(EAnchorExists);

				}

			TInt startIndex=0, endIndex=0;

			if ( iActiveEndIndex < newActiveEndIndex )

				{

				startIndex = iActiveEndIndex;

				endIndex = newActiveEndIndex; // - 1;  // select current item too

				}

			else

				{

				startIndex = newActiveEndIndex; // + 1;  // select current item too

				endIndex = iActiveEndIndex;

				}

			SelectRangeL( startIndex, endIndex );		// select always

			iActiveEndIndex = iCurrentItemIndex;

			DrawItem(iActiveEndIndex);

			}

			break;

		case EDisjointSelection:

			ClearFlags(EAnchorExists);

			ToggleItemL(newActiveEndIndex);

			iActiveEndIndex = iCurrentItemIndex;

			break;

		default:

			break;

			}

		}

	else	// Here begins the Eikon original code

		{

		switch (aSelectionMode)

			{

		case ENoSelection:

			DrawItem(iCurrentItemIndex);

			break;

		case ESingleSelection:

			{

			TInt i = 0;

			iAnchorIndex = newActiveEndIndex;

			iActiveEndIndex = newActiveEndIndex;

			SetFlags(EAnchorExists);

			TInt selectedItemIndex; 

			// deselect everything except newActiveEndIndex

			while (i < iSelectionIndexes->Count())

				{

				selectedItemIndex = (*(iSelectionIndexes))[i];

                DeselectItem(selectedItemIndex);

				}

            SelectItemL(newActiveEndIndex);

			}

			break;

		case EContiguousSelection:

			{

			TInt itemIndex=0;

			if (newActiveEndIndex == iActiveEndIndex)

				break;

			if (!(iFlags & EAnchorExists))

				{

				iAnchorIndex = newActiveEndIndex;

				iActiveEndIndex = newActiveEndIndex;

    			SetFlags(EAnchorExists);

				SelectRangeL(iAnchorIndex, newActiveEndIndex);

				break;

				}

			if ((newActiveEndIndex < iActiveEndIndex) && (iActiveEndIndex <= iAnchorIndex))

				SelectRangeL(iActiveEndIndex, newActiveEndIndex);

			else if ((newActiveEndIndex < iActiveEndIndex) && (iActiveEndIndex > iAnchorIndex))

				{

				itemIndex = iActiveEndIndex;

				while ((itemIndex > newActiveEndIndex) && (itemIndex > iAnchorIndex))

					{

                    DeselectItem(itemIndex);

					--itemIndex;

					}

				SelectRangeL(iAnchorIndex, newActiveEndIndex);

				}

			else if ((newActiveEndIndex > iActiveEndIndex) && (iActiveEndIndex < iAnchorIndex))

				{

				itemIndex = iActiveEndIndex;

				while ((itemIndex < newActiveEndIndex) && (itemIndex < iAnchorIndex))

					{

                    DeselectItem(itemIndex);

					++itemIndex;

					}

				SelectRangeL(iAnchorIndex, newActiveEndIndex);

				}

			else if ((newActiveEndIndex > iActiveEndIndex) && (iActiveEndIndex >= iAnchorIndex))

				SelectRangeL(iActiveEndIndex, newActiveEndIndex);

			iActiveEndIndex = newActiveEndIndex;

			DrawItem(iActiveEndIndex);

			}

			break;

		case EDisjointSelection: // toggled behavior

		    // Make a choice whether to mark or unmark

			// We havent made that choice yet.

			if (!ItemIsSelected(newActiveEndIndex)) 

			    {

			    SetFlags(EMarkSelection);

				ClearFlags(EUnmarkSelection);

			}

			else

			    {

			    SetFlags(EUnmarkSelection);

				ClearFlags(EMarkSelection);

			    }

			if (newActiveEndIndex == iActiveEndIndex)

				{

    			ClearFlags(EAnchorExists);

				ToggleItemL(newActiveEndIndex);

				break;

				}

			iAnchorIndex = newActiveEndIndex;

			iActiveEndIndex = newActiveEndIndex;

    		SetFlags(EAnchorExists);

			ToggleItemL(newActiveEndIndex);

			break;

		case EDisjointMarkSelection: // can only mark items, not unmark them

		    // Make a choice whether to mark or unmark

		    if (! (Flags()&EMarkSelection ||Flags()&EUnmarkSelection))

			{

			// We havent made that choice yet.

			if (ItemIsSelected(iAnchorIndex)) 

			    {

            	ClearFlags(EMarkSelection);

			    SetFlags(EUnmarkSelection);

			    }

			else

			    {

            	ClearFlags(EUnmarkSelection);

			    SetFlags(EMarkSelection);

			    }

			}

		    // order of these is important.

		    if (Flags()&EMarkSelection)

            SelectItemL(iActiveEndIndex);

		    else

            DeselectItem(iActiveEndIndex);

		    //iAnchorIndex = newActiveEndIndex;

		    iActiveEndIndex = newActiveEndIndex;

		    //SetFlags(EAnchorExists);

		    if (Flags()&EMarkSelection)

            SelectItemL(newActiveEndIndex);

		    else

            DeselectItem(newActiveEndIndex);

			DrawItem(iCurrentItemIndex);

		    break;

		case EChangeMarkMode:

		    {

		    // Clear flags, correct flag will be set on later.   

        	ClearFlags(EMarkSelection);

        	ClearFlags(EUnmarkSelection);

        	// If item is hidden, use next non-hidden item to decide markmode.

			while( iItemDrawer->Properties(newActiveEndIndex).IsSelectionHidden() 

			       && newActiveEndIndex != iActiveEndIndex )

			    {

			    if ( newActiveEndIndex > iActiveEndIndex )

			        {

			        newActiveEndIndex--;

			        }

			    else 

			        {

                    newActiveEndIndex++;

		            }

			    }

		    // Change Mark Mode to different than current mark is

			if (ItemIsSelected(newActiveEndIndex))