/*

* Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  CAknGridView handles the drawing, the mapping

*                of the grid data index to the underlying listbox index (and

*                vice versa) as well as the movement around the grid.

*

*/

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikdefmacros.h>

#endif

#include <AknGridView.h>

#include <AknGridM.h>

#include <AknUtils.h>

#include <eikenv.h>

#include <gulutil.h>

#include <eiklbv.h>

#include <eiklbi.h>

#include <eiklbm.h>

#include <eiklbx.h>

#include <eiklbx.pan>

#include <eikpanic.h>

#include <eikfrlb.h>

#include <gulutil.h>

#include <eikfrlbd.h>

#include <AknsDrawUtils.h>

#include <AknsControlContext.h>

#include <aknphysics.h>

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfxinternal.h>

#endif //RD_UI_TRANSITION_EFFECTS_LIST

#include "akntrace.h"

/**

 * Local Panic Function and Panic Codes

 */

enum TAknGridViewPanicCodes

    {

    EAknPanicGridViewGeneralPanic,

    EAknPanicGridViewInvalidRowIndex,

    EAknPanicGridViewInvalidColumnIndex,

    EAknPanicGridViewNoGraphicsContext,

    EAknPanicGridViewNoModel,

    EAknPanicGridViewInvalidNumberOfRows,

    EAknPanicGridViewInvalidNumberOfColumns,

    EAknPanicGridViewInvalidItemWidth,

    EAknPanicGridViewInvalidItemHeight

    };

GLDEF_C void Panic(TAknGridViewPanicCodes aPanic)

    {

    _LIT(KPanicCat,"AknGridView");

    User::Panic(KPanicCat, aPanic);

    }

/**

 * Constructor

 */

EXPORT_C CAknGridView::CAknGridView()

    {

    iScrollingType = EScrollFollowsItemsAndLoops;

    iScrollInSecondaryDimension = EScrollFollowsItemsAndLoops;

    iGridDetails.iGridDimensions = TSize(1,1);

    }

/**

 * Destructor

 */

EXPORT_C CAknGridView::~CAknGridView()

    {

    }

// data index <-> row/column calculation

/**

 * Converts a logical position on the grid, where the coordinates are with respect to

 * the top left hand corner of the grid, to an index for the cell with respect to the

 * ordering of the cells in the grid.

 */

EXPORT_C void CAknGridView::DataIndexFromLogicalPos(

    TInt& aItemIndex,

    TInt aRowIndex,

    TInt aColIndex) const

    {

    _AKNTRACE_FUNC_ENTER;

    // row and column orientated from  top left corner which is (0,0)

    // check minimums

    __ASSERT_ALWAYS((aRowIndex >= 0), Panic(EAknPanicGridViewInvalidRowIndex));

    __ASSERT_ALWAYS((aColIndex >= 0), Panic(EAknPanicGridViewInvalidColumnIndex));

    _AKNTRACE( "[%s] aItemIndex = %d aRowIndex = %d aColIndex = %d", 

    		   __FUNCTION__, aItemIndex, aRowIndex, aColIndex );

    // calculate number of cells from lowest index corner

    if (IsPrimaryVertical())

        {

        // work out how many complete columns from lowest index

        // to required position

        TInt numOfCols = aColIndex;

        if (!(iGridDetails.iGridFlags & ELeftToRight))

            numOfCols = (iGridDetails.iGridDimensions.iWidth - 1) - numOfCols;

        // process the row to calculate final index value depending

        // on orientation of lowest index with respect to the top to

        // bottom numbering of the rows.

        TInt adjustment = aRowIndex;

        if (!(iGridDetails.iGridFlags & ETopToBottom))

            {

            adjustment = -(adjustment + 1);

            numOfCols++;

            }

        aItemIndex = numOfCols * NumberOfRowsInView();

        aItemIndex += adjustment;

        }

    else

        {

        TInt numOfRows = aRowIndex;

        if (!(iGridDetails.iGridFlags & ETopToBottom))

            numOfRows = (iGridDetails.iGridDimensions.iHeight - 1) - numOfRows;

        TInt numOfCols  = aColIndex;

        if (!(iGridDetails.iGridFlags & ELeftToRight))

            {

            numOfCols = (NumberOfColsInView() - 1) - numOfCols;

            }

        aItemIndex = numOfRows * NumberOfColsInView();

        aItemIndex += numOfCols;

        }

    _AKNTRACE_FUNC_EXIT;

    }

/**

 * Converts an index for a cell in the grid, given with respect to the ordering

 * of the cells in the grid, to a logical position on the grid, where the coordinates

 * are with respect to the top left hand corner of the grid.

 */

EXPORT_C void CAknGridView::LogicalPosFromDataIndex(

    TInt aItemIndex,

    TInt& aRowIndex,

    TInt& aColIndex) const

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aItemIndex = %d aRowIndex = %d aColIndex = %d", 

    		   __FUNCTION__, aItemIndex, aRowIndex, aColIndex );

    // refer to DataIndexFromLogicalPos above for explanation of mapping of data indexes

    if (aItemIndex > 0)

        {

        if (IsPrimaryVertical())

            {

            aColIndex = aItemIndex / NumberOfRowsInView();

            aRowIndex = aItemIndex % NumberOfRowsInView();

            }

        else

            {

            aRowIndex = aItemIndex / NumberOfColsInView();

            aColIndex = aItemIndex % NumberOfColsInView();

            }

        }

    else

        {

        aRowIndex = 0;

        aColIndex = 0;

        }

    if (!(iGridDetails.iGridFlags & ELeftToRight))

        aColIndex = (iGridDetails.iGridDimensions.iWidth - 1) - aColIndex;

    if (!(iGridDetails.iGridFlags & ETopToBottom))

        aRowIndex = (iGridDetails.iGridDimensions.iHeight - 1) - aRowIndex;

    if (aColIndex < 0)

        aColIndex = 0;

    if (aRowIndex < 0)

        aRowIndex = 0;

    _AKNTRACE_FUNC_EXIT;

    }

/**

 * Converts a CEikListBox index for a cell in the grid, given with respect to the

 * snaking listbox top down, left to right structure underlying the grid

 * structure, to a logical position on the grid, where the coordinates are with

 * respect to the top left hand corner of the grid.

 */

EXPORT_C void CAknGridView::ListBoxIndexFromLogicalPos(

    TInt& aItemIndex,

    TInt aRowIndex,

    TInt aColIndex) const

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aItemIndex = %d aRowIndex = %d aColIndex = %d", 

    		   __FUNCTION__, aItemIndex, aRowIndex, aColIndex );

    // check minimums

    __ASSERT_DEBUG((aRowIndex >= 0), Panic(EAknPanicGridViewInvalidRowIndex));

    __ASSERT_DEBUG((aColIndex >= 0), Panic(EAknPanicGridViewInvalidColumnIndex));

    if(IsPrimaryVertical())

        {

        aItemIndex = aColIndex * NumberOfRowsInView();

        aItemIndex += aRowIndex;

        }

    else

        {

        aItemIndex = aRowIndex * NumberOfColsInView();

        aItemIndex += aColIndex;

        }

    _AKNTRACE_FUNC_EXIT;

    }

/**

 * Converts a logical position on the grid, where the coordinates are with respect to

 * the top left hand corner of the grid, to a CEikListBox index for the cell with

 * respect to the snaking listbox top down, left to right structure underlying the

 * grid structure.

 */

EXPORT_C void CAknGridView::LogicalPosFromListBoxIndex(TInt aItemIndex, TInt& aRowIndex, TInt& aColIndex) const

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aItemIndex = %d aRowIndex = %d aColIndex = %d", 

    		   __FUNCTION__, aItemIndex, aRowIndex, aColIndex );

    aColIndex = 0;

    aRowIndex = 0;

    if (aItemIndex)

        {

        if(IsPrimaryVertical())

            {

            aColIndex = aItemIndex / NumberOfRowsInView();

            aRowIndex = aItemIndex % NumberOfRowsInView();

            }

        else

            {

            aColIndex = aItemIndex % NumberOfColsInView();

            aRowIndex = aItemIndex / NumberOfColsInView();

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

// data index <-> listbox index conversion routines

/**

 * Converts an underlying CEikListBox index into the equivalent grid

 * cell index given with respect to the ordering of the cells in the grid.

 */

EXPORT_C TInt CAknGridView::ActualDataIndex(TInt aListBoxIndex) const

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aListBoxIndex = %d", 

    		   __FUNCTION__, aListBoxIndex );

    TInt logicalRow = 0;

    TInt logicalCol = 0;

    LogicalPosFromListBoxIndex(aListBoxIndex, logicalRow, logicalCol);

    TInt dataIndex = 0;

    DataIndexFromLogicalPos(dataIndex, logicalRow, logicalCol);

    _AKNTRACE_FUNC_EXIT;

    return dataIndex;

    }

/**

 * Converts a grid cell index into the equivalent CEikListBox index for

 * the underlying snaking listbox top down, left to right structure.

 */

EXPORT_C TInt CAknGridView::ListBoxIndex(TInt aDataIndex) const

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aDataIndex = %d", 

    		   __FUNCTION__, aDataIndex );

    TInt logicalRow = 0;

    TInt logicalCol = 0;

    LogicalPosFromDataIndex(aDataIndex, logicalRow, logicalCol);

    TInt listBoxIndex = 0;

    ListBoxIndexFromLogicalPos(listBoxIndex, logicalRow, logicalCol);

    _AKNTRACE_FUNC_EXIT;

    return listBoxIndex;

    }

// the current data item

/**

 * Returns the current data index with respect to the ordering of the cells in

 * the grid.

 */

EXPORT_C TInt CAknGridView::CurrentDataIndex() const

    {

    return ActualDataIndex(iCurrentItemIndex);

    }

/**

 * Sets the current data index with a value given with respect to the ordering of

 * the cells in the grid.

 */

EXPORT_C void CAknGridView::SetCurrentDataIndex(TInt aDataIndex)

    {

    _AKNTRACE( "[%s] aDataIndex = %d", 

    		   __FUNCTION__, aDataIndex );

    TRAP_IGNORE(MoveToItemIndexL(ListBoxIndex(aDataIndex),ENoSelection));

    }

// grid functions

/**

 * Checks that number of cells in the grid is always enough to fill the

 * current grid dimensions. This method should be called after any

 * method that may alter the amount of data within the grid.

 *

 */

EXPORT_C void CAknGridView::SetGridCellDimensions(TSize aGridDimensions)

    {

    // set the new grid size

    iGridDetails.iGridDimensions = aGridDimensions;

    }

/**

 * Returns the current grid dimensions.

 */

EXPORT_C TSize CAknGridView::GridCellDimensions() const

    {

    return iGridDetails.iGridDimensions;

    }

/**

 * Sets the size of the spaces between items.

 */

EXPORT_C void CAknGridView::SetSpacesBetweenItems(TSize aSizeOfSpaceBetweenItems)

    {

    iGridDetails.iSizeBetweenItems = TSize(0,0);

    if (aSizeOfSpaceBetweenItems.iWidth > 0)

        {

        iGridDetails.iSizeBetweenItems.iWidth=aSizeOfSpaceBetweenItems.iWidth;

        }

    if (aSizeOfSpaceBetweenItems.iHeight > 0)

        {

        iGridDetails.iSizeBetweenItems.iHeight=aSizeOfSpaceBetweenItems.iHeight;

        }

    }

/**

 * Sets the form of scroll to activate upon reaching the limit when moving in

 * the primary direction of grid, primary meaning whether the items are

 * organised vertically or horizontally.

 */

EXPORT_C void CAknGridView::SetPrimaryScrollingType(TScrollingType aScrollingType)

    {

    iScrollingType = aScrollingType;

    }

/**

 * Sets the form of scroll to activate upon reaching the limit when moving in

 * the secondary direction of grid.

 */

EXPORT_C void CAknGridView::SetSecondaryScrollingType(TScrollingType aSecondaryScrolling)

    {

    iScrollInSecondaryDimension = aSecondaryScrolling;

    }

/**

 * Returns true if the primary dimension of the grid is

 * vertical.

 */

EXPORT_C TBool CAknGridView::IsPrimaryVertical() const

    {

    return (iGridDetails.iGridFlags & EPrimaryIsVertical);

    }

/**

 * Returns ETrue if the CEikListBox index given exists.

 */

EXPORT_C TBool CAknGridView::ItemExists(TInt aListBoxIndex) const

    {

    TInt totalpossibleitems = iGridDetails.iGridDimensions.iHeight * iGridDetails.iGridDimensions.iWidth;

    return ((aListBoxIndex > -1) && (aListBoxIndex < totalpossibleitems));

    }

/**

 * This has been overloaded to ensure that only valid cells are drawn

 * and not the empty cells.

 */

EXPORT_C void CAknGridView::DrawItem( TInt aItemIndex ) const

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s] aItemIndex = %d", 

    		   __FUNCTION__, aItemIndex );

    if ( RedrawDisabled() || !IsVisible() )

        {

        _AKNTRACE_FUNC_EXIT;

        return;

        }

    if ( ItemExists( aItemIndex ) )

        {

        TBool transparencyEnabled( CAknEnv::Static()->TransparencyEnabled() );

        TBool drawingInitiated = ETrue;

        TPoint itemPosition( ItemPos( aItemIndex ) );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

        MAknListBoxTfxInternal* transApi =

            CAknListLoader::TfxApiInternal( iGc );

#endif // RD_UI_TRANSITION_EFFECTS_LIST

        if ( transparencyEnabled )

            {

            if ( iWin && iWin->GetDrawRect() == TRect::EUninitialized )

                {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

                drawingInitiated = transApi && !transApi->EffectsDisabled();

#else

                drawingInitiated = EFalse;

#endif

                }

            if ( !drawingInitiated )

                {

                TRect itemRect( itemPosition, ItemSize( aItemIndex ) );

                itemRect.Intersection( iViewRect );

                iWin->Invalidate( itemRect );

                iWin->BeginRedraw( itemRect );

                }

            }

        // convert to actual data index

        TInt dataIndex = ActualDataIndex( aItemIndex );

        __ASSERT_DEBUG( (iGc), Panic( EAknPanicGridViewNoGraphicsContext ) );

        if ( GridModel()->IndexContainsData( dataIndex ) )

            {

            // It must be ensured here that an item isn't drawn outside

            // the view rectangle.

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            if ( transApi )

                {

                transApi->StartDrawing( MAknListBoxTfxInternal::EListNotSpecified );

                }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

            iGc->SetClippingRect( iViewRect );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            if ( transApi )

                {

                transApi->StopDrawing();

                }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

            iItemDrawer->DrawItem(

                dataIndex,

                itemPosition,

                ItemIsSelected( aItemIndex ),

                aItemIndex == iCurrentItemIndex,

                ( iFlags & EEmphasized ) == EEmphasized,

                ( iFlags & EDimmed ) == EDimmed );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            if ( transApi )

                {

                transApi->StartDrawing( MAknListBoxTfxInternal::EListNotSpecified );

                }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

            iGc->CancelClippingRect();

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

            if ( transApi )

                {

                transApi->StopDrawing();

                }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

            }

        else

            {

            static_cast<CFormattedCellListBoxItemDrawer*>( iItemDrawer )->

                DrawEmptyItem( dataIndex,

                               ItemPos( aItemIndex ),

                               ( iFlags & EDimmed ) == EDimmed );

            }

        if ( transparencyEnabled && !drawingInitiated )

            {

            iWin->EndRedraw();

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

/**

 * This has been overloaded to ensure that if no cells exist in the

 * grid then an empty grid is displayed. And also to correct drawing.

 */

EXPORT_C void CAknGridView::Draw( const TRect* aClipRect ) const

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "The rect of grid are ( %d, %d ) ( %d, %d )", 

    		   aClipRect->iTl.iX, aClipRect->iTl.iY, 

    		   aClipRect->iBr.iX, aClipRect->iBr.iY );

    if ( RedrawDisabled() || iItemHeight == 0 || ColumnWidth() == 0 )

        {

        _AKNTRACE_FUNC_EXIT;

        return;

        }

    if ( GridModel()->NumberOfData() == 0 )