1 /*

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

    15  *

    16  */

    17 

    18 // INCLUDE FILES

    19 #include <eikenv.h>

    20 #include <eiksbfrm.h>

    21 #include <eikscrlb.h>

    22 #include <bidivisual.h>

    23 #include <avkon.rsg>

    24 #include <AknPanic.h>

    25 #include <avkon.hrh>

    26 #include <AknUtils.h>

    27 #include <aknlayoutscalable_avkon.cdl.h>

    28 #include <layoutmetadata.cdl.h>

    29 #include <AknLayout.lag>

    30 

    31 #include <aknappui.h>

    32 #include <aknconsts.h>

    33 #include <AknDef.h>

    34 #include <PUAcodes.hrh>

    35 #include <s32file.h>

    36 

    37 #ifdef RD_TACTILE_FEEDBACK

    38 #include <touchfeedback.h>

    39 #endif //RD_TACTILE_FEEDBACK

    40 // For the TEikScrollBarModelType

    41 #include <eikscrlb.h>

    42 

    43 #include <AknsDrawUtils.h>

    44 #include <featmgr.h>

    45 

    46 #include <AknsFrameBackgroundControlContext.h>

    47 

    48 #include <lmkui.mbg>

    49 

    50 #include "lmkiconmap.h"

    51 #include "CLmkUiUtils.h"

    52 #include <lmkerrors.h>

    53 

    54 // The offset because of CEikDialogPage

    55 const TInt KHorizontalDialogMargin = 0;

    56 const TInt KVerticalDialogMargin = 0;

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

    58 

    59 

    60 /// Unnamed namespace for local definitions

    61 namespace

    62     {

    63     const TInt KNumOfIcons(16);

    64     _LIT( KPanicMsg, "CLmkIconMap" );

    65 

    66     void Panic(TPanicCode aReason)

    67         {

    68         User::Panic(KPanicMsg, aReason);

    69         }

    70     } // namespace

    71 

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

    73 //Class Declaration

    74 NONSHARABLE_CLASS(CLmkIconMapExtension) : public CBase,

    75 public MObjectProvider

    76     {

    77 public:

    78     CLmkIconMapExtension();

    79     ~CLmkIconMapExtension();

    80 

    81 protected:

    82     TTypeUid::Ptr MopSupplyObject(TTypeUid aId);

    83     MObjectProvider* MopNext();

    84 

    85 public:

    86     // data

    87     MCoeControlObserver *iObserver;

    88 

    89     TUint iFlags;

    90     MObjectProvider* iIconMap;

    91     TInt iMaxVisibleRows;

    92     CAknsFrameBackgroundControlContext* iBgContext;

    93     };

    94 

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

    96 

    97 // -----------------------------------------------------------------------------

    98 // CLmkIconMapExtension::CLmkIconMapExtension

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

   100 // might leave.

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

   102 //

   103 CLmkIconMapExtension::CLmkIconMapExtension() :

   104     iMaxVisibleRows(0)

   105     {

   106     iObserver = NULL;

   107     }

   108 

   109 // -----------------------------------------------------------------------------

   110 // CLmkIconMapExtension::MopSupplyObject()

   111 // -----------------------------------------------------------------------------

   112 //

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

   114     {

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

   116     }

   117 

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

   119 // CLmkIconMapExtension::MopNext()

   120 // -----------------------------------------------------------------------------

   121 //

   122 MObjectProvider* CLmkIconMapExtension::MopNext()

   123     {

   124     return iIconMap;

   125     }

   126 

   127 // -----------------------------------------------------------------------------

   128 // CLmkIconMapExtension::~CLmkIconMapExtension()

   129 // -----------------------------------------------------------------------------

   130 //

   131 CLmkIconMapExtension::~CLmkIconMapExtension()

   132     {

   133 

   134     delete iBgContext;

   135     }

   136 

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

   138 

   139 // -----------------------------------------------------------------------------

   140 // CLmkIconMap::CLmkIconMap

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

   142 // might leave.

   143 // -----------------------------------------------------------------------------

   144 //

   145 CLmkIconMap::CLmkIconMap() :

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

   147             iCurrentPage(0), iNumPages(0)

   148     {

   149     iConsArray = (CArrayPtr<CGulIcon>*) NULL;

   150     }

   151 

   152 // -----------------------------------------------------------------------------

   153 // CLmkIconMap::NewL

   154 // Two-phased constructor.

   155 // -----------------------------------------------------------------------------

   156 //

   157 CLmkIconMap* CLmkIconMap::NewL()

   158     {

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

   160 

   161     CleanupStack::PushL(self);

   162     self->ConstructL();

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

   164     return self;

   165     }

   166 

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

   168 // CLmkIconMap::ConstructL

   169 // Symbian 2nd phase constructor can leave.

   170 // -----------------------------------------------------------------------------

   171 //

   172 void CLmkIconMap::ConstructL()

   173     {

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

   175     iExtension = new (ELeave) CLmkIconMapExtension;

   176     iExtension->iIconMap = this;

   177 

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

   179 

   180     iExtension->iFlags = 0x00;

   181 

   182     DoLayout();

   183     }

   184 

   185 // -----------------------------------------------------------------------------

   186 // CLmkIconMap::~CLmkIconMap()

   187 // -----------------------------------------------------------------------------

   188 //

   189 CLmkIconMap::~CLmkIconMap()

   190     {

   191     delete iSBFrame;

   192     iSBFrame = (CEikScrollBarFrame*) NULL;

   193 

   194     delete iOffscreenBg;

   195     delete iBitmapDevice;

   196     delete iBitmapGc;

   197 

   198     delete iExtension;

   199     iExtension = (CLmkIconMapExtension*) NULL;

   200 

   201     if (iConsArray)

   202         {

   203         iConsArray->ResetAndDestroy();

   204         delete iConsArray;

   205         iConsArray = (CArrayPtr<CGulIcon>*) NULL;

   206         }

   207     }

   208 

   209 // -----------------------------------------------------------------------------

   210 // CLmkIconMap::DoLayout()

   211 // -----------------------------------------------------------------------------

   212 //

   213 void CLmkIconMap::DoLayout()

   214     {

   215     TRAPD(err, LoadIconL());

   216     if (err)

   217         return;

   218 

   219     iIsMirrored = AknLayoutUtils::LayoutMirrored();

   220     iDrawnBefore = EFalse;

   221     CountMaxColumnsAndCellSizes();

   222     SizeChanged();

   223     }

   224 

   225 // -----------------------------------------------------------------------------

   226 // CLmkIconMap::ConstructFromResourceL()

   227 // -----------------------------------------------------------------------------

   228 //

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

   230     {

   231     LoadIconL();

   232     CreateScrollBarAndIconRowL();

   233 

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

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

   236 

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

   238         {

   239         EnableDragEvents();

   240         SetGloballyCapturing( ETrue);

   241         SetPointerCapture(ETrue);

   242         }

   243     }

   244 

   245 // -----------------------------------------------------------------------------

   246 // CLmkIconMap::LoadIcons()

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

   248 // -----------------------------------------------------------------------------

   249 //

   250 void CLmkIconMap::LoadIconL()

   251     {

   252     if (iConsArray)

   253         {

   254         iConsArray->ResetAndDestroy();

   255         }

   256     // Draw all the Icons.

   257     TFileName* iconFile = CLmkUiUtils::LmkUiIconFileLC();

   258 

   259     // Create icon bitmap and mask.

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

   261         {

   262         CFbsBitmap* bitmap = NULL;

   263         CFbsBitmap* bitmapMask = NULL;

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

   265                 EMbmLmkuiQgn_prop_lm_transport + i,

   266                 EMbmLmkuiQgn_prop_lm_transport + i + 1);

   267         i++;

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

   269         AknIconUtils::SetSize(bitmapMask, TSize(iGridItemWidth,

   270                 iGridItemHeight)); //fix

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

   272         CleanupStack::PushL(icon);

   273         if (iConsArray)

   274             iConsArray->AppendL(icon);

   275         CleanupStack::Pop(icon); // icon

   276         CleanupStack::Pop(bitmapMask); // mask

   277         CleanupStack::Pop(bitmap); // bitmap

   278         }

   279     CleanupStack::PopAndDestroy();// iconFile

   280     }

   281 

   282 // -----------------------------------------------------------------------------

   283 // CLmkIconMap::HeightInRows()

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

   285 // Depends upon the Layout size

   286 // -----------------------------------------------------------------------------

   287 //

   288 TInt CLmkIconMap::HeightInRows()

   289     {

   290     return (iRows);

   291     }

   292 

   293 // -----------------------------------------------------------------------------

   294 // CLmkIconMap::CreateScrollBarAndIconRowL()

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

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

   297 // -----------------------------------------------------------------------------

   298 //

   299 void CLmkIconMap::CreateScrollBarAndIconRowL()

   300     {

   301     __ASSERT_DEBUG(iExtension, Panic(KLmkPanicInvalidResourceData));

   302 

   303     __ASSERT_ALWAYS(iConsArray, Panic(KLmkPanicInvalidResourceData));

   304 

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

   306     iFirstVisibleRow = 0;

   307     iAnimated = EFalse;

   308     iCursorPos = TPoint(0, 0);

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

   310             % iExtension->iMaxVisibleRows ? 1 : 0);

   311     iCurrentPage = 1;

   312 

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

   314     delete iSBFrame;

   315     iSBFrame = NULL;

   316 

   317     if (AknLayoutUtils::PenEnabled())

   318         {

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

   320         }

   321     else

   322         {

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

   324         }

   325     // Decide which type of scrollbar is shown

   326     CAknAppUi* appUi = iAvkonAppUi;

   327     if (AknLayoutUtils::DefaultScrollBarType(appUi)

   328             == CEikScrollBarFrame::EDoubleSpan)

   329         {

   330         // For EDoubleSpan type scrollbar

   331         if (AknLayoutUtils::PenEnabled())

   332             {

   333             iSBFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse, ETrue,

   334                     EFalse); // window owning scrollbar

   335             }

   336         else

   337             {

   338             iSBFrame->CreateDoubleSpanScrollBarsL(EFalse, EFalse, ETrue,

   339                     EFalse); // non-window owning scrollbar

   340             }

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

   342         }

   343     else

   344         {

   345         // For EArrowHead type scrollbar

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

   347         }

   348 

   349     iSBFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff,

   350             CEikScrollBarFrame::EAuto);

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

   352     UpdateScrollIndicatorL();

   353     }

   354 

   355 // -----------------------------------------------------------------------------

   356 // CLmkIconMap::SetIndex

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

   358 // -----------------------------------------------------------------------------

   359 //

   360 void CLmkIconMap::SetIndex(TInt& aIconIndex)

   361     {

   362     iIconIndex = &aIconIndex;

   363     }

   364 

   365 // -----------------------------------------------------------------------------

   366 // CLmkIconMap::MinimumSize

   367 //

   368 // -----------------------------------------------------------------------------

   369 //

   370 TSize CLmkIconMap::MinimumSize()

   371     {

   372     iIsMirrored = AknLayoutUtils::LayoutMirrored();

   373     CountMaxColumnsAndCellSizes();

   374 

   375     TRect rect;

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

   377 

   378     TAknLayoutRect dialogLayRect;

   379 

   380     // Main pane without softkeys

   381     TRect mainPaneRect;

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

   383             mainPaneRect))

   384         {

   385         mainPaneRect = iAvkonAppUi->ClientRect();

   386         }

   387 

   388     // Dialog layout, check variety first

   389     TAknLayoutScalableParameterLimits iconMapDialogVariety =

   390             AknLayoutScalable_Avkon::popup_grid_graphic_window_ParamLimits();

   391 

   392     // Calc the variety

   393     TInt maxVariety = iconMapDialogVariety.LastVariety();

   394 

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

   396     // there is not so much varieties

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

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

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

   400 

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

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

   403     if (Layout_Meta_Data::IsLandscapeOrientation())

   404         {

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

   406         }

   407 

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

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

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

   411     if (location == AknLayoutUtils::EAknCbaLocationRight)

   412         {

   413         maxVarietyOffset = varietyOffset;

   414         }

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

   416         {

   417         maxVarietyOffset = varietyOffset + varietyOffset; // 2*

   418         }

   419 

   420     TInt varietyNumber = varietyOffset - iRows - 1;

   421 

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

   423     // (the biggest grid) variety

   424     if (varietyNumber < 0)

   425         varietyNumber = 0;

   426     // if zero rows, use the minimum

   427     else if (iRows <= 0)

   428         varietyNumber -= 1;

   429 

   430     //add the varietyoffset

   431     varietyNumber += maxVarietyOffset;

   432 

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

   434             == AknLayoutUtils::EAknCbaLocationRight))

   435         {

   436         varietyNumber = 10;

   437         }

   438     else

   439         {

   440         if (iRows == 0)

   441             {

   442             varietyNumber = 5;

   443             }

   444         else

   445             {

   446             varietyNumber = 3;

   447             }

   448         }

   449     // Layout the dialog size

   450     dialogLayRect.LayoutRect(mainPaneRect,

   451             AknLayoutScalable_Avkon::popup_grid_graphic_window(varietyNumber));

   452 

   453     // Layout the grid

   454     TAknLayoutRect gridWithScrollLayRect;

   455     gridWithScrollLayRect.LayoutRect(dialogLayRect.Rect(),

   456             AknLayoutScalable_Avkon::listscroll_popup_graphic_pane());

   457 

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

   459             gridWithScrollLayRect.Rect().Height());

   460     }

   461 

   462 // -----------------------------------------------------------------------------

   463 // CLmkIconMap::ActivateL()

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

   465 // -----------------------------------------------------------------------------

   466 //

   467 void CLmkIconMap::ActivateL()

   468     {

   469     CCoeControl::ActivateL();

   470     if (iRows > Extension()->iMaxVisibleRows)

   471         {

   472         UpdateScrollIndicatorL();

   473         }

   474     }

   475 

   476 // -----------------------------------------------------------------------------

   477 // CLmkIconMap::OfferKeyEventL

   478 // Handles all the Keypad events

   479 // -----------------------------------------------------------------------------

   480 //

   481 TKeyResponse CLmkIconMap::OfferKeyEventL(const TKeyEvent& aKeyEvent,

   482         TEventCode /*aModifiers*/)

   483     {

   484     TUint code = aKeyEvent.iCode;

   485 

   486     switch (code)

   487         {

   488         case EKeyLeftArrow:

   489         case '4':

   490             MoveCursorL(-1, 0);

   491             break;

   492         case EKeyRightArrow:

   493         case '6':

   494             MoveCursorL(1, 0);

   495             break;

   496         case EKeyUpArrow:

   497         case '2':

   498             MoveCursorL(0, -1);

   499             break;

   500         case EKeyDownArrow:

   501         case '8':

   502             MoveCursorL(0, 1);

   503             break;

   504         case EKeyOK:

   505         case '5':

   506         case EKeySpace:

   507         case EKeyEnter:

   508             {

   509             if (iConsArray)

   510                 {

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

   512                         + iCursorPos.iX;

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

   514                     {

   515                     *iIconIndex = ret;

   516                     }

   517                 else

   518                     {

   519                     *iIconIndex = -1;

   520                     }

   521                 }

   522 

   523             }

   524             break;

   525         default:

   526             return EKeyWasNotConsumed;

   527 

   528         }

   529     return EKeyWasConsumed;

   530     }

   531 

   532 // -----------------------------------------------------------------------------

   533 // CLmkIconMap::InputCapabilities()

   534 //

   535 // -----------------------------------------------------------------------------

   536 //

   537 TCoeInputCapabilities CLmkIconMap::InputCapabilities() const

   538     {

   539     return TCoeInputCapabilities(TCoeInputCapabilities::EAllText);

   540     }

   541 

   542 // -----------------------------------------------------------------------------

   543 // CLmkIconMap::SizeChanged()

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

   545 // in CEikDialogPage::SetDataPosition, so we do not do that in this method.

   546 // -----------------------------------------------------------------------------

   547 //

   548 void CLmkIconMap::SizeChanged()

   549     {

   550     // Get the layout

   551 

   552     // Main pane without softkeys

   553     TRect mainPaneRect;

   554 

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

   556             mainPaneRect))

   557         {

   558         mainPaneRect = iAvkonAppUi->ClientRect();

   559         }

   560 

   561     // Dialog layout, check variety first

   562     TAknLayoutScalableParameterLimits iconMapDialogVariety =

   563             AknLayoutScalable_Avkon::popup_grid_graphic_window_ParamLimits();

   564 

   565     TInt maxVariety = iconMapDialogVariety.LastVariety();

   566 

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

   568     // there is not so much varieties

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

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

   571     TInt varietyOffset = maxVariety + 1;

   572 

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

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

   575     if (Layout_Meta_Data::IsLandscapeOrientation())

   576         {

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

   578         }

   579 

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

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

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

   583     if (location == AknLayoutUtils::EAknCbaLocationRight)

   584         {

   585         maxVarietyOffset = varietyOffset;

   586         }

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

   588         {

   589         maxVarietyOffset = varietyOffset + varietyOffset; // 2*

   590         }

   591 

   592     TInt varietyNumber = varietyOffset - iRows - 1;

   593 

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

   595     // (the biggest grid) variety

   596     if (varietyNumber < 0)

   597         varietyNumber = 0;

   598     // if zero rows, use the minimum

   599     else if (iRows <= 0)

   600         varietyNumber -= 1;

   601 

   602     //add the varietyoffset

   603     varietyNumber += maxVarietyOffset;

   604 

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

   606             == AknLayoutUtils::EAknCbaLocationRight))

   607         {

   608         varietyNumber = 10;

   609         }

   610     else

   611         {

   612         if (iRows == 0)

   613             {

   614             varietyNumber = 5;

   615             }

   616         else

   617             {

   618             varietyNumber = 3;

   619             }

   620 

   621         }

   622 

   623     TAknLayoutRect popupGridLayRect;

   624     popupGridLayRect.LayoutRect(mainPaneRect,

   625             AknLayoutScalable_Avkon::popup_grid_graphic_window(varietyNumber));

   626 

   627     // Calculate the size relatively

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

   629 

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

   631     TAknLayoutRect gridWithScrollLayRect;

   632     gridWithScrollLayRect.LayoutRect(relativeDialog,

   633             AknLayoutScalable_Avkon::listscroll_popup_graphic_pane());

   634 

   635     // Then the grid area without scrollbar

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

   637     TAknLayoutRect gridLayRect;

   638     gridLayRect.LayoutRect(gridWithScrollLayRect.Rect(),

   639             AknLayoutScalable_Avkon::grid_graphic_popup_pane(0));

   640 

   641     // Different parent if SCT inside editing menu.

   642     TRect contentRect = gridLayRect.Rect();

   643 

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

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

   646     if (iIsMirrored)

   647         {

   648         iOffset = TPoint(contentRect.iBr.iX - KHorizontalDialogMargin

   649                 - iGridItemWidth + 1, contentRect.iTl.iY

   650                 - KVerticalDialogMargin + 1);

   651         iGridTopLeft.iX = contentRect.iBr.iX - KHorizontalDialogMargin

   652                 - (iMaxColumns * iGridItemWidth);

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

   654         }

   655     else // not mirrored

   656         {

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

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

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

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

   661         }

   662 

   663     // The last, update background context

   664     if (Extension()->iBgContext)

   665         {

   666         TInt bgVariety = 0;

   667         if (Layout_Meta_Data::IsLandscapeOrientation())

   668             bgVariety = 1;

   669 

   670         TAknLayoutRect innerRect;

   671         innerRect.LayoutRect(relativeDialog,

   672                 AknLayoutScalable_Avkon::bg_popup_window_pane_g1(bgVariety));

   673 

   674         Extension()->iBgContext->SetFrameRects(relativeDialog,

   675                 innerRect.Rect());

   676         }

   677     TRAPD(err, UpdateScrollIndicatorL());

   678     if (err)

   679         return;

   680     }

   681 

   682 // -----------------------------------------------------------------------------

   683 // CLmkIconMap::HandleResourceChange()

   684 //

   685 // -----------------------------------------------------------------------------

   686 //

   687 void CLmkIconMap::HandleResourceChange(TInt aType)

   688     {

   689     if (aType == KEikDynamicLayoutVariantSwitch)

   690         {

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

   692         TInt oldMaxColumns = iMaxColumns;

   693         //TInt oldMaxRows = 0;

   694         //oldMaxRows = iRows;

   695         // calculate the new magnitudes

   696         DoLayout();

   697 

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

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

   700 

   701         TInt oldCursorPosition = (iFirstVisibleRow + iOldCursorPos.iY)

   702                 * oldMaxColumns + iOldCursorPos.iX;

   703 

   704         TInt currentCursorPosition = (iFirstVisibleRow + iCursorPos.iY)

   705                 * oldMaxColumns + iCursorPos.iX;

   706 

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

   708         iFirstVisibleRow = Extension()->iMaxVisibleRows

   709                 * (currentCursorPosition / (iMaxColumns

   710                         * Extension()->iMaxVisibleRows));

   711 

   712         // the cursor positions are relative to current page

   713         iCursorPos.iY = (currentCursorPosition - (iMaxColumns

   714                 * iFirstVisibleRow)) / iMaxColumns;

   715         iCursorPos.iX = currentCursorPosition - (iMaxColumns

   716                 * iFirstVisibleRow) - (iMaxColumns * iCursorPos.iY);

   717 

   718         iOldCursorPos.iY = (oldCursorPosition - (iMaxColumns

   719                 * iFirstVisibleRow)) / iMaxColumns;

   720         iOldCursorPos.iX = oldCursorPosition - (iMaxColumns

   721                 * iFirstVisibleRow) - (iMaxColumns * iOldCursorPos.iY);

   722         }

   723 

   724     if (aType == KAknsMessageSkinChange)

   725         {

   726         iOffscreenBgDrawn = EFalse;

   727         }

   728     CCoeControl::HandleResourceChange(aType);

   729 

   730     }

   731 

   732 // -----------------------------------------------------------------------------

   733 // CLmkIconMap::Draw()

   734 //

   735 // -----------------------------------------------------------------------------

   736 //

   737 void CLmkIconMap::Draw(const TRect& /*aRect*/) const

   738     {

   739 

   740     TInt cursorPos = 0;

   741     CWindowGc& gc = SystemGc();

   742 

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

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

   745 

   746     TRect rect = Rect();

   747 

   748     // Main pane without softkeys

   749     TRect mainPaneRect;

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

   751             mainPaneRect))

   752         {

   753         mainPaneRect = iAvkonAppUi->ClientRect();

   754         }

   755 

   756     // Dialog layout, check variety first

   757     TAknLayoutScalableParameterLimits iconMapDialogVariety =

   758             AknLayoutScalable_Avkon::popup_grid_graphic_window_ParamLimits();

   759 

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

   761     TInt maxVariety = iconMapDialogVariety.LastVariety();

   762 

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

   764     // there is not so much varieties

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

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

   767     TInt varietyOffset = maxVariety + 1;

   768 

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

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

   771     if (Layout_Meta_Data::IsLandscapeOrientation())

   772         {

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

   774         }

   775 

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

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

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

   779     if (location == AknLayoutUtils::EAknCbaLocationRight)

   780         {

   781         maxVarietyOffset = varietyOffset;

   782         }

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

   784         {

   785         maxVarietyOffset = varietyOffset + varietyOffset; // 2*

   786         }

   787 

   788     TInt varietyNumber = varietyOffset - iRows - 1;

   789 

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

   791     // (the biggest grid) variety

   792     if (varietyNumber < 0)

   793         varietyNumber = 0;

   794     // if zero rows, use the minimum

   795     else if (iRows <= 0)

   796         varietyNumber -= 1;

   797 

   798     //add the varietyoffset

   799     varietyNumber += maxVarietyOffset;

   800 

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

   802             == AknLayoutUtils::EAknCbaLocationRight))

   803         {

   804         varietyNumber = 10;

   805         }

   806     else

   807         {

   808         varietyNumber = 3;

   809         }

   810     // Layout the dialog size

   811     TAknLayoutRect dialogLayRect;

   812     dialogLayRect.LayoutRect(mainPaneRect,

   813             AknLayoutScalable_Avkon::popup_grid_graphic_window(varietyNumber));

   814 

   815     // Get the missing height for the background

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

   817 

   818     rect.iBr.iY += backgroundHeightOffset;

   819 

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

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

   822     if (iOffscreenBg && iHasBitmapBackground)

   823         {

   824         DrawOffscreenBackgroundIfRequired();

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

   826         }

   827     else

   828         {

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

   830         }

   831 

   832     TInt numberOfIconsToBeDrawn = iConsArray->Count();

   833     numberOfIconsToBeDrawn -= (iFirstVisibleRow * iMaxColumns);

   834     if (numberOfIconsToBeDrawn > 0)

   835         {

   836         if (numberOfIconsToBeDrawn > (Extension()->iMaxVisibleRows

   837                 * iMaxColumns))

   838             {

   839             numberOfIconsToBeDrawn = Extension()->iMaxVisibleRows

   840                     * iMaxColumns;

   841             }

   842         __ASSERT_DEBUG( numberOfIconsToBeDrawn >= 1, Panic( KLmkPanicOutOfRange ) );

   843 

   844         gc.SetPenStyle(CGraphicsContext::ESolidPen);

   845         gc.SetBrushStyle(CGraphicsContext::ENullBrush);

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

   847 

   848         // 2) Draw the grid

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

   850 

   851         TInt numberOfGridCellsToBeDrawn = numberOfIconsToBeDrawn;

   852 

   853         TRgb colorLine = AKN_LAF_COLOR(219);

   854         AknsUtils::GetCachedColor(skin, colorLine, KAknsIIDQsnLineColors,

   855                 EAknsCIQsnLineColorsCG5);

   856         TRgb colorRecentLine = AKN_LAF_COLOR(215);

   857         AknsUtils::GetCachedColor(skin, colorRecentLine,

   858                 KAknsIIDQsnLineColors, EAknsCIQsnLineColorsCG7);

   859 

   860         // default pen color

   861         gc.SetPenColor(colorLine);

   862 

   863         TInt fullRows = numberOfGridCellsToBeDrawn / iMaxColumns;

   864 

   865         // how many left after the full rows

   866         numberOfGridCellsToBeDrawn -= fullRows * iMaxColumns;

   867 

   868         TPoint pos = iGridTopLeft;

   869 

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

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

   872 

   873         TInt ii = 0;

   874 

   875         if (fullRows)

   876             {

   877             // Draw full vertical lines

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

   879                 {

   880                 gc.SetPenColor(colorLine);

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

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

   883                 pos.iX += iGridItemWidth;

   884                 }

   885 

   886             pos = iGridTopLeft;

   887 

   888             // Draw full horizontal lines

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

   890                 {

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

   892                 gc.SetPenColor(colorLine);

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

   894                 pos.iY += iGridItemHeight;

   895                 }

   896             gc.SetPenColor(colorLine);

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

   898             }

   899 

   900         if (numberOfGridCellsToBeDrawn)

   901             {

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

   903             pos = iOffset;

   904             pos.iX--; // iOffset is cell area topLeft, grid is not included in it

   905             pos.iY--;

   906 

   907             pos.iY += iGridItemHeight * fullRows;

   908 

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

   910                 {

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

   912 

   913                 if (iIsMirrored)

   914                     pos.iX -= iGridItemWidth;

   915                 else

   916                     // not mirrored

   917                     pos.iX += iGridItemWidth;

   918                 }

   919             }

   920 

   921         TInt iconIndex = (iCurrentPage - 1) * (iMaxColumns

   922                 * Extension()->iMaxVisibleRows);

   923         TInt lCnt = iConsArray->Count();

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

   925         if (lCnt > 0)

   926             {

   927             TRect cellRect(TPoint(0, 0), TSize(iGridItemWidth - 1,

   928                     iGridItemHeight - 1));

   929             for (TInt j = iconIndex, i = 0; j < lCnt && (i

   930                     < numberOfIconsToBeDrawn); j++, i++)

   931                 {

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

   933                 }

   934             }

   935 

   936         }

   937     iDrawnBefore = ETrue;

   938     gc.DiscardFont();

   939     }

   940 

   941 // -----------------------------------------------------------------------------

   942 // CLmkIconMap::DrawItem()

   943 //

   944 // -----------------------------------------------------------------------------

   945 //

   946 void CLmkIconMap::DrawItem(CWindowGc& aGc, const TRect& aSctPosition,

   947         TInt aIconIndex, TBool aHighlighted, TBool aDrawBackground) const

   948     {

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

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

   951 

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

   953     TRgb color;

   954     if (!skins)

   955         aGc.SetBrushStyle(CGraphicsContext::ESolidBrush);

   956     if (aHighlighted)

   957         {

   958         TRgb colorHightLightRect = AKN_LAF_COLOR(215);

   959         AknsUtils::GetCachedColor(skin, colorHightLightRect,

   960                 KAknsIIDQsnLineColors, EAknsCIQsnLineColorsCG7);

   961         aGc.SetPenColor(colorHightLightRect);

   962         aGc.DrawRect(aSctPosition);

   963 

   964         // Shrink by one pixel in all directions.

   965         TRect innerRect = aSctPosition;

   966         innerRect.Shrink(1, 1);

   967 

   968         color = AKN_LAF_COLOR(210);

   969         AknsUtils::GetCachedColor(skin, color, KAknsIIDQsnHighlightColors,

   970                 EAknsCIQsnHighlightColorsCG1);

   971         aGc.SetBrushColor(color);

   972         aGc.Clear(innerRect);

   973         }

   974     else if (aDrawBackground)

   975         {

   976         TRect innerRect = aSctPosition;

   977         aGc.SetBrushColor(AKN_LAF_COLOR(0));

   978         if (!skins)

   979             aGc.Clear(innerRect);

   980         else

   981             AknsDrawUtils::Background(skin, cc, this, aGc, innerRect);

   982         }

   983 

   984     if (iConsArray)

   985         {

   986         TInt lCnt = iConsArray->Count();

   987         if (lCnt > 0 && aIconIndex < lCnt && aIconIndex >= 0)

   988             {

   989             TRect cellRect(TPoint(0, 0), TSize(iGridItemWidth - 1,

   990                     iGridItemHeight - 1));

   991 

   992             CGulIcon* bitmap = NULL;

   993             bitmap = iConsArray->At(aIconIndex);

   994             TInt numIconsInaPage = Extension()->iMaxVisibleRows * iMaxColumns;

   995             TInt cellIndex = aIconIndex;

   996             if (aIconIndex >= numIconsInaPage)

   997                 {

   998                 cellIndex = aIconIndex % numIconsInaPage;

   999                 }

  1000             aGc.BitBltMasked(CursorPoint(cellIndex), bitmap->Bitmap(),

  1001                     cellRect, bitmap->Mask(), EFalse);

  1002             }

  1003         }

  1004     }

  1005 

  1006 // -----------------------------------------------------------------------------

  1007 // CLmkIconMap::DrawCursor()

  1008 // Optimizes drawing. Only cursor is drawn.

  1009 // -----------------------------------------------------------------------------

  1010 void CLmkIconMap::DrawCursor() const

  1011     {

  1012     // Whole Icon Map has to be drawn at least once.

  1013     // If the user presses arrow key before Icon Map has been drawn,

  1014     // only cursor position is drawn without this check.

  1015     if (!iDrawnBefore)

  1016         {

  1017         DrawNow();

  1018         }

  1019     // Only redraw old and new cursor position cells

  1020     ActivateGc();

  1021     CWindowGc& gc = SystemGc();

  1022 

  1023     TInt cursorPos = iOldCursorPos.iX + iOldCursorPos.iY * iMaxColumns;

  1024     if (cursorPos >= 0)

  1025         {

  1026         DrawCell(cursorPos, EFalse);

  1027 

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

  1029         DrawCell(cursorPos, ETrue);

  1030         }

  1031 

  1032     gc.DiscardFont();

  1033     DeactivateGc();

  1034     }

  1035 

  1036 // -----------------------------------------------------------------------------

  1037 // CLmkIconMap::DrawCell

  1038 // -----------------------------------------------------------------------------

  1039 //

  1040 void CLmkIconMap::DrawCell(TInt aCursorPos, TBool aHighLighted) const

  1041     {

  1042     // calculate icon index

  1043     TInt iconIndex = aCursorPos + iFirstVisibleRow * iMaxColumns;

  1044 

  1045     // If we are only redrawing for animations, no need to draw non-animated items.

  1046     TRect rect = CursorRect(aCursorPos);

  1047 

  1048     Window().Invalidate(rect);

  1049     Window().BeginRedraw(rect);

  1050     DrawItem(SystemGc(), rect, iconIndex, aHighLighted, ETrue);

  1051     Window().EndRedraw();

  1052     SystemGc().DiscardFont();

  1053     }

  1054 

  1055 // -----------------------------------------------------------------------------

  1056 // CLmkIconMap::CursorRect

  1057 // -----------------------------------------------------------------------------

  1058 //

  1059 TRect CLmkIconMap::CursorRect(TInt aCursorPos) const

  1060     {

  1061     TPoint pos = iOffset;

  1062 

  1063     if (iIsMirrored)

  1064         {

  1065         pos.iX -= (aCursorPos % iMaxColumns) * iGridItemWidth;

  1066         }

  1067     else // Not mirrored

  1068         {

  1069         pos.iX += (aCursorPos % iMaxColumns) * iGridItemWidth;

  1070         }

  1071 

  1072     pos.iY += (aCursorPos / iMaxColumns) * iGridItemHeight;

  1073     return TRect(pos, TSize(iGridItemWidth - 1, iGridItemHeight - 1));

  1074     }

  1075 

  1076 // -----------------------------------------------------------------------------

  1077 // CLmkIconMap::CursorPoint

  1078 // -----------------------------------------------------------------------------

  1079 //

  1080 TPoint CLmkIconMap::CursorPoint(TInt aCursorPos) const

  1081     {

  1082     TPoint pos = iOffset;

  1083 

  1084     if (iIsMirrored)

  1085         {

  1086         pos.iX -= (aCursorPos % iMaxColumns) * iGridItemWidth;

  1087         }

  1088     else // Not mirrored

  1089         {

  1090         pos.iX += (aCursorPos % iMaxColumns) * iGridItemWidth;

  1091         }

  1092 

  1093     pos.iY += (aCursorPos / iMaxColumns) * iGridItemHeight;

  1094     return pos;

  1095     }

  1096 

  1097 // -----------------------------------------------------------------------------

  1098 // CLmkIconMap::MoveCursorL

  1099 // -----------------------------------------------------------------------------

  1100 //

  1101 void CLmkIconMap::MoveCursorL(TInt aDeltaX, TInt aDeltaY)

  1102     {

  1103     __ASSERT_DEBUG((aDeltaX <= 1) && (aDeltaX >= -1) && (aDeltaY <= 1)

  1104             && (aDeltaY >= -1) && ((aDeltaX * aDeltaY) == 0), Panic(

  1105             KLmkPanicOutOfRange));

  1106 

  1107     if (iIsMirrored)

  1108         aDeltaX = -aDeltaX;

  1109 

  1110     if ((iConsArray->Count() < 8))

  1111         return;

  1112 

  1113     iOldCursorPos = iCursorPos;

  1114     TInt oldFirstVisibleRow = iFirstVisibleRow;

  1115 

  1116     TInt globalYPos = iCursorPos.iY + iFirstVisibleRow;

  1117     TInt lastColumnOnLastRow = ((iConsArray->Count() - 1) % iMaxColumns);

  1118 

  1119     TInt skipicon = aDeltaX != 0 ? 1 : 0;

  1120 

  1121     if (aDeltaX < 0)

  1122         {

  1123         // Cursor was moved to left.

  1124         if (iCursorPos.iX > skipicon - 1)

  1125             {

  1126             iCursorPos.iX -= skipicon;

  1127             }

  1128         else

  1129             {

  1130             if (skipicon > iMaxColumns)

  1131                 {

  1132                 globalYPos--;

  1133                 iCursorPos.iX = iMaxColumns;

  1134                 }