mpxplugins/viewplugins/views/commoncontainer/inc/mpxcommoncontainerhitchcockimp.h
changeset 0 ff3acec5bc43
equal deleted inserted replaced
-1:000000000000 0:ff3acec5bc43
       
     1 /*
       
     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
       
     3 * All rights reserved.
       
     4 * This component and the accompanying materials are made available
       
     5 * under the terms of "Eclipse Public License v1.0"
       
     6 * which accompanies this distribution, and is available
       
     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".
       
     8 *
       
     9 * Initial Contributors:
       
    10 * Nokia Corporation - initial contribution.
       
    11 *
       
    12 * Contributors:
       
    13 *
       
    14 * Description:  MPX common container definition for Hitchcock platform.
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 #ifndef CMPXCOMMONCONTAINERHITCHCOCKIMP_H
       
    21 #define CMPXCOMMONCONTAINERHITCHCOCKIMP_H
       
    22 
       
    23 
       
    24 // INCLUDES
       
    25 #include <alf/alfenv.h>
       
    26 #include <alf/ialfwidgeteventhandler.h>
       
    27 #include <mul/mulevent.h>
       
    28 #include <mul/mulvisualitem.h>      // For Visual Item
       
    29 #include <mul/imulmodelprovider.h>
       
    30 
       
    31 #include <thumbnailmanager.h>
       
    32 #include <thumbnailmanagerobserver.h>
       
    33 
       
    34 #include <mpxattribute.h>
       
    35 #include "mpxcommoncontainer.h"
       
    36 #include "mpxcommoncontainersearchfieldwrapper.h"
       
    37 
       
    38 // FORWARD DECLARATIONS
       
    39 namespace Alf
       
    40     {
       
    41     class IMulListWidget;
       
    42     class IMulModel;
       
    43     class IAlfViewWidget;
       
    44     class MulVisualItem;
       
    45     }
       
    46 class CAlfEnv;
       
    47 class MEikCommandObserver;
       
    48 class CEikMenuPane;
       
    49 class MEikListBoxObserver;
       
    50 class CAknIconArray;
       
    51 class CMPXCommonListBoxArrayBase;
       
    52 class CMPXMediaArray;
       
    53 class CAknSearchField;
       
    54 class MCoeControlObserver;
       
    55 class CMPXCommonContainerMediaHelper;
       
    56 class CMPXCommonContainerTextureManager;
       
    57 class CMPXCommonUiHelper;
       
    58 class CMPXCommonContainerFilteredList;
       
    59 
       
    60 // CLASS DECLARATION
       
    61 
       
    62 /**
       
    63  *  Container class for Hitchcok common container.
       
    64  *  The view class should implement the following virtual function
       
    65  *  from MEikCommandObserver 
       
    66  *
       
    67  *  virtual void ProcessCommandL(TInt aCommandId);
       
    68  *
       
    69  *  common container uses this to pass commands back to the view class
       
    70  *  the commands supported are defined in mpxcommoncontainer.hrh
       
    71  *
       
    72  *  view container class owns this class to access List widget commands, receive
       
    73  *  CoeControl events and GetHelpContext(). The view container class should
       
    74  *  implement the following virtual functions from MViewContainer
       
    75  *
       
    76  *  virtual void HandleKeyEvent();
       
    77  *  virtual void HandleHelpContent();
       
    78  *
       
    79  *  common container uses this to pass CoeControl events back to the view
       
    80  *  container class. 
       
    81  *
       
    82  *  view class should handle the following commands in ProcessCommandL
       
    83  *  from MEikCommandObserver: 
       
    84  *  
       
    85  *  EMPXCmdCommonDelete  // delete key pressed
       
    86  *  EMPXCmdCommonResourceChange  // resource change
       
    87  *  EMPXCmdCommonEnterKey  // enter key pressed
       
    88  *
       
    89  *  @lib mpxcommoncontainer.lib
       
    90  *  @since S60 v3.1
       
    91  */
       
    92 NONSHARABLE_CLASS( CMPXCommonContainerHitchcockImp )
       
    93     : public CCoeControl
       
    94     , public MCoeControlObserver
       
    95     , public MMPXCommonContainer
       
    96     , public IAlfWidgetEventHandler
       
    97     , public Alf::IMulModelProvider
       
    98     , public MThumbnailManagerObserver
       
    99     , public MMPXCommonContainerSearchFieldObserver
       
   100     {
       
   101 public:
       
   102 
       
   103     /**
       
   104      * default C++ constructor.
       
   105      */
       
   106     CMPXCommonContainerHitchcockImp();
       
   107     
       
   108     /**
       
   109      * Destructor.
       
   110      */
       
   111     virtual ~CMPXCommonContainerHitchcockImp();
       
   112 
       
   113 
       
   114 // from base class MMPXCommonContainer
       
   115 
       
   116     /**
       
   117      * Return Coe Control
       
   118      *
       
   119      * @since 3.2
       
   120      */
       
   121     CCoeControl* CoeControl();
       
   122 
       
   123     /**
       
   124      * Set View Container
       
   125      *
       
   126      * @since 3.2
       
   127      */
       
   128     void SetViewContainer( MMPXViewContainer* aViewContainer );
       
   129 
       
   130     /**
       
   131      * Set command observer for container
       
   132      *
       
   133      * @since 3.2
       
   134      */
       
   135     void SetCommandObserver( MEikCommandObserver* aCommandObserver );
       
   136 
       
   137     /**
       
   138      * Set list box observer for container
       
   139      *
       
   140      * @since 3.2
       
   141      */
       
   142     void SetListBoxObserver( MEikListBoxObserver* aObserver );
       
   143 
       
   144     /**
       
   145      * Set layout for all elements and set sizes for icons.
       
   146      *
       
   147      * @since 3.1
       
   148      */
       
   149     void UpdateLayout();
       
   150 
       
   151     /**
       
   152      * Returns list box array, ownership not transfered
       
   153      *
       
   154      * @since 3.1
       
   155      * @return A pointer to the list box array
       
   156      */
       
   157     CMPXCommonListBoxArrayBase* ListBoxArray() const;
       
   158     
       
   159     /**
       
   160      * Sets up the listbox array, ownership not transferred
       
   161      */
       
   162     void SetListBoxArrayL( CMPXCommonListBoxArrayBase* aListBoxArray );
       
   163 
       
   164     /**
       
   165      * Return number of listbox items shown in the current listbox.
       
   166      *
       
   167      * @since 3.1
       
   168      * @return The number of items shown in the list box
       
   169      */
       
   170     TInt CurrentListItemCount() const;
       
   171 
       
   172     /**
       
   173      * Return total number of listbox items in the listbox.
       
   174      *
       
   175      * @since 3.1
       
   176      * @return Total items in the list box
       
   177      */
       
   178     TInt TotalListItemCount() const;
       
   179 
       
   180     /**
       
   181      * Gets top listbox item index (relative to the original listbox).
       
   182      * @return Top listbox item index
       
   183      *
       
   184      * @since 3.1
       
   185      */
       
   186     TInt TopLbxItemIndex() const;
       
   187     
       
   188     /**
       
   189      * Gets bottom listbox item index (relative to the original listbox).
       
   190      * @return Bottom listbox item index
       
   191      *
       
   192      * @since 3.1
       
   193      */
       
   194     TInt BottomLbxItemIndex() const;
       
   195 
       
   196     /**
       
   197      * Gets current listbox item index (relative to the original listbox).
       
   198      * @return Current listbox item index
       
   199      *
       
   200      * @since 3.1
       
   201      */
       
   202     TInt CurrentLbxItemIndex() const;
       
   203 
       
   204     /**
       
   205      * Get current selected listbox items indices (relative to the original
       
   206      * listbox). Ownership not transferred.
       
   207      *
       
   208      * @since 3.1
       
   209      * @return Current listbox item indices
       
   210      */
       
   211     const CArrayFix<TInt>* CurrentSelectionIndicesL() const;
       
   212     
       
   213     /**
       
   214      * Sewt current selected listbox items indices
       
   215      *
       
   216      * @since 3.1
       
   217      * @param aIndices Array of selection indices, ownership not transfered
       
   218      */
       
   219     void SetCurrentSelectionIndicesL( CArrayFix<TInt>* aIndices ) const;
       
   220 
       
   221     /**
       
   222      * Set top listbox item index.
       
   223      *
       
   224      * @since 3.1
       
   225      * @param aIndex Actual listbox index.
       
   226      */
       
   227     void SetLbxTopItemIndex( TInt aIndex );
       
   228 
       
   229     /**
       
   230      * Set current listbox item index.
       
   231      *
       
   232      * @since 3.1
       
   233      * @param aIndex Actual listbox index.
       
   234      */
       
   235     void SetLbxCurrentItemIndex( TInt aIndex );
       
   236 
       
   237     /**
       
   238      * Set current listbox item index and highlight it.
       
   239      *
       
   240      * @since 3.1
       
   241      * @param aIndex Actual listbox index.
       
   242      */
       
   243     void SetLbxCurrentItemIndexAndDraw( TInt aIndex );
       
   244 
       
   245     /**
       
   246      * Clear listbox selection.
       
   247      *
       
   248      * @since 3.1
       
   249      */
       
   250     void ClearLbxSelection();
       
   251 
       
   252     /**
       
   253      * Sets list box backround text. This text is visible if the list box 
       
   254      * has no items.
       
   255      *
       
   256      * @param aText The text for the empty list box background.
       
   257      * @since 3.2
       
   258      */
       
   259 	void SetLbxEmptyTextL( const TDesC& aText );
       
   260 
       
   261     /**
       
   262      * Draws list box item index
       
   263      *
       
   264      * @since 3.2
       
   265      */
       
   266     void DrawLbxItem( TInt aIndex );
       
   267     
       
   268     /**
       
   269      * Set Find box's focus.
       
   270      *
       
   271      * @since 3.1
       
   272      * @param aFocus ETrue if set focus on FindBox. Otherwise, EFalse.
       
   273      */
       
   274     void SetFindBoxFocus( TBool aFocus );
       
   275 
       
   276     /**
       
   277      * Handle listbox item addition.
       
   278      *
       
   279      * @since 3.1
       
   280      */
       
   281     void HandleLbxItemAdditionL();
       
   282     
       
   283     /**
       
   284      * Handle listbox item addition, preserving the current display index.
       
   285      *
       
   286      * @since 3.1
       
   287      */
       
   288     void HandleLbxItemAdditionPreserveIndexL();
       
   289     
       
   290     /**
       
   291      * Handle listbox item removal.
       
   292      *
       
   293      * @since 3.1
       
   294      */
       
   295     void HandleLbxItemRemovalL();
       
   296 
       
   297     /**
       
   298      * Show/hide find box
       
   299      *
       
   300      * @since 3.1
       
   301      * @param aIsVisible ETrue to set findbox visible. Otherwise, EFalse
       
   302      */
       
   303     void SetFindBoxVisibilityL( TBool aIsVisible );
       
   304 
       
   305     /**
       
   306      * Determine find box visibility
       
   307      *
       
   308      * @since 3.1
       
   309      * @return ETrue if find box is currently visible, EFalse otherwise
       
   310      */
       
   311     TBool FindBoxVisibility();
       
   312 
       
   313     /**
       
   314      * Restore the PopupCBA of find box
       
   315      */
       
   316     void RestoreFindBoxPopupCBA();
       
   317 
       
   318     /**
       
   319      * Calculate the top index of the visible items
       
   320      *
       
   321      * @since 3.1
       
   322      * @param aBottomIndex the bottom index of the visible items
       
   323      * @return top index
       
   324      */
       
   325     TInt CalculateTopIndex( TInt aBottomIndex );
       
   326 
       
   327     /**
       
   328      * Creates the container
       
   329      *
       
   330      * @since 3.1
       
   331      * @param aCollectionType collection type
       
   332      */
       
   333     void ConstructContainerL( TMPXCommonContainerCollectionType aCollectionType );
       
   334 
       
   335     /**
       
   336      * Enable/disable find box     
       
   337      * 
       
   338      * @since 3.1
       
   339      * @aEnable ETrue to enable find box, EFalse to disable
       
   340      */
       
   341     void EnableFindBox( TBool aEnable );
       
   342     
       
   343     /**
       
   344      * Enable/disable marking     
       
   345      * 
       
   346      * @since 3.1
       
   347      * @aEnable ETrue to enable marking, EFalse to disable
       
   348      */
       
   349     void EnableMarking( TBool aEnable );
       
   350 
       
   351     /**
       
   352      * Custom handling of commands for markable lists.
       
   353      */
       
   354     void HandleMarkableListProcessCommandL( TInt aCommand );
       
   355 
       
   356     /**
       
   357      * Custom handling of menu pane for markable lists
       
   358      */
       
   359     void HandleMarkableListDynInitMenuPane(
       
   360         TInt aResourceId,
       
   361         CEikMenuPane* aMenuPane );
       
   362         
       
   363     /**
       
   364      * Handle listbox array events
       
   365      *
       
   366      *  @param aEvent list box event
       
   367      */
       
   368     void HandleListBoxArrayEventL( 
       
   369         MMPXCommonListBoxArrayObserver::TMPXCommonListBoxArrayEvents aEvent );
       
   370 
       
   371     /**
       
   372      * Handles key events.
       
   373      *
       
   374      * @param aKeyEvent The key event.
       
   375      * @param aType The type of key event.
       
   376      */
       
   377     TKeyResponse HandleKeyEventL(
       
   378         const TKeyEvent& aKeyEvent,
       
   379         TEventCode aType );
       
   380     
       
   381     /**
       
   382      * Activate the container
       
   383      */
       
   384     void ActivateContainerL();
       
   385 
       
   386     /**
       
   387      * Deactivate the container
       
   388      */
       
   389     void DeactivateContainerL();
       
   390 
       
   391     /**
       
   392      * Checks whether the container is active
       
   393      */
       
   394     TBool IsContainerActive();
       
   395 
       
   396 // from base class CCoeControl
       
   397 
       
   398     /**
       
   399      * From CCoeControl.
       
   400      * Handles key events.
       
   401      *
       
   402      * @param aKeyEvent The key event.
       
   403      * @param aType The type of key event.
       
   404      */
       
   405     TKeyResponse OfferKeyEventL(
       
   406         const TKeyEvent& aKeyEvent,
       
   407         TEventCode aType );
       
   408     
       
   409     /**
       
   410      * From CCoeControl.
       
   411      * Gets the control's help context.
       
   412      *
       
   413      * @param aContext The control's help context.
       
   414      */
       
   415     void GetHelpContext( TCoeHelpContext& aContext ) const;
       
   416     
       
   417     /**
       
   418      * From CoeControl.
       
   419      * Handles a change to the control's resources.
       
   420      *
       
   421      * @param aType A message UID value.
       
   422      */
       
   423     void HandleResourceChange( TInt aType );
       
   424     
       
   425     /**
       
   426      * From CoeControl.
       
   427      * Draw this application's view to the screen
       
   428      *
       
   429      * @param aRect the rectangle of this view that needs updating
       
   430      */
       
   431     void Draw( const TRect& aRect ) const;
       
   432     
       
   433 // from base class MCoeControlObserver
       
   434 
       
   435     /**
       
   436     * From MCoeControlObserver, Acts upon changes in the hosted control's state.
       
   437     * This class's implementation is trivial and should be able to be safely 
       
   438     * re-implemented in directly client-derived classes. For non-base setting
       
   439     * page classes, a call to the base class should be made.
       
   440     * @param aControl Control that caused the event. (not used in default implementation)
       
   441     * @param aEventType Type of the event. 
       
   442     */
       
   443     void HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType);
       
   444 
       
   445 // from base class IAlfWidgetEventHandler
       
   446 
       
   447     /**
       
   448      * From IAlfWidgetEventHandler
       
   449      * Indicates whether event is accepted
       
   450      *
       
   451      * @param aControl widget control
       
   452      * @param aEvent the ALF event
       
   453      */
       
   454     bool accept( CAlfWidgetControl& aControl, const TAlfEvent& aEvent ) const;
       
   455 
       
   456     /**
       
   457      * From IAlfWidgetEventHandler
       
   458      * Sets the active states of the event handler
       
   459      *
       
   460      * @param aStates active states
       
   461      */
       
   462     void setActiveStates( unsigned int aStates );
       
   463 
       
   464     /**
       
   465      * From IAlfWidgetEventHandler
       
   466      * Performs the appropriate action for the ALF event
       
   467      *
       
   468      * @param aControl widget control
       
   469      * @param aEvent the ALF event.
       
   470      * @return TRUE if event consumed
       
   471      */
       
   472     AlfEventStatus offerEvent( CAlfWidgetControl& aControl, const TAlfEvent& aEvent );
       
   473 
       
   474     /**
       
   475      * From IAlfWidgetEventHandler
       
   476      * Make event handler interface using the specified type
       
   477      * @param aType
       
   478      */
       
   479     IAlfInterfaceBase* makeInterface( const IfId& aType );
       
   480 
       
   481     /**
       
   482      * From IAlfWidgetEventHandler
       
   483      * Sets the event handler data
       
   484      *
       
   485      * @param aData event handler initialization data
       
   486      */
       
   487     void setEventHandlerData(const AlfWidgetEventHandlerInitData& aData);
       
   488 
       
   489     /**
       
   490      * From IAlfWidgetEventHandler
       
   491      * Returns pointer to the event handler data
       
   492      */
       
   493     AlfWidgetEventHandlerInitData* eventHandlerData();
       
   494 
       
   495     /**
       
   496      * From IAlfWidgetEventHandler
       
   497      * Returns the type of EventHandler.
       
   498      * @see IAlfWidgetEventHandler::AlfEventHandlerType
       
   499      *
       
   500      * @return The type of event handler.
       
   501      */
       
   502     AlfEventHandlerType eventHandlerType();
       
   503 
       
   504     /**
       
   505      * From IAlfWidgetEventHandler
       
   506      * Returns information about the phase in the event handling cycle in
       
   507      * which the event hadler will be executed.
       
   508      * @see IAlfWidgetEventHandler::AlfEventHandlerExecutionPhase
       
   509      *
       
   510      * @return Event handler execution phase.
       
   511      */
       
   512     AlfEventHandlerExecutionPhase eventExecutionPhase();
       
   513 
       
   514 public: // from base class IMulModelProvider
       
   515 
       
   516     void ProvideData( int aStartIndex, int aCount, MulDataPath aPath );
       
   517 
       
   518 public: // from base class MThumbnailManagerObserver
       
   519 
       
   520     /**
       
   521      * From MThumbnailManagerObserver
       
   522      * Preview thumbnail generation or loading is complete.
       
   523      *
       
   524      * @param aThumbnail     An object representing the resulting thumbnail.
       
   525      * @param aId            Request ID for the operation
       
   526      */
       
   527     void ThumbnailPreviewReady( MThumbnailData& aThumbnail, TThumbnailRequestId aId );
       
   528 
       
   529     /**
       
   530      * From MThumbnailManagerObserver
       
   531      * Final thumbnail bitmap generation or loading is complete.
       
   532      *
       
   533      * @param aError         Error code.
       
   534      * @param aThumbnail     An object representing the resulting thumbnail.
       
   535      * @param aId            Request ID for the operation.
       
   536      */
       
   537     void ThumbnailReady( TInt aError, MThumbnailData& aThumbnail, TThumbnailRequestId aId );
       
   538 
       
   539 public: // from base class MMPXCommonContainerSearchFieldObserver
       
   540 
       
   541     /**
       
   542      * From MMPXCommonContainerSearchFieldObserver
       
   543      * Call when filtering word changes. Causes filtering to be updated.
       
   544      * Calling with zero-length filtering word stops filtering.
       
   545      *
       
   546      * @param aWord New filtering word.
       
   547      */
       
   548     void NewFilteringWordL( const TDesC& aWord );
       
   549 
       
   550 private:
       
   551 
       
   552     /**
       
   553      * Create list box
       
   554      */
       
   555     void CreateListBoxL();
       
   556 
       
   557     /**
       
   558      * Constructs Find box.
       
   559      *
       
   560      * @param aIsFindPopup ETrue if findbox is a popup type.
       
   561      *                     EFalse if finsbox is a fixed type.
       
   562      */
       
   563     void ConstructFindBoxL( TBool aIsFindPopup );
       
   564 
       
   565     /**
       
   566      * Creates icon array, populates iIconArray to be used by listbox
       
   567      */
       
   568     void CreateIconArrayL();
       
   569 
       
   570     /**
       
   571      * Creates the display item from the media
       
   572      */
       
   573     MulVisualItem* CreateDisplayedItemL( TInt aIndex );
       
   574 
       
   575     /**
       
   576      * Adds detail to the list item at the specified index
       
   577      */
       
   578     void AddDetailToDisplayedItemL( MulVisualItem* aVisualItem, CMPXMedia* aMedia, TInt aIndex );
       
   579 
       
   580     void SetTitleL( MulVisualItem* aVisualItem, CMPXMedia* aMedia );
       
   581     void SetDetailCountL( MulVisualItem* aVisualItem, CMPXMedia* aMedia );
       
   582     void SetDetailArtistL( MulVisualItem* aVisualItem, CMPXMedia* aMedia );
       
   583     void SetDetailAlbumL( MulVisualItem* aVisualItem, CMPXMedia* aMedia );
       
   584     void SetDetailDurationL( MulVisualItem* aVisualItem, CMPXMedia* aMedia );
       
   585     void UpdateTimeIndicatorsL( TDes& aBuf, TInt aDuration );
       
   586     void SetDetailIndicatorL( MulVisualItem* aVisualItem, TInt aIndex );
       
   587     void SetDetailIconL( MulVisualItem* aVisualItem, TInt aIndex );
       
   588     void SetDetailThumbnailL( MulVisualItem* aVisualItem, CMPXMedia* aMedia, TInt aIndex );
       
   589 
       
   590     /**
       
   591      * Set the collection context
       
   592      */
       
   593     void SetCollectionContextL();
       
   594 
       
   595     /**
       
   596      * Opens search field.
       
   597      */
       
   598     void ActivateSearchFieldL();
       
   599 
       
   600     /**
       
   601      * Closes search field, if open.
       
   602      */
       
   603     void DeactivateSearchField();
       
   604 
       
   605 private: // data
       
   606 
       
   607     /**
       
   608      * Context of collection view. It's the exact location within collection navigation
       
   609      * based on category type + category.
       
   610      */
       
   611     enum TContext
       
   612         {
       
   613         EContextUnknown,
       
   614         EContextGroupCollection,
       
   615         EContextGroupArtist,
       
   616         EContextGroupAlbum,
       
   617         EContextGroupPlaylist,
       
   618         EContextGroupSong,
       
   619         EContextGroupPodcast,
       
   620         EContextGroupGenre,
       
   621         EContextGroupComposer,
       
   622         EContextItemArtist,
       
   623         EContextItemAlbum,
       
   624         EContextItemPlaylist,
       
   625         EContextItemSong,
       
   626         EContextItemPodcast,
       
   627         EContextItemGenre,
       
   628         EContextItemComposer
       
   629         };
       
   630 
       
   631     struct TThumnailReq
       
   632         {
       
   633         TThumbnailRequestId iReqId;
       
   634         TInt                iIndex;
       
   635         };
       
   636 
       
   637     MMPXViewContainer*          iViewContainer;         // Not owned
       
   638     MEikCommandObserver*        iView;                  // Not owned
       
   639     MEikListBoxObserver*        iListBoxObserver;       // Not owned
       
   640     CMPXCommonListBoxArrayBase* iListBoxArray;          // Owned
       
   641     CArrayFixFlat<TInt>*        iListSelections;        // Owned
       
   642     CAknIconArray*              iIconArray;             // Owned
       
   643 
       
   644 //    CAknSearchField*            iFindBox;  // Owned
       
   645 
       
   646     CMPXCommonContainerTextureManager*  iTextureManager;// Owned
       
   647 	CMPXCommonUiHelper*         iCommonUiHelper;        // Owned
       
   648 
       
   649     CAlfEnv*                    iEnv;                   // Not owned
       
   650     IMulListWidget*             iListWidget;            // Not owned
       
   651     IMulModel*                  iWidgetModel;           // Not owned
       
   652     IAlfViewWidget*             iViewWidget;            // Not owned
       
   653 
       
   654     CThumbnailManager*          iThumbnailManager;      // Owned
       
   655     RArray<TThumnailReq>        iThumbnailReqArray;     // Owned
       
   656 
       
   657     CMPXCommonContainerSearchFieldWrapper* iSearchFieldWrapper;  // Owned
       
   658     CMPXCommonContainerFilteredList* iFilteredList;     // Owned
       
   659 
       
   660     TContext                    iContext;
       
   661     TInt                        iResourceOffset;        // Must be freed
       
   662 
       
   663     TBool                       iIsFindPopup;
       
   664     TBool                       iIsFindEnabled;
       
   665     TBool                       iIsMarkingEnabled;
       
   666 
       
   667 	TInt						iTopIndex;
       
   668 	TInt						iBottomIndex;
       
   669 	TInt						iIconHeight;
       
   670 	TInt						iIconWidth;
       
   671 	TInt						iIndicatorHeight;
       
   672 	TInt						iIndicatorWidth;
       
   673 
       
   674     TBool                       iAlfEnvCreated;
       
   675     TMPXCommonContainerCollectionType  iCollectionType;
       
   676     TBool                       iContainerActive;
       
   677     };
       
   678 
       
   679 #endif  // CMPXCOMMONCONTAINERHITCHCOCKIMP_H
       
   680 
       
   681 // End of File