/*

 * Copyright (c) 2002-2010 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:    LandmarksUi Content File - Landmarks icon selector map

 *

 */

// INCLUDE FILES

#include <eikenv.h>

#include <eiksbfrm.h>

#include <eikscrlb.h>

#include <bidivisual.h>

#include <avkon.rsg>

#include <AknPanic.h>

#include <avkon.hrh>

#include <AknUtils.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include <AknLayout.lag>

#include <aknappui.h>

#include <aknconsts.h>

#include <AknDef.h>

#include <PUAcodes.hrh>

#include <s32file.h>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_TACTILE_FEEDBACK

// For the TEikScrollBarModelType

#include <eikscrlb.h>

#include <AknsDrawUtils.h>

#include <featmgr.h>

#include <AknsFrameBackgroundControlContext.h>

#include <lmkui.mbg>

#include "lmkiconmap.h"

#include "CLmkUiUtils.h"

#include <lmkerrors.h>

// The offset because of CEikDialogPage

const TInt KHorizontalDialogMargin = 0;

const TInt KVerticalDialogMargin = 0;

const TInt KAknSctCBaButtonDirections = 3; // bottom, right and left

/// Unnamed namespace for local definitions

namespace

    {

    const TInt KNumOfIcons(16);

    _LIT( KPanicMsg, "CLmkIconMap" );

    void Panic(TPanicCode aReason)

        {

        User::Panic(KPanicMsg, aReason);

        }

    } // namespace

// ============================ EXTENSION CLASS ===============================

//Class Declaration

NONSHARABLE_CLASS(CLmkIconMapExtension) : public CBase,

public MObjectProvider

    {

public:

    CLmkIconMapExtension();

    ~CLmkIconMapExtension();

protected:

    TTypeUid::Ptr MopSupplyObject(TTypeUid aId);

    MObjectProvider* MopNext();

public:

    // data

    MCoeControlObserver *iObserver;

    TUint iFlags;

    MObjectProvider* iIconMap;

    TInt iMaxVisibleRows;

    CAknsFrameBackgroundControlContext* iBgContext;

    };

// ============================ MEMBER FUNCTIONS OF CLmkIconMapExtension ===============================

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

// CLmkIconMapExtension::CLmkIconMapExtension

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CLmkIconMapExtension::CLmkIconMapExtension() :

    iMaxVisibleRows(0)

    {

    iObserver = NULL;

    }

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

// CLmkIconMapExtension::MopSupplyObject()

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

//

TTypeUid::Ptr CLmkIconMapExtension::MopSupplyObject(TTypeUid aId)

    {

    return MAknsControlContext::SupplyMopObject(aId, iBgContext);

    }

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

// CLmkIconMapExtension::MopNext()

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

//

MObjectProvider* CLmkIconMapExtension::MopNext()

    {

    return iIconMap;

    }

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

// CLmkIconMapExtension::~CLmkIconMapExtension()

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

//

CLmkIconMapExtension::~CLmkIconMapExtension()

    {

    delete iBgContext;

    }

// ============================ MEMBER FUNCTIONS OF CLmkIconMap ===============================

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

// CLmkIconMap::CLmkIconMap

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CLmkIconMap::CLmkIconMap() :

    iCursorPos(TPoint(0, 0)), iOldCursorPos(TPoint(0, 0)), iMaxColumns(-1),

            iCurrentPage(0), iNumPages(0)

    {

    iConsArray = (CArrayPtr<CGulIcon>*) NULL;

    }

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

// CLmkIconMap::NewL

// Two-phased constructor.

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

//

CLmkIconMap* CLmkIconMap::NewL()

    {

    CLmkIconMap* self = new (ELeave) CLmkIconMap();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self); //self

    return self;

    }

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

// CLmkIconMap::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CLmkIconMap::ConstructL()

    {

    // Must be created here to get the member variables available

    iExtension = new (ELeave) CLmkIconMapExtension;

    iExtension->iIconMap = this;

    iConsArray = new (ELeave) CAknIconArray(KNumOfIcons);

    iExtension->iFlags = 0x00;

    DoLayout();

    }

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

// CLmkIconMap::~CLmkIconMap()

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

//

CLmkIconMap::~CLmkIconMap()

    {

    delete iSBFrame;

    iSBFrame = (CEikScrollBarFrame*) NULL;

    delete iOffscreenBg;

    delete iBitmapDevice;

    delete iBitmapGc;

    delete iExtension;

    iExtension = (CLmkIconMapExtension*) NULL;

    if (iConsArray)

        {

        iConsArray->ResetAndDestroy();

        delete iConsArray;

        iConsArray = (CArrayPtr<CGulIcon>*) NULL;

        }

    }

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

// CLmkIconMap::DoLayout()

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

//

void CLmkIconMap::DoLayout()

    {

    TRAPD(err, LoadIconL());

    if (err)

        return;

    iIsMirrored = AknLayoutUtils::LayoutMirrored();

    iDrawnBefore = EFalse;

    CountMaxColumnsAndCellSizes();

    SizeChanged();

    }

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

// CLmkIconMap::ConstructFromResourceL()

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

//

void CLmkIconMap::ConstructFromResourceL(TResourceReader& /*aReader*/)

    {

    LoadIconL();

    CreateScrollBarAndIconRowL();

    Extension()->iBgContext = CAknsFrameBackgroundControlContext::NewL(

            KAknsIIDQsnFrPopup, TRect(0, 0, 1, 1), TRect(0, 0, 1, 1), EFalse);

    if (DrawableWindow() && AknLayoutUtils::PenEnabled())

        {

        EnableDragEvents();

        SetGloballyCapturing( ETrue);

        SetPointerCapture(ETrue);

        }

    }

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

// CLmkIconMap::LoadIcons()

// This actually load the all icons to be shown on dialog from icon file

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

//

void CLmkIconMap::LoadIconL()

    {

    if (iConsArray)

        {

        iConsArray->ResetAndDestroy();

        }

    // Draw all the Icons.

    TFileName* iconFile = CLmkUiUtils::LmkUiIconFileLC();

    // Create icon bitmap and mask.

    for (TInt i(0); i < (KNumOfIcons * 2); i++)

        {

        CFbsBitmap* bitmap = NULL;

        CFbsBitmap* bitmapMask = NULL;

        AknIconUtils::CreateIconLC(bitmap, bitmapMask, *iconFile,

                EMbmLmkuiQgn_prop_lm_transport + i,

                EMbmLmkuiQgn_prop_lm_transport + i + 1);

        i++;

        AknIconUtils::SetSize(bitmap, TSize(iGridItemWidth, iGridItemHeight)); //fix

        AknIconUtils::SetSize(bitmapMask, TSize(iGridItemWidth,

                iGridItemHeight)); //fix

        CGulIcon* icon = CGulIcon::NewL(bitmap, bitmapMask);

        CleanupStack::PushL(icon);

        if (iConsArray)

            iConsArray->AppendL(icon);

        CleanupStack::Pop(icon); // icon

        CleanupStack::Pop(bitmapMask); // mask

        CleanupStack::Pop(bitmap); // bitmap

        }

    CleanupStack::PopAndDestroy();// iconFile

    }

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

// CLmkIconMap::HeightInRows()

// This actually returns the no of rows to be shown on a page

// Depends upon the Layout size

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

//

TInt CLmkIconMap::HeightInRows()

    {

    return (iRows);

    }

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

// CLmkIconMap::CreateScrollBarAndIconRowL()

// This actually creates the scroll bar sets the number of

// pages and rows on a page to be shown

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

//

void CLmkIconMap::CreateScrollBarAndIconRowL()

    {

    __ASSERT_DEBUG(iExtension, Panic(KLmkPanicInvalidResourceData));

    __ASSERT_ALWAYS(iConsArray, Panic(KLmkPanicInvalidResourceData));

    iRows = ((iConsArray->Count() - 1) / iMaxColumns) + 1;

    iFirstVisibleRow = 0;

    iAnimated = EFalse;

    iCursorPos = TPoint(0, 0);

    iNumPages = (iRows / iExtension->iMaxVisibleRows) + (iRows

            % iExtension->iMaxVisibleRows ? 1 : 0);

    iCurrentPage = 1;

    // Create and set the scb visible even though there is nothing to scroll

    delete iSBFrame;

    iSBFrame = NULL;

    if (AknLayoutUtils::PenEnabled())

        {

        iSBFrame = new (ELeave) CEikScrollBarFrame(this, this, ETrue);

        }

    else

        {

        iSBFrame = new (ELeave) CEikScrollBarFrame(this, NULL, ETrue);

        }

    // Decide which type of scrollbar is shown

    CAknAppUi* appUi = iAvkonAppUi;

    if (AknLayoutUtils::DefaultScrollBarType(appUi)

            == CEikScrollBarFrame::EDoubleSpan)

        {

        // For EDoubleSpan type scrollbar

        if (AknLayoutUtils::PenEnabled())

            {

            iSBFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse, ETrue,

                    EFalse); // window owning scrollbar

            }

        else

            {

            iSBFrame->CreateDoubleSpanScrollBarsL(EFalse, EFalse, ETrue,

                    EFalse); // non-window owning scrollbar

            }

        iSBFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EDoubleSpan);

        }

    else

        {

        // For EArrowHead type scrollbar

        iSBFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EArrowHead);

        }

    iSBFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,

            CEikScrollBarFrame::EAuto);

    iSBFrame->VerticalScrollBar()->SetMopParent(iExtension);

    UpdateScrollIndicatorL();

    }

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

// CLmkIconMap::SetIndex

// set the reference of the selected icon index from the table

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

//

void CLmkIconMap::SetIndex(TInt& aIconIndex)

    {

    iIconIndex = &aIconIndex;

    }

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

// CLmkIconMap::MinimumSize

//

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

//

TSize CLmkIconMap::MinimumSize()

    {

    iIsMirrored = AknLayoutUtils::LayoutMirrored();

    CountMaxColumnsAndCellSizes();

    TRect rect;

    // Used the set rect, but resolution changes cannot be handled when it is used

    TAknLayoutRect dialogLayRect;

    // Main pane without softkeys

    TRect mainPaneRect;

    if (!AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane,

            mainPaneRect))

        {

        mainPaneRect = iAvkonAppUi->ClientRect();

        }

    // Dialog layout, check variety first

    TAknLayoutScalableParameterLimits iconMapDialogVariety =

            AknLayoutScalable_Avkon::popup_grid_graphic_window_ParamLimits();

    // Calc the variety

    TInt maxVariety = iconMapDialogVariety.LastVariety();

    // Check the CBA, if the orientation is not landscape

    // there is not so much varieties

    AknLayoutUtils::TAknCbaLocation location = AknLayoutUtils::CbaLocation();

    TInt maxVarietyOffset = 0; // the offset for the certain cba location variety

    TInt varietyOffset = maxVariety + 1; // the number of varieties

    // landscape variety number must be calculated offset == number of varieties

    // same applies to the variety number for the biggest sized layout for the variety

    if (Layout_Meta_Data::IsLandscapeOrientation())

        {

        varietyOffset = (maxVariety + 1) / KAknSctCBaButtonDirections; // the offset for one variety

        }

    // for right and left cba buttons the max variety is not zero

    // the varities are ordered by the location of the cba and the descending order

    // e.g the biggest sized layout first, the smallest last

    if (location == AknLayoutUtils::EAknCbaLocationRight)

        {

        maxVarietyOffset = varietyOffset;

        }

    else if (location == AknLayoutUtils::EAknCbaLocationLeft)

        {

        maxVarietyOffset = varietyOffset + varietyOffset; // 2*

        }

    TInt varietyNumber = varietyOffset - iRows - 1;

    // if more lines than possible to show, use the default

    // (the biggest grid) variety

    if (varietyNumber < 0)

        varietyNumber = 0;

    // if zero rows, use the minimum

    else if (iRows <= 0)

        varietyNumber -= 1;

    //add the varietyoffset

    varietyNumber += maxVarietyOffset;

    if (Layout_Meta_Data::IsLandscapeOrientation() && (location

            == AknLayoutUtils::EAknCbaLocationRight))

        {

        varietyNumber = 10;

        }

    else

        {

        if (iRows == 0)

            {

            varietyNumber = 5;

            }

        else

            {

            varietyNumber = 3;

            }

        }

    // Layout the dialog size

    dialogLayRect.LayoutRect(mainPaneRect,

            AknLayoutScalable_Avkon::popup_grid_graphic_window(varietyNumber));

    // Layout the grid

    TAknLayoutRect gridWithScrollLayRect;

    gridWithScrollLayRect.LayoutRect(dialogLayRect.Rect(),

            AknLayoutScalable_Avkon::listscroll_popup_graphic_pane());

    return TSize(dialogLayRect.Rect().Width(),

            gridWithScrollLayRect.Rect().Height());

    }

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

// CLmkIconMap::ActivateL()

// This method is needed to set correct initial value to scroll indicator.

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

//

void CLmkIconMap::ActivateL()

    {

    CCoeControl::ActivateL();

    if (iRows > Extension()->iMaxVisibleRows)

        {

        UpdateScrollIndicatorL();

        }

    }

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

// CLmkIconMap::OfferKeyEventL

// Handles all the Keypad events

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

//

TKeyResponse CLmkIconMap::OfferKeyEventL(const TKeyEvent& aKeyEvent,

        TEventCode /*aModifiers*/)

    {

    TUint code = aKeyEvent.iCode;

    switch (code)

        {

        case EKeyLeftArrow:

        case '4':

            MoveCursorL(-1, 0);

            break;

        case EKeyRightArrow:

        case '6':

            MoveCursorL(1, 0);

            break;

        case EKeyUpArrow:

        case '2':

            MoveCursorL(0, -1);

            break;

        case EKeyDownArrow:

        case '8':

            MoveCursorL(0, 1);

            break;

        case EKeyOK:

        case '5':

        case EKeySpace:

        case EKeyEnter:

            {

            if (iConsArray)

                {

                TInt ret = iMaxColumns * (iFirstVisibleRow + iCursorPos.iY)

                        + iCursorPos.iX;

                if (ret <= iConsArray->Count())

                    {

                    *iIconIndex = ret;

                    }

                else

                    {

                    *iIconIndex = -1;

                    }

                }

            }

            break;

        default:

            return EKeyWasNotConsumed;

        }