/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: smilmedia  declaration

*

*/

#ifndef SMILMEDIA_H

#define SMILMEDIA_H

//  INCLUDES

#include <e32base.h>

#include <smilmediainterface.h>

#include <smilfocusinterface.h>

#include "smiltimecontainer.h"

#include "smilregioninterface.h"

// FORWARD DECLARATIONS

class MSmilMediaRenderer;

class CSmilTransitionFilter;

class CSmilTransition;

class CSmilArea;

// CLASS DECLARATION

class CSmilMedia : public CSmilTimeContainer, public MSmilMedia, public MSmilFocus

    {

    public:  // Constructors and destructor

		virtual const TDesC* ClassName() const { _LIT(KN,"CSmilMedia"); return &KN; }

		static CSmilMedia* NewL(CSmilPresentation* aPresentation);

        virtual ~CSmilMedia();

    public: // New functions

		/**

		* Returns the region where this media is supposed to be rendered on. May be NULL.

		*/ 

		MSmilRegion* GetRegion() const;

		/**

		* Returns the rectangle (region) where the media is supposed to be rendered on.

		*/

		TRect GetRectangle() const;

		/**

		* Invoked by renderer to ask redrawing of area covered by the media. 

		* This should be invoked when (visual) media appears, there are changes to it, and 

		* when it is removed.

		*/

		void Redraw();

		/** 

		* Invoked by a MSmillMediaRenderer object when there is a change 

		* in (known) state of its intrinsic values. For example, duration of 

		* video clip is not typically known until it is at least partially 

		* decoded. This method should be invoked by the renderer when this 

		* information becomes available.

		*/

		void RendererDurationChangedL();

		/**

		* Invoked by a MSmillMediaRenderer object when the associated media 

		* ends (end of the file or stream is reached). Renderer should also 

		* move to frozen state at this point (that is, to keep showing the last 

		* frame). 

		*/

		void RendererAtEndL();

		/**

		* Presentation

		*/

		CSmilPresentation* Presentation() const;

		/**

		 * Get name media parameter, or empty TPtrC if not found

		 */

		TPtrC GetParam(const TDesC& aName) const;

        /**

		 * Returns begin time of media relative to presentation begin time.

		 */

		TSmilTime MediaBegin() const;

        /**

		 * Returns end time of media relative to presentation begin time.

		 */

		TSmilTime MediaEnd() const;

		TPtrC Src() const { return iSrc.Text(); }

		TPtrC Alt() const { return iAlt.Text(); }

		TPtrC Type() const { return iType.Text(); }

		void SetAltL( const TDesC &aPtr );

		void SetSrcL( const TDesC& aString );	

		void SetTypeL( const TDesC& aString );

		void ForceRepeat( TBool aBool );	        		

		void SetRegion( MSmilRegion* aRegion ) { iRegion=aRegion; }

		MSmilMediaRenderer* GetRenderer() const { return iRenderer; }

		void TransitionFilterEnd(CSmilTransitionFilter* );

		void SetFocus(TBool aFocus) { iFocus = aFocus;}

		TBool HasFocus() const { return iFocus; }

		TBool IsFocusable() const;

		void SetFocusable(TBool aFocusable) { iFocusable = aFocusable;}

		void Unfreeze();	

		virtual void SetPaused(TBool aPaused);

		TPoint Center() const { return GetRectangle().Center(); }

		TSmilTime ClipBegin() { return iClipBegin; }

		TSmilTime ClipEnd() { return iClipEnd; }

		void AfterL(MSmilActive* iActive, const TSmilTime& aDelay, TBool aLazy = EFalse);

		void CancelActive(MSmilActive* aActive);

		CSmilTransitionFilter* ActiveTransitionFilter() const;

		void AddParamL(const TDesC& aName, const TDesC& aValue);

		TBool IsVisible() const;

		TBool IsScrollable() const;

		TSmilTime PredictedRemovalTime() const;

		CSmilArea* GetArea();

    protected:  // Functions from base classes

		CSmilMedia();

		virtual void ProceedL( const TSmilTime& aTime );

		virtual void ResolveL( const TSmilTime& aTps );

		virtual void RepeatL( const TSmilTime& aTime );

		virtual void BeginL( const TSmilTime& aTime );

		virtual void EndL( const TSmilTime& aTime );

		virtual TSmilTime ImplicitDuration() const;

		TSmilTime NextActivation( const TSmilTime& aTime ) const;

		TBool IsMedia() const { return ETrue; }			

		// from MSmilFocus

		TRect Rect() const { return GetRectangle(); }

		TShape Shape() const { return ERect; }

		const CArrayFixFlat<TPoint>* PolyPoints() const { return 0; }

		TBool IsSelected() const;

	private:

		void CreateRendererL(const TSmilTime& aRecalcTime);

	protected:

		RSmilTextBuf			iSrc;

		RSmilTextBuf			iAlt;

		RSmilTextBuf			iType;

		TBool					iFocus;

		TBool					iFocusable;

    private:    // Data

		MSmilRegion*			iRegion;

		MSmilMediaRenderer*		iRenderer;

		CSmilTransitionFilter*	iTransitionFilter;

	public:		

		CSmilTransition*		iTransitionIn;		

		CSmilTransition*		iTransitionOut;	

		struct CNameValuePair

			{

			~CNameValuePair() { delete iName; delete iValue; }

			HBufC* iName;

			HBufC* iValue;

			};

		RPointerArray<CNameValuePair> iParams;

		TSmilTime iClipBegin;

		TSmilTime iClipEnd;

    };

#endif      // ?INCLUDE_H   

// End of File