/*

* 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;

    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

/**

* CMainTextArray

*

* 

*

*  @lib avkon

*  @since 2.0

*/

NONSHARABLE_CLASS(CMainTextArray) : public MDesCArray, public CBase

    {

    public:

        /**

        * C++ default constructor.

        */

        CMainTextArray(TBool &aNoneExist);

        /**

        * Destructor.

        */

        ~CMainTextArray();

        /**

        * MdcaCount

        * @since 2.0

        * @return 

        */

        virtual TInt MdcaCount() const;

        /**

        * MdcaPoint

        * @since 2.0

        * @param aIndex 

        * @return 

        */

        virtual TPtrC MdcaPoint(TInt aIndex) const;

        /**

        * ConstructL

        * @since 2.0

        * @param aColours Array of colours to be in grid

        */

        void ConstructL(CArrayFixFlat<TRgb>* aColours);

        /**

        * ReSizeIcons

        * @since 5.2

        * @param aWidth the width of icon

        * @param aheight the height of icon

        */

        void ReSizeIcons( TInt aWidth, TInt aHeight );

    public: // Data

        CGulIcon* iIcon[16];

    private:    // Data

        mutable TInt iIndex;

        TInt iColourNmbr;

        TBool iNoneExist;

        CArrayFixFlat<TRgb>* iColours;

        CFbsBitmap* iBitmap[16];

        CFbsBitmapDevice* iBmpDevice[16];

        HBufC *iString;

    };

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

// CMainTextArray::CMainTextArray()

//

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

//

CMainTextArray::CMainTextArray(TBool &aNoneExist)

        : iNoneExist(aNoneExist)

    {

    }

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

// CMainTextArray::~CMainTextArray()

//

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

//

CMainTextArray::~CMainTextArray()

    {

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

        {

        delete iBitmap[i];

        delete iBmpDevice[i];

        }

    delete iString;

    }

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

// CMainTextArray::ConstructL()

// 

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

//

void CMainTextArray::ConstructL(CArrayFixFlat<TRgb>* aColours)

    {

    this->iColours = aColours;

    iColourNmbr = aColours->Count();

    if (iColourNmbr > 16)

        {

        iColourNmbr = 16;

        }

    TAknLayoutRect r;

    TAknLayoutRect rectPane;

    rectPane.LayoutRect( TRect( 0, 0, 0, 0 ), 

                       AknLayoutScalable_Avkon::cell_large_graphic_colour_popup_pane(

                                                                                     iNoneExist, 

                                                                                     0, 

                                                                                     0).LayoutLine());

    r.LayoutRect( rectPane.Rect(), 

                  AknLayoutScalable_Avkon::cell_large_graphic_colour_popup_pane_g1().LayoutLine());

    TSize bmpsize( r.Rect().Width(), r.Rect().Height() );

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

         {

         iBitmap[i] = new (ELeave) CFbsBitmap();

         iBitmap[i]->Create(bmpsize,EColor4K);

         iIcon[i] = CGulIcon::NewL(iBitmap[i]);

         iIcon[i]->SetBitmapsOwnedExternally(ETrue);

         iBmpDevice[i] = CFbsBitmapDevice::NewL(iBitmap[i]);

         iBmpDevice[i]->Resize(iBitmap[i]->SizeInPixels());

         }

    iString = HBufC::NewL(10);

    }

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

// CMainTextArray::ReSizeIcons()

//

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

//

void CMainTextArray::ReSizeIcons( TInt aWidth, TInt aHeight )

	{

	TSize bmpsize( aWidth, aHeight );

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

		 {

	     if ( iBitmap[i] )

	    	 {

	         iBitmap[i]->Resize( bmpsize );

	    	 }

	     if ( iBmpDevice[i] )

	    	 {

	         iBmpDevice[i]->Resize( iBitmap[i]->SizeInPixels() ); 	

	    	 }

		 }

	}

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

// CMainTextArray::MdcaCount()

//

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

//

TInt CMainTextArray::MdcaCount() const

    {

    return(iColourNmbr);

    }

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

// CMainTextArray::MdcaPoint()

//

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

//

TPtrC CMainTextArray::MdcaPoint(TInt aIndex) const

    {

    TRAP_IGNORE(

        {

        CFbsBitGc* fbsBitGc = CFbsBitGc::NewL();

        CleanupStack::PushL( fbsBitGc );

        fbsBitGc->Activate(iBmpDevice[aIndex]);

        fbsBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

        if (aIndex < iColourNmbr)

            {

            fbsBitGc->SetBrushColor(iColours->At(aIndex));

            }

        fbsBitGc->Clear();

        CleanupStack::PopAndDestroy(); // fbsBitGc

        });

    //fix for TSW error AJUA-7MTAXE

    iString->Des().Num(aIndex); 

    return *iString;

    }

// 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