/*

* 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:  Implementation of the lcdui List component for series 60

*

*/

// INCLUDE FILES

#include "CMIDList.h"

// CMIDDisplayable API for iDisplayable

#include "CMIDDisplayable.h"

// CMIDUtils::CopyBitmapL used in CreateIconLC

#include "CMIDUtils.h"

// using MMIDBitmapImage API in CreateIconLC

#include "lcdgr.h"

#include "lcdui.h"

#include "CMIDFont.h"

// using TMifAvkon enumeration, constants for icons

#include <avkon.mbg>

// classes definitions for creating specific list boxes

#include <aknlists.h>

// CAknSingle2GraphicStyleListBox class for creating specific list box

// CAknDouble2GraphicLargeStyleListBox class for creating specific list box

#include <aknjavalists.h>

// API for ColumnListBoxData

#include <eikclbd.h>

#include <eiklbv.h>

#include <AknBidiTextUtils.h>

// using TDisplayMode in CreateIconLC function for creating alpha bitmap

#include <gdi.h>

// using constant related to list box

#include <avkon.hrh>

#include <AknsDrawUtils.h>

#include <AknsFrameBackgroundControlContext.h>

#include <AknPictographInterface.h>

#include <skinlayout.cdl.h>

// LAF

#include <aknlayoutscalable_avkon.cdl.h> // for layout data

// using CGulIcon API for icons

#include <gulicon.h>

// CEikTextListBox API for iListBox

#include <eiktxlbx.h>

// Predefined directory paths for the use of ROM based sw

// used for retrieving selection icons

#include <data_caging_path_literals.hrh>

#include <j2me/jdebug.h>

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

// API for Popup controller (iPopupController)

#include "CMIDPopupNoteController.h"

/** This macro is executed each time a trapped call returns an error code different than KErrNone */

#undef  TRAP_INSTRUMENTATION_LEAVE

#define TRAP_INSTRUMENTATION_LEAVE(aResult) DEBUG_INT2("In CMIDList.cpp, trapped method was called at line %D and got exception %D", __LINE__, aResult);

// CONSTANTS

_LIT(KNoIconTab,    "\t");

_LIT(KIconTab,      "1\t");

_LIT(KTabulator,    "\t");

_LIT(KSpace,        " ");

// CONSTANTS used for filtering new lines from text

// Do not change sequence

_LIT(KCarriageReturnLineFeedLit,  "\r\n");

_LIT(KCarriageReturnLit,          "\r");

_LIT(KLineFeedLit,                "\n");

_LIT(KLineSeparatorLit,           "\u2028");

_LIT(KEllipsisLit,                "\u2026");

const TUint16 KExtraTabCharacters = 3;

const TUint16 KMaxNum = 10;

const TUint16 KBlankIconIndex = 0;

const TUint16 KUnselected   = '1';

const TUint16 KSelected     = '2';

const TUint16 KIconsImplicit = 1;

const TUint16 KIconsExplicit = 3;

const TUint16 KIconsNotSelected = 1;

const TUint16 KIconsSelected    = 2;

//The first text column in each list type (TListBoxType).

//Index 0 is undefined

const TInt KListTextColumn[] = {-1, 1, 1, 2, 1, 1, 1, 2, 1, 2};

/** The timeout in microseconds for visual updates. When items are added or removed

or modified, the list is not redrawn immediately but only after this timeout. This way

if more items are being added or removed or changed we reduce the number of redraws.

*/

const TInt KVisualUpdateTimeout = 60000; //60 msecs

/*If a visual update has been requested for a period longer than the cap then perform layout

even if the midlet is still performing list update operations. */

const TInt KVisualUpdateCap = 600000; //600 msecs

// ============================ MEMBER FUNCTIONS ===============================

//

// CMIDList::CMIDListItem

//

CMIDList::CMIDListItem* CMIDList::CMIDListItem::NewLC(const TDesC& aText, TInt aIconIndex)

{

    CMIDListItem* self = new(ELeave) CMIDListItem(aIconIndex);

    CleanupStack::PushL(self);

    self->ConstructL(aText);

    return self;

}

CMIDList::CMIDListItem::~CMIDListItem()

{

    delete iText;

    delete iFormatedText;

    iFont = NULL; //not owned

}

/**

 * Return the formatted text of the item. Formatted text contains icon indexes and item text

 * separated by tab characters. Each listbox type requires a different formatted text. See

 * aknlist.h for the details of each listbox.

 *

 * @param aListBoxType The type of avkon list box - this is owned by CMIDList

 * @param aChoiceType  The type of java list box - this is also owned by CMIDList

 *

 * According to aChoiceType we use avkon listboxes differently. And also accordingly to

 * the avkon listbox the formatted text may be different. Hence there is a first if

 * statement on the choice type and then a switch inside each if clause.

 **/

HBufC* CMIDList::CMIDListItem::FormattedTextLC

(const CMIDList::TListBoxType& aListBoxType,

 const MMIDChoiceGroup::TChoiceType& aChoiceType) const

{

    TBuf<KMaxNum> index;

    if (iIconIndex != KBlankIconIndex)

    {

        index.AppendNum(iIconIndex);

    }

    index.Append(KTabulator);

    // single styled ListBox types, fit policy is wrap off, iFormatedText used

    if (aListBoxType == ESingleStyle || aListBoxType == ESingleGraphicStyle

            || aListBoxType == ESingleLargeStyle || aListBoxType == ESingle2GraphicStyle

            || aListBoxType == ESingleGraphicLargeStyle)

    {

        HBufC* text = HBufC::NewMaxLC(KExtraTabCharacters + index.Size() + iFormatedText->Length());

        TPtr textPtr = text->Des();

        if (aChoiceType == MMIDChoiceGroup::EImplicit)

        {

            switch (aListBoxType)

            {

            case ESingleStyle:

                textPtr = KNoIconTab;

                textPtr += *iFormatedText;

                break;

            case ESingleGraphicStyle:

            case ESingleLargeStyle:

                textPtr = index;

                textPtr += *iFormatedText;

                break;

            default:

                User::Invariant();

            }

        }

        else

        {

            switch (aListBoxType)

            {

            case ESingleGraphicStyle:

                textPtr = KIconTab;

                textPtr += *iFormatedText;

                break;

            case ESingle2GraphicStyle:

                textPtr = KIconTab;

                textPtr += index;

                textPtr += *iFormatedText;

                break;

            case ESingleGraphicLargeStyle:

                textPtr = KIconTab;

                textPtr += index;

                textPtr += *iFormatedText;

                textPtr += KTabulator;

                textPtr += KSpace;

                break;

            default:

                User::Invariant();

            }

        }

        return text;

    }

    // double styled ListBox types, fit policy is wrap on, iText used

    else

    {

        HBufC* text = HBufC::NewMaxLC(KExtraTabCharacters + index.Size() + iText->Length());

        TPtr textPtr = text->Des();

        if (aChoiceType == MMIDChoiceGroup::EImplicit)

        {

            switch (aListBoxType)

            {

            case EDouble2Style:

                textPtr = KNoIconTab;

                textPtr += *iText;

                textPtr += KTabulator;

                break;

            case EDouble2GraphicStyle:

            case EDouble2LargeStyle:

                textPtr = index;

                textPtr += *iText;

                textPtr += KTabulator;

                break;

            default:

                User::Invariant();

            }

        }

        else

        {

            switch (aListBoxType)

            {

            case EDouble2GraphicStyle:

                textPtr = KIconTab;

                textPtr += *iText;

                textPtr += KTabulator;

                break;

            case EDouble2GraphicLargeStyle:

                textPtr = KIconTab;

                textPtr += index;

                textPtr += *iText;

                textPtr += KTabulator;

                break;

            default:

                User::Invariant();

            }

        }

        return text;

    }

}

TDesC16& CMIDList::CMIDListItem::Text()

{

    ASSERT(iText);

    return *iText;

}

TInt CMIDList::CMIDListItem::IconIndex() const

{

    return iIconIndex;

}

MMIDFont* CMIDList::CMIDListItem::Font() const

{

    return iFont;

}

TBool CMIDList::CMIDListItem::Selected() const

{

    return iSelected;

}

TBool CMIDList::CMIDListItem::GetPopupNeeded() const

{

    return iPopupNeeded;

}

void CMIDList::CMIDListItem::SetIconIndex(TInt aIconIndex)

{

    ASSERT(aIconIndex >= 0);

    iIconIndex = aIconIndex;

}

/** Replace the text of the item. Delete the memory of the old text. */

void CMIDList::CMIDListItem::SetTextL(const TDesC& aText)

{

    HBufC* newText = aText.AllocL();

    CleanupStack::PushL(newText);

    HBufC* newFormatedText = aText.AllocL();

    CleanupStack::Pop(newText);

    delete iText;

    iText = newText;

    delete iFormatedText;

    iFormatedText = newFormatedText;

    iPopupNeeded = EFalse;

    RemoveNewLineCharactersL();

    RemoveTabulators();

}

void CMIDList::CMIDListItem::SetFont(MMIDFont* aFont)

{

    iFont = aFont;

}

void CMIDList::CMIDListItem::SetSelected(TBool aSelected)

{

    iSelected = aSelected;

}

CMIDList::CMIDListItem::CMIDListItem(TInt aIconIndex)

        : iIconIndex(aIconIndex), iSelected(EFalse)

{

}

void CMIDList::CMIDListItem::ConstructL(const TDesC& aText)

{

    iPopupNeeded = EFalse;

    iText = aText.AllocL();

    RemoveTabulators();

    iFormatedText = iText->Des().AllocL();

    RemoveNewLineCharactersL();

}

void CMIDList::CMIDListItem::RemoveTabulators()

{

    TPtr textPtr = iText->Des();

    TInt tabPosition = textPtr.Find(KTabulator);

    while (tabPosition != KErrNotFound)

    {

        ASSERT(KSpace().Length() <= KTabulator().Length());

        textPtr.Replace(tabPosition, KTabulator().Length(), KSpace);

        tabPosition = textPtr.Find(KTabulator);

    }

}

// Searching new line characters in formatedText, which is copy of item text.

// If new line is found then:

// - new line character is replaced by ellipsis (...),

// - iPopupNeeded is updated to show popup window in

//   CMIDList::ShowInfoPopupL() when needed.

void CMIDList::CMIDListItem::RemoveNewLineCharactersL()

{

    const TInt KNewLineCharsArrayLength = 4;

    const TPtrC KNewLineCharsArray[KNewLineCharsArrayLength] =

    {

        KCarriageReturnLineFeedLit(),

        KCarriageReturnLit(),

        KLineFeedLit(),

        KLineSeparatorLit()

    };

    const TInt ellipsisLen = KEllipsisLit().Length();

    TBool addedEllipsis = EFalse;

    TPtr textPtrNL = iFormatedText->Des();

    TInt textPtrNLLen = textPtrNL.Length();

    // position of first new line separator

    TInt firstNewLinePos = KErrNotFound;

    // position after first new line separator

    TInt endPos = KErrNotFound;

    // count of line separator

    TInt countChar = 0;

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

    {

        firstNewLinePos = textPtrNL.Find(KNewLineCharsArray[i]);

        // if found new line separator

        if (firstNewLinePos != KErrNotFound)

        {

            // if layout alignment is left

            if (!AknLayoutUtils::LayoutMirrored())

            {

                endPos = firstNewLinePos + KNewLineCharsArray[i].Length();

                // There must be a memory reallocation when formated text

                // contains: a piece of text till new line character and

                // ellipsis added, is longer than unformated text.

                if (firstNewLinePos + ellipsisLen + 2 > textPtrNLLen)

                {

                    textPtrNL.Delete(firstNewLinePos,

                                     textPtrNL.Length() - firstNewLinePos);

                    iFormatedText = iFormatedText->ReAllocL(

                                        firstNewLinePos + ellipsisLen);

                    textPtrNL.Set(iFormatedText->Des());

                    if (countChar != 0)

                    {

                        textPtrNL += KEllipsisLit;

                    }

                    ++countChar;

                }

                // when memory reallocation isn't needed

                else

                {

                    textPtrNL.Delete(endPos, textPtrNL.Length() - endPos);

                    textPtrNL.Replace(

                        firstNewLinePos,

                        KNewLineCharsArray[i].Length(),

                        KEllipsisLit);

                    ++countChar;

                }

            }

            // if layout alignment is right

            else

            {

                // Contains: Delete ellipsis if before has been added and

                // a piece of text till new line character

                if (countChar > 0 && addedEllipsis)

                {

                    textPtrNL.Delete(0, ellipsisLen);

                    textPtrNLLen = textPtrNL.Length();

                    textPtrNL.Delete(

                        firstNewLinePos - ellipsisLen,

                        textPtrNLLen - firstNewLinePos + ellipsisLen);

                    firstNewLinePos -= ellipsisLen;

                }

                else

                {

                    textPtrNLLen = textPtrNL.Length();

                    textPtrNL.Delete(

                        firstNewLinePos,

                        textPtrNLLen - firstNewLinePos);

                }

                iFormatedText = iFormatedText->ReAllocL(

                                    textPtrNL.Length() + ellipsisLen);

                textPtrNL.Set(iFormatedText->Des());

                // If new line character is last character of the text and

                // if count of new line character is greater than zero then

                // add ellipsis.

                if (countChar != 0 &&

                        firstNewLinePos + ellipsisLen + 2 > textPtrNLLen)

                {

                    textPtrNL.Insert(0, KEllipsisLit);

                    addedEllipsis = ETrue;

                }

                else

                    // If new line character is not last character of the text

                    // then add ellipsis.

                {

                    if (firstNewLinePos + ellipsisLen + 2 <= textPtrNLLen)

                    {

                        textPtrNL.Insert(0, KEllipsisLit);

                        addedEllipsis = ETrue;

                    }

                    else

                    {

                        addedEllipsis = EFalse;

                    }

                }

                ++countChar;

            }

            iPopupNeeded = addedEllipsis;

        }

    }

}

//

// CMIDList

//

//

// Public construction and destruction methods

//

CMIDList* CMIDList::NewL(MMIDEnv& aEnv, MMIDDisplayable& aDisplayable, TInt aType,

                         RArray<TPtrC>& aStringArray, RArray<MMIDImage*>& aImageArray)

{

    CMIDList* self = new(ELeave) CMIDList(aEnv,aType);

    CleanupStack::PushL(self);

    self->ConstructL(aDisplayable, aStringArray, aImageArray);

    CleanupStack::Pop(self);

    return self;

}

CMIDList::~CMIDList()

{

    TRAP_IGNORE(DeleteAllL());

    delete iPopupController;

    iItems.ResetAndDestroy();

    delete iListBox;

    iListBox = NULL;

    if (iIconArray && iIconArrayOwned)

    {

        iIconArray->ResetAndDestroy();

        delete iIconArray;

    }

    if (iBuiltInSelectCommand)

    {

        iBuiltInSelectCommand->SetObserver(NULL);

        iBuiltInSelectCommand->Dispose();

        iBuiltInSelectCommand = NULL;

    }

    if (iMarkCommand)

    {

        iMarkCommand->SetObserver(NULL);