1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

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

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of CCmDestinationIconMap

    15 *

    16 */

    17 

    18 #include <eikenv.h>

    19 #include <eiksbfrm.h>

    20 #include <eikscrlb.h>

    21 #include <bidivisual.h>

    22 #include <avkon.rsg>

    23 #include <AknPanic.h>

    24 #include <avkon.hrh>

    25 #include <AknUtils.h>

    26 #include <aknlayoutscalable_avkon.cdl.h>

    27 #include <layoutmetadata.cdl.h>

    28 #include <AknLayout.lag>

    29 #include <data_caging_path_literals.hrh>

    30 #include <aknappui.h>

    31 #include <aknconsts.h>

    32 #include <AknDef.h>

    33 #include <PUAcodes.hrh>

    34 #include <s32file.h>

    35 #include <eikscrlb.h>   // TEikScrollBarModelType

    36 #include <AknsDrawUtils.h>

    37 #include <featmgr.h>

    38 #include <AknsFrameBackgroundControlContext.h>

    39 #include <cmmanager.mbg>

    40 #include <cmcommonconstants.h>

    41 #include <touchfeedback.h>

    42 #include "cmdesticonmap.h"

    43 #include "cmmanagerimpl.h"

    44 

    45 // The offset because of CEikDialogPage

    46 const TInt KHorizontalDialogMargin = 0;

    47 const TInt KVerticalDialogMargin = 0;

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

    49 

    50 /**

    51  * Extension class to CCmDestinationIconMap

    52  *

    53  * @since S60 v3.2

    54  */

    55 NONSHARABLE_CLASS( CCmDestinationIconMapExtension ) : public CBase, 

    56                                                       public MObjectProvider

    57     {

    58     public:

    59     

    60         CCmDestinationIconMapExtension();

    61         ~CCmDestinationIconMapExtension();

    62     

    63     protected:

    64     

    65         TTypeUid::Ptr MopSupplyObject( TTypeUid aId );

    66         MObjectProvider* MopNext();

    67     

    68     public: // data

    69         

    70         MCoeControlObserver *iObserver;

    71         

    72         TUint iFlags;

    73         MObjectProvider* iIconMap;       

    74         TInt iMaxVisibleRows;

    75         CAknsFrameBackgroundControlContext* iBgContext;

    76     };

    77 

    78 // -----------------------------------------------------------------------------

    79 // CCmDestinationIconMapExtension::CCmDestinationIconMapExtension

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

    81 // might leave.

    82 // -----------------------------------------------------------------------------

    83 //

    84 CCmDestinationIconMapExtension::CCmDestinationIconMapExtension()

    85     : iMaxVisibleRows( 0 )

    86     {

    87     iObserver = NULL;

    88     }

    89 

    90 // -----------------------------------------------------------------------------

    91 // CCmDestinationIconMapExtension::MopSupplyObject()

    92 // -----------------------------------------------------------------------------

    93 //

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

    95     {

    96     return MAknsControlContext::SupplyMopObject( aId, iBgContext );

    97     }

    98 

    99 // -----------------------------------------------------------------------------

   100 // CCmDestinationIconMapExtension::MopNext()

   101 // -----------------------------------------------------------------------------

   102 //    

   103 MObjectProvider* CCmDestinationIconMapExtension::MopNext()

   104     {

   105     return iIconMap;

   106     }

   107 

   108 // -----------------------------------------------------------------------------

   109 // CCmDestinationIconMapExtension::~CCmDestinationIconMapExtension()

   110 // -----------------------------------------------------------------------------

   111 //

   112 CCmDestinationIconMapExtension::~CCmDestinationIconMapExtension()

   113     {

   114     delete iBgContext;

   115     iBgContext = NULL;

   116     }

   117 

   118 // -----------------------------------------------------------------------------

   119 // CCmDestinationIconMap::CCmDestinationIconMap

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

   121 // might leave.

   122 // -----------------------------------------------------------------------------

   123 //

   124 CCmDestinationIconMap::CCmDestinationIconMap() 

   125     : iCursorPos( TPoint( 0,0 ) )

   126     , iOldCursorPos( TPoint( 0,0 ) )

   127     , iMaxColumns( -1 )

   128     , iDragAlreadyActive( EFalse )

   129     {

   130     }

   131 

   132 // -----------------------------------------------------------------------------

   133 // CCmDestinationIconMap::NewL

   134 // Two-phased constructor.

   135 // -----------------------------------------------------------------------------

   136 //

   137 CCmDestinationIconMap* CCmDestinationIconMap::NewL()

   138     {

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

   140 

   141     CleanupStack::PushL( self );

   142     self->ConstructL();

   143     CleanupStack::Pop( self ); //self

   144     return self;    

   145     }

   146 

   147 // -----------------------------------------------------------------------------

   148 // CCmDestinationIconMap::ConstructL

   149 // Symbian 2nd phase constructor can leave.

   150 // -----------------------------------------------------------------------------

   151 //

   152 void CCmDestinationIconMap::ConstructL()

   153     {

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

   155     iExtension = new ( ELeave ) CCmDestinationIconMapExtension;

   156     iExtension->iIconMap = this;

   157         

   158     iConsArray = new( ELeave ) CAknIconArray( KNumOfIcons );

   159     

   160     iExtension->iFlags = 0x00;

   161         

   162     DoLayout();

   163     }

   164 

   165 // -----------------------------------------------------------------------------

   166 // CCmDestinationIconMap::~CCmDestinationIconMap()

   167 // -----------------------------------------------------------------------------

   168 //

   169 CCmDestinationIconMap::~CCmDestinationIconMap()

   170     {

   171     delete iSBFrame; iSBFrame = NULL;

   172     

   173     delete iOffscreenBg;

   174     delete iBitmapDevice;

   175     delete iBitmapGc;

   176 

   177     delete iExtension; 

   178     iExtension = ( CCmDestinationIconMapExtension* )NULL;

   179     

   180     if ( iConsArray )

   181         {

   182         iConsArray->ResetAndDestroy();

   183         delete iConsArray;

   184         iConsArray = NULL;

   185         }

   186    }

   187 

   188 // -----------------------------------------------------------------------------

   189 // CCmDestinationIconMap::DoLayout()

   190 // -----------------------------------------------------------------------------

   191 //

   192 void CCmDestinationIconMap::DoLayout() 

   193     {

   194     TRAPD( err,LoadIconL() );

   195     if ( err )

   196         {

   197         return;

   198         }

   199     

   200     iIsMirrored = AknLayoutUtils::LayoutMirrored();

   201     iDrawnBefore = EFalse;

   202     CountMaxColumnsAndCellSizes();

   203     SizeChanged();

   204     }

   205 

   206 // -----------------------------------------------------------------------------

   207 // CCmDestinationIconMap::ConstructFromResourceL()

   208 // -----------------------------------------------------------------------------

   209 //

   210 void CCmDestinationIconMap::ConstructFromResourceL( 

   211                                                 TResourceReader& /*aReader*/ )

   212     {

   213     LoadIconL();

   214     CreateScrollBarAndIconRowL();

   215 

   216     iExtension->iBgContext = CAknsFrameBackgroundControlContext::NewL( 

   217                                                             KAknsIIDQsnFrPopup, 

   218                                                             TRect( 0, 0, 1, 1 ), 

   219                                                             TRect( 0, 0, 1, 1 ), 

   220                                                             EFalse );

   221 

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

   223         {

   224         EnableDragEvents();       

   225         SetGloballyCapturing( ETrue );

   226         SetPointerCapture( ETrue );

   227         }

   228     }

   229 

   230 // -----------------------------------------------------------------------------

   231 // CCmDestinationIconMap::LoadIcons()

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

   233 // -----------------------------------------------------------------------------

   234 //

   235 void CCmDestinationIconMap::LoadIconL()

   236     { 

   237     iConsArray->ResetAndDestroy();

   238     // Draw all the Icons.

   239     TParse mbmFile;

   240     User::LeaveIfError( mbmFile.Set( KManagerIconFilename, 

   241                                      &KDC_APP_BITMAP_DIR, NULL ) );

   242         

   243     // Create icon bitmap and mask.

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

   245         {

   246         CFbsBitmap* bitmap = NULL;

   247         CFbsBitmap* bitmapMask = NULL;

   248         AknIconUtils::CreateIconLC( 

   249                    bitmap, 

   250                    bitmapMask, mbmFile.FullName(),

   251                    EMbmCmmanagerQgn_prop_set_conn_dest_internet_small + i, 

   252                    EMbmCmmanagerQgn_prop_set_conn_dest_internet_small + i + 1 );

   253         i++;

   254         AknIconUtils::SetSize( bitmap, 

   255                                TSize( iGridItemWidth, iGridItemHeight ) );

   256         AknIconUtils::SetSize( bitmapMask, 

   257                                TSize( iGridItemWidth, iGridItemHeight ) );

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

   259         CleanupStack::PushL( icon );

   260         iConsArray->AppendL( icon );       

   261         CleanupStack::Pop( 3, bitmap );

   262         }        

   263     }

   264 

   265 // -----------------------------------------------------------------------------

   266 // CCmDestinationIconMap::HeightInRows()

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

   268 // Depends upon the Layout size

   269 // -----------------------------------------------------------------------------

   270 //

   271 TInt CCmDestinationIconMap::HeightInRows()

   272     {

   273     return ( iRows );

   274     }

   275 

   276 // -----------------------------------------------------------------------------

   277 // CCmDestinationIconMap::CreateScrollBarAndIconRowL()

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

   279 // pages and rows on a page to be shown

   280 // -----------------------------------------------------------------------------

   281 //

   282 void CCmDestinationIconMap::CreateScrollBarAndIconRowL()

   283     {

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

   285     iFirstVisibleRow = 0;

   286     iAnimated = EFalse;

   287     iCursorPos = TPoint( 0, 0 );

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

   289                 ( iRows % iExtension->iMaxVisibleRows ? 1 : 0 );

   290     iCurrentPage = 1;

   291     

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

   293     delete iSBFrame; iSBFrame=NULL;

   294 

   295     if ( AknLayoutUtils::PenEnabled() )

   296         {

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

   298         }

   299     else

   300         {

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

   302         }

   303     // Decide which type of scrollbar is shown

   304     CAknAppUi* appUi = iAvkonAppUi;

   305     if ( AknLayoutUtils::DefaultScrollBarType( appUi ) == 

   306          CEikScrollBarFrame::EDoubleSpan )

   307         {

   308         // For EDoubleSpan type scrollbar

   309         if ( AknLayoutUtils::PenEnabled() )

   310             {

   311             // window owning scrollbar

   312             iSBFrame->CreateDoubleSpanScrollBarsL( ETrue, 

   313                                                    EFalse, 

   314                                                    ETrue, 

   315                                                    EFalse );

   316             }

   317         else

   318             {

   319             // non-window owning scrollbar

   320             iSBFrame->CreateDoubleSpanScrollBarsL( EFalse, 

   321                                                    EFalse, 

   322                                                    ETrue, 

   323                                                    EFalse ); 

   324             }

   325         iSBFrame->SetTypeOfVScrollBar( CEikScrollBarFrame::EDoubleSpan );

   326         }

   327     else

   328         {

   329         // For EArrowHead type scrollbar

   330         iSBFrame->SetTypeOfVScrollBar( CEikScrollBarFrame::EArrowHead );

   331         }

   332     

   333     iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff,

   334                                        CEikScrollBarFrame::EAuto );

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

   336     UpdateScrollIndicatorL();

   337     }

   338 

   339 // -----------------------------------------------------------------------------

   340 // CCmDestinationIconMap::SetIndex

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

   342 // -----------------------------------------------------------------------------

   343 // 

   344 void CCmDestinationIconMap::SetIndex( TInt& aIconIndex )

   345     {

   346     iIconIndex = &aIconIndex;

   347     }

   348 

   349 // -----------------------------------------------------------------------------

   350 // CCmDestinationIconMap::MinimumSize

   351 // 

   352 // -----------------------------------------------------------------------------

   353 //

   354 TSize CCmDestinationIconMap::MinimumSize()

   355     {    

   356     iIsMirrored = AknLayoutUtils::LayoutMirrored();

   357     CountMaxColumnsAndCellSizes();

   358 

   359     TRect rect;

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

   361               

   362     TAknLayoutRect dialogLayRect;

   363         

   364     // Main pane without softkeys

   365     TRect mainPaneRect;

   366     if ( !AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPaneRect ) )

   367     {

   368     mainPaneRect = iAvkonAppUi->ClientRect();

   369     }

   370     

   371     // Dialog layout, check variety first

   372     TAknLayoutScalableParameterLimits iconMapDialogVariety = 

   373                AknLayoutScalable_Avkon::popup_grid_graphic_window_ParamLimits();

   374     

   375     // Calc the variety

   376     TInt maxVariety = iconMapDialogVariety.LastVariety();

   377     

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

   379     // there is not so much varieties

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

   381     // the offset for the certain cba location variety

   382     TInt maxVarietyOffset = 0; 

   383     // the number of varieties

   384     TInt varietyOffset = maxVariety + 1;

   385     

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

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

   388     // variety

   389     if ( Layout_Meta_Data::IsLandscapeOrientation() )

   390        {

   391        // the offset for one variety

   392        varietyOffset = ( maxVariety + 1 ) / KAknSctCBaButtonDirections;

   393        }

   394     

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

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

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

   398     if ( location == AknLayoutUtils::EAknCbaLocationRight )

   399        {

   400        maxVarietyOffset = varietyOffset;

   401        }

   402     else if ( location == AknLayoutUtils::EAknCbaLocationLeft )

   403        {

   404        maxVarietyOffset = varietyOffset + varietyOffset; // 2*

   405        }

   406     

   407     TInt varietyNumber = varietyOffset - iRows - 1; 

   408     

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

   410     // ( the biggest grid ) variety

   411     if ( varietyNumber < 0 )

   412        varietyNumber = 0;

   413     // if zero rows, use the minimum

   414     else if ( iRows<=0 )

   415        varietyNumber -= 1;

   416     

   417     //add the varietyoffset

   418     varietyNumber += maxVarietyOffset;

   419 

   420     if ( Layout_Meta_Data::IsLandscapeOrientation() && 

   421         location == AknLayoutUtils::EAknCbaLocationRight )

   422        {

   423        varietyNumber = 10;

   424        }

   425     else

   426         {

   427         if( iRows == 0 )

   428             {

   429             varietyNumber = 5;

   430             }

   431         else

   432             {

   433             varietyNumber = 3;

   434             }

   435         }       

   436     // Layout the dialog size

   437     dialogLayRect.LayoutRect( mainPaneRect, 

   438        AknLayoutScalable_Avkon::popup_grid_graphic_window( varietyNumber ) );

   439        

   440     // Layout the grid

   441     TAknLayoutRect gridWithScrollLayRect;

   442     gridWithScrollLayRect.LayoutRect( dialogLayRect.Rect(), 

   443        AknLayoutScalable_Avkon::listscroll_popup_graphic_pane() );

   444     

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

   446         gridWithScrollLayRect.Rect().Height() );

   447     }

   448 

   449 // -----------------------------------------------------------------------------

   450 // CCmDestinationIconMap::ActivateL()

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

   452 // -----------------------------------------------------------------------------

   453 //

   454  void CCmDestinationIconMap::ActivateL()

   455     {

   456     CCoeControl::ActivateL();

   457     if ( iRows > iExtension->iMaxVisibleRows )

   458         {

   459         UpdateScrollIndicatorL();

   460         }

   461     }

   462 

   463 // -----------------------------------------------------------------------------

   464 // CCmDestinationIconMap::OfferKeyEventL

   465 // Handles all the Keypad events

   466 // -----------------------------------------------------------------------------

   467 //

   468 TKeyResponse CCmDestinationIconMap::OfferKeyEventL( const TKeyEvent& aKeyEvent, 

   469                                                     TEventCode /*aModifiers*/ )

   470     {

   471     TUint code=aKeyEvent.iCode;

   472     

   473     switch ( code )

   474         {

   475         case EKeyLeftArrow:

   476         case '4':

   477             MoveCursorL( -1,0 );

   478             break;

   479         case EKeyRightArrow:

   480         case '6':

   481             MoveCursorL( 1,0 );

   482             break;

   483         case EKeyUpArrow:

   484         case '2':

   485             MoveCursorL( 0,-1 );

   486             break;

   487         case EKeyDownArrow:

   488         case '8':

   489             MoveCursorL( 0,1 );

   490             break;

   491         case EKeyOK:

   492         case '5':  

   493         case EKeySpace:

   494             {

   495             if ( iConsArray )

   496                 {

   497                 TInt ret = iMaxColumns * 

   498                            ( iFirstVisibleRow + iCursorPos.iY ) + 

   499                            iCursorPos.iX;

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

   501                     {

   502                     *iIconIndex = ret;    

   503                     }

   504                 else

   505                     {

   506                     *iIconIndex = -1;

   507                     }

   508                 }

   509                

   510             }

   511             break;

   512         default:

   513             return EKeyWasNotConsumed;

   514 

   515         }

   516     return EKeyWasConsumed;

   517     }

   518 

   519 #ifdef RD_SCALABLE_UI_V2 

   520 

   521 // -----------------------------------------------------------------------------

   522 // CCmDestinationIconMap::HandlePointerEventL

   523 // Handles all the Keypad events

   524 // -----------------------------------------------------------------------------

   525 //

   526 void CCmDestinationIconMap::HandlePointerEventL(

   527                                 const TPointerEvent& aPointerEvent )

   528     {

   529     if ( AknLayoutUtils::PenEnabled() )

   530         {

   531         TInt newGridX; // For the whole

   532         TInt newGridY; // For the whole grid.

   533         TInt yInPixels = aPointerEvent.iPosition.iY - iGridTopLeft.iY;

   534         newGridY = yInPixels / iGridItemHeight;

   535         if ( ( aPointerEvent.iPosition.iX - iGridTopLeft.iX ) < 0 )

   536             {

   537             newGridX = -1;

   538             }

   539         else

   540             {

   541             newGridX = ( aPointerEvent.iPosition.iX - iGridTopLeft.iX )

   542                                                         / iGridItemWidth;

   543             }

   544 

   545         // The pointer has been set down or dragged into the area of the grid. 

   546         // (it might be in the "white space" at the end of the grid)

   547         if ( ( yInPixels >= 0 && yInPixels < iGridItemHeight 

   548                 * iExtension->iMaxVisibleRows) &&

   549             // When the pointer is in rows except the recent icon row

   550                 ( ( ( ( newGridY + iFirstVisibleRow ) != 0 ) && 

   551                 newGridX < iMaxColumns && newGridX >= 0 ) ||

   552             // When the pointer is in the recent icon row

   553                 ( ( newGridY + iFirstVisibleRow == 0 ) && 

   554                 ( newGridX < iMaxColumns ) ) ) )

   555             {

   556             TUint globalY = newGridY + iFirstVisibleRow;

   557             // For any action to be taken, the pointer event must either be a

   558             // Button1Down or a drag event which has originated from a

   559             // Button1Down in to the grid.

   560             if ( aPointerEvent.iType == TPointerEvent::EButton1Down ||

   561                  aPointerEvent.iType == TPointerEvent::EDrag )

   562                 {

   563                 if ( aPointerEvent.iType == TPointerEvent::EDrag ) 

   564                     {

   565                     iDragAlreadyActive = ETrue;

   566                     }

   567 

   568                 // The user tapps a cell which has no icon. it is ignored.

   569                 if ( iConsArray->Count() > globalY * iMaxColumns + newGridX )

   570                     {

   571               	    // If icon is already selected then on single tap it

   572               	    // should select the icon.

   573                     if( iCursorPos.iY == newGridY && 

   574                         iCursorPos.iX == newGridX &&

   575                         aPointerEvent.iType != TPointerEvent::EDrag )

   576                         {

   577                         if ( iExtension->iObserver )

   578                             {

   579                             iExtension->iObserver->HandleControlEventL( 

   580                                   this, 

   581                                   MCoeControlObserver::EEventStateChanged );

   582                             } 

   583                         }

   584                     else if ( iCursorPos.iX + ( iCursorPos.iY + 

   585                               iFirstVisibleRow ) * iMaxColumns  < 

   586                               iConsArray->Count() )

   587                         {

   588                         iOldCursorPos = iCursorPos;

   589                         iCursorPos.iY = newGridY;

   590                         iCursorPos.iX = newGridX;

   591                         DrawCursor();

   592                         }

   593                     else

   594                         {

   595                         iOldCursorPos.iX = 0;

   596                         iOldCursorPos.iY = 0;

   597                         }

   598 				    }

   599                 }

   600             else if ( aPointerEvent.iType == TPointerEvent::EButton1Up )

   601                 {

   602                 // The pointer has been set and dragged into the area of 

   603                 // the grid.

   604                 if ( yInPixels >= 0 && yInPixels < iGridItemHeight * 

   605                      iExtension->iMaxVisibleRows && 

   606                      iDragAlreadyActive && 

   607                      iOldCursorPos == iCursorPos &&

   608                      (iConsArray->Count() > (globalY * iMaxColumns + newGridX)))

   609                     {

   610                     if ( iExtension->iObserver )

   611                         {

   612                         iExtension->iObserver->HandleControlEventL( 

   613                                 this, 

   614                                 MCoeControlObserver::EEventStateChanged );

   615                         }

   616                 	iDragAlreadyActive = EFalse;    

   617                     }

   618                 }

   619 

   620             MTouchFeedback* feedback = MTouchFeedback::Instance();

   621         

   622             if ( feedback )

   623                 {

   624                 if ( aPointerEvent.iType == TPointerEvent::EButton1Down )

   625                     {

   626                     feedback->InstantFeedback( this, ETouchFeedbackBasic );

   627                     }

   628                 else if ( aPointerEvent.iType == TPointerEvent::EDrag && iCursorPos != iOldCursorPos )

   629                     {

   630                     feedback->InstantFeedback( this, ETouchFeedbackSensitive );	

   631                     }

   632                 }

   633             }

   634         else // For a non window owning scrollbar.

   635             {

   636             if ( aPointerEvent.iType == TPointerEvent::EButton1Up )

   637                 {

   638                 iDragAlreadyActive = EFalse;

   639                 }

   640             }

   641         

   642         CCoeControl::HandlePointerEventL( aPointerEvent );

   643         }

   644     }

   645     

   646 // -----------------------------------------------------------------------------

   647 // CCmDestinationIconMap::SetObserver

   648 // Sets the observer.

   649 // -----------------------------------------------------------------------------

   650 //

   651 void CCmDestinationIconMap::SetObserver( MCoeControlObserver* aObserver  )

   652     {

   653     if ( iExtension )

   654         {

   655         iExtension->iObserver = aObserver;

   656         }

   657     }

   658 

   659 #endif //RD_SCALABLE_UI_V2    

   660 

   661 // -----------------------------------------------------------------------------

   662 // CCmDestinationIconMap::InputCapabilities()

   663 //

   664 // -----------------------------------------------------------------------------

   665 //

   666 TCoeInputCapabilities CCmDestinationIconMap::InputCapabilities() const

   667     {

   668     return TCoeInputCapabilities( TCoeInputCapabilities::EAllText );

   669     }

   670 

   671 // -----------------------------------------------------------------------------

   672 // CCmDestinationIconMap::SizeChanged()

   673 // Control position of this control is registered for skin library when 

   674 // necessary in CEikDialogPage::SetDataPosition, so we do not do that in this 

   675 // method.

   676 // -----------------------------------------------------------------------------

   677 //

   678 void CCmDestinationIconMap::SizeChanged()

   679     {

   680     // Get the layout

   681     

   682     // Main pane without softkeys

   683     TRect mainPaneRect;

   684    

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

   686                                              mainPaneRect ) )

   687        {

   688        mainPaneRect = iAvkonAppUi->ClientRect();

   689        }

   690     

   691     // Dialog layout, check variety first

   692     TAknLayoutScalableParameterLimits iconMapDialogVariety = 

   693                AknLayoutScalable_Avkon::popup_grid_graphic_window_ParamLimits();

   694     

   695     TInt maxVariety = iconMapDialogVariety.LastVariety();

   696     

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

   698     // there is not so much varieties

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

   700     // the offset for the certain cba location variety

   701     TInt maxVarietyOffset = 0;

   702     TInt varietyOffset = maxVariety + 1;

   703     

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

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

   706     // variety

   707     if ( Layout_Meta_Data::IsLandscapeOrientation() )

   708        {

   709        // the offset for one variety

   710        varietyOffset = ( maxVariety + 1 ) / KAknSctCBaButtonDirections;

   711        }

   712     

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

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

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

   716     if ( location == AknLayoutUtils::EAknCbaLocationRight )

   717        {

   718        maxVarietyOffset = varietyOffset;

   719        }

   720     else if ( location == AknLayoutUtils::EAknCbaLocationLeft )

   721        {

   722        maxVarietyOffset = varietyOffset + varietyOffset; // 2*

   723        }

   724     

   725     TInt varietyNumber = varietyOffset - iRows - 1; 

   726     

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

   728     // ( the biggest grid ) variety

   729     if ( varietyNumber < 0 )

   730        varietyNumber = 0;

   731     // if zero rows, use the minimum

   732     else if ( iRows<=0 )

   733        varietyNumber -= 1;

   734     

   735     //add the varietyoffset

   736     varietyNumber += maxVarietyOffset;

   737     

   738     if ( Layout_Meta_Data::IsLandscapeOrientation() && 

   739          location == AknLayoutUtils::EAknCbaLocationRight )

   740        {

   741        varietyNumber = 10;

   742        }

   743     else

   744         {

   745         if ( iRows == 0 )

   746             {

   747             varietyNumber = 5;

   748             }

   749         else

   750             {

   751             varietyNumber = 3;

   752             }            

   753         

   754         }       

   755     

   756     TAknLayoutRect popupGridLayRect;

   757     popupGridLayRect.LayoutRect( mainPaneRect, 

   758           AknLayoutScalable_Avkon::popup_grid_graphic_window( varietyNumber ) );

   759     

   760     // Calculate the size relatively

   761     TRect relativeDialog( TPoint( 0,0 ),popupGridLayRect.Rect().Size() );

   762     

   763     // Get the layout of the actual icon grid with scrollbar

   764     TAknLayoutRect gridWithScrollLayRect;

   765     gridWithScrollLayRect.LayoutRect( relativeDialog, 

   766        AknLayoutScalable_Avkon::listscroll_popup_graphic_pane() );

   767             

   768     // Then the grid area without scrollbar

   769     // NOTE: The grid with scroll bar is used as reference

   770     TAknLayoutRect gridLayRect;

   771     gridLayRect.LayoutRect( gridWithScrollLayRect.Rect(), 

   772        AknLayoutScalable_Avkon::grid_graphic_popup_pane( 0 ) );

   773 

   774     // Different parent if SCT inside editing menu.

   775     TRect contentRect = gridLayRect.Rect();

   776 

   777     // The x coordinate is 3 pixels to right and y coordinate 3 pixels up 

   778     // so substract from x coordinate and add to y coordinate

   779     if ( iIsMirrored ) 

   780         {

   781         iOffset = TPoint( 

   782             contentRect.iBr.iX - KHorizontalDialogMargin - iGridItemWidth + 1,  

   783             contentRect.iTl.iY - KVerticalDialogMargin + 1 );

   784         

   785         iGridTopLeft.iX = contentRect.iBr.iX - 

   786                           KHorizontalDialogMargin - 

   787                           ( iMaxColumns * iGridItemWidth );

   788         iGridTopLeft.iY = contentRect.iTl.iY - KVerticalDialogMargin;

   789         }

   790     else  // not mirrored

   791         {

   792         iOffset = TPoint( contentRect.iTl.iX - KHorizontalDialogMargin + 1, 

   793                          contentRect.iTl.iY - KVerticalDialogMargin + 1 );

   794         iGridTopLeft.iX = contentRect.iTl.iX - KHorizontalDialogMargin;

   795         iGridTopLeft.iY = contentRect.iTl.iY - KVerticalDialogMargin;

   796         }

   797     

   798        

   799     // The last, update background context

   800     if ( iExtension->iBgContext )

   801        {            

   802         TInt bgVariety = 0;

   803         if ( Layout_Meta_Data::IsLandscapeOrientation() )

   804             {

   805             bgVariety = 1;

   806             }

   807             

   808         TAknLayoutRect innerRect;

   809         innerRect.LayoutRect( 

   810                 relativeDialog, 

   811                 AknLayoutScalable_Avkon::bg_popup_window_pane_g1( bgVariety ) );

   812 

   813        iExtension->iBgContext->SetFrameRects( relativeDialog, 

   814                                               innerRect.Rect() );

   815        }

   816     

   817     TRAPD( err,UpdateScrollIndicatorL() );

   818     if ( err )

   819         {

   820         return;

   821         }

   822     }

   823 

   824 

   825 // -----------------------------------------------------------------------------

   826 // CCmDestinationIconMap::HandleResourceChange()

   827 // -----------------------------------------------------------------------------

   828 //

   829 void CCmDestinationIconMap::HandleResourceChange( TInt aType )

   830     {

   831     if ( aType == KEikDynamicLayoutVariantSwitch )

   832         {

   833         // save the old info for the magnitudes of the SCT grid

   834         TInt oldMaxColumns = iMaxColumns;

   835         //TInt oldMaxRows = 0;

   836         //oldMaxRows = iRows;

   837         // calculate the new magnitudes

   838         DoLayout();

   839         

   840         // then calculate the index position of the cursor in the icon table

   841         // and update the x and y positions for the new grid with it

   842         

   843         TInt oldCursorPosition = ( iFirstVisibleRow + iOldCursorPos.iY ) * 

   844                                  oldMaxColumns +

   845                                  iOldCursorPos.iX;

   846         

   847         TInt currentCursorPosition = ( iFirstVisibleRow + iCursorPos.iY ) * 

   848                                      oldMaxColumns +

   849                                      iCursorPos.iX;

   850         

   851         // the new first row is the top row on the page where the new focus is

   852         iFirstVisibleRow = iExtension->iMaxVisibleRows * 

   853                            ( currentCursorPosition / 

   854                            ( iMaxColumns * iExtension->iMaxVisibleRows ) );

   855         

   856         // the cursor positions are relative to current page

   857         iCursorPos.iY = ( currentCursorPosition - 

   858                         ( iMaxColumns * iFirstVisibleRow ) ) / 

   859                         iMaxColumns;

   860         iCursorPos.iX = currentCursorPosition - 

   861                         ( iMaxColumns * iFirstVisibleRow ) - 

   862                         ( iMaxColumns * iCursorPos.iY );

   863            

   864         iOldCursorPos.iY = ( oldCursorPosition - 

   865                            ( iMaxColumns * iFirstVisibleRow ) ) / 

   866                            iMaxColumns;

   867         iOldCursorPos.iX = oldCursorPosition - 

   868                            ( iMaxColumns * iFirstVisibleRow ) - 

   869                            ( iMaxColumns * iOldCursorPos.iY );

   870         }

   871 

   872     if ( aType == KAknsMessageSkinChange )

   873         {

   874         iOffscreenBgDrawn = EFalse;

   875         }

   876         

   877     CCoeControl::HandleResourceChange( aType );   

   878     }

   879 

   880 // -----------------------------------------------------------------------------

   881 // CCmDestinationIconMap::Draw()

   882 // -----------------------------------------------------------------------------

   883 //

   884 void CCmDestinationIconMap::Draw( const TRect& /*aRect*/ ) const

   885     {    

   886     TInt cursorPos = 0;

   887     CWindowGc& gc=SystemGc();

   888     

   889     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

   890     MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

   891     

   892     TRect rect = Rect();

   893     

   894     // Main pane without softkeys

   895     TRect mainPaneRect;

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

   897                                              mainPaneRect ) )

   898        {

   899        mainPaneRect = iAvkonAppUi->ClientRect();

   900        }

   901     

   902     // Dialog layout, check variety first

   903     TAknLayoutScalableParameterLimits iconMapDialogVariety = 

   904        AknLayoutScalable_Avkon::popup_grid_graphic_window_ParamLimits();

   905        

   906     // The variety starts from 0 so add +1

   907     TInt maxVariety = iconMapDialogVariety.LastVariety();

   908     

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

   910     // there is not so much varieties

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

   912     // the offset for the certain cba location variety

   913     TInt maxVarietyOffset = 0;

   914     TInt varietyOffset = maxVariety + 1;

   915     

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

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

   918     // variety

   919     if ( Layout_Meta_Data::IsLandscapeOrientation() )

   920        {

   921        // the offset for one variety

   922        varietyOffset = ( maxVariety + 1 )/KAknSctCBaButtonDirections;

   923        }

   924     

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

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

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

   928     if ( location == AknLayoutUtils::EAknCbaLocationRight )

   929        {

   930        maxVarietyOffset = varietyOffset;

   931        }

   932     else if ( location == AknLayoutUtils::EAknCbaLocationLeft )

   933        {

   934        maxVarietyOffset = varietyOffset + varietyOffset; // 2*

   935        }

   936     

   937     TInt varietyNumber = varietyOffset - iRows - 1; 

   938     

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

   940     // ( the biggest grid ) variety

   941     if ( varietyNumber < 0 )

   942         {

   943         varietyNumber = 0;

   944         }

   945     // if zero rows, use the minimum

   946     else if ( iRows<=0 )

   947         {

   948         varietyNumber -= 1;

   949         }

   950     

   951     //add the varietyoffset

   952     varietyNumber += maxVarietyOffset;

   953 

   954     if ( Layout_Meta_Data::IsLandscapeOrientation() && 

   955          location == AknLayoutUtils::EAknCbaLocationRight )

   956         {

   957         varietyNumber = 10;

   958         }

   959     else

   960         {

   961         varietyNumber = 3;

   962         }    

   963     // Layout the dialog size

   964     TAknLayoutRect dialogLayRect;

   965     dialogLayRect.LayoutRect( 

   966            mainPaneRect, 

   967           AknLayoutScalable_Avkon::popup_grid_graphic_window( varietyNumber ) );

   968     

   969     // Get the missing height for the background

   970     TInt backgroundHeightOffset = dialogLayRect.Rect().Height() - rect.iBr.iY;

   971     

   972     rect.iBr.iY += backgroundHeightOffset;

   973 

   974     // Check if we got an offscreen bitmap allocated for skin background and

   975     // there is bitmap background in the current skin.

   976     if ( iOffscreenBg && iHasBitmapBackground )

   977         {

   978         DrawOffscreenBackgroundIfRequired();

   979         gc.BitBlt( rect.iTl, iOffscreenBg );

   980         }

   981     else

   982         {

   983         AknsDrawUtils::Background( skin, cc, this, gc, rect );

   984         }

   985 

   986     TInt numberOfIconsToBeDrawn = iConsArray->Count();

   987     numberOfIconsToBeDrawn -= ( iFirstVisibleRow * iMaxColumns );

   988     if ( numberOfIconsToBeDrawn > 0 )

   989         {

   990         if ( numberOfIconsToBeDrawn > 

   991             ( iExtension->iMaxVisibleRows * iMaxColumns ) )

   992             {

   993             numberOfIconsToBeDrawn = iExtension->iMaxVisibleRows * iMaxColumns;

   994             }

   995 

   996         gc.SetPenStyle( CGraphicsContext::ESolidPen );    

   997         gc.SetBrushStyle( CGraphicsContext::ENullBrush );

   998         gc.SetPenSize( TSize( 1,1 ) );

   999 

  1000         // 2 ) Draw the grid

  1001         const TSize gridItemRectSize( iGridItemWidth + 1, iGridItemHeight + 1 );

  1002              

  1003         TInt numberOfGridCellsToBeDrawn = numberOfIconsToBeDrawn;

  1004 

  1005         TRgb colorLine = AKN_LAF_COLOR( 219 );

  1006         AknsUtils::GetCachedColor( skin, 

  1007                                    colorLine, 

  1008                                    KAknsIIDQsnLineColors, 

  1009                                    EAknsCIQsnLineColorsCG5 );

  1010         TRgb colorRecentLine = AKN_LAF_COLOR( 215 );

  1011         AknsUtils::GetCachedColor( skin, 

  1012                                    colorRecentLine, 

  1013                                    KAknsIIDQsnLineColors, 

  1014                                    EAknsCIQsnLineColorsCG7 );

  1015 

  1016         // default pen color

  1017         gc.SetPenColor( colorLine );

  1018         

  1019         TInt fullRows = numberOfGridCellsToBeDrawn / iMaxColumns;

  1020 

  1021         // how many left after the full rows

  1022         numberOfGridCellsToBeDrawn -= fullRows * iMaxColumns;

  1023 

  1024         TPoint pos = iGridTopLeft;

  1025 

  1026         TInt endX = pos.iX + iGridItemWidth * iMaxColumns + 1;

  1027         TInt endY = pos.iY + iGridItemHeight * fullRows;

  1028 

  1029         TInt ii = 0;

  1030 

  1031         if ( fullRows )

  1032             {

  1033             // Draw full vertical lines

  1034             for ( ii = 0 ; ii <= iMaxColumns ; ii++ )

  1035                 {

  1036                 gc.SetPenColor( colorLine );

  1037                 gc.SetPenSize( TSize( 1,1 ) );

  1038                 gc.DrawLine( pos, TPoint( pos.iX, endY ) );

  1039                 pos.iX += iGridItemWidth;

  1040                 }

  1041 

  1042                 pos = iGridTopLeft;

  1043 

  1044             // Draw full horizontal lines

  1045             for ( ii = 0 ; ii <= fullRows ; ii++ )

  1046                 {

  1047                 gc.SetPenSize( TSize( 1,1 ) );    

  1048                 gc.SetPenColor( colorLine );

  1049                 gc.DrawLine( pos, TPoint( endX, pos.iY ) );

  1050                 pos.iY += iGridItemHeight;

  1051                 }

  1052             gc.SetPenColor( colorLine );

  1053             gc.SetPenSize( TSize( 1,1 ) );    

  1054             }

  1055 

  1056         if ( numberOfGridCellsToBeDrawn )

  1057             {

  1058             // Remaining cells in the last, non-full row

  1059             pos = iOffset;

  1060             // iOffset is cell area topLeft, grid is not included in it

  1061             pos.iX--;

  1062             pos.iY--;

  1063 

  1064             pos.iY += iGridItemHeight * fullRows;

  1065 

  1066             for ( ii = 0 ; ii < numberOfGridCellsToBeDrawn ; ii++ )

  1067                 {

  1068                 gc.DrawRect( TRect( pos, gridItemRectSize ) );

  1069 

  1070                 if ( iIsMirrored ) 

  1071                     pos.iX -= iGridItemWidth;

  1072                 else // not mirrored

  1073                     pos.iX += iGridItemWidth; 

  1074                 }

  1075             }

  1076         

  1077         TInt iconIndex = ( iCurrentPage - 1 ) * 

  1078                          ( iMaxColumns * iExtension->iMaxVisibleRows );

  1079         TInt lCnt =  iConsArray->Count(); 

  1080         cursorPos = iCursorPos.iX + iCursorPos.iY * iMaxColumns;

  1081         if ( lCnt > 0 )

  1082             {

  1083             TRect cellRect( TPoint( 0,0 ), 

  1084                             TSize( iGridItemWidth - 1, iGridItemHeight - 1 ) );

  1085             for ( TInt j = iconIndex, i = 0; 

  1086                   j < lCnt && i < numberOfIconsToBeDrawn;

  1087                   j++, i++ )

  1088                 {

  1089                 DrawItem( gc, CursorRect( i ), j, cursorPos == i, EFalse );        

  1090                 }     

  1091             }

  1092             

  1093         }

  1094     iDrawnBefore = ETrue;

  1095     gc.DiscardFont();

  1096     }

  1097 

  1098 // -----------------------------------------------------------------------------

  1099 // CCmDestinationIconMap::DrawItem()

  1100 // -----------------------------------------------------------------------------

  1101 //

  1102 void CCmDestinationIconMap::DrawItem( 

  1103     CWindowGc& aGc,

  1104     const TRect& aSctPosition,

  1105     TInt aIconIndex,

  1106     TBool aHighlighted,

  1107     TBool aDrawBackground ) const

  1108     {

  1109     MAknsSkinInstance* skin = AknsUtils::SkinInstance();

  1110     MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

  1111     

  1112     TBool skins = AknsDrawUtils::Background( skin,cc,aGc, aSctPosition );    

  1113     TRgb color;

  1114     if ( !skins )

  1115         aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

  1116     if ( aHighlighted )

  1117         {

  1118         TRgb colorHightLightRect = AKN_LAF_COLOR( 215 );

  1119         AknsUtils::GetCachedColor( skin, 

  1120                                    colorHightLightRect, 

  1121                                    KAknsIIDQsnLineColors, 

  1122                                    EAknsCIQsnLineColorsCG7 );

  1123         aGc.SetPenColor( colorHightLightRect );

  1124         aGc.DrawRect( aSctPosition );

  1125 

  1126         // Shrink by one pixel in all directions.

  1127         TRect innerRect = aSctPosition;

  1128         innerRect.Shrink( 1,1 );

  1129 

  1130         color = AKN_LAF_COLOR( 210 );

  1131         AknsUtils::GetCachedColor( skin, 

  1132                                    color, 

  1133                                    KAknsIIDQsnHighlightColors,