/*

* 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:  Implementation for colour selection grid.

*

*/

// INCLUDE FILES

#include <aknPopupHeadingPane.h> 

#include <AknIconArray.h>

#include <eikenv.h>

#include <eikcapc.h>

#include <aknlists.h>

#include <bitstd.h>

#include <gulicon.h>

#include <fbs.h>

#include <AknsDrawUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <barsread.h>

#include <AknLayout.lag>

#include <aknenv.h>

#include <skinlayout.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknUtils.h>

#include <akntranseffect.h>

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <uikon/eikenvinterface.h>

#include <uikon/eikdefmacros.h>

#endif

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

#include <aknlistloadertfx.h>

#include <aknlistboxtfxinternal.h>

#endif //RD_UI_TRANSITION_EFFECTS_LIST

#ifdef RD_UI_TRANSITION_EFFECTS_POPUPS

#include <gfxtranseffect/gfxtranseffect.h>

#include <akntransitionutils.h>

#endif

#include <touchfeedback.h>

#include "AknColourSelectionGrid.h"

#include "akntrace.h"

enum TCSelGridFlags

    {

    ECSelGridCloseAfterDPageClicked = 0x01

    };

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

TRect ColourSelectionDialogRect()

    {

    TInt colourPopupVariety = 0;

    if (Layout_Meta_Data::IsLandscapeOrientation())

        {

        switch (AknLayoutUtils::CbaLocation())

            {

            case AknLayoutUtils::EAknCbaLocationBottom:

                //Bottom softkeyt

                colourPopupVariety = 1;

                break;

            case AknLayoutUtils::EAknCbaLocationRight:

                //Right softkeyt

                colourPopupVariety = 2;

                break;

            case AknLayoutUtils::EAknCbaLocationLeft:

                //Left softkeyt

                colourPopupVariety = 3;

                break;

            default:

                break;

            }

        }

    TRect mainPane;

    AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EPopupParent, mainPane );

    TAknLayoutRect colourPopupWindow;

    colourPopupWindow.LayoutRect(mainPane, AknLayoutScalable_Avkon::popup_large_graphic_colour_window(colourPopupVariety));     

    return colourPopupWindow.Rect();

    }

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

// DrawGrayLines

// Draws gray grid to colour selection grid

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

void DrawGrayLines(

    CWindowGc& aGc,

    const TRect& aRect,

    const TBool aNoneExist=ETrue)

    {

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( &aGc );

    if ( transApi )

        {

        transApi->StartDrawing( MAknListBoxTfxInternal::EListView );

        }

#endif

        // get the colour 

        TRgb separatorColor;

        AknsUtils::GetCachedColor(AknsUtils::SkinInstance(), separatorColor, KAknsIIDQsnLineColors, EAknsCIQsnLineColorsCG5 );

        aGc.SetPenStyle(CGraphicsContext::ESolidPen);

        aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

        aGc.SetPenColor(separatorColor);

        TInt paneSeparatorVarietyIndex = aNoneExist;

        TInt gridVarietyIndex = paneSeparatorVarietyIndex;

        // list scroll is inside popup pane

        TAknLayoutRect listScroll;

        listScroll.LayoutRect(aRect, AknLayoutScalable_Avkon::listscroll_popup_colour_pane());

        TRect listScrollRect = listScroll.Rect();

        // the grid is inside listscroll

        TAknLayoutRect grid;

        grid.LayoutRect(listScrollRect, AknLayoutScalable_Avkon::grid_large_graphic_colour_popup_pane(gridVarietyIndex));

        TRect gridRect = grid.Rect();

        // get some layout data

        TAknLayoutScalableParameterLimits limits = AknLayoutScalable_Avkon::cell_large_graphic_colour_popup_pane_ParamLimits();

        // we have to use a hardcoded width for the grid separators, 

        // because we have to make the same assumptions as the grid implementation

        // about how much gap there is between cells

        TInt cols = limits.LastColumn() + 1;

        TInt rows = limits.LastRow() + 1;

        TAknLayoutRect colourCellSize;

        if (aNoneExist)

            {

            colourCellSize.LayoutRect(gridRect, AknLayoutScalable_Avkon::aid_size_cell_colour_3_pane(1));

            }

        else

            {

            colourCellSize.LayoutRect(gridRect, AknLayoutScalable_Avkon::aid_size_cell_colour_1_pane(1));

            }

        TInt cellWidth = colourCellSize.Rect().Width();

        TInt cellHeight = colourCellSize.Rect().Height();

        TInt left = gridRect.iTl.iX;

        TInt right = gridRect.iTl.iX + (cols * cellWidth);

        TInt top = gridRect.iTl.iY;

        TInt bottom = gridRect.iTl.iY + (rows * cellHeight);

        // horizontal lines

        for(TInt row = 0; row < rows; row++)

            {

            // but cheat by dividing the grid rect into four rows 

            TInt y = top + ((row + 1) * cellHeight);

            TPoint start(left, y); // the start of the separator is before the start of the next cell

            TPoint end(right, y);

            aGc.DrawLine( start, end );

            }

        // vertical lines

        for(TInt col = 0; col <cols; col++)

            {

            // but cheat by dividing the grid rect into four cols 

            TInt x = left + ((col + 1) * cellWidth);

            TPoint start(x, top); // the start of the separator is before the start of the next cell

            TPoint end(x, bottom);

            aGc.DrawLine( start, end );

            }

        // fix for TSW error EVWG-7MCBBC

        gridRect.iBr += TPoint( 1, 1 );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    if ( transApi )

        {

        transApi->StopDrawing();

        }

#endif

    aGc.DrawRect( gridRect );

};

// CLASS DECLARATION

/**

* CColorGridView

*

*

*

*  @lib avkon

*  @since 2.0

*/

NONSHARABLE_CLASS(CColorGridView) : public CAknGridView

    {

    public:    

        /**

        * C++ default constructor.

        */

        CColorGridView();

    public: // from CAknGridView

        /**

        * draws gray grid

        * @since 2.0

        * @param aClipRect

        */

        void Draw(const TRect* aClipRect = NULL) const;

        /**

        * Sets iRect and InoneExist

        * @since 2.0

        * @param aRect

        * @param aNoneExist

        */

        void SetRect(const TRect& aRect, const TBool& aNoneExist);

        TPoint ItemPos(TInt aItemIndex) const;

    private: // data

        TAknLayoutRect iHorLine[5];

        TAknLayoutRect iVerLine[5];

        TRect iRect;

        TBool iNoneExist;

        CCoeControl *iControl;

    };

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

// CColorGridView::CColorGridView()

//

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

//

CColorGridView::CColorGridView()

    {

    }

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

// CColorGridView::SetRect()

//

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

//

void CColorGridView::SetRect(const TRect& aRect, const TBool& aNoneExist)

    {

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

    		   __FUNCTION__, 

    		   aRect.iTl.iX, aRect.iTl.iY, 

    		   aRect.iBr.iX, aRect.iBr.iY );

    iRect.SetRect(aRect.iTl, aRect.iBr);

    iNoneExist = aNoneExist;

    }

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

// CColorGridView::Draw()

//

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

//

void CColorGridView::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 );

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iGc );

    if ( transApi )

        {

        TRect drawRect = ViewRect();

        transApi->BeginRedraw(  MAknListBoxTfxInternal::EListView, drawRect );

        }

#endif // RD_UI_TRANSITION_EFFECTS_LIST

    CAknGridView::Draw(aClipRect);

    DrawGrayLines(*iGc, iRect, iNoneExist);

#ifdef RD_UI_TRANSITION_EFFECTS_LIST

    if ( transApi )

        {

        transApi->EndRedraw( MAknListBoxTfxInternal::EListView );

        }

#endif

    _AKNTRACE_FUNC_EXIT;

    }

TPoint CColorGridView::ItemPos( TInt aItemIndex ) const

    {

    TPoint p = CAknGridView::ItemPos( aItemIndex );

    p += TPoint(1,1);

    return p;

    }

/**

* Color grid

*

*  @lib avkon

*  @since 2.0

*/

NONSHARABLE_CLASS(CColorGrid) : public CAknGrid

    {    

public: // from CEikListBox

        void SizeChanged();

public: // from CAknGrid

        /**

        * OfferKeyEventL

        * @since 2.0

        * @param aKeyEvent

        * @param aType

        */

        TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType);

        /**

        * MakeViewClassInstanceL

        * Overriden from CAknGrid. Create the grid view for thus grid class.

        * @since 2.0

        * @ return grid view

        */ 

        CListBoxView* MakeViewClassInstanceL();

        /**

        * Set value to tel does none exist

        * Set value to iNoneExist

        * @since 2.0

        * @param aNoneExist Value to iNoneExist

        */

        void SetNoneExist(const TBool aNoneExist) {iNoneExist = aNoneExist;};

        void SetLegacyMode(TBool aLegacyMode);

        TBool IsLegacyMode();

public: // new functions

    /**

    * Draws the pressed down highlight to the currently selected grid item. 

    */

    void SetPressedDownState();

    /**

    * Clears the pressed down highlight if currently drawn.

    */

    void CleanPressedDownState();

private: // data

    TBool iNoneExist;

    TBool iLegacyMode;        

    TBool iSingleClickEnabled;

    };

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

// CColorGrid::SizeChanged()

//

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

void CColorGrid::SizeChanged()

    {            

    _AKNTRACE_FUNC_ENTER;

    // First call the parent SizeChanged()

    CAknGrid::SizeChanged();

    // Retrieve the itemDrawer

    CFormattedCellListBoxItemDrawer* itemDrawer = ItemDrawer();

    // Start setting up the grid

    AknListBoxLayouts::SetupStandardGrid(*this);

    // we have to calculate the size of each cell so that they match the grid lines

    TRect gridRect = Rect();

    // get some layout data

    TAknLayoutScalableParameterLimits limits = AknLayoutScalable_Avkon::cell_large_graphic_colour_popup_pane_ParamLimits();

    TInt cols = limits.LastColumn() + 1;

    TInt rows = limits.LastRow() + 1;

    TAknLayoutRect colourCellSize;

    if (iNoneExist)

        {

        colourCellSize.LayoutRect(gridRect, AknLayoutScalable_Avkon::aid_size_cell_colour_3_pane(1));

        }

    else

        {

        colourCellSize.LayoutRect(gridRect, AknLayoutScalable_Avkon::aid_size_cell_colour_1_pane(1));

        }

    TInt cellWidth = colourCellSize.Rect().Width() - 1;

    TInt cellHeight = colourCellSize.Rect().Height() - 1;

    // Define the overall size of the cell

    AknListBoxLayouts::SetupGridPos(*this, 0, 0, 0, 0, cellWidth, cellHeight);

    TPoint pointLT(0,0);

    TPoint pointWH(cellWidth, cellHeight);

    AknListBoxLayouts::SetupGridFormGfxCell( *this,

        itemDrawer,

        0/* cell index */,

        AknLayout::colour( iNoneExist ? 0 : 1 ),

        pointLT,

        pointWH );

    // Grid skinning starts

    TAknLayoutRect qsnFrPopupCenter;

    qsnFrPopupCenter.LayoutRect(gridRect,

        SkinLayout::Popup_windows_skin_placing__frame_general__Line_1(gridRect));

    itemDrawer->FormattedCellData()->SetBackgroundSkinStyle(

        &KAknsIIDQsnFrPopupCenter, qsnFrPopupCenter.Rect()); 

    DisableScrolling( ETrue );   

    // Check single click flag

    iSingleClickEnabled = iAvkonAppUi->IsSingleClickCompatible();

    _AKNTRACE_FUNC_EXIT;

    }

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

// CColorGrid::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

//

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

TKeyResponse CColorGrid::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

    {

    _AKNTRACE_FUNC_ENTER;

    TInt code = aKeyEvent.iCode;

    // With single click first key event enables highlight

    if ( iSingleClickEnabled

            && ItemDrawer()->Flags()

            & CListItemDrawer::ESingleClickDisabledHighlight )

        {      

        _AKNTRACE_FUNC_EXIT;

        return CAknGrid::OfferKeyEventL( aKeyEvent,aType );

        }

    CListBoxView::TSelectionMode selectionMode = CListBoxView::ENoSelection;

    TBool shiftKeyPressed = (aKeyEvent.iModifiers & EModifierShift);

    if (iListBoxFlags & EMultipleSelection)

        {

        if (shiftKeyPressed && iListBoxFlags & EShiftEnterMarks)

            {

            View()->SetAnchor(View()->CurrentItemIndex());

            selectionMode = CListBoxView::EDisjointMarkSelection;

            }

        else

            selectionMode = CListBoxView::ENoSelection;

        }

    TInt rowIndex = 0;

    TInt colIndex = 0;

    CAknGridView *view = (CAknGridView*)iView;

    switch (code)

        {

    case EKeyUpArrow:

        view->LogicalPosFromDataIndex(view->CurrentDataIndex(), rowIndex, colIndex);

        if (rowIndex ==0 )

            {

            _AKNTRACE_FUNC_EXIT;

            return EKeyWasNotConsumed;

            }

        iView->MoveCursorL(CListBoxView::ECursorPreviousItem, selectionMode);

        ClearMatchBuffer();

        _AKNTRACE( "[%s] EKeyUpArrow",__FUNCTION__ );

        break;

    case EKeyDownArrow:

        iView->MoveCursorL(CListBoxView::ECursorNextItem, selectionMode);

        ClearMatchBuffer();

        _AKNTRACE( "[%s] EKeyDownArrow",__FUNCTION__ );

        break;

    case EKeyLeftArrow:

        iView->MoveCursorL(CListBoxView::ECursorPreviousColumn, selectionMode);

        ClearMatchBuffer();

        _AKNTRACE( "[%s] EKeyLeftArrow",__FUNCTION__ );

        break;

    case EKeyRightArrow:

        iView->MoveCursorL(CListBoxView::ECursorNextColumn, selectionMode);

        ClearMatchBuffer();

        _AKNTRACE( "[%s] EKeyRightArrow",__FUNCTION__ );

        break;

#if defined(_DEBUG) // only needed when debuging

    case EKeyPageUp:

        iView->MoveCursorL(CListBoxView::ECursorPreviousPage, selectionMode);

        ClearMatchBuffer();

        break;

    case EKeyPageDown:

        iView->MoveCursorL(CListBoxView::ECursorNextPage, selectionMode);

        ClearMatchBuffer();

        break;

    case EKeyHome:

        iView->MoveCursorL(CListBoxView::ECursorFirstItem, selectionMode);

        ClearMatchBuffer();

        break;

    case EKeyEnd:

        iView->MoveCursorL(CListBoxView::ECursorLastItem, selectionMode);

        ClearMatchBuffer();

        break;

#endif// end of debug code

    default:

    	_AKNTRACE_FUNC_EXIT;

        return CEikListBox::OfferKeyEventL(aKeyEvent,aType);

        }

    if (iListBoxFlags & EStateChanged)

        {

        ReportEventL(MCoeControlObserver::EEventStateChanged);

        iListBoxFlags &= (~EStateChanged);

        }

    _AKNTRACE_FUNC_EXIT;

    return EKeyWasConsumed;

    }

CListBoxView* CColorGrid::MakeViewClassInstanceL()

    {

    CListBoxView* view = new (ELeave) CColorGridView();

    return view;

    }