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

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

#include <gulicon.h>

#include <avkon.hrh>

#include <aknselectionlist.h>

#include <eikclbd.h>

#include <avkon.mbg>

#include <e32math.h>

#include <aknconsts.h>

#include <AknUtils.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfx.h>

#endif // RD_UI_TRANSITION_EFFECTS_LIST

#include <swtlaffacade.h>

#include "eswtgraphics.h"

#include "swtlistboxlists.h"

#include "swtcontrolhelper.h"

#include "swtlistbox.h"

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

_LIT(KTxtTab, "\t");

_LIT(KTxtSpace, " ");

const TInt KImgIdxNull = -1;

const TInt KImgIdxOn = 0;

const TInt KImgIdxOff = 1;

const TInt KMaxIdxDigitCount = 4;

const TInt KInitImgArrLength = 2;

const TInt KInitTxtArrLength = 2;

const TInt KInitSelArrLength = 1;

const TInt KVBorderSides = 2;

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

//

// CSwtLbItem

//

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

// CSwtLbItem::CSwtLbItem

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

//

CSwtLbItem::CSwtLbItem()

        : CSwtListBoxItem(NULL, NULL, NULL, NULL)

        , iHimgIdx(KImgIdxNull)

        , iDimgIdx(KImgIdxNull)

{

}

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

// CSwtLbItem::CSwtLbItem

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

//

CSwtLbItem::CSwtLbItem(

    HBufC* aDtxt,

    const MSwtImage* aDimg,

    HBufC* aHtxt,

    const MSwtImage* aHimg)

        : CSwtListBoxItem(aDtxt, aDimg, aHtxt, aHimg)

        , iHimgIdx(KImgIdxNull)

        , iDimgIdx(KImgIdxNull)

{

}

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

// CSwtLbItem::CSwtLbItem

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

//

CSwtLbItem::CSwtLbItem(

    HBufC* aDtxt,

    const MSwtImage* aDimg,

    const TSize& aDimgSize,

    HBufC* aHtxt,

    const MSwtImage* aHimg,

    const TSize& aHimgSize)

        : CSwtListBoxItem(aDtxt, aDimg, aDimgSize, aHtxt, aHimg, aHimgSize)

        , iHimgIdx(KImgIdxNull)

        , iDimgIdx(KImgIdxNull)

{

}

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

// CSwtLbItem::~CSwtLbItem

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

//

CSwtLbItem::~CSwtLbItem()

{

}

//

// CSwtListBox

//

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

// CSwtListBox::NewL

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

//

CSwtListBox* CSwtListBox::NewL(

    MSwtDisplay& aDisplay,

    TSwtPeer aPeer,

    MSwtComposite& aParent,

    TInt aStyle)

{

    CSwtListBox* self = new(ELeave) CSwtListBox(

        aDisplay,

        aPeer,

        aParent,

        aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtListBox::CSwtListBox

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

//

CSwtListBox::CSwtListBox(

    MSwtDisplay& aDisplay,

    TSwtPeer aPeer,

    MSwtComposite& aParent,

    TInt aStyle)

        : ASwtScrollableBase(aDisplay, aPeer, &aParent, aStyle)

{

}

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

// CSwtListBox::~CSwtListBox

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

//

CSwtListBox::~CSwtListBox()

{

    // Selection items, own

    delete iPrevSelItems;

    iPrevSelItems = NULL;

    // Contained list, own

    delete iList;

    iList = NULL;

    // List images, not own. The array is reset and destroyed by

    // the destructor of the contained Avkon list

    iImgs = NULL;

    // List texts, own.

    if (iTxts)

    {

        iTxts->Reset();

        delete iTxts;

        iTxts = NULL;

    }

    // Remove all items

    RemoveSubRefs();

    iItems.ResetAndDestroy();

    // Item cells, own.

    iCells.Close();

    // Current and default colors, not own

    iDefColor = NULL;

    iColor = NULL;

}

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

// CSwtListBox::ConstructL

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

//

void CSwtListBox::ConstructL()

{

    CCoeControl& coeParent = iParent->Control()->CoeControl();

    SetContainerWindowL(coeParent);

    SetComponentsToInheritVisibility(ETrue);

    CCoeControl::MakeVisible(coeParent.IsVisible());

    CCoeControl::SetDimmed(coeParent.IsDimmed());

    // This is indeed necessary, otherwise the background might not be drawn!

    SetBackground(this);

}

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

// CSwtListBox::CountComponentControls

// From CCoeControl

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

//

TInt CSwtListBox::CountComponentControls() const

{

    return iList ? 1 : 0;

}

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

// CSwtListBox::ComponentControl

// From CCoeControl

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

//

CCoeControl* CSwtListBox::ComponentControl(TInt) const

{

    return iList;

}

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

// CSwtListBox::MakeVisible

// From CCoeControl

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

//

void CSwtListBox::MakeVisible(TBool aVisible)

{

    CCoeControl::MakeVisible(aVisible);

    FocusabilityChanged();

}

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

// CSwtListBox::SetDimmed

// From CCoeControl

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

//

void CSwtListBox::SetDimmed(TBool aDimmed)

{

    CCoeControl::SetDimmed(aDimmed);

    iList->SetDimmed(aDimmed);

    FocusabilityChanged();

}

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

// CSwtListBox::OfferKeyEventL

// From CCoeControl

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

//

TKeyResponse CSwtListBox::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType)

{

    TBool traversalDoIt = ETrue;

    // No traverse on enter / select

    if ((iStyle & KSwtStyleMulti)

            && (aKeyEvent.iCode == EKeyEnter

                || aKeyEvent.iCode == EKeyOK))

    {

        traversalDoIt = EFalse;

    }

    // No traverse on scroll by default

    if (aKeyEvent.iCode == EKeyDownArrow

            || aKeyEvent.iCode == EKeyUpArrow)

    {

        traversalDoIt = EFalse;

        if (aKeyEvent.iCode == EKeyDownArrow)

        {

            // Traverse if last item is focused and

            // there are other controls to traverse to

            if (iList->View()->CurrentItemIndex()

                    == (iList->Model()->NumberOfItems() - 1))

            {

                if (GetShell().FindTraversalTargetL(

                            ESwtTraverseArrowNext,

                            *this))

                {

                    traversalDoIt = ETrue;

                }

            }

        }

        else

        {

            // Traverse if first item is focused and

            // there are other controls to traverse to

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

            {

                if (GetShell().FindTraversalTargetL(

                            ESwtTraverseArrowPrevious,

                            *this))

                {

                    traversalDoIt = ETrue;

                }

            }

        }

    }

    return HandleKeyL(aKeyEvent, aType, traversalDoIt);

}

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

// CSwtListBox::HandleResourceChange

// From CCoeControl

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

//

void CSwtListBox::HandleResourceChange(TInt aType)

{

    if (aType == KAknsMessageSkinChange)

    {

        if (iProps.iSelectionType == ESwtLbMultiSelection)

        {

            TRAP_IGNORE(CreateListSelImgsL(iImgs));

        }

    }

    CAknControl::HandleResourceChange(aType);

    SetMaximumIconSizes();

}

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

// CSwtListBox::HandlePointerEventL

// From CCoeControl

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

//

#ifdef RD_SCALABLE_UI_V2

void CSwtListBox::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    ASSERT(iList);

    CEikScrollBarFrame* sbFrame = iList->ScrollBarFrame();

    CEikScrollBar* vsb = sbFrame ? sbFrame->GetScrollBarHandle(CEikScrollBar::EVertical) : NULL;

    // Check if we should start scrollbar grabbing

    if (aPointerEvent.iType == TPointerEvent::EButton1Down && !iVScrollBarGrabsPointerEvents)

    {

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

        {

            iVScrollBarGrabsPointerEvents = ETrue;

        }

    }

    // Deliver event to scrollbar

    if (iVScrollBarGrabsPointerEvents && vsb)

    {

        vsb->HandlePointerEventL(aPointerEvent);

    }

    // Deliver event to list

    if (!iVScrollBarGrabsPointerEvents)

    {

        // Store the selection on first pointer event.

        if (aPointerEvent.iType == TPointerEvent::EButton1Down)

        {

            if (iStyle & KSwtStyleMulti)

            {

                // Multi lists

                ASSERT(iPrevSelItems);

                GetUserSelectionL(iPrevSelItems);

            }

            iPrevFocusIndex = iList->View()->CurrentItemIndex();

        }

        iList->HandlePointerEventL(aPointerEvent);

        if (aPointerEvent.iType == TPointerEvent::EButton1Up)

        {

            TInt focusIndex = iList->View()->CurrentItemIndex();

            if (iStyle & KSwtStyleMulti)

            {

                // Multi lists

                if ((iList->View()->SelectionIndexes()->Count() != iPrevSelItems->Count()))

                {

                    if (iDisplay.RevertPointerEvent())

                    {

                        // Revert newly checked item.

                        if (iList->View()->ItemIsSelected(focusIndex))

                        {

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

                        }

                        else

                        {

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

                        }

                    }

                    else

                    {

                        iDisplay.PostSelectionEventL(iPeer);

                    }

                }

            }

            else

            {

                // Single lists

                // Compare the focus index after tap or drag ended

                if (focusIndex != iPrevFocusIndex)

                {

                    // Ensure the selection and focus index are in sync.

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

                    // Item focus highlight moved, send selection event.

                    // Changing the focus index is not subject to reverting.

                    iDisplay.PostSelectionEventL(iPeer);

                }

                // The default selection is sent from HandleListBoxEventL!

            }

        }

    }

    // Stop scrollbar grabbing

    if (iVScrollBarGrabsPointerEvents

            && aPointerEvent.iType == TPointerEvent::EButton1Up)

    {

        iVScrollBarGrabsPointerEvents = EFalse;

    }

}

#else //RD_SCALABLE_UI_V2

void CSwtListBox::HandlePointerEventL(

    const TPointerEvent& /*aPointerEvent*/)

{

}

#endif //RD_SCALABLE_UI_V2

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

// CSwtListBox::SizeChanged

// From CCoeControl

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

//

void CSwtListBox::SizeChanged()

{

    SetMaximumIconSizes();

    if (iList)

    {

        // The redraw is restored after the initialization of the listbox.

        if (iRestoreRedraw)

        {

            iRestoreRedraw = EFalse;

            iList->View()->SetDisableRedraw(EFalse);

        }

        TRect rect = BorderInnerRect();

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

        // This is a workaround for the list being drawn in the wrong place if

        // it is placed inside a mobile shell.

        iList->SetPosition(rect.iTl);

    }

    HandleSizeChanged();

}

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

// CSwtListBox::PositionChanged

// From CCoeControl

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

//

void CSwtListBox::PositionChanged()

{

    HandlePositionChanged();

}

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

// CSwtListBox::FocusChanged

// From CCoeControl

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

//

void CSwtListBox::FocusChanged(TDrawNow aDrawNow)

{

    TBool isFocused = IsFocusControl();

    // This gets called before contained list is created.

    if (iList)

    {

        iList->SetFocus(isFocused, aDrawNow);

    }

    HandleFocusChanged(aDrawNow);

}

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

// CSwtListBox::MopSupplyObject

// From CCoeControl

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

//

TTypeUid::Ptr CSwtListBox::MopSupplyObject(TTypeUid aId)

{

    TTypeUid::Ptr id = ASwtControlBase::SwtMopSupplyObject(aId);

    if (id.Pointer() == NULL)

    {

        return CAknControl::MopSupplyObject(aId);

    }

    else

    {

        return id;

    }

}

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

// CSwtListBox::Draw

// From CCoeControl

// Overriding Draw just to set correct clipping rect for the item drawer of

// the contained list. The contained list will be drawn immediately after this.

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

//

void CSwtListBox::Draw(const TRect& /*aRect*/) const

{

    // Suppress margins - they are drawn over scrollbars

    CSwtListBoxLists::SetMargins(iProps.iListType, iList, 0, 0);

    if (GetShell().UrgentPaintControl() == this)

        return;

    TRect clipRect(ClipToVisibleRect(iList->View()->ViewRect()));

    if (clipRect != iLastViewVisibleRect)

    {

        CSwtListBoxLists::SetItemDrawerClippingRect(iProps.iListType, iList, clipRect);

        iLastViewVisibleRect = clipRect;

    }

}

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

// CSwtListBox::MSKLabelL

// From ASwtControlBase

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

//

HBufC* CSwtListBox::MSKLabelL() const

{