1 /*

     2 * Copyright (c) 2002 - 2007 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:  Test akngridview.h

    15 *

    16 */

    17 

    18 

    19 /*

    20  * Include files

    21  */

    22 #include <akngridview.h>

    23 #include <akngrid.h>

    24 #include <barsread.h>

    25 #include <eikenv.h>

    26 #include <testsdkgrids.rsg>

    27 #include <eiktxlbm.h> 

    28 #include <eikdialg.h> 

    29 #include <eiklbv.h> 

    30 #include <akngridm.h>

    31 

    32 #include "testsdkgridscontainer.h"

    33 #include "stifgridview.h"

    34 #include "testsdkgrids.h"

    35 

    36 const TInt KOne = 1;

    37 const TInt KTwo = 2;

    38 const TInt KThree = 3;

    39 const TInt KZero = 0;

    40 const TInt KTen = 10;

    41 const TInt KWidth = 240;

    42 const TInt KHeight = 320;

    43 const TInt KMinusone = -1;

    44 const TInt KNine = 9;

    45 const TInt KTwoHundredThirtyeight = 238;

    46 const TInt KTwoHundredThirtynine = 239;

    47 const TInt KThreeHundredeightten = 318;

    48 const TInt KThreeHundredninetten = 319;

    49 const TInt KTestIfExist = 100000000;

    50 const TInt KTwenty = 20;

    51 

    52 _LIT( KListText, "It is a list text!");

    53 

    54 // -----------------------------------------------------------------------------

    55 // CTestSDKGrids::TestGridsGridviewDestructorAndDestructorL

    56 // -----------------------------------------------------------------------------

    57 //

    58 TInt CTestSDKGrids::TestGridsGridviewDestructorAndDestructorL( CStifItemParser& /*aItem*/ )

    59     {

    60     CAknGridView* view = new( ELeave ) CAknGridView;

    61     CleanupStack::PushL( view );

    62     STIF_ASSERT_NOT_NULL( view );

    63     CleanupStack::PopAndDestroy( view );

    64     

    65     return KErrNone;

    66     }

    67 

    68 // -----------------------------------------------------------------------------

    69 // CTestSDKGrids::TestGridsGridviewActualDataIndexL

    70 // -----------------------------------------------------------------------------

    71 //

    72 TInt CTestSDKGrids::TestGridsGridviewActualDataIndexL( CStifItemParser& /*aItem*/ )

    73     {

    74     CAknGridView* view = new( ELeave ) CAknGridView;

    75     CleanupStack::PushL( view );

    76     

    77     CAknGridView::SGrid gridnumber;

    78     gridnumber.iColsInView = KNine;

    79     gridnumber.iRowsInView = KNine;

    80     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

    81     gridnumber.iSizeOfItems = TSize( KTen, KTen );

    82     gridnumber.iPageSize = KOne;

    83     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

    84     gridnumber.iGridFlags = KOne;

    85     

    86     view->SetGridDetails( gridnumber );

    87     TInt actualdataindex = view->ActualDataIndex( KOne );

    88     STIF_ASSERT_NOT_EQUALS( KZero, actualdataindex );

    89     

    90     CleanupStack::PopAndDestroy( view );

    91     return KErrNone;

    92     }

    93 

    94 // -----------------------------------------------------------------------------

    95 // CTestSDKGrids::TestGridsGridviewListBoxIndexL

    96 // -----------------------------------------------------------------------------

    97 //

    98 TInt CTestSDKGrids::TestGridsGridviewListBoxIndexL( CStifItemParser& /*aItem*/ )

    99     {

   100     CAknGridView* view = new( ELeave ) CAknGridView;

   101     CleanupStack::PushL( view );

   102     

   103     CAknGridView::SGrid gridnumber;

   104     gridnumber.iColsInView = KNine;

   105     gridnumber.iRowsInView = KNine;

   106     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   107     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   108     gridnumber.iPageSize = KOne;

   109     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   110     gridnumber.iGridFlags = KOne;

   111     

   112     view->SetGridDetails( gridnumber );

   113     TInt listboxindex = view->ListBoxIndex( KOne );

   114     STIF_ASSERT_NOT_EQUALS( KZero, listboxindex );

   115     

   116     CleanupStack::PopAndDestroy( view );

   117     return KErrNone;

   118     }

   119 

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

   121 // CTestSDKGrids::TestGridsGridviewCurrentDataIndexL

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

   123 //

   124 TInt CTestSDKGrids::TestGridsGridviewCurrentDataIndexL( CStifItemParser& aItem )

   125     {

   126     TInt err = TestGridsGridviewSetCurrentDataIndexL( aItem );

   127     return KErrNone;

   128     }

   129 

   130 // -----------------------------------------------------------------------------

   131 // CTestSDKGrids::TestGridsGridviewSetCurrentDataIndexL

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

   133 //

   134 TInt CTestSDKGrids::TestGridsGridviewSetCurrentDataIndexL( CStifItemParser& /*aItem*/ )

   135     {

   136     CAknGridView* view = new( ELeave ) CAknGridView;

   137     CleanupStack::PushL( view );

   138     

   139     CAknGridView::SGrid gridnumber;

   140     gridnumber.iColsInView = KNine;

   141     gridnumber.iRowsInView = KNine;

   142     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   143     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   144     gridnumber.iPageSize = KOne;

   145     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   146     gridnumber.iGridFlags = KOne;

   147     

   148     view->SetGridDetails( gridnumber );

   149     

   150     CAknGrid* grid = new( ELeave ) CAknGrid();

   151     CleanupStack::PushL( grid );

   152     

   153     CAknGridM* model = new( ELeave ) CAknGridM();

   154     CleanupStack::PushL( model );

   155     grid->SetModel( model );

   156     CleanupStack::Pop( model );

   157     

   158     TResourceReader reader;

   159     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   160     grid->SetContainerWindowL( *iContainer );

   161     grid->ConstructFromResourceL( reader );

   162     

   163     CTextListBoxModel* modeltwo = grid->Model();

   164     CListItemDrawer* drawer = grid->ItemDrawer();

   165     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

   166     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

   167     CEikDialog* mydialog= new(ELeave) CEikDialog; 

   168     mydialog->PrepareLC(R_TEST_DIALOG); 

   169     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

   170     const TRect rect = iContainer->Rect();

   171     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

   172         

   173     view->SetCurrentDataIndex( KZero );

   174     TInt dataindex = view->CurrentDataIndex();

   175     STIF_ASSERT_NOT_EQUALS( KZero, dataindex );

   176     

   177     view->SetCurrentDataIndex( KThree );

   178     dataindex = view->CurrentDataIndex();

   179     STIF_ASSERT_NOT_EQUALS( KThree, dataindex );

   180     

   181     CleanupStack::PopAndDestroy( mydialog );

   182     CleanupStack::PopAndDestroy();

   183     CleanupStack::PopAndDestroy( grid );

   184     CleanupStack::Pop( view );

   185     

   186     return KErrNone;

   187     }

   188 

   189 // -----------------------------------------------------------------------------

   190 // CTestSDKGrids::TestGridsGridviewSetPrimaryScrollingTypeL

   191 // -----------------------------------------------------------------------------

   192 //

   193 TInt CTestSDKGrids::TestGridsGridviewSetPrimaryScrollingTypeL( CStifItemParser& /*aItem*/ )

   194     {

   195     CAknGridView* view = new( ELeave ) CAknGridView;

   196     CleanupStack::PushL( view );

   197     

   198     CAknGridView::SGrid gridnumber;

   199     gridnumber.iColsInView = KNine;

   200     gridnumber.iRowsInView = KNine;

   201     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   202     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   203     gridnumber.iPageSize = KOne;

   204     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   205     gridnumber.iGridFlags = KOne;

   206     

   207     view->SetGridDetails( gridnumber );

   208     

   209     CAknGridView::TScrollingType scrollingtype = CAknGridView::EScrollFollowsItemsAndStops;

   210     

   211     view->SetPrimaryScrollingType( scrollingtype );

   212     

   213     scrollingtype = CAknGridView::EScrollFollowsGrid;

   214     

   215     view->SetPrimaryScrollingType( scrollingtype );

   216     

   217     CleanupStack::PopAndDestroy( view );

   218     return KErrNone;

   219     }

   220 

   221 // -----------------------------------------------------------------------------

   222 // CTestSDKGrids::TestGridsGridviewSetSecondaryScrollingTypeL

   223 // -----------------------------------------------------------------------------

   224 //

   225 TInt CTestSDKGrids::TestGridsGridviewSetSecondaryScrollingTypeL( CStifItemParser& /*aItem*/ )

   226     {

   227     CAknGridView* view = new( ELeave ) CAknGridView;

   228     CleanupStack::PushL( view );

   229     

   230     CAknGridView::SGrid gridnumber;

   231     gridnumber.iColsInView = KNine;

   232     gridnumber.iRowsInView = KNine;

   233     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   234     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   235     gridnumber.iPageSize = KOne;

   236     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   237     gridnumber.iGridFlags = KOne;

   238     

   239     view->SetGridDetails( gridnumber );

   240     

   241     CAknGridView::TScrollingType scrollingtype = CAknGridView::EScrollFollowsItemsAndStops;

   242         

   243     view->SetSecondaryScrollingType( scrollingtype );

   244     

   245     scrollingtype = CAknGridView::EScrollFollowsGrid;

   246     

   247     view->SetSecondaryScrollingType( scrollingtype );

   248     

   249     CleanupStack::PopAndDestroy( view );

   250     

   251     return KErrNone;

   252     }

   253 

   254 // -----------------------------------------------------------------------------

   255 // CTestSDKGrids::TestGridsGridviewSetGridCellDimensionsL

   256 // -----------------------------------------------------------------------------

   257 //

   258 TInt CTestSDKGrids::TestGridsGridviewSetGridCellDimensionsL( CStifItemParser& /*aItem*/ )

   259     {

   260     CAknGridView* view = new( ELeave ) CAknGridView;

   261     CleanupStack::PushL( view );

   262     

   263     CAknGridView::SGrid gridnumber;

   264     gridnumber.iColsInView = KNine;

   265     gridnumber.iRowsInView = KNine;

   266     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   267     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   268     gridnumber.iPageSize = KOne;

   269     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   270     gridnumber.iGridFlags = KOne;

   271     

   272     view->SetGridDetails( gridnumber );

   273     

   274     TSize size( KThree, KThree );

   275     view->SetGridCellDimensions( size );

   276     

   277     TSize returnsize = view->GridCellDimensions();

   278     

   279     STIF_ASSERT_EQUALS( size, returnsize );

   280     

   281     CleanupStack::PopAndDestroy( view );

   282     return KErrNone;

   283     }

   284 

   285 // -----------------------------------------------------------------------------

   286 // CTestSDKGrids::TestGridsGridviewGridCellDimensions

   287 // -----------------------------------------------------------------------------

   288 //

   289 TInt CTestSDKGrids::TestGridsGridviewGridCellDimensionsL( CStifItemParser& aItem )

   290     {

   291     TInt err = TestGridsGridviewSetGridCellDimensionsL( aItem );

   292     return err;

   293     }

   294 

   295 // -----------------------------------------------------------------------------

   296 // CTestSDKGrids::TestGridsGridviewSetSpacesBetweenItemsL

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

   298 //

   299 TInt CTestSDKGrids::TestGridsGridviewSetSpacesBetweenItemsL( CStifItemParser& /*aItem*/ )

   300     {

   301     CAknGridView* view = new( ELeave ) CAknGridView;

   302     CleanupStack::PushL( view );

   303     

   304     CAknGridView::SGrid gridnumber;

   305     gridnumber.iColsInView = KNine;

   306     gridnumber.iRowsInView = KNine;

   307     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   308     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   309     gridnumber.iPageSize = KOne;

   310     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   311     gridnumber.iGridFlags = KOne;

   312     

   313     view->SetGridDetails( gridnumber );

   314     

   315     view->SetSpacesBetweenItems( TSize( KZero ,KZero ));

   316     view->SetSpacesBetweenItems( TSize( KThree, KThree ));

   317     

   318     CleanupStack::PopAndDestroy( view );

   319     return KErrNone;

   320     }

   321 

   322 // -----------------------------------------------------------------------------

   323 // CTestSDKGrids::TestGridsGridviewIsPrimaryVerticalL

   324 // -----------------------------------------------------------------------------

   325 //

   326 TInt CTestSDKGrids::TestGridsGridviewIsPrimaryVerticalL( CStifItemParser& /*aItem*/ )

   327     {

   328     CAknGridView* view = new( ELeave ) CAknGridView;

   329     CleanupStack::PushL( view );

   330     

   331     CAknGridView::SGrid gridnumber;

   332     gridnumber.iColsInView = KNine;

   333     gridnumber.iRowsInView = KNine;

   334     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   335     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   336     gridnumber.iPageSize = KOne;

   337     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   338     gridnumber.iGridFlags = KOne;

   339     

   340     view->SetGridDetails( gridnumber );

   341     

   342     TBool flag = view->IsPrimaryVertical();

   343     STIF_ASSERT_TRUE( flag );

   344     

   345     gridnumber.iGridFlags = KZero;

   346     view->SetGridDetails( gridnumber );

   347     

   348     flag = view->IsPrimaryVertical();

   349     STIF_ASSERT_FALSE( flag );

   350     

   351     CleanupStack::PopAndDestroy( view );    

   352     return KErrNone;

   353     }

   354 

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

   356 // CTestSDKGrids::TestGridsGridviewDataIndexFromLogicalPosL

   357 // -----------------------------------------------------------------------------

   358 //

   359 TInt CTestSDKGrids::TestGridsGridviewDataIndexFromLogicalPosL( CStifItemParser& /*aItem*/ )

   360     {

   361     CAknGridView* view = new( ELeave ) CAknGridView;

   362     CleanupStack::PushL( view );

   363     

   364     CAknGridView::SGrid gridnumber;

   365     gridnumber.iColsInView = KNine;

   366     gridnumber.iRowsInView = KNine;

   367     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   368     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   369     gridnumber.iPageSize = KOne;

   370     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   371     gridnumber.iGridFlags = KOne;

   372     

   373     view->SetGridDetails( gridnumber );

   374     

   375     TInt dataindex( KZero );

   376     view->DataIndexFromLogicalPos( dataindex, KOne, KOne );

   377     STIF_ASSERT_NOT_EQUALS( KZero, dataindex );

   378     

   379     dataindex = KZero;

   380     gridnumber.iGridFlags = KZero;

   381     

   382     view->DataIndexFromLogicalPos( dataindex, KOne, KOne );

   383     STIF_ASSERT_NOT_EQUALS( KZero, dataindex );

   384     

   385     CleanupStack::PopAndDestroy( view );

   386     return KErrNone;

   387     }

   388 

   389 // -----------------------------------------------------------------------------

   390 // CTestSDKGrids::TestGridsGridviewLogicalPosFromDataIndexL

   391 // -----------------------------------------------------------------------------

   392 //

   393 TInt CTestSDKGrids::TestGridsGridviewLogicalPosFromDataIndexL( CStifItemParser& /*aItem*/ )

   394     {

   395     CAknGridView* view = new( ELeave ) CAknGridView;

   396     CleanupStack::PushL( view );

   397     

   398     CAknGridView::SGrid gridnumber;

   399     gridnumber.iColsInView = KNine;

   400     gridnumber.iRowsInView = KNine;

   401     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   402     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   403     gridnumber.iPageSize = KOne;

   404     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   405     gridnumber.iGridFlags = KOne;

   406     

   407     view->SetGridDetails( gridnumber );

   408     

   409     TInt rowindex( KZero );

   410     TInt colindex( KZero );

   411     

   412     view->LogicalPosFromDataIndex( KNine, rowindex, colindex );

   413     STIF_ASSERT_EQUALS( KThreeHundredninetten, rowindex );

   414     STIF_ASSERT_EQUALS( KTwoHundredThirtyeight, colindex );

   415     

   416     gridnumber.iGridFlags = KZero;

   417     view->SetGridDetails( gridnumber );

   418     

   419     view->LogicalPosFromDataIndex( KNine, rowindex, colindex );

   420     STIF_ASSERT_EQUALS( KThreeHundredeightten, rowindex );

   421     STIF_ASSERT_EQUALS( KTwoHundredThirtynine, colindex );

   422     

   423     view->LogicalPosFromDataIndex( KMinusone, rowindex, colindex );

   424     STIF_ASSERT_EQUALS( KThreeHundredninetten, rowindex );

   425     STIF_ASSERT_EQUALS( KTwoHundredThirtynine, colindex );

   426     

   427     CleanupStack::PopAndDestroy( view );

   428     return KErrNone;

   429     }

   430 

   431 // -----------------------------------------------------------------------------

   432 // CTestSDKGrids::TestGridsGridviewListBoxIndexFromLogicalPosL

   433 // -----------------------------------------------------------------------------

   434 //

   435 TInt CTestSDKGrids::TestGridsGridviewListBoxIndexFromLogicalPosL( CStifItemParser& /*aItem*/ )

   436     {

   437     CAknGridView* view = new( ELeave ) CAknGridView;

   438     CleanupStack::PushL( view );

   439     

   440     CAknGridView::SGrid gridnumber;

   441     gridnumber.iColsInView = KNine;

   442     gridnumber.iRowsInView = KNine;

   443     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   444     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   445     gridnumber.iPageSize = KOne;

   446     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   447     gridnumber.iGridFlags = KOne;

   448     

   449     view->SetGridDetails( gridnumber );

   450     

   451     TInt mitemindex( KZero );

   452     view->ListBoxIndexFromLogicalPos( mitemindex, KOne, KOne );

   453     STIF_ASSERT_EQUALS( KTen, mitemindex );

   454     

   455     gridnumber.iGridFlags = KZero;

   456     view->SetGridDetails( gridnumber );

   457     

   458     view->ListBoxIndexFromLogicalPos( mitemindex, KZero, KOne );

   459     STIF_ASSERT_EQUALS( KOne, mitemindex );

   460     

   461     CleanupStack::PopAndDestroy( view );

   462     return KErrNone;

   463     }

   464 

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

   466 // CTestSDKGrids::TestGridsGridviewLogicalPosFromListBoxIndexL

   467 // -----------------------------------------------------------------------------

   468 //

   469 TInt CTestSDKGrids::TestGridsGridviewLogicalPosFromListBoxIndexL( CStifItemParser& /*aItem*/ )

   470     {

   471     CAknGridView* view = new( ELeave ) CAknGridView;

   472     CleanupStack::PushL( view );

   473     

   474     CAknGridView::SGrid gridnumber;

   475     gridnumber.iColsInView = KNine;

   476     gridnumber.iRowsInView = KNine;

   477     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   478     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   479     gridnumber.iPageSize = KOne;

   480     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   481     gridnumber.iGridFlags = KOne;

   482     

   483     view->SetGridDetails( gridnumber );

   484     

   485     TInt rolindex( KZero );

   486     TInt colindex( KZero );

   487     

   488     view->LogicalPosFromListBoxIndex( KZero, rolindex, colindex );

   489     STIF_ASSERT_EQUALS( KZero, rolindex );

   490     STIF_ASSERT_EQUALS( KZero, colindex );

   491     

   492     view->LogicalPosFromListBoxIndex( KNine, rolindex, colindex );

   493     STIF_ASSERT_EQUALS( KZero, rolindex );

   494     STIF_ASSERT_EQUALS( KOne, colindex );

   495     

   496     gridnumber.iGridFlags = KZero;

   497     view->SetGridDetails( gridnumber );

   498     

   499     view->LogicalPosFromListBoxIndex( KNine, rolindex, colindex );

   500     STIF_ASSERT_EQUALS( KOne, rolindex );

   501     STIF_ASSERT_EQUALS( KZero, colindex );

   502     

   503     CleanupStack::PopAndDestroy( view );

   504     return KErrNone;

   505     }

   506 

   507 // -----------------------------------------------------------------------------

   508 // CTestSDKGrids::TestGridsGridviewDrawEmptyListL

   509 // -----------------------------------------------------------------------------

   510 //

   511 TInt CTestSDKGrids::TestGridsGridviewDrawEmptyListL( CStifItemParser& /*aItem*/ )

   512     {

   513     CAknGridView* view = new( ELeave ) CAknGridView;

   514     CleanupStack::PushL( view );

   515     

   516     CAknGridView::SGrid gridnumber;

   517     gridnumber.iColsInView = KNine;

   518     gridnumber.iRowsInView = KNine;

   519     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   520     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   521     gridnumber.iPageSize = KOne;

   522     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   523     gridnumber.iGridFlags = KOne;

   524     

   525     view->SetGridDetails( gridnumber );

   526     

   527     TBuf<32> buf( KListText );

   528     view->SetListEmptyTextL( buf );

   529     

   530     CAknGrid* grid = new( ELeave ) CAknGrid();

   531     CleanupStack::PushL( grid );

   532     

   533     CAknGridM* model = new( ELeave ) CAknGridM();

   534     CleanupStack::PushL( model );

   535     grid->SetModel( model );

   536     CleanupStack::Pop( model );

   537     

   538     TResourceReader reader;

   539     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   540     grid->SetContainerWindowL( *iContainer );

   541     grid->ConstructFromResourceL( reader );

   542     

   543     CTextListBoxModel* modeltwo = grid->Model();

   544     CListItemDrawer* drawer = grid->ItemDrawer();

   545     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

   546     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

   547     CEikDialog* mydialog= new(ELeave) CEikDialog; 

   548     mydialog->PrepareLC(R_TEST_DIALOG); 

   549     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

   550     const TRect rect = iContainer->Rect();

   551     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

   552     

   553     view->DrawEmptyList();

   554     

   555     CleanupStack::PopAndDestroy( mydialog );

   556     CleanupStack::PopAndDestroy();

   557     CleanupStack::PopAndDestroy( grid );

   558     CleanupStack::Pop( view );

   559     

   560     return KErrNone;

   561     }

   562 

   563 // -----------------------------------------------------------------------------

   564 // CTestSDKGrids::TestGridsGridviewSetGridDetailsL

   565 // -----------------------------------------------------------------------------

   566 //

   567 TInt CTestSDKGrids::TestGridsGridviewSetGridDetailsL( CStifItemParser& aItem )

   568     {

   569     TInt err = TestGridsGridviewIsPrimaryVerticalL( aItem );

   570     return err;

   571     }

   572 

   573 // -----------------------------------------------------------------------------

   574 // CTestSDKGrids::TestGridsGridviewMoveToItemIndexLL

   575 // -----------------------------------------------------------------------------

   576 //

   577 TInt CTestSDKGrids::TestGridsGridviewMoveToItemIndexLL( CStifItemParser& /*aItem*/ )

   578     {

   579     CAknGridView* view = new( ELeave ) CAknGridView;

   580     CleanupStack::PushL( view );

   581     

   582     CAknGridView::SGrid gridnumber;

   583     gridnumber.iColsInView = KNine;

   584     gridnumber.iRowsInView = KNine;

   585     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   586     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   587     gridnumber.iPageSize = KOne;

   588     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   589     gridnumber.iGridFlags = KOne;

   590     

   591     view->SetGridDetails( gridnumber );

   592     

   593     CAknGrid* grid = new( ELeave ) CAknGrid();

   594     CleanupStack::PushL( grid );

   595     

   596     CAknGridM* model = new( ELeave ) CAknGridM();

   597     CleanupStack::PushL( model );

   598     grid->SetModel( model );

   599     CleanupStack::Pop( model );

   600     

   601     TResourceReader reader;

   602     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   603     grid->SetContainerWindowL( *iContainer );

   604     grid->ConstructFromResourceL( reader );

   605     

   606     CTextListBoxModel* modeltwo = grid->Model();

   607     CListItemDrawer* drawer = grid->ItemDrawer();

   608     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

   609     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

   610     CEikDialog* mydialog= new(ELeave) CEikDialog; 

   611     mydialog->PrepareLC(R_TEST_DIALOG); 

   612     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

   613     const TRect rect = iContainer->Rect();

   614     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

   615     

   616     view->SetCurrentItemIndex( KOne );

   617     

   618     view->MoveToItemIndexL( 200, CListBoxView::ENoSelection );

   619     view->MoveToItemIndexL( KThree, CListBoxView::ESingleSelection );

   620     view->MoveToItemIndexL( KZero, CListBoxView::EDisjointSelection );

   621     view->MoveToItemIndexL( KZero, CListBoxView::EDisjointMarkSelection );

   622     

   623     CleanupStack::PopAndDestroy( mydialog );

   624     CleanupStack::PopAndDestroy();

   625     CleanupStack::PopAndDestroy( grid );

   626     CleanupStack::Pop( view );

   627     return KErrNone;

   628     }

   629 

   630 // -----------------------------------------------------------------------------

   631 // CTestSDKGrids::TestGridsGridviewNumberOfColsInViewL

   632 // -----------------------------------------------------------------------------

   633 //

   634 TInt CTestSDKGrids::TestGridsGridviewNumberOfColsInViewL( CStifItemParser& /*aItem*/ )

   635     {

   636     CAknGridView* view = new( ELeave ) CAknGridView;

   637     CleanupStack::PushL( view );

   638     

   639     CAknGridView::SGrid gridnumber;

   640     gridnumber.iColsInView = KNine;

   641     gridnumber.iRowsInView = KNine;

   642     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   643     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   644     gridnumber.iPageSize = KOne;

   645     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   646     gridnumber.iGridFlags = KOne;

   647     

   648     view->SetGridDetails( gridnumber );

   649     

   650     TInt numberofcols = view->NumberOfColsInView();

   651     STIF_ASSERT_EQUALS( KNine, numberofcols );

   652     

   653     CleanupStack::PopAndDestroy( view );

   654     return KErrNone;

   655     }

   656 

   657 // -----------------------------------------------------------------------------

   658 // CTestSDKGrids::TestGridsGridviewNumberOfRowsInViewL

   659 // -----------------------------------------------------------------------------

   660 //

   661 TInt CTestSDKGrids::TestGridsGridviewNumberOfRowsInViewL( CStifItemParser& /*aIetm*/ )

   662     {

   663     CAknGridView* view = new( ELeave ) CAknGridView;

   664     CleanupStack::PushL( view );

   665     

   666     CAknGridView::SGrid gridnumber;

   667     gridnumber.iColsInView = KNine;

   668     gridnumber.iRowsInView = KNine;

   669     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   670     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   671     gridnumber.iPageSize = KOne;

   672     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   673     gridnumber.iGridFlags = KOne;

   674     

   675     view->SetGridDetails( gridnumber );

   676     

   677     TInt numberofcols = view->NumberOfRowsInView();

   678     STIF_ASSERT_EQUALS( KNine, numberofcols );

   679     

   680     CleanupStack::PopAndDestroy( view );

   681     return KErrNone;

   682     }

   683 

   684 // -----------------------------------------------------------------------------

   685 // CTestSDKGrids::TestGridsGridviewDrawMatcherCursorL

   686 // -----------------------------------------------------------------------------

   687 //

   688 TInt CTestSDKGrids::TestGridsGridviewDrawMatcherCursorL( CStifItemParser& /*aItem*/ )

   689     {

   690     CAknGridView* view = new( ELeave ) CAknGridView;

   691     CleanupStack::PushL( view );

   692     

   693     view->DrawMatcherCursor();

   694     

   695     CleanupStack::PopAndDestroy( view );

   696     return KErrNone;

   697     }

   698 

   699 // -----------------------------------------------------------------------------

   700 // CTestSDKGrids::TestGridsGridviewCurrentItemIndexL

   701 // -----------------------------------------------------------------------------

   702 //

   703 TInt CTestSDKGrids::TestGridsGridviewCurrentItemIndexL( CStifItemParser& /*aItem*/ )

   704     {

   705     CAknGridView* view = new( ELeave ) CAknGridView;

   706     CleanupStack::PushL( view );

   707     

   708     CAknGridView::SGrid gridnumber;

   709     gridnumber.iColsInView = KNine;

   710     gridnumber.iRowsInView = KNine;

   711     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   712     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   713     gridnumber.iPageSize = KOne;

   714     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   715     gridnumber.iGridFlags = KOne;

   716     

   717     view->SetGridDetails( gridnumber );

   718     

   719     CAknGrid* grid = new( ELeave ) CAknGrid();

   720     CleanupStack::PushL( grid );

   721     

   722     CAknGridM* model = new( ELeave ) CAknGridM();

   723     CleanupStack::PushL( model );

   724     grid->SetModel( model );

   725     CleanupStack::Pop( model );

   726     

   727     TResourceReader reader;

   728     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   729     grid->SetContainerWindowL( *iContainer );

   730     grid->ConstructFromResourceL( reader );

   731     

   732     CTextListBoxModel* modeltwo = grid->Model();

   733     CListItemDrawer* drawer = grid->ItemDrawer();

   734     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

   735     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

   736     CEikDialog* mydialog= new(ELeave) CEikDialog; 

   737     mydialog->PrepareLC(R_TEST_DIALOG); 

   738     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

   739     const TRect rect = iContainer->Rect();

   740     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

   741     

   742     TInt currentindex = view->CurrentItemIndex();

   743     STIF_ASSERT_EQUALS( KZero, currentindex );

   744     

   745     CStifGridView* stifgridview = static_cast<CStifGridView*>( view );

   746     CAknGridM* gridm = stifgridview->DoGridModel();

   747     

   748     view->SetCurrentItemIndex( KOne );

   749     currentindex = view->CurrentItemIndex();

   750     STIF_ASSERT_EQUALS( KOne, currentindex );

   751     

   752     CleanupStack::PopAndDestroy( mydialog );

   753     CleanupStack::PopAndDestroy();

   754     CleanupStack::PopAndDestroy( grid );

   755     CleanupStack::Pop( view );

   756     return KErrNone;

   757     }

   758 

   759 // -----------------------------------------------------------------------------

   760 // CTestSDKGrids::TestGridsGridviewItemExistsL

   761 // -----------------------------------------------------------------------------

   762 //

   763 TInt CTestSDKGrids::TestGridsGridviewItemExistsL( CStifItemParser& /*aItem*/ )

   764     {

   765     CStifGridView* view = new( ELeave ) CStifGridView;

   766     CleanupStack::PushL( view );

   767     

   768     CAknGridView::SGrid gridnumber;

   769     gridnumber.iColsInView = KNine;

   770     gridnumber.iRowsInView = KNine;

   771     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   772     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   773     gridnumber.iPageSize = KOne;

   774     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   775     gridnumber.iGridFlags = KOne;

   776     

   777     view->SetGridDetails( gridnumber );

   778     

   779     TBool justiceifexist = view->DoItemExists( KOne );

   780     STIF_ASSERT_TRUE( justiceifexist );

   781     justiceifexist = view->DoItemExists( KMinusone );

   782     STIF_ASSERT_FALSE( justiceifexist );

   783     justiceifexist = view->DoItemExists( KTestIfExist );

   784     STIF_ASSERT_FALSE( justiceifexist );

   785     

   786     CleanupStack::PopAndDestroy( view );

   787     return KErrNone;

   788     }

   789 

   790 // -----------------------------------------------------------------------------

   791 // CTestSDKGrids::TestGridsGridviewSetColumnWidthL

   792 // -----------------------------------------------------------------------------

   793 //

   794 TInt CTestSDKGrids::TestGridsGridviewSetColumnWidthL( CStifItemParser& /*aItem*/ )

   795     {

   796     CAknGridView* view = new( ELeave ) CAknGridView;

   797     CleanupStack::PushL( view );

   798     

   799     CAknGridView::SGrid gridnumber;

   800     gridnumber.iColsInView = KNine;

   801     gridnumber.iRowsInView = KNine;

   802     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   803     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   804     gridnumber.iPageSize = KOne;

   805     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   806     gridnumber.iGridFlags = KOne;

   807     

   808     view->SetGridDetails( gridnumber );

   809     

   810     CAknGrid* grid = new( ELeave ) CAknGrid();

   811     CleanupStack::PushL( grid );

   812     

   813     CAknGridM* model = new( ELeave ) CAknGridM();

   814     CleanupStack::PushL( model );

   815     grid->SetModel( model );

   816     CleanupStack::Pop( model );

   817     

   818     TResourceReader reader;

   819     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   820     grid->SetContainerWindowL( *iContainer );

   821     grid->ConstructFromResourceL( reader );

   822     

   823     CTextListBoxModel* modeltwo = grid->Model();

   824     CListItemDrawer* drawer = grid->ItemDrawer();

   825     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

   826     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

   827     CEikDialog* mydialog= new(ELeave) CEikDialog; 

   828     mydialog->PrepareLC(R_TEST_DIALOG); 

   829     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

   830     const TRect rect = iContainer->Rect();

   831     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

   832     

   833     view->SetColumnWidth( KTen );

   834     TInt columnwidth = view->ColumnWidth();

   835     STIF_ASSERT_EQUALS( KTen, columnwidth );

   836     

   837     view->SetColumnWidth( KWidth );

   838     columnwidth = view->ColumnWidth();

   839     STIF_ASSERT_EQUALS( KWidth, columnwidth );

   840     

   841     CleanupStack::PopAndDestroy( mydialog );

   842     CleanupStack::PopAndDestroy();

   843     CleanupStack::PopAndDestroy( grid );

   844     CleanupStack::Pop( view );

   845     return KErrNone;

   846     }

   847 

   848 // -----------------------------------------------------------------------------

   849 // CTestSDKGrids::TestGridsGridviewMoveCursorLL

   850 // -----------------------------------------------------------------------------

   851 //

   852 TInt CTestSDKGrids::TestGridsGridviewMoveCursorLL( CStifItemParser& /*aItem*/ )

   853     {

   854     CAknGrid* grid = new( ELeave ) CAknGrid();

   855     CleanupStack::PushL( grid );

   856     

   857     CAknGridM* model = new( ELeave ) CAknGridM();

   858     CleanupStack::PushL( model );

   859     grid->SetModel( model );

   860     CleanupStack::Pop( model );

   861     TResourceReader reader;

   862     grid->SetContainerWindowL( *iContainer );

   863     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   864     grid->ConstructFromResourceL( reader );

   865     CleanupStack::PopAndDestroy();

   866     

   867     grid->GridView()->MoveCursorL( CListBoxView::ECursorFirstItem, CListBoxView::ENoSelection );

   868     

   869     CleanupStack::PopAndDestroy( grid );

   870     return KErrNone;

   871     }

   872 

   873 // -----------------------------------------------------------------------------

   874 // CTestSDKGrids::TestGridsGridviewDrawL

   875 // -----------------------------------------------------------------------------

   876 //

   877 TInt CTestSDKGrids::TestGridsGridviewDrawL( CStifItemParser& /*aItem*/ )

   878     {

   879     CAknGridView* view = new( ELeave ) CAknGridView;

   880     CleanupStack::PushL( view );

   881     

   882     CAknGridView::SGrid gridnumber;

   883     gridnumber.iColsInView = KNine;

   884     gridnumber.iRowsInView = KNine;

   885     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   886     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   887     gridnumber.iPageSize = KOne;

   888     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   889     gridnumber.iGridFlags = KOne;

   890     

   891     view->SetGridDetails( gridnumber );

   892     

   893     CAknGrid* grid = new( ELeave ) CAknGrid();

   894     CleanupStack::PushL( grid );

   895     

   896     CAknGridM* model = new( ELeave ) CAknGridM();

   897     CleanupStack::PushL( model );

   898     grid->SetModel( model );

   899     CleanupStack::Pop( model );

   900     

   901     TResourceReader reader;

   902     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   903     grid->SetContainerWindowL( *iContainer );

   904     grid->ConstructFromResourceL( reader );

   905     

   906     CTextListBoxModel* modeltwo = grid->Model();

   907     CListItemDrawer* drawer = grid->ItemDrawer();

   908     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

   909     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

   910     CEikDialog* mydialog= new(ELeave) CEikDialog; 

   911     mydialog->PrepareLC(R_TEST_DIALOG); 

   912     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

   913     const TRect rect = iContainer->Rect();

   914     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

   915     

   916     view->Draw();

   917     TRect drawrect = iContainer->Rect();

   918     TRect* drawrectptr = &drawrect;

   919     view->Draw( drawrectptr );

   920     

   921     CleanupStack::PopAndDestroy( mydialog );

   922     CleanupStack::PopAndDestroy();

   923     CleanupStack::PopAndDestroy( grid );

   924     CleanupStack::Pop( view );

   925     return KErrNone;

   926     }

   927 

   928 // -----------------------------------------------------------------------------

   929 // CTestSDKGrids::TestGridsGridviewDrawItemL

   930 // -----------------------------------------------------------------------------

   931 //

   932 TInt CTestSDKGrids::TestGridsGridviewDrawItemL( CStifItemParser& /*aItem*/ )

   933     {

   934     CAknGrid* grid = new( ELeave ) CAknGrid();

   935     CleanupStack::PushL( grid );

   936     

   937     CAknGridM* model = new( ELeave ) CAknGridM();

   938     CleanupStack::PushL( model );

   939     grid->SetModel( model );

   940     CleanupStack::Pop( model );

   941     TResourceReader reader;

   942     grid->SetContainerWindowL( *iContainer );

   943     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

   944     grid->ConstructFromResourceL( reader );

   945     CleanupStack::PopAndDestroy();

   946     

   947     grid->GridView()->DrawItem( 0 );

   948     

   949     CleanupStack::PopAndDestroy( grid );

   950     return KErrNone;

   951     

   952     }

   953 

   954 // -----------------------------------------------------------------------------

   955 // CTestSDKGrids::TestGridsGridviewItemPosL

   956 // -----------------------------------------------------------------------------

   957 //

   958 TInt CTestSDKGrids::TestGridsGridviewItemPosL( CStifItemParser& /*aItem*/ )

   959     {

   960     CAknGridView* view = new( ELeave ) CAknGridView;

   961     CleanupStack::PushL( view );

   962     

   963     CAknGridView::SGrid gridnumber;

   964     gridnumber.iColsInView = KNine;

   965     gridnumber.iRowsInView = KNine;

   966     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

   967     gridnumber.iSizeOfItems = TSize( KTen, KTen );

   968     gridnumber.iPageSize = KOne;

   969     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

   970     gridnumber.iGridFlags = KOne;

   971     

   972     view->SetGridDetails( gridnumber );

   973     

   974     TPoint topleftpoint = view->ItemPos( KZero );

   975     STIF_ASSERT_EQUALS( TPoint( KZero, KZero ), topleftpoint );

   976     

   977     topleftpoint = view->ItemPos( KOne );

   978     STIF_ASSERT_NOT_EQUALS( TPoint( KZero, KZero ), topleftpoint );

   979     

   980     gridnumber.iGridFlags = KZero;

   981     view->SetGridDetails( gridnumber );

   982     

   983     topleftpoint = view->ItemPos( KZero );

   984     STIF_ASSERT_EQUALS( TPoint( KZero, KZero ), topleftpoint );

   985     

   986     topleftpoint = view->ItemPos( KOne );

   987     STIF_ASSERT_NOT_EQUALS( TPoint( KZero, KZero ), topleftpoint );

   988     

   989     CleanupStack::PopAndDestroy( view );

   990     return KErrNone;

   991     }

   992 

   993 // -----------------------------------------------------------------------------

   994 // CTestSDKGrids::TestGridsGridviewCalcBottomItemIndexL

   995 // -----------------------------------------------------------------------------

   996 //

   997 TInt CTestSDKGrids::TestGridsGridviewCalcBottomItemIndexL( CStifItemParser& /*aItem*/ )

   998     {

   999     CAknGridView* view = new( ELeave ) CAknGridView;

  1000     CleanupStack::PushL( view );

  1001     

  1002     CAknGridView::SGrid gridnumber;

  1003     gridnumber.iColsInView = KNine;

  1004     gridnumber.iRowsInView = KNine;

  1005     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

  1006     gridnumber.iSizeOfItems = TSize( KTen, KTen );

  1007     gridnumber.iPageSize = KOne;

  1008     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

  1009     gridnumber.iGridFlags = KOne;

  1010     

  1011     view->SetGridDetails( gridnumber );

  1012     

  1013     CAknGrid* grid = new( ELeave ) CAknGrid();

  1014     CleanupStack::PushL( grid );

  1015     

  1016     CAknGridM* model = new( ELeave ) CAknGridM();

  1017     CleanupStack::PushL( model );

  1018     grid->SetModel( model );

  1019     CleanupStack::Pop( model );

  1020     

  1021     TResourceReader reader;

  1022     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

  1023     grid->SetContainerWindowL( *iContainer );

  1024     grid->ConstructFromResourceL( reader );

  1025     

  1026     CTextListBoxModel* modeltwo = grid->Model();

  1027     CListItemDrawer* drawer = grid->ItemDrawer();

  1028     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

  1029     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

  1030     CEikDialog* mydialog= new(ELeave) CEikDialog; 

  1031     mydialog->PrepareLC(R_TEST_DIALOG); 

  1032     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

  1033     const TRect rect = iContainer->Rect();

  1034     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

  1035         

  1036     view->CalcBottomItemIndex();

  1037     

  1038     CleanupStack::PopAndDestroy( mydialog );

  1039     CleanupStack::PopAndDestroy();

  1040     CleanupStack::PopAndDestroy( grid );

  1041     CleanupStack::Pop( view );

  1042     return KErrNone;

  1043     }

  1044 

  1045 // -----------------------------------------------------------------------------

  1046 // CTestSDKGrids::TestGridsGridviewCalcNewTopItemIndexSoItemIsVisibleL

  1047 // -----------------------------------------------------------------------------

  1048 //

  1049 TInt CTestSDKGrids::TestGridsGridviewCalcNewTopItemIndexSoItemIsVisibleL( CStifItemParser& /*aItem*/ )

  1050     {

  1051     CAknGridView* view = new( ELeave ) CAknGridView;

  1052     CleanupStack::PushL( view );

  1053     

  1054     CAknGridView::SGrid gridnumber;

  1055     gridnumber.iColsInView = KNine;

  1056     gridnumber.iRowsInView = KNine;

  1057     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

  1058     gridnumber.iSizeOfItems = TSize( KTen, KTen );

  1059     gridnumber.iPageSize = KOne;

  1060     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

  1061     gridnumber.iGridFlags = KOne;

  1062     

  1063     view->SetGridDetails( gridnumber );

  1064     

  1065     CAknGrid* grid = new( ELeave ) CAknGrid();

  1066     CleanupStack::PushL( grid );

  1067     

  1068     CAknGridM* model = new( ELeave ) CAknGridM();

  1069     CleanupStack::PushL( model );

  1070     grid->SetModel( model );

  1071     CleanupStack::Pop( model );

  1072     

  1073     TResourceReader reader;

  1074     CEikonEnv::Static()->CreateResourceReaderLC( reader, R_TESTSDKGRIDS_GRID );

  1075     grid->SetContainerWindowL( *iContainer );

  1076     grid->ConstructFromResourceL( reader );

  1077     

  1078     CTextListBoxModel* modeltwo = grid->Model();

  1079     CListItemDrawer* drawer = grid->ItemDrawer();

  1080     CWsScreenDevice * screendevice = CEikonEnv::Static()->ScreenDevice();

  1081     RWindowGroup& parent = CCoeEnv::Static()->RootWin();

  1082     CEikDialog* mydialog= new(ELeave) CEikDialog; 

  1083     mydialog->PrepareLC(R_TEST_DIALOG); 

  1084     RWindow* window = (RWindow*)mydialog->DrawableWindow(); 

  1085     const TRect rect = iContainer->Rect();

  1086     view->ConstructL( modeltwo, drawer, screendevice, &parent, window, rect, KTen );

  1087     

  1088     TInt topitemindex = view->CalcNewTopItemIndexSoItemIsVisible( KZero );

  1089     STIF_ASSERT_EQUALS( KZero, topitemindex );

  1090     

  1091     topitemindex = view->CalcNewTopItemIndexSoItemIsVisible( KOne );

  1092     STIF_ASSERT_NOT_EQUALS( KZero, topitemindex );

  1093     

  1094     view->SetTopItemIndex( KTwo );

  1095     topitemindex = view->CalcNewTopItemIndexSoItemIsVisible( KOne );

  1096     STIF_ASSERT_EQUALS( KZero, topitemindex );

  1097     

  1098     gridnumber.iGridFlags = KZero;

  1099     view->SetGridDetails( gridnumber );

  1100     

  1101     topitemindex = view->CalcNewTopItemIndexSoItemIsVisible( KOne );

  1102     STIF_ASSERT_EQUALS( KZero, topitemindex );

  1103     

  1104     view->SetTopItemIndex( KZero );

  1105     topitemindex = view->CalcNewTopItemIndexSoItemIsVisible( KOne );

  1106     STIF_ASSERT_NOT_EQUALS( KZero, topitemindex );

  1107     

  1108     CleanupStack::PopAndDestroy( mydialog );

  1109     CleanupStack::PopAndDestroy();

  1110     CleanupStack::PopAndDestroy( grid );

  1111     CleanupStack::Pop( view );

  1112     return KErrNone;

  1113     }

  1114 

  1115 // -----------------------------------------------------------------------------

  1116 // CTestSDKGrids::TestGridsGridviewDrawItemRangeL

  1117 // -----------------------------------------------------------------------------

  1118 //

  1119 TInt CTestSDKGrids::TestGridsGridviewDrawItemRangeL( CStifItemParser& /*aItem*/ )

  1120     {

  1121     CAknGridView* view = new( ELeave ) CAknGridView;

  1122     CleanupStack::PushL( view );

  1123     

  1124     CAknGridView::SGrid gridnumber;

  1125     gridnumber.iColsInView = KNine;

  1126     gridnumber.iRowsInView = KNine;

  1127     gridnumber.iSizeBetweenItems = TSize( KZero, KZero );

  1128     gridnumber.iSizeOfItems = TSize( KTen, KTen );

  1129     gridnumber.iPageSize = KOne;

  1130     gridnumber.iGridDimensions = TSize( KWidth, KHeight );

  1131     gridnumber.iGridFlags = KOne;

  1132     

  1133     view->SetGridDetails( gridnumber );

  1134     

  1135     CAknGrid* grid = new( ELeave ) CAknGrid();