/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <aknenv.h>

#include <aknlists.h>

#include <eikclbd.h>

#include <eikclb.h>

#include "swtsortedlist.h"

const TInt KSwtArrayGranularity = 4;

const TInt KSwtSearchFieldTextLimit = 20;

const TInt KSwtExtraWidthToDisplayCursorInArabicLayout = 1;

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

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

// CSwtSortedList::NewL

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

//

CSwtSortedList* CSwtSortedList::NewL(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                                     MSwtComposite& aParent, TInt aStyle)

{

    CSwtSortedList* self = new(ELeave) CSwtSortedList(

        aDisplay, aPeer, aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtSortedList::~CSwtSortedList

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

//

CSwtSortedList::~CSwtSortedList()

{

    delete iSearchField;

}

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

// CSwtSortedList::CSwtSortedList

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

//

CSwtSortedList::CSwtSortedList(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                               MSwtComposite& aParent, TInt aStyle)

        : CSwtListBase(aDisplay, aPeer, aParent, aStyle)

{

}

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

// CSwtSortedList::ConstructL

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

//

void CSwtSortedList::ConstructL()

{

    if ((iStyle & KSwtStyleDown) != 0)

    {

        iIsOrderDown = ETrue;

    }

    CSwtListBase::ConstructL();

}

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

// CSwtSortedList::Filter

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

//

CAknListBoxFilterItems* CSwtSortedList::Filter() const

{

    // The model created by CSwtListBoxSingle or

    // CSwtListBoxSingleGraphic is CAknFilteredTextListBoxModel.

    CAknFilteredTextListBoxModel* model = STATIC_CAST(

                                              CAknFilteredTextListBoxModel*,iList->Model());

    ASSERT(model);

    return model->Filter();

}

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

// CSwtSortedList::InsertItemL

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

//

void CSwtSortedList::InsertItemL(

    const TDesC &aPtr,

    CDesCArray* aItemArray,

    TKeyCmpText aTextComparisonType)

{

    ASSERT(aItemArray != NULL);

    HBufC* itemText = CreateItemTextLC(aPtr);

    if (!iIsOrderDown)

    {

        aItemArray->InsertIsqAllowDuplicatesL(*itemText, aTextComparisonType);

        iTextItems->InsertIsqAllowDuplicatesL(aPtr, aTextComparisonType);

    }

    else

    {

        TInt ind(0);

        for (ind = 0; ind < iTextItems->Count(); ind++)

        {

            if ((*iTextItems)[ind].CompareC(aPtr) < 0)

            {

                aItemArray->InsertL(ind, *itemText);

                iTextItems->InsertL(ind, aPtr);

                break;

            }

        }

        // If no item in list or if the item must be appended at the end of the list

        if (ind == iTextItems->Count())

        {

            aItemArray->AppendL(*itemText);

            iTextItems->AppendL(aPtr);

        }

    }

    CleanupStack::PopAndDestroy(itemText);

    UpdateListMskL();

}

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

// CSwtSortedList::GetSelectionLC

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

//

CPtrCArray* CSwtSortedList::GetSelectionLC() const

{

    const CArrayFix<TInt>* selectionIndexes = iList->View()->SelectionIndexes();

    if (!selectionIndexes)

    {

        return NULL;

    }

    TInt nbSelection(selectionIndexes->Count());

    CPtrCArray* selectedItemArray = new(ELeave) CPtrC16Array(KSwtArrayGranularity);

    CleanupStack::PushL(selectedItemArray);

    TInt selIndex;

    CAknListBoxFilterItems* filter = NULL;

    if (iSearchField)

    {

        filter = Filter();

    }

    for (TInt index=0; index<nbSelection; ++index)

    {

        selIndex = selectionIndexes->At(index);

        if (selIndex >= 0 && selIndex < iTextItems->Count())

        {

            if (iSearchField && filter)

            {

                if (filter->FilteredNumberOfItems() > 0)// if there are visible items after filtering

                {

                    selIndex = filter->FilteredItemIndex(selIndex);

                    selectedItemArray->AppendL((*iTextItems)[selIndex]);

                }

            }

            else

            {

                selectedItemArray->AppendL((*iTextItems)[selIndex]);

            }

        }

    }

    return selectedItemArray;

}

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

// CSwtSortedList::HandleItemAdditionL

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

//

void CSwtSortedList::HandleItemAdditionL(TInt aNewFocusIndex)

{

    ASSERT(iList->View());

    ASSERT(iList->Model());

    SetTextMaxWidth(ComputeTextMaxWidth());

    if (iSearchField)

    {

        CAknListBoxFilterItems* filter = Filter();

        ASSERT(filter);

        filter->HandleItemArrayChangeL();

    }

    else

    {

        // S60 behavior: the new added item is the new focused item

        // and becomes the top item

        TInt newItemIndex(0);

        if ((aNewFocusIndex >= 0) && (aNewFocusIndex < iList->Model()->NumberOfItems()))

        {

            newItemIndex = aNewFocusIndex;

        }

        iList->SetCurrentItemIndex(newItemIndex);

        if (iList->CurrentItemIndex() >= 0)

        {

            iList->SetTopItemIndex(iList->CurrentItemIndex());

        }

        iList->HandleItemAdditionL();

    }

    // if we are in single selection, update the selection

    // to be the same as the current item index.

    if ((iStyle & KSwtStyleSingle) != 0)

    {

        iList->View()->UpdateSelectionL(CListBoxView::ESingleSelection);

    }

    UpdateListMskL();

}

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

// CSwtSortedList::HandleItemRemovalL

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

//

void CSwtSortedList::HandleItemRemovalL(

    const RArray<TInt>& aRemovedItemIndices,

    TInt aOldFocusIndex)

{

    SetTextMaxWidth(ComputeTextMaxWidth());

    TInt newFocusIndex(0);

    if (aRemovedItemIndices.Count())

    {

        CalcFocusIndexAfterItemRemoval(

            newFocusIndex,

            aRemovedItemIndices,

            aOldFocusIndex);

    }

    ASSERT((newFocusIndex == 0)

           || ((newFocusIndex > 0)

               && (newFocusIndex < iList->Model()->NumberOfItems())));

    iList->SetCurrentItemIndex(newFocusIndex);

    iList->HandleItemRemovalL();

    // Filter update must happen after list update

    if (iSearchField)

    {

        CAknListBoxFilterItems* filter = Filter();

        ASSERT(filter);

        filter->HandleItemArrayChangeL();

    }

    // if we are in single selection, update the selection

    // to be the same as the current item index.

    if ((iStyle & KSwtStyleSingle) != 0)

    {

        iList->View()->UpdateSelectionL(CListBoxView::ESingleSelection);

    }

    UpdateListMskL();

    Redraw();

}

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

// CSwtSortedList::HandleOfferKeyEventL

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

//

void CSwtSortedList::HandleOfferKeyEventL()

{

    if (iSearchField)

    {

        if (iStyle & KSwtStyleSingle)

        {

            const_cast<CListBoxView::CSelectionIndexArray*>(

                iList->View()->SelectionIndexes())->Reset();

        }

        CAknListBoxFilterItems* filter = Filter();

        ASSERT(filter);

        filter->HandleOfferkeyEventL();

        if ((iStyle & KSwtStyleSingle) && iTextItems->Count() > 0)

        {

            iList->View()->SelectItemL(0);

        }

    }

}

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

// CSwtSortedList::SearchFieldHeight

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

//

TInt CSwtSortedList::SearchFieldHeight() const

{

    TInt searchHeight(0);

    if (iSearchField)

    {

        searchHeight = CSwtLafFacade::GetLayoutRect(

                           CSwtLafFacade::EFindPane, BorderInnerRect()).Rect().Height();

    }

    return searchHeight;

}

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

// CSwtSortedList::GetSearchFieldPosition

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

//

void CSwtSortedList::GetSearchFieldPosition(TPoint& aPosition)

{

    TRect controlRect(BorderInnerRect());

    aPosition.iX = controlRect.iTl.iX;

    aPosition.iY = Max(0, controlRect.iBr.iY - SearchFieldHeight());

}

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

// CSwtSortedList::SetSearchFieldSize

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

//

void CSwtSortedList::GetSearchFieldSize(TSize& aSize)

{

    TRect controlRect(BorderInnerRect());

    aSize.iWidth =  controlRect.Width();

    aSize.iHeight = Min(controlRect.Height(), SearchFieldHeight());

}

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

// CSwtSortedList::SetSearchFieldSize

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

//

void CSwtSortedList::UpdateSearchTextViewRect(const CAknSearchField* aSearchField)

{

    if (aSearchField != NULL)

    {

        // Fix to display text cursor in Arabic layout

        TAknLayoutId currentLayoutId;

        CAknEnv::Static()->GetCurrentLayoutId(currentLayoutId);

        if (currentLayoutId == EAknLayoutIdABRW)

        {

            CTextView* textView = aSearchField->Editor().TextView();

            ASSERT(textView);

            TRect viewRect(textView->ViewRect());

            viewRect.iBr.iX += KSwtExtraWidthToDisplayCursorInArabicLayout;

            textView->SetViewRect(viewRect);

        }

    }

}

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

// CSwtSortedList::UpdateSearchFieldBounds

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

//

void CSwtSortedList::UpdateSearchFieldBounds()

{

    TPoint pos;

    TSize size;

    GetSearchFieldPosition(pos);

    GetSearchFieldSize(size);

    iSearchField->SetExtent(pos, size);

    UpdateSearchTextViewRect(iSearchField);

}

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

// CSwtSortedList::UpdateSize

// From CSwtListBase

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

//

void CSwtSortedList::UpdateSize()

{

    TRect controlRect(BorderInnerRect());

    //Update the search field size if exists

    TInt listHeight(controlRect.Height());

    if (iSearchField != NULL)

    {

        listHeight = Max(0, listHeight - SearchFieldHeight());

        UpdateSearchFieldBounds();

    }

    iList->SetSize(TSize(controlRect.Width(), listHeight));

}

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

// CSwtSortedList::CountComponentControls

// From CCoeControl

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

//

TInt CSwtSortedList::CountComponentControls() const

{

    // The filter is orphaned to force its editor to draw CAknSearchField's

    // background instead of our Shell's background.

    return 1;

}

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

// CSwtSortedList::ComponentControl

// From CCoeControl

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

//

CCoeControl* CSwtSortedList::ComponentControl(TInt /*aIndex*/) const

{

    // The filter is orphaned to force its editor to draw CAknSearchField's

    // background instead of our Shell's background.

    return iList;

}

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

// CSwtSortedList::MakeVisible

// From CCoeControl

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

//

void CSwtSortedList::MakeVisible(TBool aVisible)

{

    CCoeControl::MakeVisible(aVisible);

    FocusabilityChanged();

    // WORKAROUND START

    // There can be situations where the cursor is blinking even when the list

    // is not focused. This is yet another slow down but there is no other way

    // to avoid the strange behaviour. The cursor visibility setters are private.

    // Unfocusing the search field will also hide the cursor :)

    if (iSearchField && !IsFocused())

    {

        // Enforce no focus on the editor

        iSearchField->Editor().SetFocus(EFalse);

    }

    // WORKAROUND END

}

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

// CSwtSortedList::SetDimmed

// From CCoeControl

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

//

void CSwtSortedList::SetDimmed(TBool aDimmed)

{

    CCoeControl::SetDimmed(aDimmed);

    iList->SetDimmed(aDimmed);

    if (iSearchField)

    {

        iSearchField->SetDimmed(aDimmed);

    }

    FocusabilityChanged();

}

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

// CSwtSortedList::HandleResourceChange

// From CCoeControl

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

//

void CSwtSortedList::HandleResourceChange(TInt aType)

{

    if (aType == KAknsMessageSkinChange)

    {

        TRAP_IGNORE(CreateIconArrayL(iList));

    }

    CAknControl::HandleResourceChange(aType);

}

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

// CSwtSortedList::HandlePointerEventL

// From CCoeControl

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

//

#ifdef RD_SCALABLE_UI_V2

void CSwtSortedList::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    // Check if we should start filter grabbing

    if (aPointerEvent.iType == TPointerEvent::EButton1Down

            && !iFilterGrabsPointerEvents)

    {

        if (iSearchField && iSearchField->Rect().Contains(aPointerEvent.iPosition))

        {

            iFilterGrabsPointerEvents = ETrue;

        }

    }

    // Deliver event to filter

    if (iFilterGrabsPointerEvents)

    {

        if (iSearchField)

        {

            iSearchField->HandlePointerEventL(aPointerEvent);

        }

    }

    // Check if we should stop filter grabbing

    if (aPointerEvent.iType == TPointerEvent::EButton1Up

            && iFilterGrabsPointerEvents)

    {

        iFilterGrabsPointerEvents = EFalse;

    }

    // Deliver event to list

    if (!iFilterGrabsPointerEvents)

    {

        CSwtListBase::HandlePointerEventL(aPointerEvent);

    }

    else

    {

        PostMouseEventL(aPointerEvent);

    }

}

#endif //RD_SCALABLE_UI_V2

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

// CSwtSortedList::PositionChanged

// From CCoeControl

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

//

void CSwtSortedList::PositionChanged()

{

    //Update the search field size if exists

    if (iSearchField != NULL)

    {

        UpdateSearchFieldBounds();

    }

    CSwtListBase::PositionChanged();

}

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