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

 * 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 <eikenv.h>

#include <aknenv.h>

#include <eikclbd.h>

#include <gulicon.h>

#include <AknUtils.h>

#include <aknappui.h>

#include <avkon.mbg>

#include <aknconsts.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfx.h>

#endif // RD_UI_TRANSITION_EFFECTS_LIST

#include <swtlaffacade.h>

#include "eswtmobileextensions.h"

#include "swtfont.h"

#include "swtlistbase.h"

_LIT(KTextTab, "\t");

const TInt KCheckBoxOffIndex = 1;

const TInt KCheckBoxOnIndex = 0;

const TUint KIconIndexLengthMax = 1;

const TInt KVBorderSides = 2;

const TInt KHBorderSides = 2;

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

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

// CSwtListBase::CreateListBoxL

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

//

CEikTextListBox* CSwtListBase::CreateListBoxL(TInt aStyle)

{

    iListType = (aStyle & KSwtStyleMulti) ? ESwtLbSingleGraphic : ESwtLbSingle;

    CEikTextListBox* listBox = CSwtListBoxLists::NewListL(iListType);

    CSwtListBoxLists::SetListObserver(iListType, listBox, this);

    CleanupStack::PushL(listBox);

    listBox->ConstructL(this, (iStyle & KSwtStyleMulti) ?

                        EAknListBoxStylusMultiselectionList : EAknListBoxSelectionList);

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    // Effects do not work with non window owning scrollbars.

    CWindowGc* gc = listBox->View()->ItemDrawer()->Gc();

    MAknListBoxTfx* transApi = CAknListLoader::TfxApi(gc);

    if (transApi)

    {

        transApi->EnableEffects(EFalse);

    }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

    listBox->SetContainerWindowL(*this);

    listBox->SetCurrentItemIndex(0);

    listBox->MakeVisible(ETrue);

    listBox->SetComponentsToInheritVisibility();

    static_cast<CEikColumnListBox*>(listBox)->ItemDrawer()->ColumnData()->SetSkinEnabledL(EFalse);

#ifdef RD_SCALABLE_UI_V2

    listBox->SetListBoxObserver(this);

#endif // RD_SCALABLE_UI_V2

    CleanupStack::Pop(listBox);

    return listBox;

}

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

// CSwtListBase::CreateListBoxModelL

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

//

void CSwtListBase::CreateListBoxModelL()

{

    iTextItems = new(ELeave) CDesCArrayFlat(3);

}

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

// CSwtListBase::CreateScrollBarsL

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

//

void CSwtListBase::CreateScrollBarsL(CEikTextListBox* aLb)

{

    ASSERT(aLb);

    aLb->CreateScrollBarFrameL();

#ifdef RD_SCALABLE_UI_V2

    // WARNING!!! The expanded touch area does not move correctly togehter with the scrollbars!

    aLb->ScrollBarFrame()->SetScrollBarFrameFlags(CEikScrollBarFrame::EDisableExpandedTouchArea);

#endif // RD_SCALABLE_UI_V2

    // In eSWT all scrollbars must be non window owing the main reason being that

    // the scrollbars must draw at exact same time with the parent control. This

    // is especially essential in ScrolledComposite. If the scrollbars would be

    // window owing, they would draw too much ahead of the parents creating an

    // ugly visual effect when flicking the ScrolledComposite.

    // The drawback of having non window owing scrollbars is too many paint events

    // which affects on the speed of kinetic scrolling in lists.

    aLb->ScrollBarFrame()->CreateDoubleSpanScrollBarsL(EFalse, EFalse, ETrue, EFalse);

    aLb->ScrollBarFrame()->SetScrollBarVisibilityL(

        CEikScrollBarFrame::EOff,

        iStyle & KSwtStyleVScroll ?

        CEikScrollBarFrame::EOn : CEikScrollBarFrame::EOff);

}

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

// CSwtListBase::CreateIconArrayL

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

//

void CSwtListBase::CreateIconArrayL(CEikTextListBox* aLb)

{

    ASSERT(aLb);

    // Create icon array

    CArrayPtr<CGulIcon>* icons = new(ELeave)CArrayPtrFlat<CGulIcon>(2);

    CleanupStack::PushL(icons);

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    // Check box on

    CFbsBitmap* bmp = NULL;

    CFbsBitmap* mask = NULL;

    CGulIcon* checkBox = NULL;

    AknsUtils::CreateIconLC(AknsUtils::SkinInstance(),

                            KAknsIIDQgnPropCheckboxOn, bmp, mask,

                            AknIconUtils::AvkonIconFileName(),

                            EMbmAvkonQgn_prop_checkbox_on,

                            EMbmAvkonQgn_prop_checkbox_on_mask);

    checkBox = CGulIcon::NewL(bmp, mask);

    CleanupStack::PushL(checkBox);

    icons->AppendL(checkBox);

    CleanupStack::Pop(3);   // bmp, mask, checkbox

    // Check box off

    bmp = NULL;

    mask = NULL;

    checkBox = NULL;

    AknsUtils::CreateIconLC(AknsUtils::SkinInstance(),

                            KAknsIIDQgnPropCheckboxOff, bmp, mask,

                            AknIconUtils::AvkonIconFileName(),

                            EMbmAvkonQgn_prop_checkbox_off,

                            EMbmAvkonQgn_prop_checkbox_off_mask);

    checkBox = CGulIcon::NewL(bmp, mask);

    CleanupStack::PushL(checkBox);

    icons->AppendL(checkBox);

    CleanupStack::Pop(3);   // bmp, mask, checkbox

    CleanupStack::Pop(icons);

    // Set icon array

    CColumnListBoxData* listBoxData = static_cast<CEikColumnListBox*>(aLb)->ItemDrawer()->ColumnData();

    if (listBoxData->IconArray())

    {

        listBoxData->IconArray()->ResetAndDestroy();

        delete listBoxData->IconArray();

    }

    listBoxData->SetIconArray(icons);

}

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

// CSwtListBase::CreateItemTextLC

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

//

HBufC* CSwtListBase::CreateItemTextLC(

    const TDesC& aPtr,

    TBool aSelected)

{

    // Allocate memory for the resut string.

    TInt textLength = aPtr.Length() + KTextTab().Length();

    if (iStyle & KSwtStyleMulti)

    {

        textLength += KIconIndexLengthMax;

    }

    HBufC* textBuf = HBufC::NewLC(textLength);

    TPtr itemText(textBuf->Des());

    itemText.Zero();

    if (iStyle & KSwtStyleMulti)

    {

        itemText.AppendNum(aSelected?KCheckBoxOnIndex:KCheckBoxOffIndex);

    }

    itemText.Append(KTextTab);

    itemText.Append(aPtr);

    return textBuf;

}

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

// CSwtListBase::UpdateSize

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

//

void CSwtListBase::UpdateSize()

{

    ASSERT(iList);

    ASSERT(iList->Model());

    iList->SetSize(BorderInnerRect().Size());

}

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

// CSwtListBase::UpdateListBoxFontL

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

//

void CSwtListBase::UpdateListBoxFontL()

{

    ASSERT(iList);

    CColumnListBoxItemDrawer* itemDrawer = static_cast<CEikColumnListBox*>(iList)->ItemDrawer();

    ASSERT(itemDrawer);

    CColumnListBoxData* listBoxData = itemDrawer->ColumnData();

    ASSERT(listBoxData);

    // If a font has been set, apply it to the Avkon list. Its item height is also modified.

    if (iFont)

    {

        TInt newItemHeight(

            iDefaultItemHeight +

            (iFont->Font().HeightInPixels() - DefaultFont().Font().HeightInPixels()));

        newItemHeight = Max(iDefaultItemHeight, newItemHeight);

        iList->SetItemHeightL(newItemHeight);

        listBoxData->SetColumnFontL(KTextColumnIndex, &iFont->Font());

        listBoxData->SetColumnBaselinePosL(KTextColumnIndex, 0);

    }

}

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

// CSwtListBase::UpdateListBoxTextColorL

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

//

void CSwtListBase::UpdateListBoxTextColorL()

{

    ASSERT(iList);

    // If a text color has been set, apply it to the Avkon list.

    if (iTextColor)

    {

        static_cast<CEikColumnListBox*>(iList)->ItemDrawer()->SetTextColor(

            TRgb(iTextColor->RgbValue()));

    }

    // If no color set, then the default color is retrieved

    // from the current skin and applied to the Avkon list.

    else

    {

        MAknsSkinInstance* skin = AknsUtils::SkinInstance();

        TRgb defaultColor;

        TInt error = AknsUtils::GetCachedColor(

                         skin,

                         defaultColor,

                         KAknsIIDQsnTextColors,

                         EAknsCIQsnTextColorsCG6);

        if (!error)

        {

            static_cast<CEikColumnListBox*>(iList)->ItemDrawer()->SetTextColor(defaultColor);

        }

    }

}

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

// CSwtListBase::Scrollable

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

//

MSwtScrollable* CSwtListBase::Scrollable()

{

    return this;

}

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

// CSwtListBase::DeselectItems

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

//

void CSwtListBase::DeselectItems(

    const TInt* aIndices,

    TInt aCount)

{

    ASSERT(iList);

    ASSERT(iList->View());

    if (aIndices)

    {

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

        {

            iList->View()->DeselectItem(aIndices[i]);

        }

    }

    TRAP_IGNORE(UpdateListMskL());

}

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

// CSwtListBase::DeselectItem

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

//

void CSwtListBase::DeselectItem(const TInt aIndex)

{

    ASSERT(iList);

    ASSERT(iList->Model());

    ASSERT(iList->View());

    if (iList->Model()->NumberOfItems() == 0

            || iList->SelectionIndexes()->Count() == 0)

    {

        return;

    }

    iList->View()->DeselectItem(aIndex);

    TRAP_IGNORE(UpdateListMskL());

}

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

// CSwtListBase::DeselectRange

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

//

void CSwtListBase::DeselectRange(TInt aStart, TInt aEnd)

{

    ASSERT(iList);

    ASSERT(iList->Model());

    ASSERT(iList->View());

    TInt count = iList->Model()->NumberOfItems();

    if (count == 0

            || aStart >= count

            || iList->SelectionIndexes()->Count() == 0)

    {

        return;

    }

    if (aStart < 0)

    {

        aStart = 0;

    }

    if (aEnd >= count)

    {

        aEnd = count - 1;

    }

    for (TInt i = aStart; i <= aEnd; i++)

    {

        iList->View()->DeselectItem(i);

    }

    TRAP_IGNORE(UpdateListMskL());

}

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

// CSwtListBase::DeselectAll

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

//

void CSwtListBase::DeselectAll()

{

    ASSERT(iList);

    ASSERT(iList->Model());

    if (iList->Model()->NumberOfItems() == 0

            || iList->SelectionIndexes()->Count() == 0)

    {

        return;

    }

    iList->ClearSelection();

    TRAP_IGNORE(UpdateListMskL());

}

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

// CSwtListBase::GetFocusIndex

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

//

TInt CSwtListBase::GetFocusIndex() const

{

    ASSERT(iList);

    ASSERT(iList->Model());

    if (iList->Model()->NumberOfItems() == 0)

    {

        return -1;

    }

    return iList->CurrentItemIndex();

}

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

// CSwtListBase::GetSelectionCount

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

//

TInt CSwtListBase::GetSelectionCount() const

{

    ASSERT(iList);

    return iList->SelectionIndexes()->Count();

}

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

// CSwtListBase::GetSelectionIndices

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

//

const CArrayFix<TInt>* CSwtListBase::GetSelectionIndices() const

{

    ASSERT(iList);

    return iList->SelectionIndexes();

}

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

// CSwtListBase::SelectItemL

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

//

void CSwtListBase::SelectItemL(TInt aIndex, TBool aScroll)

{

    ASSERT(iList);

    ASSERT(iList->Model());

    ASSERT(iList->View());

    if (aIndex >= iList->Model()->NumberOfItems()

            || iList->View()->ItemIsSelected(aIndex))

    {

        return;

    }

    if (!(iStyle & KSwtStyleMulti))

    {

        if (aScroll && iList->View()->ViewRect().Height() >= iList->ItemHeight())

        {

            iList->View()->VerticalMoveToItemL(aIndex, CListBoxView::ESingleSelection);

        }

        else

        {

            TInt old = iList->CurrentItemIndex();

            //we do not call CEikListBox::SetCurrentItemIndex, because we do not want to scroll.

            iList->View()->SetCurrentItemIndex(aIndex);

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

            if (old != -1)

            {

                iList->View()->DrawItem(old);

            }

        }

    }

    else

    {

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

        if (aScroll)

        {

            iList->ScrollToMakeItemVisible(aIndex);

        }

    }

    UpdateListMskL();

}

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

// CSwtListBase::SelectRangeL

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

//

void CSwtListBase::SelectRangeL(TInt aStart, TInt aEnd)

{

    ASSERT(iList);

    ASSERT(iList->Model());

    ASSERT(iList->View());

    TInt count = iList->Model()->NumberOfItems();

    if (count == 0 || aStart >= count)

    {

        return;

    }

    TInt end(aEnd);

    if (end >= count)

    {

        end = count - 1;

    }

    TInt start(aStart);

    if (start < 0)

    {

        start = 0;

    }

    for (TInt index = start; index <= end; ++index)

    {

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

    }

    UpdateListMskL();

}

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

// CSwtListBase::SelectAllL

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

//

void CSwtListBase::SelectAllL()

{

    ASSERT(iList);

    ASSERT(iList->View());

    for (TInt index = 0; index < iList->Model()->NumberOfItems(); ++index)

    {

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

    }

    UpdateListMskL();

}

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

// CSwtListBase::ShowSelection

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

//

void CSwtListBase::ShowSelection() const

{

    ASSERT(iList);

    if (GetSelectionCount() == 0)

    {

        return;

    }

    iList->ScrollToMakeItemVisible((*iList->SelectionIndexes())[0]);

}

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

// CSwtListBase::PostSelectionEvent

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

//

void CSwtListBase::PostSelectionEvent() const

{

    TRAP_IGNORE(iDisplay.PostSelectionEventL(iPeer));

}