mobilemessaging/smilui/playerinc/SmilPlayerPresentationController.h
branchRCL_3
changeset 27 7fdbb852d323
parent 0 72b543305e3a
equal deleted inserted replaced
26:ebe688cedc25 27:7fdbb852d323
       
     1 /*
       
     2 * Copyright (c) 2003-2005 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: SmilPlayerPresentationController  declaration
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #ifndef SMILPLAYERPRESENTATIONCONTROLLER_H
       
    20 #define SMILPLAYERPRESENTATIONCONTROLLER_H
       
    21 
       
    22 // INCLUDES
       
    23 #include <coecntrl.h>
       
    24 
       
    25 #include <smilplayerinterface.h>
       
    26 #include <remconcoreapi.h> // TRemConCoreApiOperationId
       
    27 #include "SmilPlayer.hrh"
       
    28 #include <AknUtils.h>
       
    29 
       
    30 #include <MsgMedia.hrh>
       
    31 
       
    32 
       
    33 // FORWARD DECLARATIONS
       
    34 class MMediaFactoryFileInfo;
       
    35 class CSmilPlayerMediaFactory;
       
    36 class CSmilTransitionFactory;
       
    37 class CSmilPlayerDialog;
       
    38 class CAknWaitDialog;
       
    39 class CMDXMLDocument;
       
    40 class CMDXMLNode;
       
    41 class CMDXMLElement;
       
    42 class CSmilPlayerPresentationControl;
       
    43 class CAknNavigationDecorator;
       
    44 class CSmilPlayerIndicatorController;
       
    45 class CSendUi;
       
    46 
       
    47 class CAiwServiceHandler;
       
    48 
       
    49 // CLASS DECLARATION
       
    50 
       
    51 /**
       
    52 * Controller class of the presentation.
       
    53 */
       
    54 NONSHARABLE_CLASS(CSmilPlayerPresentationController) : public CCoeControl,
       
    55                                                        public MSmilPlayer
       
    56     {
       
    57     public: // Constructors and destructor
       
    58 
       
    59         /**
       
    60         * Static constructor.
       
    61         *
       
    62         * @param aRect            Control rectangle.
       
    63         * @param aBaseUrl         Base URL used to resolve relative URLs.
       
    64         * @param aFileInfo        Handle to the media objects.
       
    65         * @param aParent          Dialog class of this controller
       
    66         * @param aDOM             SMIL Document Object Model
       
    67         * @param aVolumeEnabled   Specified whether audio is enabled.
       
    68         *
       
    69         * @return pointer to the object
       
    70         */
       
    71         static CSmilPlayerPresentationController* NewL( const TRect& aRect,
       
    72                                                         const TDesC& aBaseUrl,
       
    73                                                         MMediaFactoryFileInfo* aFileInfo,
       
    74                                                         CSmilPlayerDialog* aParent,
       
    75                                                         CMDXMLDocument* aDOM,
       
    76                                                         TBool aVolumeEnabled );
       
    77         /**
       
    78         * Constructor.
       
    79         *
       
    80         * @param aRect            Control rectangle.
       
    81         * @param aBaseUrl         Base URL used to resolve relative URLs.
       
    82         * @param aFileInfo        Handle to the media objects.
       
    83         * @param aParent          Dialog class of this controller
       
    84         * @param aFileHandle      File handle to .smil file
       
    85         * @param aVolumeEnabled   Specified whether audio is enabled.
       
    86         *
       
    87         * @return pointer to the object
       
    88         */
       
    89         static CSmilPlayerPresentationController* NewL( const TRect& aRect,
       
    90                                                         const TDesC& aBaseUrl,
       
    91                                                         MMediaFactoryFileInfo* aFileInfo,
       
    92                                                         CSmilPlayerDialog* aParent,
       
    93                                                         RFile& aFileHandle,
       
    94                                                         TBool aVolumeEnabled );
       
    95 
       
    96         /**
       
    97         * Destructor.
       
    98         */
       
    99         virtual ~CSmilPlayerPresentationController();
       
   100 
       
   101     public: // New functions
       
   102         
       
   103         /**
       
   104         * Returns buffer bitmap
       
   105         *
       
   106         * @since 2.0
       
   107         *
       
   108         * @return Pointer to buffer bitmap.
       
   109         */
       
   110         inline CFbsBitmap* BufferBitmap();
       
   111 
       
   112         /**
       
   113         * Returns buffer bitmap context
       
   114         *
       
   115         * @since 2.0
       
   116         *
       
   117         * @return Pointer to buffer bitmap context..
       
   118         */
       
   119         inline CFbsBitGc* BufferContext();
       
   120 
       
   121         /**
       
   122         * Prepares presentation controller to dialog close.
       
   123         *
       
   124         * @since 2.0
       
   125         */
       
   126         void PrepareExitL();
       
   127 
       
   128         /**
       
   129         * Controller states
       
   130         */
       
   131         enum TSmilPresControllerStates
       
   132             {
       
   133             EStatePlay,
       
   134             EStateStop,
       
   135             EStatePause,
       
   136             EStateResume
       
   137             };
       
   138             
       
   139         /**
       
   140         * Changes presentation state. 
       
   141         *
       
   142         * @since 3.0
       
   143         *
       
   144         * @param aState New state.
       
   145         */
       
   146         void ChangeStateL( TSmilPresControllerStates aState );
       
   147 
       
   148         /**
       
   149         * Stops timers for pause and volume indicator.
       
   150         *
       
   151         * @since 2.0
       
   152         */
       
   153         void StopTimer();
       
   154 
       
   155         /**
       
   156         * Invalidates the redraw area
       
   157         *
       
   158         * @since 2.0
       
   159         *
       
   160         * @param aArea  Value of the invalidated area
       
   161         */
       
   162         void RedrawArea( const TRect& aArea ) const;
       
   163         
       
   164         /**
       
   165         * Returns the Presentation object of the player.
       
   166         *
       
   167         * @since 2.0
       
   168         *
       
   169         * @return CSmilPresentation
       
   170         */
       
   171         inline CSmilPresentation* Presentation();
       
   172 
       
   173         /**
       
   174         * Set the visibility of the status pane
       
   175         *
       
   176         * @since 2.0
       
   177         *
       
   178         * @param aValue Boolean value whether to make normal statuspane visible or not.
       
   179         */
       
   180         void SetStatusPaneVisibilityL( TBool aValue );
       
   181 
       
   182         /**
       
   183         * Returns whether achor exists.
       
   184         *
       
   185         * @since 2.0
       
   186         * 
       
   187         * @return ETrue if anchor exists otherwise EFalse is returned.
       
   188         */
       
   189         TBool AnchorExist() const;
       
   190 
       
   191         /**
       
   192         * Returns whether achor is to internal link.
       
   193         *
       
   194         * @since 2.0
       
   195         *
       
   196         * @return ETrue if anchor is to internal link otherwise EFalse is returned.
       
   197         */
       
   198         TBool AnchorIsInternalLink() const;
       
   199 
       
   200         /**
       
   201         * Returns whether focused object scrolling activation is enabled.
       
   202         *
       
   203         * @since 2.0
       
   204         * 
       
   205         * @return ETrue if scrolling activation is enabled otherwise EFalse is returned.
       
   206         */
       
   207         TBool ScrollingActivationEnabled() const;
       
   208 
       
   209         /**
       
   210         * Returns whether focused object is scrollable
       
   211         *
       
   212         * @since 2.0
       
   213         * 
       
   214         * @return ETrue if focused object is scrollable otherwise EFalse is returned.
       
   215         */
       
   216         TBool FocusedObjectScrollable() const;
       
   217 
       
   218         /**
       
   219         * Returns whether focused object scrolling deactivation is enabled.
       
   220         *
       
   221         * @since 2.0
       
   222         *
       
   223         * @return ETrue if scrolling deactivation is enabled otherwise EFalse is returned.
       
   224         */
       
   225         inline TBool ScrollingDeactivationEnabled() const;
       
   226 
       
   227         /**
       
   228         * Activates the focused object for scrolling
       
   229         *
       
   230         * @since 2.0
       
   231         */
       
   232         void ActivateScrollingL();
       
   233 
       
   234         /**
       
   235         * Deactivates the focused object from scrolling
       
   236         *
       
   237         * @since 2.0
       
   238         */
       
   239         void DeactivateScrollingL();
       
   240 
       
   241         /**
       
   242         * Activates the link defined in the focused object
       
   243         *
       
   244         * @since 2.0
       
   245         */
       
   246         inline void OpenLinkL();
       
   247 
       
   248         /**
       
   249         * Returns whether some object is focused.
       
   250         *
       
   251         * @since 2.0
       
   252         *
       
   253         * @return ETrue if object is focused otherwise EFalse is returned.
       
   254         */
       
   255         inline TBool ObjectFocused() const;
       
   256 
       
   257         /**
       
   258         * Switches status pane to the given one.
       
   259         *
       
   260         * @since 3.0
       
   261         *
       
   262         * @param aNewPaneResourceId New statuspane's resource ID
       
   263         * @param aSetOwnIndicators  Specifies whether own indicators should be used
       
   264         * @param aOldPaneResourceId Old statuspane resource ID for storing.
       
   265         *
       
   266         */
       
   267         void SwitchStatusPaneL( TInt aNewPaneResourceId,
       
   268                                 TBool aSetOwnIndicators, 
       
   269                                 TInt& aOldPaneResourceId );
       
   270 
       
   271         /**
       
   272         * Called just before activating
       
   273         *
       
   274         * @since 2.0
       
   275         *
       
   276         * @return ETrue if presentationcontroller is initialized ok otherwise EFalse.
       
   277         */
       
   278         TBool InitializeL();
       
   279         
       
   280         /**
       
   281         * Sets correct layout for the presentation controller.
       
   282         *
       
   283         * @since 3.0
       
   284         *
       
   285         */
       
   286         void LayoutPresentationL();
       
   287         
       
   288         /**
       
   289         * Indicates whether the presentation is overlapped by another
       
   290         * dialog (e.g. FindUi).
       
   291         * 
       
   292         * @return ETrue if overlapped, otherwise EFalse.
       
   293         */   
       
   294         TBool IsPresentationOverlapped();
       
   295 
       
   296         /**
       
   297         * Sets flag to indicate that the presentation is overlapped.
       
   298         * 
       
   299         * @param aOverlapped ETrue / EFalse for setting the flag likewise.
       
   300         */   
       
   301         void SetPresentationOverlapped( TBool aOverlapped );
       
   302         
       
   303         /**
       
   304         * Sets the correct presentation layout, when a dialog (e.g. FindUi)
       
   305         * is overlapping the presentation.
       
   306         */ 
       
   307         void LayoutOverlappedPresentation();
       
   308         
       
   309         /**
       
   310         * Sends an activation event to focused media.
       
   311         *
       
   312         * @since 3.0
       
   313         */
       
   314         void ActivateFocusedMediaL();
       
   315         
       
   316         /**
       
   317         * Handles Remote Control Server Operations.
       
   318         *
       
   319         * @since 3.0
       
   320         *
       
   321         * @param aOperation An operation ID to handle.
       
   322         */
       
   323         void HandleRCSOperation( TRemConCoreApiOperationId aOperation );
       
   324         
       
   325         /**
       
   326         * Handles scroll key event.
       
   327         *
       
   328         * @since 3.0
       
   329         *
       
   330         */
       
   331         TKeyResponse HandleScrollKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType );
       
   332 
       
   333         /**
       
   334         * Handles volume key event.
       
   335         *
       
   336         * @since 3.0
       
   337         *
       
   338         */
       
   339         TKeyResponse HandleVolumeKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType );
       
   340         
       
   341         /**
       
   342         * Returns all presentation's text on single buffer. Individual texts are separated
       
   343         * with two paragraph separators from each others.
       
   344         *
       
   345         * @since 3.0
       
   346         *
       
   347         * @return Text buffer. Buffer may be NULL and it must be otherwise freed by client.
       
   348         */
       
   349         HBufC* PresentationTextL();
       
   350         
       
   351         /**
       
   352         * Returns whether presentation have asked media type.
       
   353         *
       
   354         * @since 3.0
       
   355         
       
   356         * @param aType Enumeration of TSmilMediaType
       
   357         *
       
   358         * @return ETrue if presentation have asked media type otherwise EFalse.
       
   359         */
       
   360         TBool PresentationContains( const TMsgMediaType& aType ) const;
       
   361         
       
   362         /**
       
   363         * Handles the pointer-events. One tap activates area and
       
   364         *  second tap enables scrolling
       
   365         */                
       
   366         void HandlePointerEventL( const TPointerEvent& aPointerEvent );
       
   367         
       
   368         /**
       
   369         * Controls the taps on the corresponding area, 
       
   370         *   either playing or pausing the presentation after the tap
       
   371         */
       
   372         void PlayPauseTappedL();
       
   373         
       
   374         /**
       
   375         * Returns whether asked media type if focused.
       
   376         * 
       
   377         * @since 3.2
       
   378         * 
       
   379         * @param aMediaType Enumeration of TSmilMediaType
       
   380         *
       
   381         * @return ETrue if asked media type is focused otherwise EFalse.
       
   382         *
       
   383         */
       
   384         TBool IsFocused( const TMsgMediaType& aMediaType ) const;
       
   385 
       
   386         /**
       
   387         * Activates focused media object.
       
   388         */
       
   389         void ActivateFocusedL();
       
   390         
       
   391         /**
       
   392          * Returns SMIL players own statuspane current visibility.
       
   393          * 
       
   394          * @return ETrue if own statuspane is visible and EFalse if it is not.
       
   395          */
       
   396         TBool OwnStatusPaneVisible();
       
   397         
       
   398         /**
       
   399          * Returns whether wide screen statuspane should be used.
       
   400          * 
       
   401          * @return ETrue/EFalse Use/Don't use
       
   402          */
       
   403          static TBool UseWidescreenStatusPane();
       
   404 
       
   405         
       
   406     public: // Functions from base classes
       
   407 
       
   408         /** 
       
   409         * From MSmilPlayer
       
   410         * Returns the media factory object that is responsible of 
       
   411         * creating the media renderers
       
   412         *
       
   413         * @since 2.0
       
   414         *
       
   415         */
       
   416         inline virtual MSmilMediaFactory* GetMediaFactory(
       
   417                         const CSmilPresentation* aPres ) const;        
       
   418 
       
   419         /**
       
   420         * From MSmilPlayer  
       
   421         * Returns the transition factory object that is responsible of 
       
   422         * creating the transition renderers
       
   423         *
       
   424         * @since 2.0
       
   425         *
       
   426         */
       
   427         inline virtual MSmilTransitionFactory* GetTransitionFactory( 
       
   428                         const CSmilPresentation* aPres ) const;
       
   429         
       
   430         /** 
       
   431         * From MSmilPlayer
       
   432         * Evaluate a content control attribute for true or false. 
       
   433         * Attributes 
       
   434         *       systemOperatingSystem
       
   435         *       systemCPU
       
   436         *       systemScreenSize 
       
   437         *       systemScreenDepth 
       
   438         * are handled inside the SMIL engine, the rest are passed to this method.
       
   439         *
       
   440         * @since 2.0
       
   441         *
       
   442         */
       
   443         inline virtual TBool EvaluateContentControlAttribute(
       
   444                         const TDesC& aName, const TDesC& aValue );
       
   445 
       
   446         /** 
       
   447         * From MSmilPlayer
       
   448         * Return the dimensions of the drawing surface
       
   449         *
       
   450         * @since 2.0
       
   451         *
       
   452         */
       
   453         inline virtual TRect GetDimensions(const CSmilPresentation* aPres );
       
   454 
       
   455         /**
       
   456         * From MSmilPlayer  
       
   457         * Return the EIKON GUI control that is used as the view for the given 
       
   458         * presentation.
       
   459         *
       
   460         * SMIL Engine never calls this method. It might be used by 
       
   461         * implementations of MSmilMediaRenderer interface.
       
   462         *
       
   463         * @since 2.0
       
   464         *
       
   465         */
       
   466         inline virtual CCoeControl* GetControl(const CSmilPresentation* aPres );
       
   467 
       
   468         /** 
       
   469         * From MSmilPlayer
       
   470         * The engine calls this method to initiate redrawing of the given area. 
       
   471         * Implementation of this method should in turn call Draw method of the 
       
   472         * given presentation object.
       
   473         *
       
   474         * @since 2.0
       
   475         *
       
   476         */
       
   477         inline virtual void Redraw(TRect aArea, CSmilPresentation* aPres );
       
   478 
       
   479         /** 
       
   480         * This method is called by the engine as a result of hyperlink
       
   481         * activation. Player should open the given (relative to the
       
   482         * presentation base) url. However, the current presentation MUST NOT
       
   483         * be deleted during execution of this method, as this method is
       
   484         * invoked by the current presentation,
       
   485         * 
       
   486         * aAnchor - contains addition information about the link. can be 0.
       
   487         *
       
   488         * source/destination states: 
       
   489         * EPlay - (continue) play the presentation
       
   490         * EStop - stop the source presentation or open destination presentation
       
   491         *   in stopped state
       
   492         * EPause - pause the source presentation, continue it after,
       
   493         *   destination finishes
       
   494         *
       
   495         * 3GPP profile does not require respecting these states,
       
   496         *   aAnchor may be ignored
       
   497         *
       
   498         * @since 2.0
       
   499         *
       
   500         */
       
   501         virtual void OpenDocumentL(
       
   502                         const TDesC& aUrl,
       
   503                         const CSmilAnchor* aAnchor,
       
   504                         const CSmilPresentation* aPres );       
       
   505 
       
   506         /** 
       
   507         * Invoked when a presentation state changes. aEvent is 
       
   508         * EStarted - presentation started playing,
       
   509         * EStopped - presentation was stopped,
       
   510         * EPaused - presentation was paused
       
   511         * EResumed - paused presentation was resumed
       
   512         * ESeeked - presentation was seeked to a new position on timeline
       
   513         * EMediaNotFound - opening media failed, aText contains the media url
       
   514         * or
       
   515         * EEndReached - presentation has reached its end time. whether it is
       
   516         * paused or stopped depends on EndAction setting.
       
   517         * one of the negative system wide error codes (from a trapped leave
       
   518         * inside engine RunL() method). 
       
   519         * In this case the playing presentation is stopped automatically and
       
   520         * the presentation can not be restarted.
       
   521         *
       
   522         * @since 2.0
       
   523         *
       
   524         */
       
   525         virtual void PresentationEvent(
       
   526                         TInt aEvent,
       
   527                         const CSmilPresentation* aPres,
       
   528                         const TDesC& aText );
       
   529 
       
   530     private:
       
   531 
       
   532         /**
       
   533         * C++ constructor.
       
   534         */
       
   535         CSmilPlayerPresentationController( CMDXMLDocument* aDOM,
       
   536                                            MMediaFactoryFileInfo* aFileInfo,
       
   537                                            CSmilPlayerDialog* aParent,
       
   538                                            RFile& aFileHandle );
       
   539 
       
   540         /**
       
   541         * By default Symbian 2nd phase constructor is private.
       
   542         */
       
   543         void ConstructL( const TRect& aRect, const TDesC& aBaseUrl, TBool aVolumeEnabled );
       
   544 
       
   545     private: // New functions
       
   546 
       
   547         /**
       
   548         * Parses the presentation file
       
   549         */
       
   550         void DoParsingL();
       
   551 
       
   552         /**
       
   553         * Calls to references phone number
       
   554         */
       
   555         void CallL( const TDesC& aString );
       
   556 
       
   557         /**
       
   558         * Sends message (SMS, MMS or e-mail) to selected item
       
   559         */
       
   560         void SendMessageL( const TUid& aMtmUid, const TDesC& aString );
       
   561 
       
   562         /**
       
   563         * Goes to referenced URL
       
   564         */
       
   565         void GoToUrlL( const TDesC& aString );
       
   566 
       
   567         /**
       
   568         * Load text string and shows a confirm dialog
       
   569         */
       
   570         TBool LoadTextAndConfirmL( TInt aResourceId, const TDesC& aString ) const;
       
   571 
       
   572         /**
       
   573         * Shows confirm query to the user
       
   574         */
       
   575         TBool ShowConfirmQueryL( TInt aResource, const TDesC& aText ) const;
       
   576         
       
   577         /**
       
   578         * Resets the control state.
       
   579         */
       
   580         void Reset();
       
   581         
       
   582         /**
       
   583         * Sets correct layout for indicators.
       
   584         */  
       
   585         void LayoutIndicators();
       
   586         
       
   587         /**
       
   588         * Sets correct layout for presentation control.
       
   589         */
       
   590         void LayoutPresentationControl();
       
   591         
       
   592         /**
       
   593         * Performs volume change key handling.
       
   594         */ 
       
   595         TKeyResponse DoHandleVolumeKeyL( const TKeyEvent& aKeyEvent, TEventCode aType );
       
   596         
       
   597         /**
       
   598         * Performs Remote Control Operation handling.
       
   599         */
       
   600         void DoHandleRCSOperationL( TRemConCoreApiOperationId aOperation );
       
   601         
       
   602         /**
       
   603         * Initializes double buffer.
       
   604         */
       
   605         void InitializeDoubleBufferL();
       
   606         
       
   607     private: // Functions from base classes
       
   608 
       
   609         /**
       
   610         * From CoeControl,CountComponentControls.
       
   611         */
       
   612         TInt CountComponentControls() const;
       
   613 
       
   614         /**
       
   615         * From CCoeControl,ComponentControl.
       
   616         */
       
   617         CCoeControl* ComponentControl( TInt aIndex ) const;
       
   618 
       
   619         /**
       
   620         * From CCoeControl,Draw.
       
   621         */
       
   622         void Draw( const TRect& aRect ) const;
       
   623 
       
   624     private: // data
       
   625             
       
   626         // iDOM
       
   627         CMDXMLDocument* iDOM;
       
   628 
       
   629         // A Font and Bitmap server, which managed bitmap as a graphics device.
       
   630         CFbsBitmapDevice*               iBufferDevice;
       
   631 
       
   632         // Implementation of a bitmapped graphics context.
       
   633         CFbsBitGc*                      iBufferContext;
       
   634 
       
   635         // Presentation class to the engine
       
   636         CSmilPresentation*              iPresentation;
       
   637 
       
   638         // Factory class for the media
       
   639         CSmilPlayerMediaFactory*        iMediaFactory;
       
   640 
       
   641         // Factory class for the transitions
       
   642         CSmilTransitionFactory*         iTransitionFactory;
       
   643 
       
   644         // Store class for the medias
       
   645         MMediaFactoryFileInfo*          iFileInfo;
       
   646 
       
   647         // Dialog class for this class
       
   648         CSmilPlayerDialog*              iParent;
       
   649 
       
   650         // A bitmap managed by the Font and Bitmap server.
       
   651         // Provided to the CSmilTransitionFactory class.
       
   652         CFbsBitmap*                     iBufferBitmap;
       
   653 
       
   654         // Wait dialog.
       
   655         CAknWaitDialog* iWaitDialog;
       
   656         
       
   657         // SendUi 
       
   658         CSendUi* iSendUi;
       
   659 
       
   660         CAiwServiceHandler* iServiceHandler;
       
   661 
       
   662         //
       
   663         TBool iScrollingTogglePerformedWhileLinkExist;
       
   664 
       
   665         //
       
   666         TInt iLayoutResId;
       
   667 
       
   668         // Presentation control of the player
       
   669         CSmilPlayerPresentationControl* iPresentationControl;
       
   670         
       
   671         // Controller class for this class
       
   672         CAknNavigationDecorator* iIndicatorContainer;
       
   673         
       
   674         // Indicator controller.
       
   675         CSmilPlayerIndicatorController* iIndicatorController;
       
   676         
       
   677         //
       
   678         TBool iDOMInternallyOwned;
       
   679         
       
   680         //
       
   681         TRect iPresentationRect;
       
   682         
       
   683         // .smil file handle (can be KNullHandle).
       
   684         RFile iFileHandle;
       
   685         
       
   686         // Base URL that is used for resolving relative URLs.
       
   687         HBufC* iBaseUrl;
       
   688         
       
   689         // Flag to indicate that layout change is needed.
       
   690         TBool iChangeLayout;
       
   691         
       
   692         // Last selected object
       
   693         CSmilObject* iTappedObject;
       
   694         
       
   695         // Current visibility of own statuspane.
       
   696         TBool iOwnStatusPaneVisible;    
       
   697         
       
   698         // Flag to indicate if the presentation is overlapped by another dialog (e.g. FindUi)
       
   699         TBool iPresentationOverlapped;
       
   700     };
       
   701 
       
   702 #include "SmilPlayerPresentationController.inl"
       
   703 
       
   704 #endif // SMILPLAYERPRESENTATIONCONTROLLER_H
       
   705 
       
   706 // End of File