classicui_pub/lists_api/inc/aknlists.h
changeset 0 2f259fa3e83a
child 15 08e69e956a8c
equal deleted inserted replaced
-1:000000000000 0:2f259fa3e83a
       
     1 /*
       
     2 * Copyright (c) 2002 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: 
       
    15 *
       
    16 */
       
    17 
       
    18 #ifndef __AKNLISTS_H__
       
    19 #define __AKNLISTS_H__
       
    20 
       
    21 #include <eikclb.h>
       
    22 #include <eikfrlb.h>
       
    23 #include <eikslb.h>
       
    24 #include <AknGrid.h>
       
    25 #include <AknUtils.h>
       
    26 
       
    27 #include <AknPanic.h>
       
    28 
       
    29 
       
    30 class TAknTextLineLayout;
       
    31 class MAknsSkinInstance;
       
    32 class MAknsControlContext;
       
    33 
       
    34 /** THIS FILE INCLUDES:
       
    35  *  1) All listbox layouts specified in Avkon LAF specification
       
    36  *      a) General list pane descendants
       
    37  *      b) Pop up window list pane descendants
       
    38  *      c) Grid panes
       
    39  *  2) Utilities that help building listbox layouts based on LAF specification
       
    40  *  3) Other helper classes that handle listbox behavior
       
    41  */
       
    42 
       
    43 
       
    44 //
       
    45 //
       
    46 // Helper template definitions.
       
    47 // (these are before concrete listbox classes because they're needed for inheritance)
       
    48 //
       
    49 
       
    50 
       
    51 /**
       
    52  * This adds correct horizontal and vertival lines to the listbox and handles empty listbox!
       
    53  *
       
    54  * This class is only useful if you're writing your own list layout. 
       
    55  * Please use the predefined layouts instead, for example CAknSingleStyleListBox.
       
    56  */
       
    57 template<class T>
       
    58 class AknListBoxLinesTemplate : public T
       
    59     {
       
    60 public:
       
    61     /** AknListBoxLinesTemplate
       
    62      *
       
    63      * Read AVKON_LISTBOX_LINES resources. 
       
    64      *
       
    65      * The following predefined lines are available:
       
    66      * R_LIST_PANE_LINES_A_COLUMN
       
    67      * R_LIST_PANE_LINES_AB_COLUMN
       
    68      * R_LIST_PANE_LINES_AB_COLUMN_X
       
    69      * R_LIST_PANE_LINES_AB_COLUMN_XX
       
    70      * R_LIST_PANE_LINES_BC_COLUMN
       
    71      * R_LIST_PANE_LINES_BC_COLUMN_X
       
    72      * R_LIST_PANE_LINES_BC_COLUMN_XX
       
    73      * 
       
    74      */
       
    75     IMPORT_C AknListBoxLinesTemplate(TInt aResourceId);
       
    76     /** SizeChanged()
       
    77      * 
       
    78      * Determines position of the lines
       
    79      */
       
    80     IMPORT_C void SizeChanged();
       
    81     /** Draw()
       
    82      * 
       
    83      * Draws the lines
       
    84      */
       
    85     IMPORT_C void Draw(const TRect& aRect) const;
       
    86     /** CountComponentControls()
       
    87      * 
       
    88      * Choose controls to use as child controls
       
    89      */
       
    90     IMPORT_C TInt CountComponentControls() const;
       
    91     /** CountComponentControls()
       
    92      * 
       
    93      * Choose controls to use as child controls
       
    94      */
       
    95     IMPORT_C CCoeControl* ComponentControl(TInt aIndex) const;
       
    96 
       
    97 private:
       
    98     TInt iSpare0;                           // was iResourceId;
       
    99     TAknLayoutRect iVertLine1, iVertLine2;  // not used
       
   100     TAknLayoutRect iHoriLine;               // not used
       
   101     TBool iResized;
       
   102     TInt iSpare[2];
       
   103     };
       
   104 
       
   105 /**
       
   106  * Empty layout for popup lists
       
   107  */
       
   108 
       
   109 template<class T>
       
   110 class AknPopupListEmpty : public T
       
   111     {
       
   112    /**
       
   113     * Draws empty list when needed. See AknDraw::DrawEmptyList().
       
   114     */
       
   115     IMPORT_C virtual void Draw(const TRect &aRect) const;
       
   116     };
       
   117 
       
   118 
       
   119 	/** 
       
   120 	* Avkon version of eikon's column listbox.
       
   121 	* Content for list items are tab-separated strings.
       
   122 	*
       
   123 	* See methods 
       
   124 	*   CEikListBox::ConstructFromResourceL()
       
   125 	*   CEikListBox::ConstructL()
       
   126 	*   CEikTextListBox::SetItemArray()
       
   127 	*   CEikColumnListBoxData::SetIconArray()
       
   128 	* 
       
   129 	* Related flags for ConstructL() (avkon.hrh)
       
   130 	*   EAknListBoxSelectionList
       
   131 	*   EAknListBoxMenuList
       
   132 	*   EAknListBoxMarkableList
       
   133 	*   EAknListBoxMultiselectionList
       
   134 	*   EAknListBoxViewerFlags
       
   135 	*
       
   136 	* Related flags for dialogs (avkon.hrh)
       
   137 	*   EAknDialogSelectionList
       
   138 	*   EAknDialogMenuList
       
   139 	*   EAknDialogMultiselectionList
       
   140 	*
       
   141 	* @since Series 60 0.9
       
   142 	*
       
   143 	*/
       
   144 class CAknColumnListBox : public CEikColumnListBox
       
   145     {
       
   146 public:
       
   147     /** 
       
   148 	* Creates new @c CAknColumnListBoxView object and returns pointer to it.
       
   149 	* @return Pointer to the list box view which displays the list items which
       
   150 	* are currently visible in a list box.
       
   151     */
       
   152     IMPORT_C virtual CListBoxView* MakeViewClassInstanceL();
       
   153     
       
   154     /** 
       
   155     * Creates @c CAknFilteredTextListBoxModel object.
       
   156     */
       
   157     IMPORT_C virtual void CreateModelL();
       
   158 
       
   159     /** 
       
   160     * Listbox rectangle calculation. Rounds down the height of the rectangle
       
   161     * (if necessary) so that only a whole number of items can be displayed
       
   162     * inside the list box.
       
   163     * @param aRect The size of the listbox.
       
   164     * @return The number of pixels reduced.
       
   165     */
       
   166     IMPORT_C virtual TInt AdjustRectHeightToWholeNumberOfItems(TRect& aRect) const;
       
   167     
       
   168     /**
       
   169      * From CCoeControl.     
       
   170      * Handles pointer events
       
   171      */
       
   172     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
       
   173 private:
       
   174     /**
       
   175     * From CAknControl
       
   176     */
       
   177     IMPORT_C void* ExtensionInterface( TUid aInterface );
       
   178 private: // listbox use only
       
   179 	IMPORT_C virtual void CEikListBox_Reserved(); 
       
   180     };
       
   181 
       
   182 
       
   183 //
       
   184 // These define what features are needed --> you can remove shortcuts from ALL lists by changing these..
       
   185 // Templates available: AknListBoxLinesTemplate<> AknListBoxShortCutTemplate<>
       
   186 typedef AknListBoxLinesTemplate<CAknColumnListBox > CEikColumnListBoxTypedef;
       
   187 typedef AknListBoxLinesTemplate<CEikFormattedCellListBox > CEikFormattedCellListBoxTypedef;
       
   188 typedef AknListBoxLinesTemplate<CEikSettingsListBox > CEikSettingsListBoxTypedef;
       
   189 typedef CAknGrid CAknSelectionGridTypedef;
       
   190 
       
   191 // Templates available: AknListBoxShortCutTemplate<> AknListBoxLinesTemplate<>
       
   192 #define AKNCOLUMNLISTBOXNAME(x) AknListBoxLinesTemplate<CAknColumnListBox >(x)
       
   193 #define AKNDOUBLELISTBOXNAME(x) AknListBoxLinesTemplate<CEikFormattedCellListBox >(x)
       
   194 #define AKNSETTINGLISTBOXNAME(x) AknListBoxLinesTemplate<CEikSettingsListBox >(x)
       
   195 
       
   196 // Templates available: AknListBoxLinesTemplate<>, AknListBoxShortCutTemplate<>
       
   197 #define AKNCOLUMNLISTBOX AknListBoxLinesTemplate<CAknColumnListBox >
       
   198 #define AKNFORMATTEDLISTBOX AknListBoxLinesTemplate<CEikFormattedCellListBox >
       
   199 #define AKNSETTINGSLISTBOX AknListBoxLinesTemplate<CEikSettingsListBox >
       
   200 #define AKNGRID CAknGrid
       
   201 
       
   202 
       
   203 
       
   204 
       
   205 
       
   206 
       
   207 
       
   208 //
       
   209 //
       
   210 // Derived listboxes (Use these in applications!)
       
   211 // These are only for full screen lists -- the Rect() of the list must be ClientRect()
       
   212 //
       
   213 //
       
   214 
       
   215 
       
   216 /**
       
   217  * list_single_pane
       
   218  *
       
   219  * list item string format: "\tTextLabel\t0\t1"
       
   220  * where 0 and 1 are indexes to icon array
       
   221  */
       
   222 
       
   223 class CAknSingleStyleListBox : public CEikColumnListBoxTypedef
       
   224     {
       
   225 public:
       
   226     IMPORT_C CAknSingleStyleListBox();
       
   227     /** SizeChanged()
       
   228      * 
       
   229      * Determines layout of the listbox
       
   230      */
       
   231     IMPORT_C void SizeChanged();
       
   232     /** MinimumSize()
       
   233      * 
       
   234      * Determines size of the listbox for use in dialogs.
       
   235      */
       
   236     IMPORT_C TSize MinimumSize();
       
   237     /**
       
   238      * From CCoeControl.     
       
   239      * Handles pointer events
       
   240      */
       
   241     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);  
       
   242 private:
       
   243     void SizeChangedL();
       
   244     };
       
   245 
       
   246 /**
       
   247  * list_single_number_pane
       
   248  *
       
   249  * list item string format: "2\tTextLabel\t0\t1"
       
   250  * where 0 and 1 are indexes to icon array
       
   251  */
       
   252 
       
   253 class CAknSingleNumberStyleListBox : public CEikColumnListBoxTypedef
       
   254     {
       
   255 public:
       
   256     IMPORT_C CAknSingleNumberStyleListBox();
       
   257     /** SizeChanged()
       
   258      * 
       
   259      * Determines layout of the listbox
       
   260      */
       
   261     IMPORT_C void SizeChanged();
       
   262     /** MinimumSize()
       
   263      * 
       
   264      * Determines size of the listbox for use in dialogs.
       
   265      */
       
   266     IMPORT_C TSize MinimumSize();
       
   267     /**
       
   268      * From CCoeControl.     
       
   269      * Handles pointer events
       
   270      */
       
   271     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);   
       
   272 private:
       
   273     void SizeChangedL();
       
   274     };
       
   275 
       
   276 /**
       
   277  * list_single_heading_pane
       
   278  *
       
   279  * list item string format: "Heading\tTextLabel\t0\t1"
       
   280  * where 0 and 1 are indexes to icon array
       
   281  *
       
   282  */
       
   283 
       
   284 class CAknSingleHeadingStyleListBox : public CEikColumnListBoxTypedef
       
   285     {
       
   286 public:
       
   287     IMPORT_C CAknSingleHeadingStyleListBox();
       
   288     /** SizeChanged()
       
   289      * 
       
   290      * Determines layout of the listbox
       
   291      */
       
   292     IMPORT_C void SizeChanged();
       
   293     /** MinimumSize()
       
   294      * 
       
   295      * Determines size of the listbox for use in dialogs.
       
   296      */
       
   297     IMPORT_C TSize MinimumSize();
       
   298     /**
       
   299      * From CCoeControl.     
       
   300      * Handles pointer events
       
   301      */
       
   302     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   303 
       
   304 protected:
       
   305     /** CreateItemDrawerL()
       
   306      *
       
   307      * Chooses which itemdrawer to use.
       
   308      */
       
   309     IMPORT_C virtual void CreateItemDrawerL();
       
   310     
       
   311    /** MakeViewClassInstanceL()
       
   312     *
       
   313     * Chooses which listbox view class to use
       
   314     */
       
   315     IMPORT_C virtual CListBoxView* MakeViewClassInstanceL();
       
   316 private:
       
   317     void SizeChangedL();
       
   318     };
       
   319 
       
   320 
       
   321 /**
       
   322  * list_single_graphic_pane
       
   323  *
       
   324  * list item string format: "0\tTextLabel\t1\t2"
       
   325  * where 0,1,2 are index to the icon array 
       
   326  */
       
   327 
       
   328 class CAknSingleGraphicStyleListBox : public CEikColumnListBoxTypedef
       
   329     {
       
   330 public: 
       
   331     IMPORT_C CAknSingleGraphicStyleListBox();
       
   332     /** SizeChanged()
       
   333      * 
       
   334      * Determines layout of the listbox
       
   335      */
       
   336     IMPORT_C void SizeChanged();
       
   337     /** MinimumSize()
       
   338      * 
       
   339      * Determines size of the listbox for use in dialogs.
       
   340      */
       
   341     IMPORT_C TSize MinimumSize();
       
   342     /**
       
   343      * From CCoeControl.     
       
   344      * Handles pointer events
       
   345      */
       
   346     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   347 private:
       
   348     void SizeChangedL();
       
   349     };
       
   350 
       
   351 /**
       
   352  * list_single_Graphic_heading_pane
       
   353  *
       
   354  * list item string format: "0\tHeading\tTextLabel\t1\t2"
       
   355  * where 0,1,2 are index to the icon array 
       
   356  */
       
   357 
       
   358 class CAknSingleGraphicHeadingStyleListBox : public CEikColumnListBoxTypedef
       
   359     {
       
   360 public:
       
   361     IMPORT_C CAknSingleGraphicHeadingStyleListBox();
       
   362     /** SizeChanged()
       
   363      * 
       
   364      * Determines layout of the listbox
       
   365      */
       
   366     IMPORT_C void SizeChanged();
       
   367     /** MinimumSize()
       
   368      * 
       
   369      * Determines size of the listbox for use in dialogs.
       
   370      */
       
   371     IMPORT_C TSize MinimumSize();
       
   372     /**
       
   373      * From CCoeControl.     
       
   374      * Handles pointer events
       
   375      */
       
   376     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);    
       
   377 protected:
       
   378     IMPORT_C virtual void CreateItemDrawerL();
       
   379    /** MakeViewClassInstanceL()
       
   380     *
       
   381     * Chooses which listbox view class to use
       
   382     */
       
   383     IMPORT_C virtual CListBoxView* MakeViewClassInstanceL();
       
   384 private:
       
   385     void SizeChangedL();
       
   386     };
       
   387 
       
   388 /**
       
   389  * list_single_number_heading_pane
       
   390  *
       
   391  * list item string format: "1\tHeading\tTextLabel\t2\t3"
       
   392  * where 2 and 3 are indexes to icon array
       
   393  */
       
   394 
       
   395 class CAknSingleNumberHeadingStyleListBox : public CEikColumnListBoxTypedef
       
   396     {
       
   397 public:
       
   398     IMPORT_C CAknSingleNumberHeadingStyleListBox();
       
   399     /** SizeChanged()
       
   400      * 
       
   401      * Determines layout of the listbox
       
   402      */
       
   403     IMPORT_C void SizeChanged();
       
   404     /** MinimumSize()
       
   405      * 
       
   406      * Determines size of the listbox for use in dialogs.
       
   407      */
       
   408     IMPORT_C TSize MinimumSize();
       
   409     /**
       
   410      * From CCoeControl.     
       
   411      * Handles pointer events
       
   412      */
       
   413     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   414 protected:
       
   415     IMPORT_C virtual void CreateItemDrawerL();
       
   416    /** MakeViewClassInstanceL()
       
   417     *
       
   418     * Chooses which listbox view class to use
       
   419     */
       
   420     IMPORT_C virtual CListBoxView* MakeViewClassInstanceL();
       
   421 private:
       
   422     void SizeChangedL();
       
   423     };
       
   424 
       
   425 /**
       
   426  * list_single_large_pane
       
   427  *
       
   428  * list item string format: "1\tTextLabel\t0\t0"
       
   429  * where 0 is an index to icon array
       
   430  */
       
   431 
       
   432 class CAknSingleLargeStyleListBox : public CEikColumnListBoxTypedef
       
   433     {
       
   434 public:
       
   435     IMPORT_C CAknSingleLargeStyleListBox();
       
   436     /** SizeChanged()
       
   437      * 
       
   438      * Determines layout of the listbox
       
   439      */
       
   440     IMPORT_C void SizeChanged();
       
   441     /** MinimumSize()
       
   442      * 
       
   443      * Determines size of the listbox for use in dialogs.
       
   444      */
       
   445     IMPORT_C TSize MinimumSize();
       
   446     /**
       
   447      * From CCoeControl.     
       
   448      * Handles pointer events
       
   449      */
       
   450     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);   
       
   451 private:
       
   452     void SizeChangedL();
       
   453     };
       
   454 
       
   455 /**
       
   456  * list_double_pane and list_big_single_pane
       
   457  *
       
   458  * list item string format: " \tFirstLabel\tSecondLabel\t0\t0"
       
   459  * where 0 is an index to icon array
       
   460  */
       
   461 
       
   462 class CAknDoubleStyleListBox : public CEikFormattedCellListBoxTypedef
       
   463     {
       
   464 public:
       
   465     IMPORT_C CAknDoubleStyleListBox();
       
   466     /** SizeChanged()
       
   467      * 
       
   468      * Determines layout of the listbox
       
   469      */
       
   470     IMPORT_C void SizeChanged();
       
   471     /** MinimumSize()
       
   472      * 
       
   473      * Determines size of the listbox for use in dialogs.
       
   474      */
       
   475     IMPORT_C TSize MinimumSize();
       
   476     /**
       
   477      * From CCoeControl.     
       
   478      * Handles pointer events
       
   479      */
       
   480     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   481 private:
       
   482     void SizeChangedL();
       
   483     };
       
   484 
       
   485 /**
       
   486  * list_twoline_pane
       
   487  *
       
   488  * list item string format: " \tFirstLongLabel\t\t0"
       
   489  * where 0 is an index to icon array
       
   490  */
       
   491 
       
   492 class CAknDoubleStyle2ListBox : public CAknDoubleStyleListBox
       
   493     {
       
   494 public:
       
   495     /** SizeChanged()
       
   496      * 
       
   497      * Determines layout of the listbox
       
   498      */
       
   499     IMPORT_C void SizeChanged();
       
   500     /** CreateItemDrawerL()
       
   501      *
       
   502      * Chooses which itemdrawer to use.
       
   503      */
       
   504     IMPORT_C void CreateItemDrawerL();
       
   505     /**
       
   506      * From CCoeControl.     
       
   507      * Handles pointer events
       
   508      */
       
   509     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
       
   510 private:
       
   511     void SizeChangedL();
       
   512     };
       
   513 
       
   514  /**
       
   515  * list_double_number_pane and list_big_single_number_pane
       
   516  *
       
   517  * list item string format: "1\tFirstLabel\t\t0\t0"
       
   518  * list item string format: "1\tFirstLabel\tSecondLabel\t0\t0"
       
   519  * where 0 is an index to icon array
       
   520  *
       
   521  */
       
   522 
       
   523 class CAknDoubleNumberStyleListBox : public CEikFormattedCellListBoxTypedef
       
   524     {
       
   525 public:
       
   526     IMPORT_C CAknDoubleNumberStyleListBox();
       
   527     /** SizeChanged()
       
   528      * 
       
   529      * Determines layout of the listbox
       
   530      */
       
   531     IMPORT_C void SizeChanged();
       
   532     /** MinimumSize()
       
   533      * 
       
   534      * Determines size of the listbox for use in dialogs.
       
   535      */
       
   536     IMPORT_C TSize MinimumSize();
       
   537     /**
       
   538      * From CCoeControl.     
       
   539      * Handles pointer events
       
   540      */
       
   541     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   542 private:
       
   543     void SizeChangedL();
       
   544     };
       
   545 
       
   546 /**
       
   547  * list_double_time_pane
       
   548  */
       
   549 
       
   550 class CAknDoubleTimeStyleListBox : public CEikFormattedCellListBoxTypedef
       
   551     {
       
   552 public:
       
   553     IMPORT_C CAknDoubleTimeStyleListBox();
       
   554     /** SizeChanged()
       
   555      * 
       
   556      * Determines layout of the listbox
       
   557      */
       
   558     IMPORT_C void SizeChanged();
       
   559     /** MinimumSize()
       
   560      * 
       
   561      * Determines size of the listbox for use in dialogs.
       
   562      */
       
   563     IMPORT_C TSize MinimumSize();
       
   564     /**
       
   565      * From CCoeControl.     
       
   566      * Handles pointer events
       
   567      */
       
   568     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
       
   569 private:
       
   570     void SizeChangedL();
       
   571     };
       
   572 
       
   573 /**
       
   574  * list_double_large_pane
       
   575  *
       
   576  * list item string format: "1\tFirstLabel\tSecondLabel\t0\t0"
       
   577  *
       
   578  * where 0 is an index of small (13x13) icon in icon array
       
   579  *   and 1 is an index of a thumbnail image
       
   580  *
       
   581  * Good thumbnail image sizes for this list are:
       
   582  *   30x40, 36x44, 40x30, 40x48, 44x36.
       
   583  */
       
   584 
       
   585 class CAknDoubleLargeStyleListBox : public CEikFormattedCellListBoxTypedef
       
   586     {
       
   587 public:
       
   588     IMPORT_C CAknDoubleLargeStyleListBox();
       
   589     /** SizeChanged()
       
   590      * 
       
   591      * Determines layout of the listbox
       
   592      */
       
   593     IMPORT_C void SizeChanged();
       
   594     /** MinimumSize()
       
   595      * 
       
   596      * Determines size of the listbox for use in dialogs.
       
   597      */
       
   598     IMPORT_C TSize MinimumSize();
       
   599     /** CreateItemDrawerL()
       
   600      *
       
   601      * Chooses which itemdrawer to use.
       
   602      */
       
   603     IMPORT_C virtual void CreateItemDrawerL();
       
   604     /**
       
   605      * From CCoeControl.     
       
   606      * Handles pointer events
       
   607      */
       
   608     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   609 private:
       
   610     void SizeChangedL();
       
   611     };
       
   612 
       
   613 
       
   614 /**
       
   615  * list_double_graphic_pane
       
   616  *
       
   617  * list item string format: "0\tFirstLabel\tSecondLabel\t0"
       
   618  * where 0 is index to icon array
       
   619  *
       
   620  */
       
   621 
       
   622 class CAknDoubleGraphicStyleListBox : public CEikFormattedCellListBoxTypedef
       
   623     {
       
   624 public:
       
   625     IMPORT_C CAknDoubleGraphicStyleListBox();
       
   626     /** SizeChanged()
       
   627      * 
       
   628      * Determines layout of the listbox
       
   629      */
       
   630     IMPORT_C void SizeChanged();
       
   631     /** MinimumSize()
       
   632      * 
       
   633      * Determines size of the listbox for use in dialogs.
       
   634      */
       
   635     IMPORT_C TSize MinimumSize();
       
   636     /**
       
   637      * From CCoeControl.     
       
   638      * Handles pointer events
       
   639      */
       
   640     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   641 private:
       
   642     void SizeChangedL();
       
   643     };
       
   644 
       
   645 
       
   646 /** 
       
   647  * list_double2_graphic_pane
       
   648  *
       
   649  * list item string format: "0\tFirstLabel\tSecondLabel\t0"
       
   650  * where 0 is index to icon array
       
   651  *
       
   652  */
       
   653 
       
   654 class CAknDouble2GraphicStyleListBox : public CEikFormattedCellListBoxTypedef
       
   655     {
       
   656 public:
       
   657     IMPORT_C CAknDouble2GraphicStyleListBox();
       
   658     /** SizeChanged()
       
   659      * 
       
   660      * Determines layout of the listbox
       
   661      */
       
   662     IMPORT_C void SizeChanged();
       
   663     /** MinimumSize()
       
   664      * 
       
   665      * Determines size of the listbox for use in dialogs.
       
   666      */
       
   667     IMPORT_C TSize MinimumSize();
       
   668 
       
   669 	/** CreateItemDrawerL()
       
   670      *
       
   671      * Chooses which itemdrawer to use.
       
   672      */
       
   673     IMPORT_C void CreateItemDrawerL();
       
   674     /**
       
   675      * From CCoeControl.     
       
   676      * Handles pointer events
       
   677      */
       
   678     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   679 private:
       
   680     void SizeChangedL();
       
   681     };
       
   682 
       
   683 
       
   684 /**
       
   685  * list_double2_large_graphic_pane
       
   686  *
       
   687  * list item string format: "1\tFirstLabel\tSecondLabel\t0"
       
   688  *
       
   689  * where 0 is an index of small (13x13) icon in icon array
       
   690  *   and 1 is an index of a thumbnail image
       
   691  *
       
   692  */
       
   693 
       
   694 class CAknDouble2LargeStyleListBox : public CEikFormattedCellListBoxTypedef
       
   695     {
       
   696 public:
       
   697     IMPORT_C CAknDouble2LargeStyleListBox();
       
   698     /** SizeChanged()
       
   699      * 
       
   700      * Determines layout of the listbox
       
   701      */
       
   702     IMPORT_C void SizeChanged();
       
   703     /** MinimumSize()
       
   704      * 
       
   705      * Determines size of the listbox for use in dialogs.
       
   706      */
       
   707     IMPORT_C TSize MinimumSize();
       
   708     /** CreateItemDrawerL()
       
   709      *
       
   710      * Chooses which itemdrawer to use.
       
   711      */
       
   712     IMPORT_C virtual void CreateItemDrawerL();
       
   713     /**
       
   714      * From CCoeControl.     
       
   715      * Handles pointer events
       
   716      */
       
   717     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   718 private:
       
   719     void SizeChangedL();
       
   720     };
       
   721 
       
   722 
       
   723 /**
       
   724 *  list_double2_graphic_large_graphic_pane
       
   725 *
       
   726 *  This is similar but not identical to
       
   727 *  java list CAknDouble2GraphicLargeStyleListBox
       
   728 *
       
   729 *  list item string format: "0\t1\tFirstLabel\tSecondLabel\t2\t3"
       
   730 *
       
   731 *  where 0 (mandatory), 2 and 3 (optional) are an index of small icon
       
   732 *  in icon array and 1 (mandatory) is an index of a thumbnail image
       
   733 *
       
   734 *  @lib avkon
       
   735 *  @since Series 60 2.8
       
   736 */
       
   737 
       
   738 class CAknDouble2GraphicLargeGraphicStyleListBox : public CEikFormattedCellListBoxTypedef
       
   739     {
       
   740 public:
       
   741     IMPORT_C CAknDouble2GraphicLargeGraphicStyleListBox();
       
   742     /** SizeChanged()
       
   743      * 
       
   744      * Determines layout of the listbox
       
   745      */
       
   746     IMPORT_C void SizeChanged();
       
   747     /** MinimumSize()
       
   748      * 
       
   749      * Determines size of the listbox for use in dialogs.
       
   750      */
       
   751     IMPORT_C TSize MinimumSize();
       
   752     /** CreateItemDrawerL()
       
   753      *
       
   754      * Chooses which itemdrawer to use.
       
   755      */
       
   756     IMPORT_C virtual void CreateItemDrawerL();
       
   757     /**
       
   758      * From CCoeControl.     
       
   759      * Handles pointer events
       
   760      */
       
   761     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);   
       
   762 private:
       
   763     void SizeChangedL();
       
   764     };
       
   765 
       
   766 
       
   767 /**
       
   768  * list_double2_graphic_pane
       
   769  *
       
   770  * list item string format: "1\tFirstLabel\tSecondLabel\t0"
       
   771  * where 0 is an index to icon array
       
   772  *
       
   773  */
       
   774 
       
   775 class CAknFormDoubleGraphicStyleListBox : public CAknDoubleGraphicStyleListBox
       
   776     {
       
   777 public:
       
   778     /** SizeChanged()
       
   779      * 
       
   780      * Determines layout of the listbox
       
   781      */
       
   782     IMPORT_C void SizeChanged();
       
   783     /**
       
   784      * From CCoeControl.     
       
   785      * Handles pointer events
       
   786      */
       
   787     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   788 private:
       
   789     void SizeChangedL();
       
   790     };
       
   791 typedef CAknFormDoubleGraphicStyleListBox CAknSingleBigHeadingGraphicListBox;
       
   792 
       
   793 /**
       
   794  * list_double2_pane
       
   795  *
       
   796  * list item string format: " \tFirstLabel\tSecondLabel\t0"
       
   797  * where 0 is an index to icon array
       
   798  */
       
   799 
       
   800 class CAknFormDoubleStyleListBox : public CAknDoubleStyleListBox
       
   801     {
       
   802 public:
       
   803     /** SizeChanged()
       
   804      * 
       
   805      * Determines layout of the listbox
       
   806      */
       
   807     IMPORT_C void SizeChanged();
       
   808     /**
       
   809      * From CCoeControl.     
       
   810      * Handles pointer events
       
   811      */
       
   812     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   813 private:
       
   814     void SizeChangedL();
       
   815     };
       
   816 typedef CAknFormDoubleStyleListBox CAknSingleBigHeadingListBox;
       
   817 
       
   818 
       
   819 /**
       
   820  * list_setting_pane and list_big_single_setting_pane
       
   821  *
       
   822  * list item string format: "\tFirstLabel\t\tValueText"
       
   823  * list item string format: "\tFirstLabel\t0\t"
       
   824  * list item string format: "\tFirstLabel\t\tValueText\t*"
       
   825  * list item string format: "\tFirstLabel\t\t\t\tSecondLabel"
       
   826  * where 0 is an index to icon array
       
   827  */
       
   828 
       
   829 class CAknSettingStyleListBox : public CEikSettingsListBoxTypedef
       
   830     {
       
   831 public:
       
   832     IMPORT_C CAknSettingStyleListBox();
       
   833     /** SizeChanged()
       
   834      * 
       
   835      * Determines layout of the listbox
       
   836      */
       
   837     IMPORT_C void SizeChanged();
       
   838     /** MinimumSize()
       
   839      * 
       
   840      * Determines size of the listbox for use in dialogs.
       
   841      */
       
   842     IMPORT_C TSize MinimumSize();
       
   843     /**
       
   844      * From CCoeControl.     
       
   845      * Handles pointer events
       
   846      */
       
   847     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   848 private:
       
   849     void SizeChangedL();
       
   850     };
       
   851 
       
   852 /**
       
   853  * list_setting_number_pane and list_big_single_setting_number_pane
       
   854  *
       
   855  * list item string format: "1\tFirstLabel\t\tValueText"
       
   856  * list item string format: "2\tFirstLabel\t0\t"
       
   857  * list item string format: "3\tFirstLabel\t\tValueText\t*"
       
   858  * list item string format: "4\tFirstLabel\t\t\t\tSecondLabel"
       
   859  * where 0 is an index to icon array
       
   860  * and 1..4 is list item number shown on screen
       
   861  */
       
   862 class CAknSettingNumberStyleListBox : public CEikSettingsListBoxTypedef
       
   863     {
       
   864 public:
       
   865     IMPORT_C CAknSettingNumberStyleListBox();
       
   866     /** SizeChanged()
       
   867      * 
       
   868      * Determines layout of the listbox
       
   869      */
       
   870     IMPORT_C void SizeChanged();
       
   871     /** MinimumSize()
       
   872      * 
       
   873      * Determines size of the listbox for use in dialogs.
       
   874      */
       
   875     IMPORT_C TSize MinimumSize();
       
   876     /**
       
   877      * From CCoeControl.     
       
   878      * Handles pointer events
       
   879      */
       
   880     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
   881 private:
       
   882     void SizeChangedL();
       
   883     };
       
   884 
       
   885 
       
   886 //
       
   887 // Use the popup styles with CAknPopupList and CAknListQueryDialog
       
   888 //
       
   889 
       
   890 /**
       
   891  * list_single_popup_menu_pane
       
   892  *
       
   893  * list item string format: "FirstLabel\t0"
       
   894  *
       
   895  * where 0 is an index to icon array
       
   896  */
       
   897 
       
   898 class CAknSinglePopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
   899     {
       
   900 public:
       
   901     /** SizeChanged()
       
   902      * 
       
   903      * Determines layout of the listbox
       
   904      */
       
   905     IMPORT_C void SizeChanged();
       
   906     /** MinimumSize()
       
   907      * 
       
   908      * Determines size of the listbox for use in dialogs.
       
   909      */
       
   910     IMPORT_C TSize MinimumSize();
       
   911     protected:
       
   912     /** CreateItemDrawerL()
       
   913      *
       
   914      * Chooses which itemdrawer to use.
       
   915      */
       
   916     IMPORT_C virtual void CreateItemDrawerL();
       
   917     /**
       
   918      * From CCoeControl.     
       
   919      * Handles pointer events
       
   920      */
       
   921     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
       
   922 private:
       
   923     void SizeChangedL();
       
   924     };
       
   925 
       
   926 /**
       
   927  * list_single_graphic_popup_menu_pane
       
   928  *
       
   929  * list item string format: "0\tLabel"
       
   930  *
       
   931  * where 0 is an index to icon array
       
   932  */
       
   933 
       
   934 class CAknSingleGraphicPopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
   935     {
       
   936 public:
       
   937     /** SizeChanged()
       
   938      * 
       
   939      * Determines layout of the listbox
       
   940      */
       
   941     IMPORT_C void SizeChanged();
       
   942     /** MinimumSize()
       
   943      * 
       
   944      * Determines size of the listbox for use in dialogs.
       
   945      */
       
   946     IMPORT_C TSize MinimumSize();
       
   947     protected:
       
   948     /** CreateItemDrawerL()
       
   949      *
       
   950      * Chooses which itemdrawer to use.
       
   951      */
       
   952     IMPORT_C virtual void CreateItemDrawerL();
       
   953     /**
       
   954      * From CCoeControl.     
       
   955      * Handles pointer events
       
   956      */
       
   957     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);  
       
   958 private:
       
   959     void SizeChangedL();
       
   960     };
       
   961 
       
   962 /**
       
   963  * list_single_graphic_bt_popup_menu_pane
       
   964  *
       
   965  * list item string format: "0\tLabel"
       
   966  *
       
   967  * where 0 is an index to icon array
       
   968  *
       
   969  */
       
   970 
       
   971 class CAknSingleGraphicBtPopupMenuStyleListBox : public CAknSingleGraphicPopupMenuStyleListBox
       
   972     {
       
   973 public:
       
   974     /** SizeChanged()
       
   975      * 
       
   976      * Determines layout of the listbox
       
   977      */
       
   978     IMPORT_C virtual void SizeChanged();
       
   979     /**
       
   980      * From CCoeControl.     
       
   981      * Handles pointer events
       
   982      */
       
   983     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);    
       
   984     };
       
   985 
       
   986 /**
       
   987  * list_single_heading_popup_menu_pane
       
   988  *
       
   989  * list item string format: "Heading\tLabel"
       
   990  *
       
   991  */
       
   992 
       
   993 class CAknSingleHeadingPopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
   994     {
       
   995 public:
       
   996     IMPORT_C CAknSingleHeadingPopupMenuStyleListBox();
       
   997     /** SizeChanged()
       
   998      * 
       
   999      * Determines layout of the listbox
       
  1000      */
       
  1001     IMPORT_C void SizeChanged();
       
  1002     /** MinimumSize()
       
  1003      * 
       
  1004      * Determines size of the listbox for use in dialogs.
       
  1005      */
       
  1006     IMPORT_C TSize MinimumSize();
       
  1007     /**
       
  1008      * From CCoeControl.     
       
  1009      * Handles pointer events
       
  1010      */
       
  1011     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);    
       
  1012 protected:
       
  1013     /** CreateItemDrawerL()
       
  1014      *
       
  1015      * Chooses which itemdrawer to use.
       
  1016      */
       
  1017     IMPORT_C virtual void CreateItemDrawerL();
       
  1018 private:
       
  1019     void SizeChangedL();
       
  1020     };
       
  1021 
       
  1022 
       
  1023 /**
       
  1024  * list_single_graphic_heading_popup_menu_pane
       
  1025  *
       
  1026  * list item string format: "0\tHeading\tLabel"
       
  1027  *
       
  1028  * where 0 is an index to icon array
       
  1029  *
       
  1030  */
       
  1031 
       
  1032 class CAknSingleGraphicHeadingPopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1033 
       
  1034     {
       
  1035 public:
       
  1036     IMPORT_C CAknSingleGraphicHeadingPopupMenuStyleListBox();
       
  1037     /** SizeChanged()
       
  1038      * 
       
  1039      * Determines layout of the listbox
       
  1040      */
       
  1041     IMPORT_C void SizeChanged();
       
  1042     /** MinimumSize()
       
  1043      * 
       
  1044      * Determines size of the listbox for use in dialogs.
       
  1045      */
       
  1046     IMPORT_C TSize MinimumSize();
       
  1047     /**
       
  1048      * From CCoeControl.     
       
  1049      * Handles pointer events
       
  1050      */
       
  1051     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
  1052 protected:
       
  1053     /** CreateItemDrawerL()
       
  1054      *
       
  1055      * Chooses which itemdrawer to use.
       
  1056      */
       
  1057     IMPORT_C virtual void CreateItemDrawerL();
       
  1058 private:
       
  1059     void SizeChangedL();
       
  1060     };
       
  1061 
       
  1062 /**
       
  1063  * list_double_popup_menu_pane
       
  1064  *
       
  1065  * list item string format: "FirstLabel\tSecondLabel"
       
  1066  *
       
  1067  */
       
  1068 
       
  1069 class CAknDoublePopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1070     {
       
  1071 public:
       
  1072     /** SizeChanged()
       
  1073      * 
       
  1074      * Determines layout of the listbox
       
  1075      */
       
  1076     IMPORT_C void SizeChanged();
       
  1077     /** MinimumSize()
       
  1078      * 
       
  1079      * Determines size of the listbox for use in dialogs.
       
  1080      */
       
  1081     IMPORT_C TSize MinimumSize();
       
  1082     /**
       
  1083      * From CCoeControl.     
       
  1084      * Handles pointer events
       
  1085      */
       
  1086     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
  1087 protected:
       
  1088     /** CreateItemDrawerL()
       
  1089      *
       
  1090      * Chooses which itemdrawer to use.
       
  1091      */
       
  1092     IMPORT_C virtual void CreateItemDrawerL();
       
  1093 private:
       
  1094     void SizeChangedL();
       
  1095     };
       
  1096 
       
  1097 /**
       
  1098  * list_single_popup_submenu_pane
       
  1099  *
       
  1100  * DO NOT USE
       
  1101  *
       
  1102  */
       
  1103 
       
  1104 class CAknSinglePopupSubmenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1105     {
       
  1106 public:
       
  1107     /** SizeChanged()
       
  1108      * 
       
  1109      * Determines layout of the listbox
       
  1110      */
       
  1111     IMPORT_C void SizeChanged();
       
  1112     /** MinimumSize()
       
  1113      * 
       
  1114      * Determines size of the listbox for use in dialogs.
       
  1115      */
       
  1116     IMPORT_C TSize MinimumSize();
       
  1117     /**
       
  1118      * From CCoeControl.     
       
  1119      * Handles pointer events
       
  1120      */
       
  1121     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
  1122 private:
       
  1123     void SizeChangedL();
       
  1124     };
       
  1125 
       
  1126 
       
  1127 /**
       
  1128  * list_double_large_graphic_popup_menu_pane
       
  1129  *
       
  1130  * list item string format: "0\tFirstLabel\tSecondLabel"
       
  1131  *
       
  1132  * where 0 is an index to icon array
       
  1133  *
       
  1134  */
       
  1135 
       
  1136 class CAknDoubleLargeGraphicPopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1137     {
       
  1138 public:
       
  1139     /** SizeChanged()
       
  1140      * 
       
  1141      * Determines layout of the listbox
       
  1142      */
       
  1143     IMPORT_C void SizeChanged();
       
  1144     /** MinimumSize()
       
  1145      * 
       
  1146      * Determines size of the listbox for use in dialogs.
       
  1147      */
       
  1148     IMPORT_C TSize MinimumSize();
       
  1149     /**
       
  1150      * From CCoeControl.     
       
  1151      * Handles pointer events
       
  1152      */
       
  1153     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
       
  1154 protected:
       
  1155     /** CreateItemDrawerL()
       
  1156      *
       
  1157      * Chooses which itemdrawer to use.
       
  1158      */
       
  1159     IMPORT_C virtual void CreateItemDrawerL();
       
  1160 private:
       
  1161     void SizeChangedL();
       
  1162     };
       
  1163 
       
  1164 
       
  1165 /**
       
  1166  * list_double2_popup_menu_pane
       
  1167  *
       
  1168  * list item string format: "FirstLabel\tSecondLabel"
       
  1169  *
       
  1170  */
       
  1171 
       
  1172 class CAknDouble2PopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1173     {
       
  1174 public:
       
  1175     /** SizeChanged()
       
  1176      * 
       
  1177      * Determines layout of the listbox
       
  1178      */
       
  1179     IMPORT_C void SizeChanged();
       
  1180     /** MinimumSize()
       
  1181      * 
       
  1182      * Determines size of the listbox for use in dialogs.
       
  1183      */
       
  1184     IMPORT_C TSize MinimumSize();
       
  1185     /**
       
  1186      * From CCoeControl.     
       
  1187      * Handles pointer events
       
  1188      */
       
  1189     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);  
       
  1190 protected:
       
  1191     /** CreateItemDrawerL()
       
  1192      *
       
  1193      * Chooses which itemdrawer to use.
       
  1194      */
       
  1195     IMPORT_C virtual void CreateItemDrawerL();
       
  1196 private:
       
  1197     void SizeChangedL();
       
  1198     };
       
  1199     
       
  1200     
       
  1201 /**
       
  1202  * list_single_2graphic_pane_cp2
       
  1203  *
       
  1204  * list item string format: "0\t1\tTextLabel\t2\t3"
       
  1205  *
       
  1206  * where 0,1,2,3 are index to the icon array 
       
  1207  */
       
  1208 
       
  1209 class CAknSingle2GraphicPopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1210     {
       
  1211 public:
       
  1212     IMPORT_C CAknSingle2GraphicPopupMenuStyleListBox();
       
  1213     /** SizeChanged()
       
  1214      * 
       
  1215      * Determines layout of the listbox
       
  1216      */
       
  1217     IMPORT_C void SizeChanged();
       
  1218     /** MinimumSize()
       
  1219      * 
       
  1220      * Determines size of the listbox for use in dialogs.
       
  1221      */
       
  1222     IMPORT_C TSize MinimumSize();
       
  1223     protected:
       
  1224     /** CreateItemDrawerL()
       
  1225      *
       
  1226      * Chooses which itemdrawer to use.
       
  1227      */
       
  1228     IMPORT_C virtual void CreateItemDrawerL();
       
  1229     /**
       
  1230      * From CCoeControl.     
       
  1231      * Handles pointer events
       
  1232      */
       
  1233     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
       
  1234 private:
       
  1235     void SizeChangedL();
       
  1236     };
       
  1237 
       
  1238 
       
  1239 
       
  1240 /**
       
  1241  * list_double_graphic_pane
       
  1242  *
       
  1243  * list item string format: "0\tFirstLabel\tSecondLabel\t1\t2"
       
  1244  * where 0 is index to icon array
       
  1245  *
       
  1246  */
       
  1247 class CAknDoubleGraphicPopupMenuStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1248     {
       
  1249 public:
       
  1250     IMPORT_C CAknDoubleGraphicPopupMenuStyleListBox();
       
  1251     /** SizeChanged()
       
  1252      * 
       
  1253      * Determines layout of the listbox
       
  1254      */
       
  1255     IMPORT_C void SizeChanged();
       
  1256     /** MinimumSize()
       
  1257      * 
       
  1258      * Determines size of the listbox for use in dialogs.
       
  1259      */
       
  1260     IMPORT_C TSize MinimumSize();
       
  1261     protected:
       
  1262     /** CreateItemDrawerL()
       
  1263      *
       
  1264      * Chooses which itemdrawer to use.
       
  1265      */
       
  1266     IMPORT_C virtual void CreateItemDrawerL();
       
  1267     /**
       
  1268      * From CCoeControl.     
       
  1269      * Handles pointer events
       
  1270      */
       
  1271     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);
       
  1272 private:
       
  1273     void SizeChangedL();
       
  1274     };
       
  1275     
       
  1276 // --- end of popup styles
       
  1277 
       
  1278 
       
  1279 
       
  1280 /** list_set_pane
       
  1281  * Setting Page component uses this
       
  1282  *
       
  1283  * list item string format: "1\tShortLabel"
       
  1284  * list item string format: "\t\tLongLabel"
       
  1285  *
       
  1286  */
       
  1287 class CAknSetStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1288     {
       
  1289 public:
       
  1290     IMPORT_C void ConstructWithWindowL(const CCoeControl *aParent, TInt aFlags);
       
  1291     /** SizeChanged()
       
  1292      * 
       
  1293      * Determines layout of the listbox
       
  1294      */
       
  1295     IMPORT_C void SizeChanged();
       
  1296     /** MinimumSize()
       
  1297      * 
       
  1298      * Determines size of the listbox for use in dialogs.
       
  1299      */
       
  1300     IMPORT_C TSize MinimumSize();
       
  1301     IMPORT_C void Draw(const TRect& aRect) const;
       
  1302     IMPORT_C TTypeUid::Ptr MopSupplyObject(TTypeUid aId);
       
  1303 
       
  1304     /**
       
  1305      * From CCoeControl.     
       
  1306      * Handles pointer events
       
  1307      */
       
  1308     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
  1309 
       
  1310 protected:
       
  1311     /** CreateItemDrawerL()
       
  1312      *
       
  1313      * Chooses which itemdrawer to use.
       
  1314      */
       
  1315     IMPORT_C virtual void CreateItemDrawerL();
       
  1316    /** MakeViewClassInstanceL()
       
  1317     *
       
  1318     * Chooses which listbox view class to use
       
  1319     */
       
  1320     IMPORT_C CListBoxView *MakeViewClassInstanceL();
       
  1321 private:
       
  1322     void SizeChangedL();
       
  1323     };
       
  1324 
       
  1325 /** list_form_graphic_pane
       
  1326  * Form popup field should use this
       
  1327  *
       
  1328  * list item string format: "1\tShortLabel"
       
  1329  * list item string format: "\t\tLongLabel"
       
  1330  *
       
  1331  */
       
  1332 class CAknFormGraphicStyleListBox : public AknPopupListEmpty<CEikFormattedCellListBox>
       
  1333     {
       
  1334 public:
       
  1335     IMPORT_C void ConstructWithWindowL(const CCoeControl *aParent, TInt aFlags);
       
  1336     /** SizeChanged()
       
  1337      * 
       
  1338      * Determines layout of the listbox
       
  1339      */
       
  1340     IMPORT_C void SizeChanged();
       
  1341     /** MinimumSize()
       
  1342      * 
       
  1343      * Determines size of the grid for use in dialogs.
       
  1344      */
       
  1345     IMPORT_C TSize MinimumSize();
       
  1346     /** CreateItemDrawerL()
       
  1347      *
       
  1348      * Chooses which itemdrawer to use.
       
  1349      */
       
  1350     IMPORT_C virtual void CreateItemDrawerL();
       
  1351     /** Listbox rectangle calculation.
       
  1352      */
       
  1353     IMPORT_C virtual TInt AdjustRectHeightToWholeNumberOfItems(TRect &aRect) const;
       
  1354      /**
       
  1355      * From CCoeControl
       
  1356      * Handles pointerevents of popupfield's list
       
  1357      * @param aPointerEvent pointerevent to be handled
       
  1358      */
       
  1359     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
  1360 private:
       
  1361     void SizeChangedL();
       
  1362 	};
       
  1363 
       
  1364 class CAknFormGraphicWideStyleListBox : public CAknFormGraphicStyleListBox
       
  1365     {
       
  1366 public:
       
  1367     IMPORT_C void SizeChanged();
       
  1368     IMPORT_C TSize MinimumSize();
       
  1369     // From CCoeControl
       
  1370     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);  
       
  1371 private:
       
  1372     void SizeChangedL();
       
  1373     };
       
  1374 
       
  1375 
       
  1376 /** grid_app_pane
       
  1377  * Application Shell uses this (note that part of layout needs to be done
       
  1378  * inside application -- the listbox will not be in correct position on the
       
  1379  * screen by just using this -- see listapp)
       
  1380  *
       
  1381  * list item string format: "1\tLabel"
       
  1382  * list item string format: "1\tLabel\t1"
       
  1383  */
       
  1384 
       
  1385 /**
       
  1386  * grid_pinb_pane
       
  1387  *
       
  1388  * list item string format: "1"
       
  1389  * list item string format: "1\t1"
       
  1390  * list item string format: "1\t1\t1"
       
  1391  * list item string format: "1\t\t1"
       
  1392  */
       
  1393 
       
  1394 class CAknPinbStyleGrid : public CAknSelectionGridTypedef
       
  1395     {
       
  1396 public:
       
  1397     /** SizeChanged()
       
  1398      * 
       
  1399      * Determines layout of the grid
       
  1400      */
       
  1401     IMPORT_C void SizeChanged();
       
  1402     /** MinimumSize()
       
  1403      * 
       
  1404      * Determines size of the grid for use in dialogs.
       
  1405      */
       
  1406     IMPORT_C TSize MinimumSize();
       
  1407 
       
  1408     /**
       
  1409      * From CCoeControl.     
       
  1410      * Handles pointer events
       
  1411      */
       
  1412     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
  1413 
       
  1414 private:    
       
  1415     void SizeChangedL();
       
  1416     };
       
  1417 
       
  1418 
       
  1419 /**
       
  1420  * grid_qdial_pane
       
  1421  */
       
  1422 
       
  1423 class CAknQdialStyleGrid : public CAknSelectionGridTypedef
       
  1424     {
       
  1425 public:
       
  1426     /** SizeChanged()
       
  1427      * 
       
  1428      * Determines layout of the grid
       
  1429      */
       
  1430     IMPORT_C virtual void SizeChanged();
       
  1431     /** MinimumSize()
       
  1432      * 
       
  1433      * Determines size of the grid for use in dialogs.
       
  1434      */
       
  1435     IMPORT_C TSize MinimumSize();
       
  1436 
       
  1437     /**
       
  1438      * From CCoeControl.     
       
  1439      * Handles pointer events
       
  1440      */
       
  1441     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent); 
       
  1442 
       
  1443 private:
       
  1444     void SizeChangedL();
       
  1445     };
       
  1446 
       
  1447 /**
       
  1448  * grid_cale_month_pane
       
  1449  */
       
  1450 
       
  1451 class CAknCaleMonthStyleGrid : public CAknSelectionGridTypedef
       
  1452     {
       
  1453 public:
       
  1454     /** SizeChanged()
       
  1455      * 
       
  1456      * Determines layout of the listbox
       
  1457      */
       
  1458     IMPORT_C void SizeChanged();
       
  1459     /** MinimumSize()
       
  1460      * 
       
  1461      * Determines size of the grid for use in dialogs.
       
  1462      */
       
  1463     IMPORT_C TSize MinimumSize();
       
  1464     /**
       
  1465      * From CCoeControl.     
       
  1466      * Handles pointer events
       
  1467      */
       
  1468     IMPORT_C void HandlePointerEventL(const TPointerEvent& aPointerEvent);  
       
  1469 
       
  1470 private:
       
  1471     void SizeChangedL();
       
  1472     };
       
  1473 
       
  1474 
       
  1475 
       
  1476 //
       
  1477 //
       
  1478 // Here we have itemdrawer/view modifications needed by the lists
       
  1479 //
       
  1480 //
       
  1481 
       
  1482 // This class is to keep drawing routines that depend on avkon and which we cannot place to
       
  1483 // eikstd or uikon because of that.
       
  1484 
       
  1485 	/**
       
  1486  	* A view that provides empty lists for use with find pane
       
  1487  	* @since Series 60 0.9
       
  1488  	*/
       
  1489 class CAknColumnListBoxView : public CColumnListBoxView
       
  1490     {
       
  1491 public:
       
  1492 
       
  1493 	/**
       
  1494 	* Enables find in empty list. Basically same as @c SetFindEmptyListState()
       
  1495 	* when it is set @c ETrue.
       
  1496 	*/
       
  1497     IMPORT_C void EnableFindEmptyList();
       
  1498     
       
  1499     /**
       
  1500     * Sets find in empty list visible or hides it.
       
  1501     * @param aUsedWithFind Setter to set find visible or to hide it.
       
  1502     */
       
  1503     IMPORT_C void SetFindEmptyListState(TBool aUsedWithFind);
       
  1504     
       
  1505     /**
       
  1506     * Draws empty list with or without find depending if it has been enabled.
       
  1507     * @param aClientRect The client rectangle.
       
  1508     */
       
  1509     IMPORT_C void DrawEmptyList(const TRect &aClientRect) const;
       
  1510     
       
  1511     /**
       
  1512     * Calls @c CColumnListBoxView::CalcBottomItemIndex() and removes filtering
       
  1513     * from find box if new list items are added. Called by listbox control when
       
  1514     * either the size of the listbox or the number of items in its model has
       
  1515     * changed.
       
  1516     */
       
  1517     IMPORT_C virtual void CalcBottomItemIndex();
       
  1518     TBool GetFindEmptyListState();    
       
  1519 private: // overridden from CListBoxView
       
  1520 	IMPORT_C virtual TAny* Reserved_1();
       
  1521 private:
       
  1522     TBool iEmptyListWithFind;
       
  1523     };
       
  1524 
       
  1525 /**
       
  1526  * empty list for settings item editing
       
  1527  */
       
  1528 
       
  1529 class CAknSetStyleListBoxView : public CFormattedCellListBoxView
       
  1530     {
       
  1531 public:
       
  1532     IMPORT_C void DrawEmptyList(const TRect &aClientRect) const ;
       
  1533 private: // overridden from CListBoxView
       
  1534 	IMPORT_C virtual TAny* Reserved_1();
       
  1535     };
       
  1536 
       
  1537 
       
  1538 /**
       
  1539  * Horizontal lines and empty list support for views
       
  1540  */
       
  1541 
       
  1542 class CSingleHeadingStyleView : public CAknColumnListBoxView
       
  1543     {
       
  1544 public:
       
  1545     IMPORT_C void Draw(const TRect* ) const;
       
  1546     IMPORT_C void DrawEmptyList(const TRect& aClientRect) const;
       
  1547 private: // overridden from CListBoxView
       
  1548 	IMPORT_C virtual TAny* Reserved_1();
       
  1549     };
       
  1550 
       
  1551 /**
       
  1552  * Horizontal lines support for item drawer.
       
  1553  */
       
  1554 class CSingleHeadingStyleItemDrawer : public CColumnListBoxItemDrawer 
       
  1555     {
       
  1556 public:
       
  1557     IMPORT_C CSingleHeadingStyleItemDrawer(MTextListBoxModel* aTextListBoxModel, const CFont* aFont, CColumnListBoxData* aColumnData);
       
  1558     IMPORT_C ~CSingleHeadingStyleItemDrawer();
       
  1559 
       
  1560     IMPORT_C virtual void DrawItem(TInt aItemIndex, TPoint aItemRectPos, TBool aItemIsSelected, TBool aItemIsCurrent, TBool aViewIsEmphasized, TBool aViewIsDimmed) const;
       
  1561 
       
  1562 public:
       
  1563     IMPORT_C void SetTopItemIndex(TInt aTop);
       
  1564 
       
  1565 private:
       
  1566     TInt iTopItemIndex;
       
  1567 	CCoeEnv* iCoeEnv;
       
  1568     };
       
  1569 
       
  1570 /**
       
  1571  * Thumbnail image positioning for double large styles.
       
  1572  */
       
  1573 class CDoubleLargeStyleItemDrawer : public CFormattedCellListBoxItemDrawer
       
  1574     {
       
  1575 public:
       
  1576     IMPORT_C CDoubleLargeStyleItemDrawer(MTextListBoxModel* aTextListBoxModel, const CFont* aFont, CFormattedCellListBoxData* aFormattedCellData, CEikListBox *aListBox);
       
  1577     IMPORT_C void DrawItem(TInt aItemIndex, TPoint aItemRectPos, TBool aItemIsSelected, TBool aItemIsCurrent, TBool aViewIsEmphasized, TBool aViewIsDimmed) const;
       
  1578 private:
       
  1579 	IMPORT_C void CFormattedCellListBoxItemDrawer_Reserved();
       
  1580 private:
       
  1581     CEikListBox *iListBox_tmp;
       
  1582     };
       
  1583 
       
  1584 
       
  1585 /**
       
  1586  * Word wrapping for double2 styles
       
  1587  */
       
  1588 class CWordWrappedFormattedCellItemDrawer : public CFormattedCellListBoxItemDrawer
       
  1589     {
       
  1590 public:
       
  1591     IMPORT_C CWordWrappedFormattedCellItemDrawer(MTextListBoxModel* aTextListBoxModel, const CFont* aFont, CFormattedCellListBoxData* aFormattedCellData, CEikListBox *aListBox, TInt aSubCell, TInt aSubCell2);
       
  1592     IMPORT_C void DrawItem(TInt aItemIndex, TPoint aItemRectPos, TBool aItemIsSelected, TBool aItemIsCurrent, TBool aViewIsEmphasized, TBool aViewIsDimmed) const;
       
  1593     IMPORT_C void DrawItemText(TInt aItemIndex,
       
  1594 			       const TRect &aItemTextRect,
       
  1595 			       TBool aItemIsCurrent,
       
  1596 			       TBool,
       
  1597 			       TBool aItemIsSelected) const;
       
  1598 private:
       
  1599 	IMPORT_C void CFormattedCellListBoxItemDrawer_Reserved();
       
  1600 private:
       
  1601     TInt iSubCell, iSubCell2;
       
  1602     };
       
  1603 
       
  1604 //
       
  1605 //
       
  1606 //  here starts section for building new listboxes.
       
  1607 //
       
  1608 
       
  1609 //
       
  1610 // This is helper class that makes the conversion between European LAF and
       
  1611 // different listbox itemdrawer implementations.
       
  1612 //
       
  1613 // Notice, this CEikListBox is a good friend with this class.
       
  1614 //
       
  1615 // 
       
  1616 
       
  1617 /** AknListBoxLayouts
       
  1618  * Building listbox layouts from European Avkon LAF.
       
  1619  *
       
  1620  * The LAF specification has 3 kinds of tables:
       
  1621  *   Graphics tables
       
  1622  *   Text tables
       
  1623  *   Pane coordinates
       
  1624  * The graphics tables map to SetupColumnGfxCell() and SetupFormGfxCell()
       
  1625  * The text tables map to SetupColumnTextCell() and SetupFormGfxCell()
       
  1626  * The pane coordinates map to SetupListboxPos().
       
  1627  *
       
  1628  * This class is mostly useless if you don't have LAF specification available!
       
  1629  *
       
  1630  * You probably want to use predefined layouts; See CAknSingleStyleListBox.
       
  1631  *
       
  1632  * NOTE: This class is old design. You should consider looking at aknutils.h: AknLayoutUtils
       
  1633  *       whenever you want to build things from the LAF specification. 
       
  1634  */
       
  1635 
       
  1636 class AknListBoxLayouts
       
  1637     {
       
  1638 public:
       
  1639     /**
       
  1640      * Setup borders etc.
       
  1641      */
       
  1642     IMPORT_C static void SetupStandardListBox(CEikListBox& aListBox);
       
  1643      /**
       
  1644      * Setup grid position
       
  1645      * since 2.0
       
  1646      */
       
  1647     static void SetupGridPos(CAknGrid& aGrid,
       
  1648                      const TAknWindowLineLayout &aLayout);
       
  1649    /**
       
  1650      * Setup grid position
       
  1651      */
       
  1652     IMPORT_C static void SetupGridPos(CAknGrid& aGrid,
       
  1653     			     TInt l, 
       
  1654     			     TInt t, 
       
  1655     			     TInt /*r*/, 
       
  1656     			     TInt /*b*/, 
       
  1657     			     TInt W, 
       
  1658     			     TInt H);
       
  1659     /**
       
  1660      * Setup list position
       
  1661      */
       
  1662     IMPORT_C static void SetupListboxPos(CEikListBox& aListBox,
       
  1663 				TInt startx, 
       
  1664     				TInt starty, 
       
  1665     				TInt,
       
  1666     				TInt, 
       
  1667     				TInt /*width*/, 
       
  1668     				TInt height);
       
  1669 
       
  1670     /*
       
  1671     * non-exported new internal version
       
  1672     */
       
  1673     static void SetupListboxPosL( CEikListBox& aListBox,
       
  1674                                   const TAknWindowLineLayout& aLayout ); // layout of first item
       
  1675         
       
  1676     /**
       
  1677      * Setup text foreground and background colors to default
       
  1678      */
       
  1679     IMPORT_C static void SetupStandardColumnListbox(CColumnListBoxItemDrawer* aItemDrawer);	
       
  1680     /**
       
  1681      * Setup text foreground and background colors to default
       
  1682      */
       
  1683     IMPORT_C static void SetupStandardFormListbox(CFormattedCellListBoxItemDrawer* aItemDrawer);
       
  1684     /**
       
  1685      * Setup text foreground and background colors to default
       
  1686      */
       
  1687     IMPORT_C static void SetupStandardGrid(CAknGrid& aGrid);
       
  1688     
       
  1689     /**
       
  1690      * Setup a single graphics cell of list item
       
  1691      */
       
  1692     IMPORT_C static void SetupColumnGfxCell(CEikListBox& aListBox, 
       
  1693 				   CColumnListBoxItemDrawer* aItemDrawer, 
       
  1694 				   TInt index,
       
  1695 				   TInt l, 
       
  1696 				   TInt t, 
       
  1697 				   TInt r, 
       
  1698 				   TInt b, 
       
  1699 				   TInt W, 
       
  1700 				   TInt H, 
       
  1701 				   TInt startx, 
       
  1702 				   TInt endx);
       
  1703     
       
  1704     /**
       
  1705      * Setup a single text cell of list item
       
  1706      */
       
  1707     IMPORT_C static void SetupColumnTextCell(CEikListBox& aListBox, 
       
  1708 				    CColumnListBoxItemDrawer* aItemDrawer, 
       
  1709 				    TInt index,
       
  1710 				    const CFont *font, 
       
  1711 				    TInt /*C*/, 
       
  1712 				    TInt lm, 
       
  1713 				    TInt rm, 
       
  1714 				    TInt B, 
       
  1715 				    TInt /*W*/, 
       
  1716 				    CGraphicsContext::TTextAlign aAlign, 
       
  1717 				    TInt startx, 
       
  1718 				    TInt endx);
       
  1719     /**
       
  1720      * Setup a single text cell of list item
       
  1721      */
       
  1722     IMPORT_C static void SetupColumnTextCell(CEikListBox& aListBox, 
       
  1723 				    CColumnListBoxItemDrawer* aItemDrawer, 
       
  1724 				    TInt index,
       
  1725 				    const TAknTextLineLayout &aLayout,
       
  1726 				    TInt startx, 
       
  1727 				    TInt endx); // use with aknlayoutcompiler
       
  1728 
       
  1729     /**
       
  1730      * Setup a single graphics cell of list item
       
  1731      */
       
  1732     IMPORT_C static void SetupFormGfxCell(CEikListBox& aListBox, 
       
  1733 				 CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1734 				 TInt index,
       
  1735 				 TInt l, 
       
  1736 				 TInt t, 
       
  1737 				 TInt /*r*/, 
       
  1738 				 TInt /*b*/, 
       
  1739 				 TInt W, 
       
  1740 				 TInt H, 
       
  1741 				 TPoint p1, 
       
  1742 				 TPoint p2);
       
  1743 
       
  1744 
       
  1745     /**
       
  1746      * Setup a single graphics cell of list item
       
  1747      *
       
  1748      * This version is needed for grid cells. (the FormGfxCell works in
       
  1749      * most cases, but this is needed if you want exact positioning of
       
  1750      * the erased area..)
       
  1751      */
       
  1752     IMPORT_C static void SetupGridFormGfxCell(CAknGrid& aListBox, 
       
  1753 				 CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1754 				 TInt index,
       
  1755 				 TInt l, 
       
  1756 				 TInt t, 
       
  1757 				 TInt /*r*/, 
       
  1758 				 TInt /*b*/, 
       
  1759 				 TInt W, 
       
  1760 				 TInt H, 
       
  1761 				 TPoint aP1, 
       
  1762 				 TPoint aP2);
       
  1763     /**
       
  1764      * Setup a single graphics cell of list item
       
  1765      *
       
  1766      * This version is needed for grid cells. (the FormGfxCell works in
       
  1767      * most cases, but this is needed if you want exact positioning of
       
  1768      * the erased area..)
       
  1769      * since 2.6
       
  1770      */
       
  1771 
       
  1772     IMPORT_C static void SetupGridFormGfxCell(CAknGrid& aGrid,
       
  1773                  CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1774                  TInt aIndex,
       
  1775                  const TAknWindowLineLayout& aLine,
       
  1776                  TPoint& aP1, 
       
  1777                  TPoint& aP2);         
       
  1778 
       
  1779     /**
       
  1780      * Setup a single text cell of list item
       
  1781      */    
       
  1782     IMPORT_C static void SetupFormTextCell(CEikListBox& aListBox, 
       
  1783 				  CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1784 				  TInt index,
       
  1785 				  const CFont *font, 
       
  1786 				  TInt /*C*/, 
       
  1787 				  TInt lm,
       
  1788 				  TInt /*rm*/, 
       
  1789 				  TInt B, 
       
  1790 				  TInt W, 
       
  1791 				  CGraphicsContext::TTextAlign aAlign, 
       
  1792 				  TPoint p1, 
       
  1793 				  TPoint p2);
       
  1794     /**
       
  1795      * Setup a single text cell of list item
       
  1796      *
       
  1797      * This is for removing flicker for settings
       
  1798      *
       
  1799      */
       
  1800     IMPORT_C static void SetupFormAntiFlickerTextCell(CEikListBox& aListBox, 
       
  1801 				  CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1802 				  TInt index,
       
  1803 				  const CFont *font, 
       
  1804 				  TInt /*C*/, 
       
  1805 				  TInt lm,
       
  1806 				  TInt /*rm*/, 
       
  1807 				  TInt B, 
       
  1808 				  TInt W, 
       
  1809 				  CGraphicsContext::TTextAlign aAlign, 
       
  1810 				  TPoint p1, 
       
  1811 				  TPoint p2);
       
  1812 
       
  1813     /**
       
  1814      * Setup a single text cell of list item
       
  1815      */
       
  1816     IMPORT_C static void SetupFormTextCell(CEikListBox& aListBox, 
       
  1817 				  CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1818 				  TInt index,
       
  1819 				  const TAknTextLineLayout &aLayout,
       
  1820 				  const TPoint &p1, 
       
  1821 				  const TPoint &p2); // use with layout compiler
       
  1822     /**
       
  1823      * Setup a single text cell of list item
       
  1824      *
       
  1825      * This is for removing flicker for settings
       
  1826      */
       
  1827     IMPORT_C static void SetupFormAntiFlickerTextCell(CEikListBox& aListBox, 
       
  1828 				  CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1829 				  TInt index,
       
  1830 				  const TAknTextLineLayout &aLayout,
       
  1831 				  const TPoint &p1, 
       
  1832 				  const TPoint &p2); // use with layout compiler
       
  1833 
       
  1834     /**
       
  1835      * Setup a graphic element for a column listbox using aknlayout.dll
       
  1836      */
       
  1837     IMPORT_C static void SetupColumnGfxCell(CEikListBox& aListBox, 
       
  1838 				   CColumnListBoxItemDrawer* aItemDrawer, 
       
  1839 				   TInt aIndex,
       
  1840 				   const TAknWindowLineLayout &aLayout,
       
  1841 				   TInt startx, 
       
  1842 				   TInt endx);
       
  1843 
       
  1844     /**
       
  1845      * Setup a single graphics cell of list item using aknlayout.dll
       
  1846      */
       
  1847     IMPORT_C static void SetupFormGfxCell(CEikListBox& aListBox, 
       
  1848 				 CFormattedCellListBoxItemDrawer* aItemDrawer, 
       
  1849 				 TInt index,
       
  1850 				 const TAknWindowLineLayout &aLayout,
       
  1851 				 const TPoint &p1, 
       
  1852 				 const TPoint &p2);
       
  1853 
       
  1854 
       
  1855     /**
       
  1856      * Setup a graphic element for a column listbox using aknlayout.dll
       
  1857      */
       
  1858     IMPORT_C static void SetupListboxPos(CEikListBox& aListBox, 
       
  1859 				   const TAknWindowLineLayout &aLayout);
       
  1860 				   
       
  1861     /**
       
  1862      * This function returns a correct offset to revise layout data.
       
  1863      *
       
  1864      * Attention: The function is only effective for QHD lanscape model. 
       
  1865      * It always return 0 in QVGA, QVGA2, VGA and VAG3. 
       
  1866      * A panic will take place if it is used in other models.
       
  1867      *
       
  1868      * @since S60 5.0
       
  1869      *
       
  1870      * @param aScreenRect Size of Screen.
       
  1871      * @return Offset of listscroll_menu_pane's layout 
       
  1872      */
       
  1873     static TInt AdjustPopupLayoutData( const TRect& aScreenRect );				   
       
  1874     };
       
  1875 
       
  1876 /**
       
  1877 * General utilities relating to listboxes
       
  1878 *
       
  1879 * @since Series 60 0.9
       
  1880 */
       
  1881 class AknListBoxUtils
       
  1882     {
       
  1883 public:
       
  1884     /**
       
  1885     * This function is similar to @c HandleItemRemovalL(). This function has
       
  1886     * to call when the items should be removed. If a leave occurs the framework
       
  1887     * generates a Symbian Leave code.
       
  1888     * @param aListBox A pointer to @c CEikListBox object.
       
  1889     * @param aValueOfCurrentItemIndexBeforeRemoval A current item index value 
       
  1890     * before removal.
       
  1891     * @param aCurrentItemWasRemoved @c ETrue if removed @c EFalse if not.
       
  1892     */
       
  1893     IMPORT_C static void HandleItemRemovalAndPositionHighlightL(CEikListBox *aListBox, TInt aValueOfCurrentItemIndexBeforeRemoval, TBool aCurrentItemWasRemoved);
       
  1894     
       
  1895     /**
       
  1896     * This function should be called after one or more items have been removed.
       
  1897     * If a leave occurs the framework generates a Symbian Leave code. 
       
  1898     * @param aListBox A pointer to @c CEikListBox object.
       
  1899     * @param aValueOfCurrentItemIndexBeforeRemoval A current item index value 
       
  1900     * before removal.
       
  1901     * @param aIndexesToRemovedItems A thin templated base class for arrays of
       
  1902     * fixed length objects.
       
  1903     */
       
  1904     IMPORT_C static void HandleItemRemovalAndPositionHighlightL(CEikListBox *aListBox, TInt aValueOfCurrentItemIndexBeforeRemoval, CArrayFix<TInt> &aIndexesToRemovedItems);
       
  1905 
       
  1906     /** 
       
  1907     * @deprecated
       
  1908     */
       
  1909     IMPORT_C static TBool ListBoxLinesShown(MAknsSkinInstance *aInstance, MAknsControlContext *aCc);
       
  1910     };
       
  1911 
       
  1912 #endif
       
  1913 
       
  1914 
       
  1915 
       
  1916 
       
  1917 
       
  1918