mpxplugins/viewplugins/views/podcastview/inc/mpxpodcastcollectionviewimp.h
changeset 0 ff3acec5bc43
child 18 c54d95799c80
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 podcast collection view implementation
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 
       
    20 #ifndef C_CMPXPODCASTCOLLECTIONVIEWIMP_H
       
    21 #define C_CMPXPODCASTCOLLECTIONVIEWIMP_H
       
    22 
       
    23 
       
    24 // INCLUDES
       
    25 #include <eikspmod.h>
       
    26 #include <eikclb.h>
       
    27 #include <AknProgressDialog.h>  // MProgressDialogCallback
       
    28 #include <eikprogi.h>
       
    29 #include <AknWaitDialog.h>
       
    30 #include <mpxmediageneraldefs.h>
       
    31 #include <mpxcollectionobserver.h>
       
    32 #include <mpxplaybackobserver.h>
       
    33 #include <mpxcollectionuihelper.h>
       
    34 #include <mpxcollectionuihelperobserver.h>
       
    35 #include <mpxcollectionhelper.h>
       
    36 #include <mpxcollectionpath.h>  // TMPXItemId
       
    37 #include <mpxviewactivationobserver.h>
       
    38 #include "mpxpodcastcollectionview.h"
       
    39 
       
    40 #include "mpxplaybackframeworkdefs.h" // TMPXPlaybackPlayerType
       
    41 
       
    42 // FORWARD DECLARATIONS
       
    43 class CMPXPodcastCollectionViewContainer;
       
    44 class MMPXCollectionUtility;
       
    45 class CMPXCollectionPlaylist;
       
    46 class MMPXPlaybackUtility;
       
    47 class CMPXCommonUiHelper;
       
    48 class MMPXViewUtility;
       
    49 class CSendUi;
       
    50 class CAknNavigationDecorator;
       
    51 class CAknNaviLabel;
       
    52 class CAknNavigationControlContainer;
       
    53 class CEikButtonGroupContainer;
       
    54 
       
    55 class MMPXPlayerManager;
       
    56 class CAiwServiceHandler;
       
    57 #ifdef UPNP_INCLUDED
       
    58 class CUpnpCopyCommand;
       
    59 #endif
       
    60 // CLASS DECLARATION
       
    61 
       
    62 /**
       
    63  *  MPX Podcast Collection view.
       
    64  *
       
    65  *  @lib mpxpodcastcollectionview.lib
       
    66  *  @since S60 v3.0
       
    67  */
       
    68 NONSHARABLE_CLASS( CMPXPodcastCollectionViewImp ) : public CMPXPodcastCollectionView,
       
    69                                              public MMPXCollectionObserver,
       
    70                                              public MMPXPlaybackObserver,
       
    71                                              public MMPXPlaybackCallback,
       
    72                                              public MEikListBoxObserver,
       
    73                                              public MProgressDialogCallback,
       
    74                                              public MMPXCollectionFindObserver,
       
    75                                              public MMPXCHelperObserver,
       
    76                                              public MMPXViewActivationObserver,
       
    77                                              public MCoeViewDeactivationObserver,
       
    78                                              public MCoeViewActivationObserver
       
    79     {
       
    80 public:
       
    81 
       
    82     /**
       
    83      * Two-phased constructor.
       
    84      *
       
    85      * @since 3.0
       
    86      * @return Pointer to newly created object.
       
    87      */
       
    88     static CMPXPodcastCollectionViewImp* NewL();
       
    89 
       
    90     /**
       
    91      * Two-phased constructor.
       
    92      *
       
    93      * @since 3.0
       
    94      * @return Pointer to newly created object.
       
    95      */
       
    96     static CMPXPodcastCollectionViewImp* NewLC();
       
    97 
       
    98     /**
       
    99      * Destructor.
       
   100      */
       
   101     virtual ~CMPXPodcastCollectionViewImp();
       
   102 
       
   103     /**
       
   104      * Delete the selected items
       
   105      *
       
   106      * @ since 3.0
       
   107      */
       
   108     void DeleteSelectedItemsL();
       
   109 
       
   110 private:
       
   111 
       
   112     /**
       
   113      * C++ default constructor.
       
   114      */
       
   115     CMPXPodcastCollectionViewImp();
       
   116 
       
   117     /**
       
   118      * By default Symbian 2nd phase constructor is private.
       
   119      */
       
   120     void ConstructL();
       
   121 
       
   122     /**
       
   123      * Updates list box
       
   124      *
       
   125      * @param aEntries Podcast collection entries opened. Method may
       
   126      *                 update the entries array by removing the playing item
       
   127      *                 if currently within Never Played list view.
       
   128      * @param aIndex focused entry
       
   129      */
       
   130     void UpdateListBoxL(CMPXMedia& aEntries,
       
   131                         TInt aIndex );
       
   132 
       
   133     /**
       
   134      * Displays error notes.
       
   135      *
       
   136      * @param aError Error ID to be handled.
       
   137      */
       
   138     void HandleErrorL( TInt aError );
       
   139 
       
   140     /**
       
   141      * Updates the navi pane
       
   142      */
       
   143     void UpdateNaviPaneL();
       
   144 
       
   145     /**
       
   146      * Updates the title pane
       
   147      */
       
   148     void UpdateTitlePaneL();
       
   149 
       
   150     /**
       
   151      * Updates the option menu
       
   152      *
       
   153      */
       
   154     void UpdateOptionMenuL();
       
   155 
       
   156     /**
       
   157      * Start either the delete progress note
       
   158      */
       
   159     void StartProgressNoteL();
       
   160 
       
   161     /**
       
   162      * Updates the progress note text and progress bar
       
   163      * 
       
   164      * @param	aProgress 		Indicates the portion of the process completed
       
   165      * @param 	aProgressText	Text to be displayed on the progress note  	
       
   166      */
       
   167     void UpdateProcessL(TInt aProgress,const TDesC& aProgressText);
       
   168 
       
   169     /**
       
   170      * Updates the copy to remote menu attachment
       
   171      *
       
   172      */
       
   173     void UpdateCopyToRemoteMenu(TInt aMenuPane);
       
   174 
       
   175     /**
       
   176      * Updates playback status/indicatior
       
   177      * @param aStatusChangeFlag flag to indicate if a status change
       
   178      *        has indeed been detected
       
   179      * Returns the current selection index if the paths match
       
   180      */
       
   181     TInt UpdatePlaybackStatusL(TBool aStatusChangeFlag);
       
   182 
       
   183     /**
       
   184      * Change the button group
       
   185      *
       
   186      * @aResId resource ID
       
   187      */
       
   188     void SetNewCbaL( TInt aResId );
       
   189 
       
   190     /**
       
   191      * Display collection details
       
   192      *
       
   193      * @param aMedia media object containing the library details
       
   194      */
       
   195     void ShowCollectionDetailsL( const CMPXMedia& aMedia );
       
   196 
       
   197     /**
       
   198      * Handles Upnp menus from DynInitMenuPaneL()
       
   199      *
       
   200      * @param aResourceId the id of the resource being initialized
       
   201      * @param aMenuPane the menu pane the resource belongs to
       
   202      */
       
   203     void HandleDynInitUpnpL( TInt aResourceId, CEikMenuPane& aMenuPane );
       
   204 
       
   205     /**
       
   206      * Checks if UPnP AP is defined
       
   207      *
       
   208      * @return ETrue if visible, EFalse otherwise
       
   209      */
       
   210     TBool IsUpnpVisible();
       
   211 
       
   212     /**
       
   213      * Displays the available players in the Play via submenu
       
   214      *
       
   215      * @param aMenuPane Menu pane to put the sub menu items
       
   216      */
       
   217     void AddPlayersNamesToMenuL( CEikMenuPane& aMenuPane );
       
   218 
       
   219     /**
       
   220      * Adds one player type to the Play via submenu
       
   221      *
       
   222      * @param aMenuPane menu pane to add player name to
       
   223      * @param aCommandId ID of the command
       
   224      * @param aPlayerManager player manager
       
   225      * @param aPlayerType type of the player
       
   226      * @param aMenuText optional menu text
       
   227      */
       
   228     void AddPlayerNameToMenuL( CEikMenuPane& aMenuPane,
       
   229                                TInt aCommandId,
       
   230                                MMPXPlayerManager& aPlayerManager,
       
   231                                TMPXPlaybackPlayerType& aPlayerType,
       
   232                                const TDesC& aMenuText = KNullDesC );
       
   233 
       
   234     /**
       
   235      * Retrieves the current player name and type
       
   236      */
       
   237     void GetCurrentPlayerDetails();
       
   238 
       
   239     /**
       
   240      * Selects a new player for audio playback
       
   241      *
       
   242      * @param aCommand Command Id to identify which player to use
       
   243      */
       
   244     void SelectNewPlayerL( TInt aCommand );
       
   245 
       
   246     /**
       
   247      * Copies selected file(s) to remote player
       
   248      */
       
   249     void CopySelectedItemsToRemoteL();
       
   250 
       
   251     /**
       
   252      * Handle call back from collectionframework for Copy to Remote command
       
   253      *
       
   254      * @param aMedia media
       
   255      * @param aComplete all selected medias have been found
       
   256      */
       
   257     void DoHandleCopyToRemoteL(const CMPXMedia& aMedia,
       
   258                                TBool aComplete = ETrue );
       
   259 
       
   260 
       
   261     /**
       
   262      * checks if send option should be shown the option is selected
       
   263      *
       
   264      * @return ETrue if send command should be hided, EFalse if it should be shown
       
   265      */
       
   266     TBool SendOptionVisibilityL();
       
   267 
       
   268     /**
       
   269      * Checks if file details option should be shown
       
   270      *
       
   271      * @return ETrue if the command should be hiden, EFalse if it should be shown
       
   272      */
       
   273     TBool FileDetailsOptionVisibilityL();
       
   274 
       
   275     /**
       
   276      * Handle send command
       
   277      */
       
   278     void DoSendL();
       
   279 
       
   280     /**
       
   281      * Handle call back from collectionframework for send command
       
   282      *
       
   283      * @param aMedia media
       
   284      * @param aError error code
       
   285      */
       
   286     void DoHandleSendL(const CMPXMedia& aMedia, TInt aError );
       
   287     /**
       
   288      * Prepares media object for selected items
       
   289      *
       
   290      * @param aMedia on return, populates the media object with a media array
       
   291      *        containing info for currently selected items used by playlist
       
   292      *        does not own this object
       
   293      *
       
   294      * @return error code
       
   295      */
       
   296     TInt PrepareMediaForSelectedItemsL( CMPXMedia* aMedia );
       
   297 
       
   298     /**
       
   299      * Set/clears the flags for item in database
       
   300      * @param aIndex index of the item in the list box
       
   301      * @param aMedia media object containing at least the following attribute:
       
   302      *        TMPXAttribute( KMPXMediaIdGeneral,EMPXMediaGeneralCollectionId )
       
   303      * @param aFlag flag to set/clear
       
   304      * @param aSet ETrue to set the flag, EFalse to clear the flag
       
   305      * @param aEnableInfoDialog ETrue to enable info dialog display, EFalse to disable
       
   306      */
       
   307     void UpdateDatabaseFlagL( TInt aIndex,
       
   308                               const CMPXMedia& aMedia,
       
   309                               TUint aFlag,
       
   310                               TBool aSet,
       
   311                               TBool aEnableInfoDialog = ETrue );
       
   312 
       
   313     /**
       
   314      * Handle playback message
       
   315      *
       
   316      * @param aMessage playback message
       
   317      */
       
   318     void DoHandlePlaybackMessageL( const CMPXMessage& aMessage );
       
   319 
       
   320     /**
       
   321      * Handle collection message
       
   322      *
       
   323      * @param aMessage collection message
       
   324      */
       
   325     void DoHandleCollectionMessageL( const CMPXMessage& aMessage );
       
   326 
       
   327     /**
       
   328      * Updates a media to the collection
       
   329      * @param aMedia media to update
       
   330      * @param aSync synchronous operation or not
       
   331      */
       
   332     void DoSetCollectionL( CMPXMedia* aMedia, TBool aSync );
       
   333 
       
   334 #ifdef __ENABLE_MSK
       
   335     /**
       
   336      * Updates the middle softkey display to a label or icon depending on whether
       
   337      * there are marked indices
       
   338      * @param aMskId middle softkey command id
       
   339      */
       
   340     void UpdateMiddleSoftKeyDisplayL( TInt aMskId );
       
   341 #endif // __ENABLE_MSK
       
   342 
       
   343     /**
       
   344      * Changes the selected episode(s) status to Played /unplayed
       
   345      * @param aPlayed played status to set (EFalse: unplayed)
       
   346      */
       
   347     void SetPlayedStatusL( TBool aPlayed );
       
   348 
       
   349     /**
       
   350      * From MProgressDialogCallback
       
   351      * Callback method
       
   352      * Get's called when a dialog is dismissed.
       
   353      */
       
   354     void DialogDismissedL( TInt aButtonId );
       
   355 
       
   356     /**
       
   357      * From MMPXCollectionObserver
       
   358      * Handle collection message.
       
   359      *
       
   360      * @param aMessage Collection message
       
   361      * @param aErr system error code.
       
   362      */
       
   363     void HandleCollectionMessage(
       
   364         CMPXMessage* aMessage, TInt aError );
       
   365 
       
   366     /**
       
   367      *  From MMPXCollectionObserver
       
   368      *  Handles the collection entries being opened. Typically called
       
   369      *  when client has Open()'d a folder
       
   370      *
       
   371      *  @param aEntries collection entries opened
       
   372      *  @param aIndex focused entry
       
   373      *  @param aComplete ETrue no more entries. EFalse more entries
       
   374      *                   expected
       
   375      *  @param aError error code
       
   376      */
       
   377     void HandleOpenL(const CMPXMedia& aEntries,
       
   378                      TInt aIndex,
       
   379                      TBool aComplete,
       
   380                      TInt aError );
       
   381 
       
   382     /**
       
   383      *  From MMPXCollectionObserver
       
   384      *  Handles the collection entries being opened. Typically called
       
   385      *  when client has Open()'d an item. Client typically responds by
       
   386      *  'playing' the item
       
   387      *
       
   388      *  @param aPlaylist Podcast collection path to item
       
   389      *  @param aError error code
       
   390      */
       
   391     void HandleOpenL(const CMPXCollectionPlaylist& aPlaylist,
       
   392                      TInt aError );
       
   393 
       
   394     /**
       
   395      *
       
   396      *  From MMPXCollectionObserver
       
   397      *  Handle media properties
       
   398      *
       
   399      *  @param aMedia media
       
   400      *  @param aError error code
       
   401      */
       
   402     void HandleCollectionMediaL(const CMPXMedia& aMedia,
       
   403                                 TInt aError );
       
   404 
       
   405 // from base class MMPXCHelperObserver
       
   406 
       
   407     /**
       
   408      * From MMPXCHelperObserver
       
   409      * Handles the completion of any collection helper event.
       
   410      *
       
   411      * @param aOperation, operation completed
       
   412      * @param aErr. the error code
       
   413      * @param aArgument Argument returned from the operation
       
   414      */
       
   415     void HandleOperationCompleteL( TCHelperOperation aOperation,
       
   416                                    TInt aErr,
       
   417                                    void* aArgument );
       
   418 
       
   419 // from base class MMPXPlaybackObserver
       
   420 
       
   421     /**
       
   422      * From MMPXPlaybackObserver
       
   423      * Handle playback message
       
   424      *
       
   425      * @since 3.0
       
   426      * @param aMessage playback message
       
   427      * @param aErr system error code.
       
   428      */
       
   429     void HandlePlaybackMessage( CMPXMessage* aMessage, TInt aError );
       
   430 
       
   431 // from base class MMPXPlaybackCallback
       
   432 
       
   433     /**
       
   434      * From MMPXPlaybackCallback
       
   435      * Handle playback property
       
   436      *
       
   437      * @since 3.0
       
   438      * @param aProperty the property
       
   439      * @param aValue the value of the property
       
   440      * @param aError error code
       
   441      */
       
   442     void HandlePropertyL(TMPXPlaybackProperty aProperty,
       
   443                          TInt aValue,
       
   444                          TInt aError );
       
   445 
       
   446     /**
       
   447      * From MMPXPlaybackCallback
       
   448      * Method is called continously until aComplete=ETrue, signifying that
       
   449      * it is done and there will be no more callbacks
       
   450      * Only new items are passed each time
       
   451      *
       
   452      * @since 3.0
       
   453      * @param aPlayer UID of the subplayer
       
   454      * @param aSubPlayers a list of sub players
       
   455      * @param aComplete ETrue no more sub players. EFalse more subplayer
       
   456      *                  expected
       
   457      * @param aError error code
       
   458      */
       
   459     void HandleSubPlayerNamesL(TUid aPlayer,
       
   460                                const MDesCArray* aSubPlayers,
       
   461                                TBool aComplete,
       
   462                                TInt aError );
       
   463 
       
   464     /**
       
   465      * From MMPXPlaybackCallback
       
   466      * Handle media properties
       
   467      *
       
   468      * @since 3.0
       
   469      * @param aMedia media
       
   470      * @param aError error code
       
   471      */
       
   472     void HandleMediaL(const CMPXMedia& aMedia,
       
   473                       TInt aError );
       
   474 
       
   475 // from base class CAknView
       
   476 
       
   477     /**
       
   478      * From CAknView
       
   479      * Returns views id.
       
   480      *
       
   481      * @since 3.0
       
   482      * @return Views Uid
       
   483      */
       
   484     TUid Id() const;
       
   485 
       
   486     /**
       
   487      * From CAknView
       
   488      * Command handling function.
       
   489      *
       
   490      * @since 3.0
       
   491      * @param aCommand Command which is handled
       
   492      */
       
   493     void HandleCommandL( TInt aCommand );
       
   494 
       
   495     /**
       
   496      * From CAknView
       
   497      * Handles a view activation.
       
   498      *
       
   499      * @param aPrevViewId Specifies the view previously active.
       
   500      * @param aCustomMessageId Specifies the message type.
       
   501      * @param aCustomMessage The activation message.
       
   502      */
       
   503     void DoActivateL(const TVwsViewId& aPrevViewId,
       
   504                      TUid aCustomMessageId,
       
   505                      const TDesC8& aCustomMessage );
       
   506 
       
   507     /**
       
   508      * From CAknView
       
   509      * View deactivation function.
       
   510      */
       
   511     void DoDeactivate();
       
   512 
       
   513     /**
       
   514      * From CAknView
       
   515      * Foreground event handling function.
       
   516      *
       
   517      * @param aForeground Indicates the required focus state of the control.
       
   518      */
       
   519     void HandleForegroundEventL( TBool aForeground );
       
   520 
       
   521 // from base class MEikMenuObserver
       
   522 
       
   523     /**
       
   524      * From MEikMenuObserver
       
   525      * Dynamically initialises a menu pane.
       
   526      *
       
   527      * @param aResourceId The ID of the menu pane.
       
   528      * @param aMenuPane The menu pane itself.
       
   529      */
       
   530     void DynInitMenuPaneL(TInt aResourceId,
       
   531                           CEikMenuPane* aMenuPane );
       
   532 
       
   533 // from MEikListBoxObserver
       
   534 
       
   535     /**
       
   536      * Handles listbox events.
       
   537      *
       
   538      * @param aListBox Listbox where the event occurred.
       
   539      * @param aEventType Event type.
       
   540      */
       
   541      void HandleListBoxEventL(CEikListBox* aListBox,
       
   542                               TListBoxEvent aEventType );
       
   543 
       
   544 // from MEikCommandObserver
       
   545 
       
   546     /**
       
   547      * Processes user commands.
       
   548      *
       
   549      * @param aCommandId ID of the command to respond to.
       
   550      */
       
   551     virtual void ProcessCommandL(TInt aCommandId);
       
   552 
       
   553 // from MMPXCollectionFindObserver
       
   554 
       
   555     /**
       
   556     *  Handle callback for "find" operation
       
   557     *  @param aEntries, CMPXMedia to be returned
       
   558     *  @param aComplete ETrue no more entries. EFalse more entries
       
   559     *                   expected
       
   560     *  @param aError error code
       
   561     */
       
   562     virtual void HandleFindAllL(const CMPXMedia& aResults,
       
   563                                 TBool aComplete,TInt aError);
       
   564 
       
   565     /**
       
   566      * Launch Nokia Podcasting Application
       
   567      *
       
   568      */
       
   569     void LaunchPodcastAppL();
       
   570 
       
   571     /**
       
   572      * Launch Nokia Podcasting Application
       
   573      *
       
   574      */
       
   575     TInt CheckPodcastAppL();
       
   576 
       
   577     /**
       
   578      * Helper method that checks to see if the specified episode is
       
   579      * currently playing.
       
   580      *
       
   581      * @param aItem id of item to check if currently playing
       
   582      * @return ETrue if item currently playing else EFalse
       
   583      */
       
   584     TBool IsCurrentlyPlayingL(const TMPXItemId& aItem);
       
   585 
       
   586 // from MMPXViewActivationObserver
       
   587 
       
   588    /**
       
   589     * From MMPXViewActivationObserver
       
   590     * Handle view activation.
       
   591     *
       
   592     * @param aCurrentViewType Current view type Uid.
       
   593     * @param aPreviousViewType Previous view type Uid.
       
   594     */
       
   595     void HandleViewActivation(
       
   596         const TUid& aCurrentViewType,
       
   597         const TUid& aPreviousViewType );
       
   598 
       
   599 // from MCoeViewActivationObserver
       
   600 
       
   601    /**
       
   602     * From MCoeViewActivationObserver
       
   603     * Handle view activation.
       
   604     *
       
   605     * @param aNewlyActivatedViewId newly activated view id.
       
   606     * @param aViewIdToBeDeactivated deactivated view id.
       
   607     */
       
   608     void HandleViewActivation(
       
   609         const TVwsViewId& aNewlyActivatedViewId,
       
   610         const TVwsViewId& aViewIdToBeDeactivated );
       
   611 
       
   612 // from MCoeViewDeactivationObserver
       
   613    /**
       
   614     * Handles view deactivation notification from view server
       
   615     */
       
   616     void HandleViewDeactivation(const TVwsViewId& aViewIdToBeDeactivated,
       
   617                                 const TVwsViewId& aNewlyActivatedViewId);
       
   618     
       
   619     /**
       
   620      * Stores the current list box item index.
       
   621      */
       
   622     void StoreListboxItemIndexL();
       
   623 
       
   624 private:    // Data
       
   625 
       
   626     CMPXPodcastCollectionViewContainer* iContainer;  // own
       
   627     MMPXCollectionUtility*      iCollectionUtility;  // not own
       
   628     MMPXPlaybackUtility*        iPlaybackUtility;
       
   629     MMPXViewUtility*            iViewUtility;
       
   630     CMPXCommonUiHelper*         iCommonUiHelper;
       
   631     MMPXCollectionUiHelper*     iCollectionUiHelper;
       
   632     CMPXMedia*                  iMediaToSet; // own
       
   633 
       
   634     CSendUi*                    iSendUi;
       
   635     HBufC*                      iTitle;
       
   636     HBufC*                      iNumEpisode;
       
   637     HBufC*                      iDuration;
       
   638     HBufC*                      iOriginalTitle;
       
   639     HBufC*                      iOriginalDuration;
       
   640     CArrayFix<TInt>*            iBottomIndex;
       
   641 
       
   642     TBool                       iBackOneLevel;
       
   643     TBool                       iPossibleJump;
       
   644     TBool                       iChangeRTForAllProfiles;
       
   645     TBool                       iIsWaitNoteCanceled;
       
   646     TBool                       iIsDeleting;
       
   647     TBool                       iHandlingKeyEvent;
       
   648     TBool                       iExitOptionHidden;
       
   649     TBool                       iIgnoreNextFocusChangedMessage;
       
   650 
       
   651     // HandleOpen was called and listbox was updated, only EFalse
       
   652     // when view is activated
       
   653     TBool                       iHandleOpenProcessed;
       
   654 
       
   655     TInt                        iCurrentMediaLOp;   // current mediaL operation
       
   656     TInt                        iCurrentFindAllLOp; // current FindAllL operation
       
   657     TInt                        iLastDepth;
       
   658     TInt                        iLastSelectedIndex;
       
   659     TInt                        iCurrNotYetPlayedListIndex;
       
   660     TInt                        iResourceOffset;        // must be freed
       
   661 #ifdef __ENABLE_MSK
       
   662     TInt                        iCurrentMskId;
       
   663     TBool                       iShowContextMenu;
       
   664 #endif // __ENABLE_MSK
       
   665 
       
   666     CAknNavigationDecorator*        iNaviDecorator;
       
   667     CAknNaviLabel*                  iNaviLabel;
       
   668     CAknNavigationControlContainer* iNaviPane;
       
   669 
       
   670     CEikButtonGroupContainer*       iCba; // owned
       
   671 
       
   672     RArray<TUid> iPlayersList;
       
   673     CAiwServiceHandler* iServiceHandler;
       
   674     TInt iErrorAttachCopyMenu;
       
   675     TMPXPlaybackPlayerType iCurrentPlayerType;
       
   676     TInt iCurrentlyAttachedCopyToMenuPane;
       
   677     HBufC* iSubPlayerName;
       
   678     TBool iUpnpFrameworkSupport;
       
   679 
       
   680     TMPXItemId iSelectedItem;
       
   681     // Progress note for delete
       
   682     CAknProgressDialog*	iProgressDialog;
       
   683     CEikProgressInfo*	iProgressInfo;
       
   684 #ifdef UPNP_INCLUDED
       
   685     CUpnpCopyCommand* iUpnpCopyCommand; 
       
   686 #endif
       
   687     };
       
   688 
       
   689 #endif  // C_CMPXPODCASTCOLLECTIONVIEWIMP_H
       
   690 
       
   691 // End of File