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

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

#include <aknlists.h>

#include <avkon.mbg>

#include <gulicon.h>

#include <AknIconArray.h>

#include <AknLayoutFont.h>

#include <AknsBasicBackgroundControlContext.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfx.h>

#endif // RD_UI_TRANSITION_EFFECTS_LIST

#include <eswtcore.rsg>

#include <swtlaffacade.h>

#include "swtcontrolmenu.h"

#include "swtmenuitem.h"

#include "swtgrid.h"

#include "swtlistview.h"

#include "swtcontrolhelper.h"

#include "swtinstancecounts.h"

#include "swtdisplay.h"

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#ifdef ESWT_NATIVE_UITHREAD_OWN_HEAP

#define DEBUG_CHECK_IMAGES

#endif // ESWT_NATIVE_UITHREAD_OWN_HEAP

// Column indexes of the subcells in the list item format string.

// Gfx cell has to be first for it to be drawn first.

static const TInt KIconColumn       = 0;

static const TInt KTextColumn       = 1;

static const TInt KItemMarkColumn   = 2;

// Constants used for listbox text string formatting

const TInt KSpaceForIndex = 20;

_LIT(KColumnSeparator, "\t");

_LIT(KSeparatorReplacement, " ");

// The indexes for marked and unmarked icons in the icon array

_LIT(KMarkOffIconArrayIndex, "1");

_LIT(KMarkOnIconArrayIndex, "0");

static const TInt KMarkOnIconArrayIndexInt  = 0;

static const TInt KSwtListViewItemGranularity = 4;

static const TInt KRowCalculationPrecisionInPixels = 5;

// ======== LOCAL FUNCTIONS ========

#ifdef DEBUG_CHECK_IMAGES

static void CheckRefImages(RPointerArray<const MSwtImage>& aRefImgArr,

                           CArrayPtrFlat<CGulIcon>& aImgArr,

                           const TSize& aMaxImageSize)

{

    TInt countImg = aImgArr.Count() - 2;

    TInt countRefImg = aRefImgArr.Count();

    if (countImg != countRefImg)

    {

        ASSERT(EFalse);

    }

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

    {

        const CGulIcon* img = aImgArr[i + 2];

        const MSwtImage* refImg = aRefImgArr[i];

        if (img)

        {

            const CFbsBitmap* bmp = img->Bitmap();

            const CFbsBitmap* mask = img->Mask();

            ASSERT(bmp);

            if (refImg)

            {

                // The item has a valid image.

                // The bitmap is NOT owned.

                ASSERT(img->BitmapsOwnedExternally());

                const CFbsBitmap& bitmap = refImg->Bitmap();

                TSize imageSize = refImg->Bitmap().SizeInPixels();

                imageSize = SwtControlHelper::GetAspectRatioScaledBitmapSize(

                                imageSize, aMaxImageSize);

                __UHEAP_MARK;

                ASSERT(bmp == &refImg->SubBitmap(imageSize));

                ASSERT(mask == refImg->SubMaskBitmap(imageSize, ETrue));

                // If image is not scaled, the primary refcount of

                // the image >= 2, otherwise it's >= 1 and subrefcount

                // for the given size should also be >= 1.

                if (imageSize == refImg->Bitmap().SizeInPixels())

                {

                    ASSERT(refImg->RefCount() >= 2);

                }

                else

                {

                    ASSERT(refImg->RefCount() >= 1);

                    ASSERT(refImg->SubRefCount(imageSize) >= 1);

                }

                __UHEAP_MARKEND;

            }

            else

            {

                // The item has a blank image (null image set from Java side)

                // The bitmap is owned.

                ASSERT(bmp->SizeInPixels() == TSize(0, 0));

                ASSERT(!mask);

            }

        }

    }

}

#endif // DEBUG_CHECK_IMAGES

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

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

// CSwtListView Constructor

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

//

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

                           MSwtComposite& aParent, TInt aStyle)

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

        iLeftToRight(ETrue),

        iTopToBottom(ETrue),

        iNumOfRows(1),

        iNumOfColumns(1),

        iWidthOfSpaceBetweenItems(0),

        iHeightOfSpaceBetweenItems(0),

        iDensity(EMediumListViewDensity),   // must match Java-side default

        iIsGridCellLayoutNeeded(EFalse),

        iFlickScrollingOngoing(EFalse)

{

    // Default to horizontal layout orientation (vertical scrollbar)

    //if( iStyle & KSwtStyleVertical )

    //    {

    //    iVerticalOrientation = ETrue;

    //    }

    //else

    //    {

    iVerticalOrientation = EFalse;

    iStyle &= ~KSwtStyleHScroll;

    iStyle |= KSwtStyleVScroll;

    //    }

}

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

// 2nd phase construction

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

//

void CSwtListView::ConstructL()

{

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

    SetContainerWindowL(coeParent);

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

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

    SetComponentsToInheritVisibility(ETrue);

    iGrid = new(ELeave) CSwtGrid(this);

    iGrid->SetContainerWindowL(*this);

    if (AknLayoutUtils::LayoutMirrored())

    {

        iLeftToRight = EFalse;

    }

    // Construct either markable or normal grid

    TInt gridFlags = 0;

    if (iStyle & KSwtStyleMulti)

    {

#if defined( RD_SCALABLE_UI_V2)

        // For touch to work the same way as in other lists we need different

        // list styles for the grid.

        gridFlags |= CEikListBox::EMultipleSelection |

                     CEikListBox::ES60StyleMultiselection |

                     CEikListBox::EShiftEnterMarks;

#else

        gridFlags |= EAknListBoxMarkableGrid;

#endif

        // Enabling marking only by pressing enter key

        gridFlags |= CEikListBox::EEnterMarks;

        // Create control menu

        iMenu = CSwtControlMenu::NewL(iDisplay, NULL, 0);

        iMenuItemEditList = CSwtMenuItem::NewL(iDisplay, NULL, *iMenu, 0, 0);

        HBufC* buffer = iCoeEnv->AllocReadResourceLC(R_LISTVIEW_EDIT_LIST);

        TPtrC ptr = buffer->Des();

        iMenuItemEditList->SetTextL(ptr);

        CleanupStack::PopAndDestroy(buffer);

        iSubMenu = CSwtControlMenu::NewL(iDisplay, NULL, 0);

        iMenuItemEditList->SetMenuL(iSubMenu);

        iSubMenu->SetObserver(this);

        iMenuItemMarkUnmark = CSwtMenuItem::NewL(iDisplay, NULL, *iSubMenu, 0, 0, EAknCmdMark);

        iMenuItemMarkAll = CSwtMenuItem::NewL(iDisplay, NULL, *iSubMenu, 1, 0, EAknMarkAll);

        iMenuItemUnmarkAll = CSwtMenuItem::NewL(iDisplay, NULL, *iSubMenu, 2, 0, EAknUnmarkAll);

        iMarkString = iCoeEnv->AllocReadResourceL(R_LISTVIEW_MARK_ONE);

        iUnmarkString = iCoeEnv->AllocReadResourceL(R_LISTVIEW_UNMARK_ONE);

        ptr.Set(iMarkString->Des());

        iIsMarkDisplayed = ETrue;

        iMenuItemMarkUnmark->SetTextL(ptr);

        buffer = iCoeEnv->AllocReadResourceLC(R_LISTVIEW_MARK_ALL);

        ptr.Set(buffer->Des());

        iMenuItemMarkAll->SetTextL(ptr);

        CleanupStack::PopAndDestroy(buffer);

        buffer = iCoeEnv->AllocReadResourceLC(R_LISTVIEW_UNMARK_ALL);

        ptr.Set(buffer->Des());

        iMenuItemUnmarkAll->SetTextL(ptr);

        CleanupStack::PopAndDestroy(buffer);

#ifdef RD_SCALABLE_UI_V2

        iStylusPopupMenu = CSwtControlMenu::NewL(iDisplay, NULL, 0);

        iStylusPopupMenu->SetObserver(this);

        iStylusPopupMarkAll = CSwtMenuItem::NewL(iDisplay, NULL, *iStylusPopupMenu, 0, 0, EAknMarkAll);

        iStylusPopupMarkAll->SetTextL(iMenuItemMarkAll->Text());

        iStylusPopupUnmarkAll = CSwtMenuItem::NewL(iDisplay, NULL, *iStylusPopupMenu, 1, 0, EAknUnmarkAll);

        iStylusPopupUnmarkAll->SetTextL(iMenuItemUnmarkAll->Text());

    }

    iOldSelectionArray = new(ELeave) CArrayFixFlat<TInt>(2);

    iSelectionArray = new(ELeave) CArrayFixFlat<TInt>(2);

    iGrid->ConstructL(this, gridFlags);

    CArrayPtr< CGulIcon >* icons = new(ELeave) CAknIconArray(KSwtListViewItemGranularity);

    CleanupStack::PushL(icons);

    // Marked icon

    CGulIcon* markedIcon = GetMarkedItemIconL();

    CleanupStack::PushL(markedIcon);

    icons->AppendL(markedIcon);

    // Unmarked icon

    CGulIcon* unmarkedIcon = CreateIconL(NULL);

    CleanupStack::PushL(unmarkedIcon);

    icons->AppendL(unmarkedIcon);

    // Attach icon array to grid’s item drawer, itemDrawer takes ownership

    iGrid->ItemDrawer()->FormattedCellData()->SetIconArrayL(icons);

    CleanupStack::Pop(3, icons);

    DoGridCellLayoutL(iDensity);

    // This is needed to correct skinned background drawing problems when

    // the control is repositioned.

    iGrid->ItemDrawer()->ColumnData()->SetSkinEnabledL(EFalse);

    // Create non-window owning scrollbars to avoid clipping problems.

    iGrid->CreateScrollBarFrameL();

#ifdef RD_SCALABLE_UI_V2

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

    iGrid->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.

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

    iGrid->SetScrollbarVisibility(KSwtStyleVScroll, ETrue);

    iGrid->SetScrollbarVisibility(KSwtStyleHScroll, EFalse);

    UpdateControlMenu();

    // WORKAROUND! This is to avoid CAknGrid crash when its size is 0

    // and the List Transition Effects try to draw the grid. In fact the

    // root cause of the crash is our Shell not being always ready to draw

    // which is what Avkon expects. If that would be the case, the List

    // Transition Effects will never get a chance to draw a size 0 grid.

    iGrid->SetRect(TRect(0, 0, 1, 0));

#ifdef RD_SCALABLE_UI_V2

    iGrid->SetListBoxObserver(this);

#endif // RD_SCALABLE_UI_V2

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

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

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

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

    if (transApi)

    {

        transApi->EnableEffects(EFalse);

    }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

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

    SetBackground(this);

    ActivateL();

}

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

// Sets up the grid based on the given density and the style flags received

// at the construction time. Can/must be called again to reset the layout.

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

//

void CSwtListView::DoGridCellLayoutL(const TSwtListViewDensity& aDensity)

{

    // Load the layout data for the resolution

    TSize cellSize(0, 0);

    TRect iconSubcell(0, 0, 0, 0);

    TRect selectionMarkSubcell(0, 0, 0, 0);

    TRect textSubcell(0, 0, 0, 0);

    TInt textCellFontId = 0;

    LoadLayouts(aDensity, cellSize, iconSubcell, selectionMarkSubcell, textSubcell, textCellFontId);

    ASSERT(textCellFontId != 0);

    CalcRowsColumns(cellSize, iNumOfColumns, iNumOfRows);

    iGrid->SetLayoutL(iVerticalOrientation,

                      iLeftToRight,

                      iTopToBottom,

                      iNumOfColumns,

                      iNumOfRows,

                      cellSize,

                      iWidthOfSpaceBetweenItems,

                      iHeightOfSpaceBetweenItems);

    iGrid->SetPrimaryScrollingType(CAknGridView::EScrollIncrementLineAndLoops);

    iGrid->SetSecondaryScrollingType(CAknGridView::EScrollIncrementLineAndLoops);

    const CAknLayoutFont* font = AknLayoutUtils::LayoutFontFromId(textCellFontId);

    ASSERT(font != NULL);

    const TInt KTextDefaultColor = 215; // 215 = black, overridden later

    CFormattedCellListBoxItemDrawer* itemDrawer = iGrid->ItemDrawer();

    // Setup the icon subcell

    AknListBoxLayouts::SetupGridFormGfxCell(

        *iGrid,                 // Reference to grid control

        itemDrawer,             // Pointer to the item drawer

        KIconColumn,            // Column index

        iconSubcell.iTl.iX,     // Left position

        iconSubcell.iTl.iY,     // Top position

        0,                      // Right - unused

        0,                      // Bottom - unused

        iconSubcell.Width(),    // Width

        iconSubcell.Height(),   // Height

        iconSubcell.iTl,        // Start position

        iconSubcell.iBr);       // End position

    // Setup the text subcell

    AknListBoxLayouts::SetupFormTextCell(

        *iGrid,                     // Reference to grid

        itemDrawer,                 // Pointer to the item drawer

        KTextColumn,                // Column index

        font,                       // The font

        KTextDefaultColor,          // Color

        textSubcell.iTl.iX,         // Left margin

        0,                          // Right margin - unused

        (textSubcell.iTl.iY + textSubcell.Height() - (font->MaxDescent())),  // Baseline

        textSubcell.Width(),        // Text width

        CGraphicsContext::ECenter,  // Text alignment

        textSubcell.iTl,            // Start position

        textSubcell.iBr);           // End position

    CFormattedCellListBoxData* gridData = itemDrawer->FormattedCellData();

    gridData->SetTransparentSubCellL(KTextColumn, ETrue);

    // Set-up markable grid if required

    if (iStyle & KSwtStyleMulti)

    {

        // Set column index in the format string

        itemDrawer->SetItemMarkPosition(KItemMarkColumn);

        // Set icon array index of marked item icon

        itemDrawer->SetItemMarkReplacement(KMarkOnIconArrayIndex);

        // Don’t display all items as marked initially

        itemDrawer->SetItemMarkReverse(ETrue);

        // Setup the selection mark subcell

        AknListBoxLayouts::SetupFormGfxCell(

            *iGrid,                         // Reference to grid control

            itemDrawer,                     // Pointer to the item drawer

            KItemMarkColumn,                // Column index

            selectionMarkSubcell.iTl.iX,    // Left position

            selectionMarkSubcell.iTl.iY,    // Top position

            0,                              // Right - unused

            0,                              // Bottom - unused

            selectionMarkSubcell.Width(),   // Width

            selectionMarkSubcell.Height(),  // Height

            selectionMarkSubcell.iTl,       // Start position

            selectionMarkSubcell.iBr);      // End position

        gridData->SetTransparentSubCellL(KItemMarkColumn, ETrue);

    }

    TSize maxImageSize = iconSubcell.Size();

    if (iMaxImageSize != maxImageSize)

    {

        UpdateImageSizes(maxImageSize);

        iMaxImageSize = maxImageSize;

    }

    UpdateTextColorL();

}

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

// A helper to get the text array of item texts.

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

//

CDesCArray* CSwtListView::GetTextArray() const

{

    MDesCArray* array = GetGridModel()->ItemTextArray();

    return static_cast<CDesCArray*>(array);

}

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

// A helper to get the array of icons.

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

//

CAknIconArray* CSwtListView::GetIconArray() const

{

    CArrayPtr<CGulIcon>* array = iGrid->ItemDrawer()->FormattedCellData()->IconArray();

    return static_cast<CAknIconArray*>(array);

}

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

// A helper to get the model of the grid.

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

//

CAknGridM* CSwtListView::GetGridModel() const

{

    return static_cast<CAknGridM*>(iGrid->Model());

}

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

// A helper to get the view of the grid.

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

//

CAknGridView* CSwtListView::GetGridView() const

{

    return static_cast<CAknGridView*>(iGrid->View());

}

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

// A helper to get array of logical selection indices.

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

//

void CSwtListView::GetSelection(CArrayFix<TInt>* aSelectionArray) const

{

    CAknGridView* gridView = GetGridView();

    if (aSelectionArray && gridView)

    {

        aSelectionArray->Reset();

        TRAP_IGNORE(gridView->GetSelectionIndexesL(aSelectionArray));

        // The returned indexes are not the logical indexes (which take

        // right-to-left ordering into account), make them logical if

        // necessary.

        if (!iLeftToRight)

        {

            for (int i = 0; i < aSelectionArray->Count(); i++)

            {

                aSelectionArray->At(i) =

                    gridView->ActualDataIndex(aSelectionArray->At(i));

            }

        }

    }

}

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

// A helper to get logical selection index.

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

//

TInt CSwtListView::GetSelectionL(const TInt aIndex) const

{

    if (iLeftToRight)

    {

        return aIndex;

    }

    CAknGridView* gridView = GetGridView();

    if (!gridView)

    {

        User::Leave(ESwtErrorCannotGetSelection);

    }

    return gridView->ActualDataIndex(aIndex);

}

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

// A helper to set selection array of logical selection indices.

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

//

void CSwtListView::SetSelectionL(const CArrayFix<TInt>* aSelectionArray) const

{

    CAknGridView* gridView = GetGridView();

    if (aSelectionArray && gridView)

    {

        gridView->ClearSelection();

        for (TInt i = 0; i < aSelectionArray->Count(); i++)

        {

            TInt item = aSelectionArray->At(i);

            if (!iLeftToRight)