/*

* Copyright (c) 2006 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 of CCmDestinationIconMap

*

*/

#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 <data_caging_path_literals.hrh>

#include <aknappui.h>

#include <aknconsts.h>

#include <AknDef.h>

#include <PUAcodes.hrh>

#include <s32file.h>

#include <eikscrlb.h>   // TEikScrollBarModelType

#include <AknsDrawUtils.h>

#include <featmgr.h>

#include <AknsFrameBackgroundControlContext.h>

#include <cmmanager.mbg>

#include <cmcommonconstants.h>

#include <touchfeedback.h>

#include "cmdesticonmap.h"

#include "cmmanagerimpl.h"

// The offset because of CEikDialogPage

const TInt KHorizontalDialogMargin = 0;

const TInt KVerticalDialogMargin = 0;

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

/**

 * Extension class to CCmDestinationIconMap

 *

 * @since S60 v3.2

 */

NONSHARABLE_CLASS( CCmDestinationIconMapExtension ) : public CBase, 

                                                      public MObjectProvider

    {

    public:

        CCmDestinationIconMapExtension();

        ~CCmDestinationIconMapExtension();

    protected:

        TTypeUid::Ptr MopSupplyObject( TTypeUid aId );

        MObjectProvider* MopNext();

    public: // data

        MCoeControlObserver *iObserver;

        TUint iFlags;

        MObjectProvider* iIconMap;       

        TInt iMaxVisibleRows;

        CAknsFrameBackgroundControlContext* iBgContext;

    };

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

// CCmDestinationIconMapExtension::CCmDestinationIconMapExtension

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

// might leave.

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

//

CCmDestinationIconMapExtension::CCmDestinationIconMapExtension()

    : iMaxVisibleRows( 0 )

    {

    iObserver = NULL;

    }

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

// CCmDestinationIconMapExtension::MopSupplyObject()

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

//

TTypeUid::Ptr CCmDestinationIconMapExtension::MopSupplyObject( TTypeUid aId )

    {

    return MAknsControlContext::SupplyMopObject( aId, iBgContext );

    }

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

// CCmDestinationIconMapExtension::MopNext()

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

//    

MObjectProvider* CCmDestinationIconMapExtension::MopNext()

    {

    return iIconMap;

    }

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

// CCmDestinationIconMapExtension::~CCmDestinationIconMapExtension()

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

//

CCmDestinationIconMapExtension::~CCmDestinationIconMapExtension()

    {

    delete iBgContext;

    iBgContext = NULL;

    }

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

// CCmDestinationIconMap::CCmDestinationIconMap

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

// might leave.

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

//

CCmDestinationIconMap::CCmDestinationIconMap() 

    : iCursorPos( TPoint( 0,0 ) )

    , iOldCursorPos( TPoint( 0,0 ) )

    , iMaxColumns( -1 )

    , iDragAlreadyActive( EFalse )

    {

    }

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

// CCmDestinationIconMap::NewL

// Two-phased constructor.

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

//

CCmDestinationIconMap* CCmDestinationIconMap::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); //self

    return self;    

    }

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

// CCmDestinationIconMap::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCmDestinationIconMap::ConstructL()

    {

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

    iExtension = new ( ELeave ) CCmDestinationIconMapExtension;

    iExtension->iIconMap = this;

    iConsArray = new( ELeave ) CAknIconArray( KNumOfIcons );

    iExtension->iFlags = 0x00;

    DoLayout();

    }

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

// CCmDestinationIconMap::~CCmDestinationIconMap()

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

//

CCmDestinationIconMap::~CCmDestinationIconMap()

    {

    delete iSBFrame; iSBFrame = NULL;

    delete iOffscreenBg;

    delete iBitmapDevice;

    delete iBitmapGc;

    delete iExtension; 

    iExtension = ( CCmDestinationIconMapExtension* )NULL;

    if ( iConsArray )

        {

        iConsArray->ResetAndDestroy();

        delete iConsArray;

        iConsArray = NULL;

        }

   }

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

// CCmDestinationIconMap::DoLayout()

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

//

void CCmDestinationIconMap::DoLayout() 

    {

    TRAPD( err,LoadIconL() );

    if ( err )

        {

        return;

        }

    iIsMirrored = AknLayoutUtils::LayoutMirrored();

    iDrawnBefore = EFalse;

    CountMaxColumnsAndCellSizes();

    SizeChanged();

    }

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

// CCmDestinationIconMap::ConstructFromResourceL()

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

//

void CCmDestinationIconMap::ConstructFromResourceL( 

                                                TResourceReader& /*aReader*/ )

    {

    LoadIconL();

    CreateScrollBarAndIconRowL();

    iExtension->iBgContext = CAknsFrameBackgroundControlContext::NewL( 

                                                            KAknsIIDQsnFrPopup, 

                                                            TRect( 0, 0, 1, 1 ), 

                                                            TRect( 0, 0, 1, 1 ), 

                                                            EFalse );

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

        {

        EnableDragEvents();       

        SetGloballyCapturing( ETrue );

        SetPointerCapture( ETrue );

        }

    }

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

// CCmDestinationIconMap::LoadIcons()

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

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

//

void CCmDestinationIconMap::LoadIconL()

    // Draw all the Icons.

    TParse mbmFile;

    User::LeaveIfError( mbmFile.Set( KManagerIconFilename, 

                                     &KDC_APP_BITMAP_DIR, NULL ) );

    // Create icon bitmap and mask.

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

        {

        CFbsBitmap* bitmap = NULL;

        CFbsBitmap* bitmapMask = NULL;

        AknIconUtils::CreateIconLC( 

                   bitmap, 

                   bitmapMask, mbmFile.FullName(),

                   EMbmCmmanagerQgn_prop_set_conn_dest_internet_small + i, 

                   EMbmCmmanagerQgn_prop_set_conn_dest_internet_small + i + 1 );

        i++;

        AknIconUtils::SetSize( bitmap, 

                               TSize( iGridItemWidth, iGridItemHeight ) );

        AknIconUtils::SetSize( bitmapMask, 

                               TSize( iGridItemWidth, iGridItemHeight ) );

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

        CleanupStack::PushL( icon );

        iConsArray->AppendL( icon );       

        CleanupStack::Pop( 3, bitmap );

        }        

    }

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

// CCmDestinationIconMap::HeightInRows()

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

// Depends upon the Layout size

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

//

TInt CCmDestinationIconMap::HeightInRows()

    {

    return ( iRows );

    }

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

// CCmDestinationIconMap::CreateScrollBarAndIconRowL()

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

// pages and rows on a page to be shown

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

//

void CCmDestinationIconMap::CreateScrollBarAndIconRowL()

    {

    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() )

            {

            // window owning scrollbar

            iSBFrame->CreateDoubleSpanScrollBarsL( ETrue, 

                                                   EFalse, 

                                                   ETrue, 

                                                   EFalse );

            }

        else

            {

            // non-window owning scrollbar

            iSBFrame->CreateDoubleSpanScrollBarsL( EFalse, 

                                                   EFalse, 

                                                   ETrue, 

                                                   EFalse ); 

            }

        iSBFrame->SetTypeOfVScrollBar( CEikScrollBarFrame::EDoubleSpan );

        }

    else

        {

        // For EArrowHead type scrollbar

        iSBFrame->SetTypeOfVScrollBar( CEikScrollBarFrame::EArrowHead );

        }

    iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,

                                       CEikScrollBarFrame::EAuto );

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

    UpdateScrollIndicatorL();

    }

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

// CCmDestinationIconMap::SetIndex

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

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

// 

void CCmDestinationIconMap::SetIndex( TInt& aIconIndex )

    {

    iIconIndex = &aIconIndex;

    }

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

// CCmDestinationIconMap::MinimumSize

// 

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

//

TSize CCmDestinationIconMap::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();

    // the offset for the certain cba location variety

    TInt maxVarietyOffset = 0; 

    // the number of varieties

    TInt varietyOffset = maxVariety + 1;

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

       {

       // the offset for one variety

       varietyOffset = ( maxVariety + 1 ) / KAknSctCBaButtonDirections;

       }

    // 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() );

    }

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

// CCmDestinationIconMap::ActivateL()

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

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

//

 void CCmDestinationIconMap::ActivateL()

    {

    CCoeControl::ActivateL();

    if ( iRows > iExtension->iMaxVisibleRows )

        {

        UpdateScrollIndicatorL();

        }

    }

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

// CCmDestinationIconMap::OfferKeyEventL

// Handles all the Keypad events

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

//

TKeyResponse CCmDestinationIconMap::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:

            {

            if ( iConsArray )

                {

                TInt ret = iMaxColumns * 

                           ( iFirstVisibleRow + iCursorPos.iY ) + 

                           iCursorPos.iX;

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

                    {

                    *iIconIndex = ret;    

                    }

                else

                    {

                    *iIconIndex = -1;

                    }

                }

            }

            break;

        default:

            return EKeyWasNotConsumed;

        }

    return EKeyWasConsumed;

    }

#ifdef RD_SCALABLE_UI_V2 

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

// CCmDestinationIconMap::HandlePointerEventL

// Handles all the Keypad events

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

//

void CCmDestinationIconMap::HandlePointerEventL(

                                const TPointerEvent& aPointerEvent )

    {