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

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

#include <eiktxlbm.h>

#include <AknBidiTextUtils.h>

#include <AknUtils.h>

#include <AknsDrawUtils.h>

#include <aknappui.h>

#include <avkon.hrh>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

#include <eswtcore.rsg>

#include <swtlaffacade.h>

#include "eswt.h"

#include "swttablelistbox.h"

#include "swttableitemdrawer.h"

#include "swttablelistboxview.h"

#include "swtimagetextitem.h"

#include "swtfont.h"

// These are only used as a fallback in case skin color is not available

const TInt KSwtGridColorRed(200);

const TInt KSwtGridColorGreen(200);

const TInt KSwtGridColorBlue(200);

#ifdef RD_TACTILE_FEEDBACK

// Id for the only feedback area

const TInt KTouchFeedbackRectId1(0);

#endif // RD_TACTILE_FEEDBACK

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

CSwtTableListBox* CSwtTableListBox::NewL(MSwtDisplay& aDisplay, CSwtTable &aTable)

{

    CSwtTableListBox* self = new(ELeave) CSwtTableListBox(aDisplay, aTable);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

CSwtTableListBox::~CSwtTableListBox()

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->RemoveFeedbackForControl(this);

    }

#endif // RD_TACTILE_FEEDBACK

    delete iOldSelectionArray;

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

    }

}

void CSwtTableListBox::DeselectItems(const TInt* aIndices, TInt aCount) const

{

    if (!aIndices ||

            aCount == 0 ||

            iModel->NumberOfItems() == 0 ||

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

    {

        return; // The array is empty

    }

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

    {

        iView->DeselectItem(aIndices[ i ]);

    }

}

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

{

    TInt count = iModel->NumberOfItems();

    if (count == 0 || aStart >= count || SelectionIndexes()->Count() == 0)

    {

        return;

    }

    if (aStart < 0)

    {

        aStart = 0;

    }

    if (aEnd >= count)

    {

        aEnd = count - 1;

    }

    if (aStart == 0 && aEnd == count - 1)

    {

        ClearSelection();

    }

    else

    {

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

        {

            iView->DeselectItem(i);

        }

    }

}

const MSwtFont& CSwtTableListBox::GetDefaultFont() const

{

    return *iDefaultFont;

}

TRect CSwtTableListBox::GetItemRect(TInt aRowIndex) const

{

    TRect itemRect(iView->ItemPos(aRowIndex), iView->ItemSize(aRowIndex));

    itemRect.Move(0, iTable.GetHeaderHeight());

    return itemRect;

}

TInt CSwtTableListBox::GetSelectionCount() const

{

    return SelectionIndexes()->Count();

}

void CSwtTableListBox::SelectAllL() const

{

    ASSERT(iView);

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

    {

        iView->SelectItemL(index);

    }

}

void CSwtTableListBox::SetFocusIndex(TInt aIndex) const

{

    ASSERT(iView);

    TInt old = CurrentItemIndex();

    if (old != aIndex)

    {

        SetCurrentItemIndex(aIndex);

        iView->DrawItem(aIndex);

        if (old != -1)

        {

            iView->DrawItem(old);

        }

    }

}

void CSwtTableListBox::SelectItemL(TInt aIndex, TBool aScroll) const

{

    ASSERT(aIndex >= 0);

    if (aIndex >= iModel->NumberOfItems() ||

            iView->ItemIsSelected(aIndex))

    {

        return;

    }

    if (!(iTable.Style() & KSwtStyleMulti))

    {

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

        {

            iView->VerticalMoveToItemL(aIndex, CListBoxView::ESingleSelection);

        }

        else

        {

            TInt old = CurrentItemIndex();

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

            iView->SetCurrentItemIndex(aIndex);

            iView->UpdateSelectionL(CListBoxView::ESingleSelection);

            if (old != -1)

            {

                iView->DrawItem(old);

            }

        }

    }

    else

    {

        iView->SelectItemL(aIndex);

        if (aScroll)

        {

            ScrollToMakeItemVisible(aIndex);

        }

    }

}

void CSwtTableListBox::SelectRangeL(TInt aStart, TInt aEnd) const

{

    ASSERT(iListBoxFlags & EMultipleSelection);

    ASSERT(aStart >= 0);

    TInt count = iModel->NumberOfItems();

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

    {

        return;

    }

    if (aEnd >= count)

    {

        aEnd = count - 1;

    }

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

    {

        iView->SelectItemL(index);

    }

}

void CSwtTableListBox::ShowSelection() const

{

    ASSERT(iListBoxFlags & EMultipleSelection);

    if (GetSelectionCount() == 0)

    {

        return;

    }

    TInt smallestIndex = (*SelectionIndexes())[ 0 ];

    for (TInt i = 1; i < SelectionIndexes()->Count(); ++i)

    {

        smallestIndex = Min(smallestIndex, (*SelectionIndexes())[ i ]);

    }

    ScrollToMakeItemVisible(smallestIndex);

}

void CSwtTableListBox::ProcessKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    // Horizontal scrolling

    TInt scrollAmount = HorizontalScrollPixelsPerArrowEvent();

    if (aKeyEvent.iCode == EKeyLeftArrow)

    {

        iView->HScroll(-scrollAmount);

        UpdateScrollBarThumbs();

        return;

    }

    else if (aKeyEvent.iCode == EKeyRightArrow)

    {

        iView->HScroll(scrollAmount);

        UpdateScrollBarThumbs();

        return;

    }

    // No items or not a normal key event

    if (iModel->NumberOfItems() == 0 || aType != EEventKey)

    {

        CEikTextListBox::OfferKeyEventL(aKeyEvent, aType);

        return;

    }

    TBool scroll = aKeyEvent.iCode == EKeyDownArrow || aKeyEvent.iCode == EKeyUpArrow

                   || aKeyEvent.iCode == EKeyNext || aKeyEvent.iCode == EKeyPrevious;

    TBool submit = aKeyEvent.iCode == EKeyEnter || aKeyEvent.iCode == EKeyOK;

    // For performance considerations, assuming that Enter or Select always

    // does change the multi selection. If the assumption is wrong, we must

    // store the multi selection before the key is handled and then compare:

    // if ( ( iListBoxFlags & EMultipleSelection ) && submit )

    // iView->GetSelectionIndexesL( iOldSelectionArray );

    // Store selection before letting the list handle the key.

    if (!(iListBoxFlags & EMultipleSelection) && scroll)

    {

        iPrevFocusIndex = CurrentItemIndex();

    }

    CEikTextListBox::OfferKeyEventL(aKeyEvent, aType);

    if (scroll || submit)

    {

        if (!(iListBoxFlags & EMultipleSelection))

        {

            // Single lists

            if (submit)

            {

                // Item submited, send default selection event.

                iTable.PostDefaultSelectionEventL(CurrentItemIndex());

            }

            else

            {

                if (CurrentItemIndex() != iPrevFocusIndex)

                {

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

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

                    // Item focus highlight moved, send selection event.

                    iTable.PostSelectionEventL(KSwtNone, CurrentItemIndex());

                }

            }

        }

        else

        {

            // Multi lists

            // For performance considerations, assuming that Enter or Select always

            // does change the multi selection. If the assumption is wrong, here's

            // how we must check if the selection really changed:

            // if ( submit && iOldSelectionArray && iOldSelectionArray->Count()

            // != iView->SelectionIndexes()->Count() )

            if (submit)

            {

                // Multi selection changed, send selection event.

                iTable.PostSelectionEventL(KSwtStyleCheck, CurrentItemIndex());

            }

        }

    }

}

void CSwtTableListBox::HandleDataSizeChangeL()

{

    iView->CalcDataWidth();

    SetViewRectFromClientRect(ClientRect());

    TableView()->ValidateHScrollOffset();// Set the offset before updating the scrollbars

    HandleItemAdditionL();               // This will update the scrollbars

}

void CSwtTableListBox::DrawGrid(CWindowGc& aGc, const TRect& aClippingRect) const

{

    TInt lineWidth(iTable.GetGridLineWidth());

    if (lineWidth == 0)

    {

        return;

    }

    aGc.SetClippingRect(aClippingRect);

    TRgb gridLineColor(TRgb(KSwtGridColorRed, KSwtGridColorGreen, KSwtGridColorBlue));

    TInt error = AknsUtils::GetCachedColor(AknsUtils::SkinInstance(),

                                           gridLineColor,

                                           KAknsIIDQsnLineColors,

#ifdef RD_JAVA_S60_RELEASE_9_2

                                           EAknsCIQsnLineColorsCG15

#else

                                           EAknsCIQsnLineColorsCG6

#endif

    aGc.SetPenColor(gridLineColor);

    aGc.SetPenSize(TSize(lineWidth, lineWidth));

    aGc.SetPenStyle(CGraphicsContext::ESolidPen);

    aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

    // Set-up a drawing rectangle to position the grid correctly relative

    // to the view

    TRect drawRect(iTable.ClientRect());

    TRect viewRect = iView->ViewRect();

    const TInt dataWidth(iView->DataWidth());

    const TInt viewWidth(iView->ViewRect().Width());

    const TInt hScrollOffset(iView->HScrollOffset());

    drawRect.iTl.iY = iView->ItemPos(iView->TopItemIndex()).iY;

    drawRect.Move(-hScrollOffset, 0/*TableView()->VOffset()*/);

    drawRect.iBr.iX = drawRect.iTl.iX + dataWidth;

    if (drawRect.iBr.iX < iView->ViewRect().iBr.iX)

    {

        drawRect.iBr.iX = iView->ViewRect().iBr.iX;

    }

    TInt lastPotentialItemIndex = Min(iModel->NumberOfItems() - 1, lastIndex);

    if (drawRect.iBr.iY > viewRect.iBr.iY) drawRect.iBr.iY = viewRect.iBr.iY;

    TInt headerHeight(iTable.GetHeaderHeight());

    // First draw the horizontal lines, if any

    TPoint p1(drawRect.iTl);

    TPoint p2(drawRect.iBr.iX, drawRect.iTl.iY);

    // Draw a line below each item, but stop if we are getting out of

    // clipping rectangle

    TInt itemHeight = ItemHeight();

    while (itemHeight > 0 && p1.iY <= drawRect.iBr.iY && p1.iY <= aClippingRect.iBr.iY)

    {

        aGc.DrawLine(p1, p2);

        p1.iY += itemHeight;

        p2.iY += itemHeight;

    }

    // Then draw the vertical lines

    // Compute the first column edge location

    TSwtTableMargins margins(iTable.GetMargins());

    TInt directionFactor;

    if (AknLayoutUtils::LayoutMirrored())

    {

        directionFactor = -1;

        p1.SetXY(drawRect.iBr.iX, drawRect.iTl.iY);

        p2.SetXY(drawRect.iBr.iX, drawRect.iBr.iY);

    }

    else

    {

        directionFactor = 1;

        p1.SetXY(drawRect.iTl.iX, drawRect.iTl.iY);

        p2.SetXY(drawRect.iTl.iX, drawRect.iBr.iY);

    }

    p1.iX += directionFactor * margins.iLeft;

    p2.iX += directionFactor * margins.iLeft;

    if (iTable.Style() & KSwtStyleMulti ||

            iTable.Style() & KSwtStyleCheck)

    {

        TInt checkBoxWidth(iTable.GetCheckBoxSize().iWidth);

        p1.iX += directionFactor * checkBoxWidth;

        p2.iX += directionFactor * checkBoxWidth;

    }

    // Draw a line after each column

    const RArray<TInt>& columnWidths = iTable.GetColumnWidths();

    TInt columnCount(iTable.GetColumnCount());

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

    {

        TInt linePosDelta(directionFactor * columnWidths[ i ]);

        p1.iX += linePosDelta;

        p2.iX += linePosDelta;

        if (linePosDelta != 0)

        {

            aGc.DrawLine(p1, p2);

        }

    }

}

void CSwtTableListBox::HandleResourceChangeL(TInt aType)

{

    CCoeControl::HandleResourceChange(aType);

    // Update the default font

    if (aType == KEikDynamicLayoutVariantSwitch || aType == KAknsMessageSkinChange)

    {

        iDefaultFont->RemoveRef();

        TableItemDrawer()->SetFont(LayoutFont());

        ResetDefaultFontFromItemDrawerL();

        iTable.ListBoxDefaultFontChanged();

        HandleDataSizeChangeL();

        if (iTable.ListMode())

        {

            iTable.PackColumn(0);

        }

    }

}

TRect CSwtTableListBox::ClientRect() const

{

    TRect rect(Rect());

    if (iSBFrame)

    {

        if (iSBFrame->ScrollBarVisibility(CEikScrollBar::EVertical)

                != CEikScrollBarFrame::EOff)

        {

            if (AknLayoutUtils::LayoutMirrored())

            {

                rect.iTl.iX += iDisplay.UiUtils().ScrollBarBreadth(

                                   iSBFrame->VerticalScrollBar());

            }

            else

            {

                rect.iBr.iX -= iDisplay.UiUtils().ScrollBarBreadth(

                                   iSBFrame->VerticalScrollBar());

            }

        }

        if (iSBFrame->ScrollBarVisibility(CEikScrollBar::EHorizontal)

                != CEikScrollBarFrame::EOff)

        {

            rect.iBr.iY -= iDisplay.UiUtils().ScrollBarBreadth(

                               iSBFrame->GetScrollBarHandle(CEikScrollBar::EHorizontal));

        }

    }

    return rect;

}

void CSwtTableListBox::SetRequiredHeightInNumOfItems(const TInt& aRequiredHeightInNumOfItems)

{

    iRequiredHeightInNumOfItems= aRequiredHeightInNumOfItems;

}

CSwtTableItemDrawer* CSwtTableListBox::TableItemDrawer() const

{

    return static_cast< CSwtTableItemDrawer* >(iItemDrawer);

} //lint !e1763

CSwtTableListBoxView* CSwtTableListBox::TableView() const

{

    return static_cast< CSwtTableListBoxView* >(iView);

} //lint !e1763

void CSwtTableListBox::ResetDefaultFontFromItemDrawerL()

{

    iDefaultFont = CSwtFont::NewL(iDisplay.Device(), *TableItemDrawer()->Font(0));

}

const CFont* CSwtTableListBox::LayoutFont()

{

    const CFont* font = AknLayoutUtils::FontFromId(

                            CSwtLafFacade::GetFontId(CSwtLafFacade::EListSingleGraphicPaneT1Font, 0));