1 /*

     2 * Copyright (c) 2002-2009 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:  This is a concrete class for the handling of a grid.

    15 *                The class handles a rectangular grid arrangement of items

    16 *                held in any linear ordering i.e. cells ordered top to

    17 *                bottom and left, left to right and down etc.

    18 *

    19 */

    20 

    21 

    22 #include <AknGrid.h>

    23 #include <avkon.hrh>

    24 #include <avkon.rsg>

    25 

    26 #include <barsread.h>

    27 

    28 #include <AknGridView.h>

    29 #include <AknGridM.h>

    30 #include <eiklbm.h>

    31 #include <eiklbi.h>

    32 #include <eiklbx.h>

    33 

    34 #include <eikenv.h>

    35 #include <eiklbx.pan>

    36 #include <eikkeys.h>

    37 

    38 #include <AknsUtils.h>

    39 

    40 //formatted listbox

    41 #include <eikfrlbd.h>

    42 #include <eikfrlb.h>

    43 

    44 #include <AknDef.h>

    45 #include <aknlayoutscalable_avkon.cdl.h>

    46 #include <AknsControlContext.h>

    47 #include "layoutmetadata.cdl.h"

    48 #include <aknphysics.h>

    49 

    50 #ifdef RD_UI_TRANSITION_EFFECTS_LIST

    51     #include <aknlistloadertfx.h>

    52     #include <aknlistboxtfxinternal.h>

    53 #endif //RD_UI_TRANSITION_EFFECTS_LIST

    54 

    55 #include <touchfeedback.h>

    56 #include "akntrace.h"

    57 

    58 const TInt KDefaultLineHeightForHorizontalGrid = 10;

    59 

    60 const TInt KEikListBoxPointerRepeatInterval = 100000;  // 0.1 seconds in micro seconds

    61 

    62 const TInt KEikListBoxInvalidIndex = -1;

    63 

    64 enum TGridOrientation

    65     {

    66     EGridOrientationHorizontal,

    67     EGridOrientationVertical

    68     };

    69 enum TGridHorizontal

    70     {

    71     EGridHorizontalRightToLeft,

    72     EGridHorizontalLeftToRight,

    73     EGridHorizontalWritingDirection,

    74     EGridHorizontalAntiWritingDirection

    75     };

    76 enum TGridVertical

    77     {

    78     EGridVerticalBottomToTop,

    79     EGridVerticalTopToBottom

    80     };

    81 

    82 

    83 /**

    84 * Local Panic Function and Panic Codes 

    85 */

    86 enum TAknGridPanicCodes

    87     {

    88     EAknPanicGridGeneralPanic,

    89     EAknPanicGridModelAlreadyExists,

    90     EAknPanicGridInvalidNumberOfPrimaryItems,

    91     EAknPanicGridNoView

    92     };

    93     

    94 

    95 enum TAknGridStateFlags

    96     {

    97     EAknGridStateButton1DownInGrid = 0x01

    98     };

    99 

   100 // ================= Extension class ========================

   101 NONSHARABLE_CLASS(CAknGridExtension) : public CBase

   102     {

   103     public:

   104         CAknGridExtension();

   105         ~CAknGridExtension();

   106     TInt GetScrollingSpeed( TBool aIsOverItem, TInt aItemIndex, CAknGridView& aView, 

   107                             const TPoint& aPoint ) const;

   108     

   109 

   110     public: // data 

   111         TInt iFlags;

   112         // EMMA-7A8B9F.Ugly hack. Prevent MopSupplyObject being invoked 

   113         // from CEikListBox::MopGetObject()

   114         TBool iIsFromBaseClass;

   115         TPoint iLastPoint;

   116         TBool iKineticScrolling;

   117         TBool iSingleClickEnabled;

   118     };

   119 

   120 CAknGridExtension::CAknGridExtension() 

   121     : 

   122     iFlags(0), 

   123     iIsFromBaseClass( EFalse ),

   124     iLastPoint( 0, 0 ), 

   125     iKineticScrolling( CAknPhysics::FeatureEnabled() ),

   126     iSingleClickEnabled( iAvkonAppUi->IsSingleClickCompatible() )

   127     {

   128     }

   129 

   130 CAknGridExtension::~CAknGridExtension()

   131     {

   132     }

   133     

   134 TInt CAknGridExtension::GetScrollingSpeed( TBool aIsOverItem, TInt aItemIndex, 

   135                                            CAknGridView& aView, const TPoint& aPoint ) const

   136     {

   137     TInt itemCountInRow = aView.NumberOfColsInView();

   138     TInt speed = 0;

   139     TInt y = aPoint.iY - iLastPoint.iY;

   140     if ( aIsOverItem )

   141         {

   142         if ( aView.BottomItemIndex() - aItemIndex < itemCountInRow 

   143             &&  y> 0 )

   144             {

   145             speed = 1;

   146             }

   147         else if ( aItemIndex - aView.TopItemIndex() < itemCountInRow 

   148             && y < 0 )

   149             {

   150             speed = -1;

   151             }

   152         }

   153     else

   154         {

   155         speed = 0;

   156         }

   157     return speed;

   158     }

   159     

   160     

   161 // ================= CAknGrid class ========================

   162 

   163 GLDEF_C void Panic(TAknGridPanicCodes aPanic)

   164     {

   165     _LIT(KPanicCat,"AknGrid");

   166     User::Panic(KPanicCat, aPanic);

   167     }

   168 

   169 

   170 EXPORT_C CAknGrid::CAknGrid()

   171     {

   172     }

   173 

   174 EXPORT_C CAknGrid::~CAknGrid()

   175     {

   176     delete iExtension;

   177     }

   178 

   179 /**

   180 * This function must only be called before ConstructL()

   181 */

   182 EXPORT_C void CAknGrid::SetModel(CAknGridM* aModel)

   183     {

   184     __ASSERT_ALWAYS(!iModel, Panic(EAknPanicGridModelAlreadyExists));

   185     iModel = aModel;

   186     }

   187 

   188 EXPORT_C void CAknGrid::ConstructL(const CCoeControl* aParent, TInt aFlags)

   189     {

   190     _AKNTRACE_FUNC_ENTER;

   191     if (!iModel)

   192         {

   193         iModel = new(ELeave) CAknGridM;

   194         }

   195     

   196     GridModel()->ConstructL();

   197 

   198     CreateItemDrawerL();

   199     ItemDrawer()->FormattedCellData()->SetControl(this);

   200     CEikListBox::ConstructL(aParent, aFlags);

   201     

   202     if ( !iExtension )

   203         {

   204         iExtension = new (ELeave) CAknGridExtension;    

   205         }

   206 

   207     // the default scrolling method is follows items

   208     SetPrimaryScrollingType( CAknGridView::EScrollFollowsItemsAndLoops );

   209     SetSecondaryScrollingType( CAknGridView::EScrollFollowsItemsAndLoops );

   210     _AKNTRACE_FUNC_EXIT;

   211     }

   212 

   213 EXPORT_C void CAknGrid::ConstructFromResourceL(TResourceReader& aReader)

   214     {

   215     _AKNTRACE_FUNC_ENTER;

   216     RestoreCommonListBoxPropertiesL(aReader);        

   217     TInt requiredCellCharWidth=aReader.ReadInt16();

   218  

   219     if (!iModel)

   220         iModel = new(ELeave) CAknGridM;

   221 

   222     TInt items=aReader.ReadInt32();

   223     if (!items)

   224         {

   225         STATIC_CAST(CAknGridM*,iModel)->ConstructL();

   226         }

   227     else

   228         {

   229         CDesCArray* desArray=iCoeEnv->ReadDesCArrayResourceL(items);

   230         CleanupStack::PushL(desArray);

   231 

   232         STATIC_CAST(CAknGridM*,iModel)->ConstructL(desArray);

   233         CleanupStack::Pop( desArray );

   234         }

   235  

   236     CreateItemDrawerL();

   237     iItemDrawer->SetDrawMark(EFalse);

   238     ItemDrawer()->FormattedCellData()->SetControl(this);

   239     STATIC_CAST(CFormattedCellListBoxItemDrawer*,iItemDrawer)->SetCellWidthInChars(requiredCellCharWidth);

   240     CreateViewL();

   241 

   242     // empty text

   243     HBufC* emptyGridText = aReader.ReadHBufCL();

   244     if (emptyGridText)

   245         {

   246         CleanupStack::PushL(emptyGridText);

   247         SetEmptyGridTextL(*emptyGridText);

   248         CleanupStack::PopAndDestroy( emptyGridText );

   249         }

   250 

   251     TInt gridStyle=aReader.ReadInt32();

   252 

   253     TResourceReader reader;

   254     if (!gridStyle)

   255         {

   256         iEikonEnv->CreateResourceReaderLC(reader,R_AVKON_GRID_STYLE_DEFAULT);

   257         }

   258     else

   259         {

   260         iEikonEnv->CreateResourceReaderLC(reader,gridStyle);

   261         }

   262 

   263     SetLayoutFromResourceL(reader);

   264     CleanupStack::PopAndDestroy(); // reader

   265     

   266     if ( !iExtension )

   267         {        

   268         iExtension = new (ELeave) CAknGridExtension;  

   269         }

   270     _AKNTRACE_FUNC_EXIT;

   271     }

   272 

   273 /**

   274 * This routine assumes that SetLayoutL has been called to set

   275 * up the grid.

   276 */

   277 EXPORT_C void CAknGrid::SizeChanged()

   278     {

   279     _AKNTRACE_FUNC_ENTER;

   280     TRect clientRect = iBorder.InnerRect(Rect());

   281 

   282     TInt currentDataIndex = 0;

   283     CAknGridView* gridView = GridView();

   284 

   285     // reset item offset

   286     gridView->SetItemOffsetInPixels( 0 );

   287 

   288     if (iCurrentIsValid) // appshell does not call HandleItemAddition!

   289         {                // so this is never called. See CAknAppStyleGrid::SizeChanged()

   290         // remember current position

   291         currentDataIndex = gridView->CurrentDataIndex();

   292         }

   293 

   294     TRect rect(clientRect);

   295     rect.SetRect(rect.iTl.iX + ListBoxMargins().iLeft, rect.iTl.iY + ListBoxMargins().iTop,

   296                  rect.iBr.iX - ListBoxMargins().iRight, rect.iBr.iY - ListBoxMargins().iBottom);

   297     iView->SetViewRect(rect);

   298     _AKNTRACE( "The rect of grid are ( %d, %d ) ( %d, %d )", 

   299     		   rect.iTl.iX, rect.iTl.iY, 

   300     		   rect.iBr.iX, rect.iBr.iY );

   301     TRAPD(err1, HandleViewRectSizeChangeL());

   302     if (err1)

   303         {

   304         if (iSBFrameOwned == ENotOwnedExternally)

   305             {

   306             delete iSBFrame;

   307             iSBFrame = 0;

   308             }

   309         }

   310 

   311     // check grid orientated to show current focus (item height

   312     // change may have moved the focus to a new page)

   313     if (iCurrentIsValid)

   314         {

   315         gridView->SetCurrentDataIndex(currentDataIndex);

   316         }

   317 

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

   319     TRgb color;

   320     

   321     TInt error = AknsUtils::GetCachedColor( skin,

   322                                             color,

   323                                             KAknsIIDQsnTextColors,

   324                                             EAknsCIQsnTextColorsCG11 );

   325     if (!error)

   326         {

   327         ItemDrawer()->SetHighlightedTextColor( color );

   328         }

   329     _AKNTRACE_FUNC_EXIT;

   330     }

   331 

   332 /**

   333 * Protected routine used by functions to check/alter the dimensions

   334 * of the grid as data items are added or removed or the

   335 * size of the items are altered.

   336 * This routine assumes that SetLayoutL has been called.

   337 * This will not leave if scrollbars have both been turned off.

   338 */

   339 EXPORT_C void CAknGrid::CalcGridSizeL()

   340     {

   341     _AKNTRACE_FUNC_ENTER;

   342     __TEST_INVARIANT;

   343 

   344     CAknGridView* gridView = GridView();

   345     TSize gridSize = gridView->GridCellDimensions();

   346 

   347     TInt definedItems = GridModel()->IndexOfLastDataItem() + 1;

   348 

   349     if (definedItems > 0)

   350         {

   351         // item height determines iHeight

   352         if (iItemHeight < 1)

   353             {

   354             // item height must exist - so set to default value

   355             // for now

   356             CEikListBox::SetItemHeightL(KDefaultLineHeightForHorizontalGrid);

   357             }

   358 

   359         if(iOrientationFlags.IsSet(EGridOrientationVertical))

   360             {

   361             gridSize.iHeight = iNumOfRowsInView;

   362             gridSize.iWidth = definedItems / gridSize.iHeight; 

   363             if (definedItems % gridSize.iHeight)

   364                 gridSize.iWidth++;

   365             }

   366         else

   367             {

   368             gridSize.iWidth = iNumOfColsInView;

   369             gridSize.iHeight = definedItems / gridSize.iWidth; 

   370             if (definedItems % gridSize.iWidth)

   371                 gridSize.iHeight++;

   372             }

   373         }

   374     else

   375         {

   376         //no defined items so grid empty

   377         gridSize.iWidth = 1;

   378         gridSize.iHeight = 1;

   379         if (iOrientationFlags.IsSet(EGridOrientationVertical))

   380             gridSize.iHeight = iNumOfRowsInView;

   381         else

   382             gridSize.iWidth = iNumOfColsInView;

   383         }

   384     // set number of cells in grid

   385     gridView->SetGridCellDimensions(gridSize);

   386     _AKNTRACE_FUNC_EXIT;

   387     }

   388 

   389 

   390 /**

   391 * Creates a formatted list item drawer.

   392 */

   393 EXPORT_C void CAknGrid::CreateItemDrawerL()

   394     {

   395     CFormattedCellListBoxData* data=CFormattedCellGridData::NewL();

   396     CleanupStack::PushL(data);

   397 

   398     data->SetControl( this );

   399     data->CreatePictographInterfaceL();

   400 

   401     iItemDrawer=new(ELeave) CFormattedCellListBoxItemDrawer(Model(), iEikonEnv->NormalFont(), data);

   402     CleanupStack::Pop( data );

   403     }

   404 

   405 /**

   406 * Gives the formatted list item drawer being used by the grid.

   407 */

   408 EXPORT_C CFormattedCellListBoxItemDrawer* CAknGrid::ItemDrawer() const

   409     {

   410     return STATIC_CAST(CFormattedCellListBoxItemDrawer*,iItemDrawer);

   411     }

   412 

   413 /**

   414 * Informs the grid that the data in the model has altered.

   415 * It is assumed that the grid has been initialised by a call to SetLayoutL

   416 * before this function is called for the first time.

   417 */

   418 EXPORT_C void CAknGrid::HandleItemAdditionL()

   419     {

   420     _AKNTRACE_FUNC_ENTER;

   421     __TEST_INVARIANT;

   422 

   423     if (GridModel()->NumberOfData() <= 0)

   424         return;

   425 

   426     TInt currentDataIndex = 0;

   427 

   428     CAknGridView* gridView = GridView();

   429 

   430     if (iCurrentIsValid)

   431         {

   432         // remember current position

   433         currentDataIndex = gridView->CurrentDataIndex();

   434         }

   435 

   436     CalcGridSizeL();

   437 

   438     CEikListBox::HandleItemAdditionL();

   439 

   440     // check the current marker is set to the first item in the 

   441     // grid if it hasn't been set yet otherwise ensure current marker still

   442     // on cell item before new items were added. 

   443     if (!iCurrentIsValid)

   444         SetStartPositionL(PositionAtIndex(0));

   445     else

   446         gridView->SetCurrentDataIndex(currentDataIndex);

   447 

   448     iCurrentIsValid = ETrue;

   449 

   450     // redraw everything visible since all/most will have been affected

   451     DrawNow();

   452     UpdateScrollBarsL();

   453     _AKNTRACE_FUNC_EXIT;

   454     }

   455 

   456 /**

   457 * Informs the  grid that the data in the model has altered.

   458 * It is assumed that the grid has been initialised by a call to SetLayoutL

   459 * before this function is called for the first time.

   460 */

   461 EXPORT_C void CAknGrid::HandleItemRemovalL()

   462     {

   463     _AKNTRACE_FUNC_ENTER;

   464     __TEST_INVARIANT;

   465 

   466     if (!iCurrentIsValid)

   467         return;

   468 

   469     CAknGridView* gridView = GridView();

   470 

   471     TInt currentDataIndex = gridView->CurrentDataIndex();

   472 

   473     CalcGridSizeL();

   474 

   475     CEikListBox::HandleItemRemovalL();

   476 

   477     // check if need to reposition current index since may have been

   478     // on one of those just deleted.

   479     CAknGridM* gridModel = GridModel();

   480     if (!gridModel->IndexContainsData(currentDataIndex))

   481         currentDataIndex = gridModel->IndexOfLastDataItem();

   482 

   483     gridView->SetCurrentDataIndex(currentDataIndex);

   484 

   485     // redraw everything visible since all/most will have been affected

   486     DrawNow();

   487     UpdateScrollBarsL();

   488     _AKNTRACE_FUNC_EXIT;

   489     }

   490 

   491 /**

   492 * Sets the orientation of the grid, either vertical or horizontal, the

   493 * ordering of the data and the size of the primary dimension of the

   494 * grid.

   495 * Note: The value for the parameter aNumOfItemsInPrimaryOrient must be

   496 * greater than zero since this determines the number of items (be it rows

   497 * or columns) in the primary orientation of the grid.

   498 */

   499 EXPORT_C void CAknGrid::SetLayoutL(TBool aVerticalOrientation,

   500                                    TBool aLeftToRight,

   501                                    TBool aTopToBottom,

   502                                    TInt aNumOfItemsInPrimaryOrient,

   503                                    TInt aNumOfItemsInSecondaryOrient,

   504                                    TSize aSizeOfItems,

   505                                    TInt aWidthOfSpaceBetweenItems,

   506                                    TInt aHeightOfSpaceBetweenItems)

   507     {

   508     _AKNTRACE_FUNC_ENTER;

   509     TGridOrientation gridOrientation = EGridOrientationHorizontal;

   510     if (aVerticalOrientation)

   511         gridOrientation = EGridOrientationVertical;

   512 

   513     TGridHorizontal gridHorizontal = EGridHorizontalWritingDirection;

   514     if (aLeftToRight)

   515         gridHorizontal = EGridHorizontalLeftToRight;

   516     else

   517         gridHorizontal = EGridHorizontalRightToLeft;

   518 

   519     TGridVertical gridVertical = EGridVerticalBottomToTop;

   520     if (aTopToBottom)

   521         gridVertical = EGridVerticalTopToBottom;

   522     

   523     DoSetLayoutL(gridOrientation,

   524                  gridHorizontal,

   525                  gridVertical,

   526                  aNumOfItemsInPrimaryOrient,

   527                  aNumOfItemsInSecondaryOrient,

   528                  aSizeOfItems,

   529                  aWidthOfSpaceBetweenItems,

   530                  aHeightOfSpaceBetweenItems);

   531     _AKNTRACE_FUNC_EXIT;

   532 

   533     }

   534 

   535 void CAknGrid::DoSetLayoutL(TInt aOrientation,

   536                             TInt aHorizontal,

   537                             TInt aVertical,

   538                             TInt aNumOfItemsInPrimaryOrient,

   539                             TInt aNumOfItemsInSecondaryOrient,

   540                             TSize aSizeOfItems,

   541                             TInt aWidthOfSpaceBetweenItems,

   542                             TInt aHeightOfSpaceBetweenItems)

   543     {

   544     _AKNTRACE_FUNC_ENTER;

   545     // this must be the first method called after the construction of

   546     // the grid

   547     __TEST_INVARIANT;

   548 

   549     // number of primary items must be > 0

   550     __ASSERT_ALWAYS((aNumOfItemsInPrimaryOrient > 0), Panic(EAknPanicGridInvalidNumberOfPrimaryItems));

   551 

   552     // store number of items in primary in case of SizeChange

   553     // never used iNumOfItemsInPrimaryOrient = aNumOfItemsInPrimaryOrient;

   554 

   555     iSpaceBetweenItems.iWidth = aWidthOfSpaceBetweenItems;

   556     iSpaceBetweenItems.iHeight = aHeightOfSpaceBetweenItems;

   557 

   558     iOrientationFlags.ClearAll(); 

   559     iHorizontalFlags.ClearAll();

   560     iVerticalFlags.ClearAll();

   561     TInt gridFlags = 0;

   562 

   563     switch(aOrientation)

   564         {

   565         case EGridOrientationHorizontal:

   566             iOrientationFlags.Set(EGridOrientationHorizontal);

   567             iNumOfRowsInView = aNumOfItemsInSecondaryOrient;

   568             iNumOfColsInView = aNumOfItemsInPrimaryOrient;

   569             break;

   570         case EGridOrientationVertical: // drop through to default

   571         default: // use default to keep BC with old code

   572             iOrientationFlags.Set(EGridOrientationVertical);

   573             gridFlags |= CAknGridView::EPrimaryIsVertical;

   574             iNumOfRowsInView = aNumOfItemsInPrimaryOrient;

   575             iNumOfColsInView = aNumOfItemsInSecondaryOrient;

   576             break;

   577         }

   578 

   579     switch(aHorizontal)

   580         {

   581         case EGridHorizontalRightToLeft:      // drop through

   582         case EGridHorizontalLeftToRight:      // drop through

   583         case EGridHorizontalWritingDirection: // drop through

   584         case EGridHorizontalAntiWritingDirection:

   585             iHorizontalFlags.Set(aHorizontal);

   586             break;

   587         default: // use default to keep BC with old code

   588             iHorizontalFlags.Set(EGridHorizontalWritingDirection);

   589             break;

   590         }

   591 

   592     TBool isMirrored = AknLayoutUtils::LayoutMirrored();

   593     if (isMirrored)

   594         {

   595         if (iHorizontalFlags.IsSet(EGridHorizontalAntiWritingDirection)

   596             || iHorizontalFlags.IsSet(EGridHorizontalLeftToRight))

   597             gridFlags |= CAknGridView::ELeftToRight;

   598         }

   599     else

   600         {

   601         if (iHorizontalFlags.IsSet(EGridHorizontalWritingDirection)

   602             || iHorizontalFlags.IsSet(EGridHorizontalLeftToRight))

   603             gridFlags |= CAknGridView::ELeftToRight;

   604         }

   605 

   606     switch(aVertical)

   607         {

   608         case EGridVerticalBottomToTop:

   609             iVerticalFlags.Set(EGridVerticalBottomToTop);

   610             break;

   611         case EGridVerticalTopToBottom: // drop through to default

   612         default: // use default to keep BC with old code

   613             iVerticalFlags.Set(EGridVerticalTopToBottom);

   614             gridFlags |= CAknGridView::ETopToBottom;

   615             break;

   616         }

   617         

   618     CAknGridView* gridView = GridView();

   619 

   620     gridView->SetSpacesBetweenItems(iSpaceBetweenItems);

   621     CAknGridView::SGrid gridDetails;

   622     // define a single cell grid size to start with - the grid will only become

   623     // real after we've added some data and called HandleItemAdditionL. Because

   624     // this method is being called when dynamic layout switch is handled we

   625     // cannot set gridDetails.iGridDimensions = TSize(1,1). Instead, we use the

   626     // grid view's value -> a fully populated grid no longer loses its

   627     // dimension information. Default value TSize(1,1) is now set in grid

   628     // view's constructor.

   629     gridDetails.iGridDimensions = gridView->GridCellDimensions();

   630     gridDetails.iGridFlags = gridFlags;

   631     gridDetails.iPageSize = iNumOfColsInView*iNumOfRowsInView;

   632     gridDetails.iColsInView = iNumOfColsInView;

   633     gridDetails.iRowsInView = iNumOfRowsInView;

   634     gridDetails.iSizeBetweenItems = iSpaceBetweenItems;

   635     gridDetails.iSizeOfItems = aSizeOfItems;

   636     CalcGridSizeL();

   637     gridView->SetGridDetails(gridDetails);

   638 

   639     gridView->SetColumnWidth(aSizeOfItems.iWidth);

   640     SetItemHeightL(aSizeOfItems.iHeight);

   641     SetItemsInSingleLine(gridDetails.iColsInView);

   642 

   643     // Create the scroll bars

   644     _AKNTRACE( "Create scroll bar" );

   645     CreateScrollBarFrameL(ETrue, EFalse, ETrue);

   646     ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);

   647     UpdateScrollBarsL();

   648     _AKNTRACE_FUNC_EXIT;

   649     }

   650     

   651 EXPORT_C void CAknGrid::HandlePointerEventL(const TPointerEvent& aPointerEvent) 

   652     {     

   653     _AKNTRACE_FUNC_ENTER;

   654     if ( AknLayoutUtils::PenEnabled() ) 

   655         {

   656         // Scroll bar

   657         // Do not use iSBFrame->VerticalScrollBar()->Rect() to test, 

   658         // because of iSBFrame->VerticalScrollBar owning window.

   659         if( iSBFrame && TRect(iSBFrame->VerticalScrollBar()->Position(), 

   660             iSBFrame->VerticalScrollBar()->Size()).Contains ( aPointerEvent.iPosition ))

   661             {

   662             if ( !ScrollingDisabled()

   663                 && iExtension->iFlags & EAknGridStateButton1DownInGrid )

   664                 {

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

   666                     {

   667                     iExtension->iFlags &= ~EAknGridStateButton1DownInGrid;

   668                     }

   669                 CEikListBox::HandlePointerEventL( aPointerEvent );

   670                 }

   671             else

   672                 {

   673                 CCoeControl::HandlePointerEventL( aPointerEvent );

   674                 }

   675             return;

   676             }

   677         else

   678             {

   679             CAknGridView* gridView = GridView();

   680             TInt itemIndex = 0;

   681             

   682             TRect visibleItemsRect(gridView->ViewRect().iTl, 

   683                 TSize(gridView->ItemSize(itemIndex).iWidth * iNumOfColsInView, 

   684                 gridView->ItemSize(itemIndex).iHeight * iNumOfRowsInView));

   685         

   686         // switch pointer event type and set button 1 down in grid flag on and off depending where event happened.

   687             switch (aPointerEvent.iType)

   688                 {

   689                 case TPointerEvent::EButton1Down:

   690                     iExtension->iLastPoint = aPointerEvent.iPosition;

   691                     if ( visibleItemsRect.Contains(aPointerEvent.iPosition) )

   692                         {

   693                         iExtension->iFlags |= EAknGridStateButton1DownInGrid;                

   694                         }

   695                     _AKNTRACE( "TPointerEvent::EButton1Down" );

   696                     break;

   697 

   698                 case TPointerEvent::EButton1Up:

   699                     {

   700                     iExtension->iFlags &= ~EAknGridStateButton1DownInGrid;

   701                     _AKNTRACE( "TPointerEvent::EButton1Up" );

   702                     break;

   703                     }

   704 

   705                 default:

   706                     {

   707                     break;

   708                     }

   709                 }

   710 

   711             CEikListBox::HandlePointerEventL( aPointerEvent ); // eventually will call CAknGrid::HandleDragEventL if dragged

   712             }

   713         }

   714     _AKNTRACE_FUNC_EXIT;

   715     }

   716 

   717 EXPORT_C void* CAknGrid::ExtensionInterface( TUid /*aInterface*/ ) 

   718     { 

   719     return NULL;

   720     }

   721 

   722 /**

   723 * Sets the layout from a resource. Layout includes orientation 

   724 * (either vertical or horizontal), horizontal and vertical direction 

   725 * of numbering, the number of items in the primary and secondary

   726 * orientation, and the primary and secondary scrolling types.

   727 */

   728 EXPORT_C void CAknGrid::SetLayoutFromResourceL(TResourceReader& aReader)

   729     {

   730     _AKNTRACE_FUNC_ENTER;

   731     TInt layoutFlags = aReader.ReadInt16();

   732     TInt primaryScroll=aReader.ReadInt16();

   733     TInt secondaryScroll=aReader.ReadInt16();

   734     TInt numItemsInPrimaryOrient=aReader.ReadInt16();

   735     TInt numItemsInSecondaryOrient=aReader.ReadInt16();

   736     TInt height = aReader.ReadInt16();

   737     TInt width = aReader.ReadInt16();

   738     TInt gapWidth = aReader.ReadInt16();

   739     TInt gapHeight = aReader.ReadInt16();

   740 

   741     TGridOrientation gridOrientation = EGridOrientationHorizontal;

   742     if (layoutFlags & EAknGridVerticalOrientation)

   743         gridOrientation = EGridOrientationVertical;

   744 

   745     TGridHorizontal gridHorizontal = EGridHorizontalWritingDirection;

   746     if (layoutFlags & EAknGridLeftToRight)

   747         gridHorizontal = EGridHorizontalLeftToRight;

   748     else if (layoutFlags & EAknGridRightToLeft)

   749         gridHorizontal = EGridHorizontalRightToLeft;

   750 //        else if (layoutFlags & EAknGridHorizontalAntiWritingDirection)

   751 //                gridHorizontal = EGridHorizontalAntiWritingDirection;

   752     else if (layoutFlags & EAknGridLanguageSpecificHorizontalDirection)

   753         gridHorizontal = EGridHorizontalWritingDirection;

   754 

   755     TGridVertical gridVertical = EGridVerticalTopToBottom;

   756     if (layoutFlags & EAknGridBottomToTop)

   757         gridVertical = EGridVerticalBottomToTop;

   758 

   759     CAknGridView::TScrollingType prime = CAknGridView::EScrollFollowsItemsAndLoops;

   760     CAknGridView::TScrollingType second = CAknGridView::EScrollFollowsItemsAndLoops;

   761 

   762     switch(primaryScroll)

   763         {

   764         case EAknGridFollowsItemsAndStops:

   765             prime = CAknGridView::EScrollFollowsItemsAndStops;

   766             break;

   767         case EAknGridFollowsItemsAndLoops:

   768             prime = CAknGridView::EScrollFollowsItemsAndLoops;

   769             break;

   770         case EAknGridFollowsGrid:

   771             prime = CAknGridView::EScrollFollowsGrid;

   772             break;

   773         case EAknGridStops:

   774             prime = CAknGridView::EScrollStops;

   775             break;

   776         case EAknGridIncrementLineAndStops:

   777             prime = CAknGridView::EScrollIncrementLineAndStops;

   778             break;

   779         case EAknGridIncrementLineAndLoops:

   780             prime = CAknGridView::EScrollIncrementLineAndLoops;

   781             break;

   782         default:

   783             break;

   784         }

   785 

   786     switch(secondaryScroll)

   787         {

   788         case EAknGridFollowsItemsAndStops:

   789             second = CAknGridView::EScrollFollowsItemsAndStops;

   790             break;

   791         case EAknGridFollowsItemsAndLoops:

   792             second = CAknGridView::EScrollFollowsItemsAndLoops;

   793             break;

   794         case EAknGridFollowsGrid:

   795             second = CAknGridView::EScrollFollowsGrid;

   796             break;

   797         case EAknGridStops:

   798             second = CAknGridView::EScrollStops;

   799             break;

   800         case EAknGridIncrementLineAndStops:

   801             second = CAknGridView::EScrollIncrementLineAndStops;

   802             break;

   803         case EAknGridIncrementLineAndLoops:

   804             second = CAknGridView::EScrollIncrementLineAndLoops;

   805             break;

   806         default:

   807             break;

   808         }

   809     TSize itemSize(width,height);

   810     DoSetLayoutL(gridOrientation, gridHorizontal, gridVertical, numItemsInPrimaryOrient, numItemsInSecondaryOrient, itemSize, gapWidth, gapHeight);

   811     SetPrimaryScrollingType(prime);

   812     SetSecondaryScrollingType(second);

   813     _AKNTRACE_FUNC_EXIT;

   814     }

   815 

   816 

   817 /**

   818 * Sets the movement of the cursor with respect to scrolling when the

   819 * end item in the current row or column, whichever is the primary

   820 * orientation of the data items, is encountered. The movement maybe

   821 * either stop, loop back to same row or column or move onto the

   822 * next logical data item in the sequence.

   823 */

   824 EXPORT_C void CAknGrid::SetPrimaryScrollingType(CAknGridView::TScrollingType aScrollingType)

   825     {

   826     __TEST_INVARIANT;

   827     GridView()->SetPrimaryScrollingType(aScrollingType);

   828     }

   829 

   830 /**

   831 * Sets the movement of the cursor with respect to scrolling when the

   832 * end item in the secondary dimension of the grid is encountered.

   833 * The movement maybe either stop, loop back back to same row or column

   834 * or move onto the next logical data item in the sequence.

   835 */

   836 EXPORT_C void CAknGrid::SetSecondaryScrollingType(CAknGridView::TScrollingType aSecondaryScrolling)

   837     {

   838     __TEST_INVARIANT;

   839     GridView()->SetSecondaryScrollingType(aSecondaryScrolling);

   840     }

   841 

   842 /**

   843 * Returns the current grid data index.

   844 * Returns -1 if the grid is empty.

   845 */

   846 EXPORT_C TInt CAknGrid::CurrentDataIndex() const

   847     {

   848     _AKNTRACE_FUNC_ENTER;

   849     __TEST_INVARIANT;

   850     if (GridModel()->NumberOfData() < 1)

   851     	{

   852     	_AKNTRACE( "no data in model, return -1" );

   853     	_AKNTRACE_FUNC_EXIT;

   854         return -1;

   855     	}

   856     TInt startOffset = GridModel()->IndexOfFirstDataItem();

   857     _AKNTRACE_FUNC_EXIT;

   858     return (GridView()->CurrentDataIndex() - startOffset);

   859     }

   860 

   861 /**

   862 * Moves the cursor to the required grid data index.

   863 */

   864 EXPORT_C void CAknGrid::SetCurrentDataIndex(TInt aDataIndex)

   865     {

   866     _AKNTRACE_FUNC_ENTER;

   867     __TEST_INVARIANT;

   868     _AKNTRACE( "[%s] aDataIndex = %d", 

   869     		   __FUNCTION__, aDataIndex );

   870     TInt startOffset = GridModel()->IndexOfFirstDataItem();

   871 

   872     if (startOffset == -1)

   873     	{

   874     	_AKNTRACE_FUNC_EXIT;

   875         return; // there is no data yet

   876     	}

   877     TInt newIndex = aDataIndex + startOffset;

   878 

   879     GridView()->SetCurrentDataIndex(newIndex);

   880     UpdateScrollBarThumbs();

   881     _AKNTRACE_FUNC_EXIT;

   882     }

   883 

   884 /**

   885 * Sets the starting position of the data within the grid.

   886 * <p>

   887 * Note: a blank page cannot be accessed (since cannot move into empty cells)

   888 * so a totally blank page is the same as if the page never existed since

   889 * the user cannot scroll into it. For this reason it is suggested that

   890 * the start position be no more than one page into the grid.

   891 */

   892 EXPORT_C void CAknGrid::SetStartPositionL(TPoint aGridStartPosition)

   893     {

   894     _AKNTRACE_FUNC_ENTER;

   895     __TEST_INVARIANT;

   896 

   897     TInt dataIndex;

   898     CAknGridView* gridView = GridView();

   899     gridView->DataIndexFromLogicalPos(dataIndex,aGridStartPosition.iY,aGridStartPosition.iX);

   900 

   901     // set the number of blank start cells

   902     GridModel()->SetStartCells(dataIndex);

   903 

   904     // need to check grid size

   905     CalcGridSizeL();

   906 

   907     // check current item position

   908     gridView->SetCurrentDataIndex(dataIndex);

   909     iCurrentIsValid = ETrue;

   910     _AKNTRACE_FUNC_EXIT;

   911     }

   912 

   913 /**

   914 * Gives the data index at the grid position given.

   915 * The position must be given with respect to the top left corner

   916 * of the grid.

   917 * An index value of -1 is given if the grid position given is

   918 * invalid.

   919 */

   920 EXPORT_C TInt CAknGrid::IndexOfPosition(TPoint aGridPosition) const

   921     {

   922     _AKNTRACE_FUNC_ENTER;

   923     __TEST_INVARIANT;

   924 

   925     TInt indexValue = -1;

   926 

   927 

   928     CAknGridView* gridView = GridView();

   929     TSize gridSize = gridView->GridCellDimensions();

   930 

   931     if ((aGridPosition.iY >= 0)&&

   932         (aGridPosition.iX >= 0)&&

   933         (aGridPosition.iX < gridSize.iWidth)&&

   934         (aGridPosition.iY < gridSize.iHeight))

   935         {

   936         // grid position is valid

   937         gridView->DataIndexFromLogicalPos(indexValue, aGridPosition.iY, aGridPosition.iX);

   938 

   939         indexValue -= GridModel()->IndexOfFirstDataItem();

   940         }

   941         

   942     _AKNTRACE_FUNC_EXIT;    

   943     return indexValue;

   944     }

   945 

   946 /**

   947 * Gives the position of the data item required.

   948 * The logical position is given with respect to the top left 

   949 * hand corner of the grid.

   950 * A position of (-1,-1) is given if the data item is not valid.

   951 */

   952 EXPORT_C TPoint CAknGrid::PositionAtIndex(TInt aItemIndex) const

   953     {

   954     _AKNTRACE_FUNC_ENTER;

   955     __TEST_INVARIANT;

   956     _AKNTRACE(" [%s] aItemIndex = %d", 

   957         		  __FUNCTION__, aItemIndex );

   958     

   959     TPoint gridPosition(-1,-1);

   960 

   961     CAknGridM* gridModel = GridModel();

   962 

   963     TInt startOffset = gridModel->IndexOfFirstDataItem();

   964     TInt newIndex = aItemIndex + startOffset;

   965 

   966     if (ItemExists(newIndex))

   967         {

   968         if (gridModel->IndexContainsData(newIndex))

   969             {

   970             GridView()->

   971                 LogicalPosFromDataIndex(newIndex, gridPosition.iY, gridPosition.iX);

   972             }

   973         }

   974 

   975     _AKNTRACE_FUNC_EXIT;

   976     return gridPosition;

   977     }

   978 

   979 

   980 EXPORT_C CListBoxView* CAknGrid::MakeViewClassInstanceL() 

   981     {

   982     return (new(ELeave) CAknGridView);

   983     }

   984 

   985 /**

   986 * Sets the column width of the grid.

   987 * Column width cannot be set in a horizontal grid since the number

   988 * of columns in the grid is defined by the initialising call to

   989 * SetLayoutL.

   990 * The column width cannot be larger than the width of the viewing

   991 * rectangle.

   992 */

   993 EXPORT_C void CAknGrid::SetColumnWidth(TInt aColumnWidth)

   994     {

   995     _AKNTRACE_FUNC_ENTER;

   996     __TEST_INVARIANT;

   997     _AKNTRACE(" [%s] aColumnWidth = %d", 

   998     		  __FUNCTION__, aColumnWidth );

   999     

  1000     if (aColumnWidth < 1)

  1001         return;

  1002 

  1003     TInt currentDataIndex = 0;

  1004 

  1005     CAknGridView* gridView = GridView();

  1006     if (iCurrentIsValid)

  1007         {

  1008         // remember current position

  1009         currentDataIndex = gridView->CurrentDataIndex();

  1010         }

  1011 

  1012     // hold the users value in case needed in the method

  1013     // HandleItemAdditionL

  1014     iMinColWidth = aColumnWidth;

  1015 

  1016     gridView->SetColumnWidth(aColumnWidth);

  1017 

  1018     // check grid orientated to show current focus (item height

  1019     // change may have moved the focus to a new page)

  1020     if (iCurrentIsValid)

  1021         gridView->SetCurrentDataIndex(currentDataIndex);

  1022     _AKNTRACE_FUNC_EXIT;

  1023     }

  1024 

  1025 /**

  1026 * Sets the row height of the grid.

  1027 * Row height cannot be set in a vertical grid since the number

  1028 * of rows in the grid is defined by the initialising call to

  1029 * SetLayoutL.

  1030 * The row height cannot be larger than the height of the viewing

  1031 * rectangle.

  1032 */

  1033 EXPORT_C void CAknGrid::SetItemHeightL(TInt aHeight)

  1034     {

  1035     _AKNTRACE_FUNC_ENTER;

  1036     __TEST_INVARIANT;

  1037     _AKNTRACE(" [%s] aHeight = %d", 

  1038     		  __FUNCTION__, aHeight );

  1039 

  1040     if (aHeight < 1)

  1041         return;

  1042 

  1043     TInt currentDataIndex = 0;

  1044 

  1045     CAknGridView* gridView = GridView();

  1046     if (iCurrentIsValid)

  1047         {

  1048         // remember current position

  1049         currentDataIndex = gridView->CurrentDataIndex();

  1050         }

  1051 

  1052     // this ensures that if user changes the item height then the

  1053     // grid details will change in line as well

  1054     iItemHeight = aHeight;

  1055 

  1056     gridView->SetItemHeight(aHeight);

  1057 

  1058     CalcGridSizeL();

  1059 

  1060     // check grid orientated to show current focus (item height

  1061     // change may have moved the focus to a new page)

  1062     if (iCurrentIsValid)

  1063         gridView->SetCurrentDataIndex(currentDataIndex);

  1064     _AKNTRACE_FUNC_EXIT;

  1065     }

  1066 

  1067 /**

  1068 * Processes the user key events or passes them onto the underlying

  1069 * listbox code.

  1070 */

  1071 EXPORT_C TKeyResponse CAknGrid::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

  1072     {

  1073     _AKNTRACE_FUNC_ENTER;

  1074     // SERIES60 LAF

  1075     CListBoxView::TSelectionMode selectionMode = CListBoxView::ENoSelection;

  1076 

  1077     TBool shiftKeyPressed = (aKeyEvent.iModifiers & EModifierShift);

  1078     if (iListBoxFlags & EMultipleSelection)

  1079         {

  1080         if (shiftKeyPressed && iListBoxFlags & EShiftEnterMarks)

  1081             {

  1082             View()->SetAnchor(View()->CurrentItemIndex());

  1083             selectionMode = CListBoxView::EDisjointMarkSelection;

  1084             }

  1085         else

  1086             selectionMode = CListBoxView::ENoSelection;

  1087         }

  1088         

  1089     // With single click first key event enables highlight

  1090     if ( iExtension->iSingleClickEnabled

  1091             && ItemDrawer()->Flags()

  1092             &  CListItemDrawer::ESingleClickDisabledHighlight )

  1093         {

  1094         if ( aKeyEvent.iCode == EKeyUpArrow || 

  1095              aKeyEvent.iCode == EKeyDownArrow ||

  1096              aKeyEvent.iCode == EKeyLeftArrow || 

  1097              aKeyEvent.iCode == EKeyRightArrow ||   

  1098              aKeyEvent.iCode == EKeyEnter || 

  1099              aKeyEvent.iCode == EKeyOK )

  1100             {

  1101             _AKNTRACE_FUNC_EXIT;

  1102             return CEikListBox::OfferKeyEventL( aKeyEvent, aType );

  1103             }

  1104         }

  1105     

  1106     switch (aKeyEvent.iCode)

  1107         {

  1108         case EKeyUpArrow:

  1109             iView->MoveCursorL(CListBoxView::ECursorPreviousItem, selectionMode);

  1110             ClearMatchBuffer();

  1111             _AKNTRACE( "EKeyUpArrow" );

  1112             break;

  1113         case EKeyDownArrow:

  1114             iView->MoveCursorL(CListBoxView::ECursorNextItem, selectionMode);

  1115             ClearMatchBuffer();

  1116             _AKNTRACE( "EKeyDownArrow" );

  1117             break;

  1118 

  1119         case EKeyPrevious:

  1120             {

  1121             const TBool disableRedraw = aKeyEvent.iRepeats;

  1122             TBool redrawDisabled = iView->RedrawDisabled();

  1123             if ( disableRedraw )

  1124                 {

  1125                 iView->SetDisableRedraw(ETrue);

  1126                 }

  1127             

  1128             ((CAknGridView*)iView)->

  1129                 MoveCursorWithRepeatsL( EFalse, selectionMode, 1 + aKeyEvent.iRepeats );

  1130             ClearMatchBuffer();

  1131                 

  1132             if ( disableRedraw )

  1133                 {

  1134                 iView->SetDisableRedraw(redrawDisabled);