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 hg lib.

    15 *

    16 */

    17 

    18 

    19 

    20 #ifndef CMPXCOMMONCONTAINERHGIMP_H

    21 #define CMPXCOMMONCONTAINERHGIMP_H

    22 

    23 

    24 // INCLUDES

    25 #include <e32hashtab.h>

    26 #include <ganes/HgScrollBufferObserverIface.h>

    27 #include <ganes/HgSelectionObserverIface.h>

    28 #include <ganes/HgItem.h>

    29 #include <thumbnailmanager.h>

    30 #include <thumbnailmanagerobserver.h>

    31 

    32 #include <mpxattribute.h>

    33 #include "mpxcommoncontainer.h"

    34 

    35 

    36 // FORWARD DECLARATIONS

    37 class MEikCommandObserver;

    38 class CEikMenuPane;

    39 class MEikListBoxObserver;

    40 class CAknIconArray;

    41 class CMPXCommonListBoxArrayBase;

    42 class CMPXMediaArray;

    43 class CAknSearchField;

    44 class MCoeControlObserver;

    45 class CMPXCommonContainerMediaHelper;

    46 class CMPXCommonContainerTextureManager2;

    47 class CMPXCommonUiHelper;

    48 class CHgScroller;

    49 class CHgScrollerWithTitle;

    50 class CAknsBasicBackgroundControlContext;

    51 

    52 //Albumart request queue

    53 struct TAlbumArtRequest

    54 	{

    55   TInt        iIndex;

    56 	HBufC*		iAlbumArtUri;

    57   TSglQueLink iLink;

    58 	};

    59 

    60 

    61 // CLASS DECLARATION

    62 

    63 /**

    64  *  Container class for Hg common container.

    65  *  The view class should implement the following virtual function

    66  *  from MEikCommandObserver

    67  *

    68  *  virtual void ProcessCommandL(TInt aCommandId);

    69  *

    70  *  common container uses this to pass commands back to the view class

    71  *  the commands supported are defined in mpxcommoncontainer.hrh

    72  *

    73  *  view container class owns this class to access List widget commands, receive

    74  *  CoeControl events and GetHelpContext(). The view container class should

    75  *  implement the following virtual functions from MViewContainer

    76  *

    77  *  virtual void HandleKeyEvent();

    78  *  virtual void HandleHelpContent();

    79  *

    80  *  common container uses this to pass CoeControl events back to the view

    81  *  container class.

    82  *

    83  *  view class should handle the following commands in ProcessCommandL

    84  *  from MEikCommandObserver:

    85  *

    86  *  EMPXCmdCommonDelete  // delete key pressed

    87  *  EMPXCmdCommonResourceChange  // resource change

    88  *  EMPXCmdCommonEnterKey  // enter key pressed

    89  *

    90  *  @lib mpxcommoncontainer.lib

    91  *  @since S60 v3.1

    92  */

    93 NONSHARABLE_CLASS( CMPXCommonContainerHgImp )

    94     : public CCoeControl

    95     , public MCoeControlObserver

    96     , public MMPXCommonContainer

    97 	, public MHgScrollBufferObserver

    98 	, public MHgSelectionObserver

    99     , public MThumbnailManagerObserver

   100     {

   101 public:

   102 

   103     /**

   104      * default C++ constructor.

   105      */

   106     CMPXCommonContainerHgImp();

   107 

   108     /**

   109      * Destructor.

   110      */

   111     virtual ~CMPXCommonContainerHgImp();

   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 aRect the rectangle that defines the control's extent.

   332      */

   333     void ConstructContainerL( TMPXCommonContainerCollectionType /*aCollectionTyp*/ );

   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 // from base class CCoeControl

   387 

   388     /**

   389      * From CCoeControl.

   390      * Handles key events.

   391      *

   392      * @param aKeyEvent The key event.

   393      * @param aType The type of key event.

   394      */

   395     TKeyResponse OfferKeyEventL(

   396         const TKeyEvent& aKeyEvent,

   397         TEventCode aType );

   398 

   399     /**

   400      * From CCoeControl.

   401      * Gets the control's help context.

   402      *

   403      * @param aContext The control's help context.

   404      */

   405     void GetHelpContext( TCoeHelpContext& aContext ) const;

   406 

   407     /**

   408      * From CoeControl.

   409      * Handles a change to the control's resources.

   410      *

   411      * @param aType A message UID value.

   412      */

   413     void HandleResourceChange( TInt aType );

   414 

   415     /**

   416      * From CoeControl.

   417      * Draw this application's view to the screen

   418      *

   419      * @param aRect the rectangle of this view that needs updating

   420      */

   421     void Draw( const TRect& aRect ) const;

   422 

   423     /**

   424      * From CoeControl.

   425      * Get the control input capabilities

   426      */

   427 	TCoeInputCapabilities InputCapabilities() const;

   428 

   429 // from base class MCoeControlObserver

   430 

   431     /**

   432     * From MCoeControlObserver, Acts upon changes in the hosted control's state.

   433     * This class's implementation is trivial and should be able to be safely

   434     * re-implemented in directly client-derived classes. For non-base setting

   435     * page classes, a call to the base class should be made.

   436     * @param aControl Control that caused the event. (not used in default implementation)

   437     * @param aEventType Type of the event.

   438     */

   439     void HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType);

   440 

   441 

   442 // from base class MHgScrollBufferObserver

   443 

   444     /**

   445      * from MHgScrollBufferObserver

   446      * Buffer position changed.

   447      * The items between the aBufferStart and aBufferEnd should be loaded as soon as possible.

   448      *

   449      * @param aBufferStart The index of the first item in buffer.

   450      * @param aBufferEnd The index of the last item in buffer.

   451      * @param aDirection report direction of scrolling

   452      */

   453     void Request(TInt aBufferStart, TInt aBufferEnd, THgScrollDirection aDirection);

   454 

   455 // from base class MHgBufferOwner

   456 

   457     /**

   458      * from MHgBufferOwner

   459      *

   460      *

   461      */

   462     void Release(TInt aReleaseStart, TInt aReleaseEnd);

   463 

   464 

   465 // from base class MHgSelectionObserver

   466 

   467     /**

   468      * Handle selection.

   469      *

   470      * @param aIndex Selected item index.

   471      */

   472     void HandleSelectL( TInt aIndex );

   473 

   474     /**

   475      * Handle opening.

   476      *

   477      * @param aIndex Opened item index.

   478      */

   479     void HandleOpenL( TInt aIndex );

   480 

   481 public: // from base class MThumbnailManagerObserver

   482 

   483     /**

   484      * From MThumbnailManagerObserver

   485      * Preview thumbnail generation or loading is complete.

   486      *

   487      * @param aThumbnail     An object representing the resulting thumbnail.

   488      * @param aId            Request ID for the operation

   489      */

   490     void ThumbnailPreviewReady( MThumbnailData& aThumbnail, TThumbnailRequestId aId );

   491 

   492     /**

   493      * From MThumbnailManagerObserver

   494      * Final thumbnail bitmap generation or loading is complete.

   495      *

   496      * @param aError         Error code.

   497      * @param aThumbnail     An object representing the resulting thumbnail.

   498      * @param aId            Request ID for the operation.

   499      */

   500     void ThumbnailReady( TInt aError, MThumbnailData& aThumbnail, TThumbnailRequestId aId );

   501 

   502     TTypeUid::Ptr MopSupplyObject(TTypeUid aId);

   503 

   504 

   505 private:

   506 

   507     /**

   508      * Create list box

   509      */

   510     void CreateListBoxL( TInt count );

   511 

   512     /**

   513      * Create list box with Title

   514      */

   515     void CreateListBoxWithTitleL( TInt count );

   516 

   517 

   518     /**

   519      * Creates icon array, populates iIconArray to be used by listbox

   520      */

   521     void CreateIconArrayL();

   522 

   523     /**

   524      * Sets default icon for HgList

   525      */

   526     void SetDefaultIconL();

   527 

   528     /**

   529      * Sets default icon for list item

   530      */

   531     void SetDefaultIconL(TInt aIndex);

   532 

   533     /*

   534 	 * Adds detail to the list item at the specified index

   535      */

   536     void AddDetailToDisplayedItemL( CHgItem* aVisualItem, CMPXMedia* aMedia, TInt aIndex);

   537     void AddThumbnailToDisplayedItemL( CHgItem* aVisualItem, CMPXMedia* aMedia, TInt aIndex);

   538     void SetTitleL( CHgItem* aVisualItem, CMPXMedia* aMedia );

   539     void SetDetailCountL( CHgItem* aVisualItem, CMPXMedia* aMedia );

   540     void SetDetailArtistL( CHgItem* aVisualItem, CMPXMedia* aMedia );

   541     void SetDetailAlbumL( CHgItem* aVisualItem, CMPXMedia* aMedia );

   542     void SetDetailDurationL( CHgItem* aVisualItem, CMPXMedia* aMedia );

   543     void UpdateTimeIndicatorsL( TDes& aBuf, TInt aDuration );

   544     void SetDetailIndicatorL( CHgItem* aVisualItem, TInt aIndex );

   545     void SetDetailIconL( CHgItem* aVisualItem, TInt aIndex );

   546     void SetDetailThumbnailL( CMPXMedia* aMedia, TInt aIndex = 0 );

   547 

   548     /**

   549      * Set the collection context

   550      */

   551     void SetCollectionContextL();

   552 

   553     void ProvideDataL( TInt aStart, TInt aEnd );

   554 

   555     void SetScrollbarType();

   556 

   557     void CancelTNRequest();

   558 

   559     /**

   560       * Save the selected album item

   561       *

   562       */

   563     void SaveSelectedAlbumItemL();

   564 

   565     /**

   566      * Write the album name, artist name and album art in media data to file

   567      *

   568      * @param aMedia         the selected media data in Album view

   569      */

   570     void WriteToStreamFileL( const CMPXMedia* aMedia );

   571 

   572     /**

   573      * Read the album name, artist name and album art from file

   574      *

   575      * @param aMedia         the media data will be returned

   576      */

   577     void ReadFromStreamFileL( CMPXMedia* aMedia );

   578 

   579     /**

   580      * Refresh list as needed

   581      */

   582     void RefreshL(TInt aIndex);

   583 

   584     /**

   585      * Refresh list as needed

   586      */

   587     void RefreshNoThumbnailL(TInt aIndex);

   588     

   589 	/**

   590 	* Clean AlbumArt request Queue

   591 	*/

   592     void CleanAlbumArtReqQueue();

   593 

   594     /**

   595      * Handle requests in visible area

   596      * @param aBufferStart  the starting buffer index

   597      * @param aBufferEnd  the ending buffer index

   598      */

   599     void ProvideDataIntersectL(TInt aBufferStart, TInt aBufferEnd);

   600 

   601     /**

   602      * Refresh list as needed

   603      * @param aBufferStart  the starting buffer index

   604      * @param aBufferEnd  the ending buffer index

   605      */

   606     void ProvideDataDifferenceL(TInt aBufferStart, TInt aBufferEnd);

   607     void ProvideDataWithoutThumbnailsL(const CMPXMediaArray& aMediaArray, TInt aStartIndex = 0);

   608 

   609 private: // data

   610 

   611     /**

   612      * Context of collection view. It's the exact location within collection navigation

   613      * based on category type + category.

   614      */

   615     enum TContext

   616         {

   617         EContextUnknown,

   618         EContextGroupCollection,

   619         EContextGroupArtist,

   620         EContextGroupAlbum,

   621         EContextGroupPlaylist,

   622         EContextGroupSong,

   623         EContextGroupPodcast,

   624         EContextGroupGenre,

   625         EContextGroupComposer,

   626         EContextItemArtist,

   627         EContextItemAlbum,

   628         EContextItemPlaylist,

   629         EContextItemSong,

   630         EContextItemPodcast,

   631         EContextItemGenre,

   632         EContextItemComposer

   633         };

   634 

   635     enum TDefaultIcon

   636         {

   637         EMPXDefaultIconNotSet = -1,

   638         EMPXDefaultIconArtist,

   639         EMPXDefaultIconAlbum,

   640         EMPXDefaultIconPlaylist,

   641         EMPXDefaultIconSongs,

   642         EMPXDefaultIconPodcasts,

   643         EMPXDefaultIconGenre,

   644         EMPXDefaultIconComposer,

   645         EMPXDefaultTitleIconPodcasts,

   646         EMPXDefaultIconEmpty

   647         };

   648 

   649     MMPXViewContainer*          iViewContainer;         // Not owned

   650     MEikCommandObserver*        iView;                  // Not owned

   651     MEikListBoxObserver*        iListBoxObserver;       // Not owned

   652     CMPXCommonListBoxArrayBase* iListBoxArray;          // Owned

   653     CArrayFixFlat<TInt>*        iListSelections;        // Owned

   654     CAknIconArray*              iIconArray;             // Owned

   655 

   656     CMPXCommonContainerTextureManager2*  iTextureManager;// Owned

   657 	CMPXCommonUiHelper*         iCommonUiHelper;        // Owned

   658 

   659     CHgScroller* 				iListWidget;  		    // Owned

   660     CHgScroller* 				iPrevListWidget;  		    // Owned

   661     CHgScrollerWithTitle*       iScrollerWithTitle;

   662     CThumbnailManager*          iThumbnailManager;      // Owned

   663 

   664     TContext                    iContext;

   665     TContext                    iPrevContext;

   666     TInt                        iResourceOffset;        // Must be freed

   667     TBool                       iIsMarkingEnabled;

   668 	TInt						iTopIndex;

   669 	TInt						iBottomIndex;

   670 	TSize						iImageSize;

   671     CAknsBasicBackgroundControlContext* iBgContext; 	// Owned

   672 

   673     typedef RHashMap<TInt, TInt> RThumbnailReqHashMap;

   674     RThumbnailReqHashMap iThumbnailReqHashMap;

   675 

   676     HBufC* iEpisodeTitle;

   677     HBufC* iAlbumTitle;

   678     HBufC* iSongTitle;

   679 

   680     TBool iPodcastContext;

   681     TBool iTitleSet;

   682     TDefaultIcon iCurrentDefaultIcon;

   683     TFileName iSelectedAlbumItemFileName;

   684     CMPXMedia* iSelectedMediaInAlbumView;

   685     // Queue for Albumart asynchronous requests

   686     TSglQue<TAlbumArtRequest>   iRequestQueue;

   687     TAlbumArtRequest*           iAlbumArtRequest;

   688     TInt                        iRequestCount;

   689     TInt  iQueueCounter;

   690     

   691     THgScrollDirection iDirection;

   692     RArray<TBool>  iThumbnailReqMap;

   693     TInt  iLastValidMediaItemIndex;

   694     TInt iRequestStart;

   695     TInt iRequestEnd;

   696 

   697     };

   698 

   699 #endif  // CMPXCOMMONCONTAINERHGIMP_H

   700 

   701 // End of File