//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation.  All Rights Reserved.
//
//  File:       mstime.idl
//
//  Abstract:   Interface definitions for TIME components
//----------------------------------------------------------------------------
cpp_quote("//=--------------------------------------------------------------------------=")
cpp_quote("// mstime.h")
cpp_quote("//=--------------------------------------------------------------------------=")
cpp_quote("// (C) Copyright Microsoft Corporation.  All Rights Reserved.")
cpp_quote("//")
cpp_quote("// THIS CODE AND INFORMATION IS PROVIDED \"AS IS\" WITHOUT WARRANTY OF")
cpp_quote("// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO")
cpp_quote("// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A")
cpp_quote("// PARTICULAR PURPOSE.")
cpp_quote("//=--------------------------------------------------------------------------=")
cpp_quote("")

#include "mstimeid.h"
import "servprov.idl";

cpp_quote("#include <olectl.h>")
cpp_quote("#include <mstimeid.h>")
    
interface ITIMEElementCollection;
interface ITIMEState;
interface ITIMEPlayList;

[
    uuid(87C96271-ADDB-4745-B2E8-DF88A8472FD1),
    lcid(0x0000),
    version(1.0)
]
library MSTIME
{
    typedef enum _TimeState
    {
        TS_Inactive = 0,
        TS_Active   = 1,
        TS_Cueing   = 2,
        TS_Seeking  = 3,
        TS_Holding  = 4,
    } TimeState;

    importlib("STDOLE2.TLB");
    
    #include <olectl.h>

    [
        object,
        uuid(403E2540-4520-11D3-93AB-00A0C967A438),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEActiveElementCollection : IDispatch
    {
        [id(DISPID_ACTIVEELMENTS_LENGTH), propget] 
            HRESULT length([out, retval] long* p);
        [id(DISPID_ACTIVEELMENTS_NEWENUM), propget, restricted, hidden] 
            HRESULT _newEnum([out, retval] IUnknown** p);
        [id(DISPID_ACTIVEELMENTS_ITEM)] 
            HRESULT item( [defaultvalue("0"), in] VARIANT varIndex, [out, retval] VARIANT* pvarResult);
    }

    
    [
        object,
        uuid(1C2EF64E-F07D-4338-9771-9154491CD8B9),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEElement : IDispatch
    {
        // XML Attributes

        [propget, id(DISPID_TIMEELEMENT_ACCELERATE)]
        HRESULT accelerate([out, retval] VARIANT *);
        [propput, id(DISPID_TIMEELEMENT_ACCELERATE)]
        HRESULT accelerate([in] VARIANT);

        [propget, id(DISPID_TIMEELEMENT_AUTOREVERSE)]
        HRESULT autoReverse([out, retval] VARIANT *);
        [propput, id(DISPID_TIMEELEMENT_AUTOREVERSE)]
        HRESULT autoReverse([in] VARIANT );

        [propget, id(DISPID_TIMEELEMENT_BEGIN)]
        HRESULT begin([out, retval] VARIANT * time);
        [propput, id(DISPID_TIMEELEMENT_BEGIN)]
        HRESULT begin([in] VARIANT time);

        [propget, id(DISPID_TIMEELEMENT_DECELERATE)]
        HRESULT decelerate([out, retval] VARIANT * );
        [propput, id(DISPID_TIMEELEMENT_DECELERATE)]
        HRESULT decelerate([in] VARIANT);

        [propget, id(DISPID_TIMEELEMENT_DUR)]
        HRESULT dur([out, retval] VARIANT * time);
        [propput, id(DISPID_TIMEELEMENT_DUR)]
        HRESULT dur([in] VARIANT time);

        [propget, id(DISPID_TIMEELEMENT_END)]
        HRESULT end([out, retval] VARIANT * time);
        [propput, id(DISPID_TIMEELEMENT_END)]
        HRESULT end([in] VARIANT time);

        [propget, id(DISPID_TIMEELEMENT_FILL)]
        HRESULT fill([out, retval] BSTR * f);
        [propput, id(DISPID_TIMEELEMENT_FILL)]
        HRESULT fill([in] BSTR f);

        [propget, id(DISPID_TIMEELEMENT_MUTE)]
        HRESULT mute([out, retval] VARIANT * b);
        [propput, id(DISPID_TIMEELEMENT_MUTE)]
        HRESULT mute([in] VARIANT b);

        [propget, id(DISPID_TIMEELEMENT_REPEATCOUNT)]
        HRESULT repeatCount([out, retval] VARIANT * c);
        [propput, id(DISPID_TIMEELEMENT_REPEATCOUNT)]
        HRESULT repeatCount([in] VARIANT c);

        [propget, id(DISPID_TIMEELEMENT_REPEATDUR)]
        HRESULT repeatDur([out, retval] VARIANT * time);
        [propput, id(DISPID_TIMEELEMENT_REPEATDUR)]
        HRESULT repeatDur([in] VARIANT time);

        [propget, id(DISPID_TIMEELEMENT_RESTART)]
        HRESULT restart([out, retval] BSTR *);
        [propput, id(DISPID_TIMEELEMENT_RESTART)]
        HRESULT restart([in] BSTR );

        [propget, id(DISPID_TIMEELEMENT_SPEED)]
        HRESULT speed([out, retval] VARIANT * speed);
        [propput, id(DISPID_TIMEELEMENT_SPEED)]
        HRESULT speed([in] VARIANT speed);

        [propget, id(DISPID_TIMEELEMENT_SYNCBEHAVIOR)]
        HRESULT syncBehavior([out, retval] BSTR * sync);
        [propput, id(DISPID_TIMEELEMENT_SYNCBEHAVIOR)]
        HRESULT syncBehavior([in] BSTR sync);

        [propget, id(DISPID_TIMEELEMENT_SYNCTOLERANCE)]
        HRESULT syncTolerance([out, retval] VARIANT * tol);
        [propput, id(DISPID_TIMEELEMENT_SYNCTOLERANCE)]
        HRESULT syncTolerance([in] VARIANT tol);

        [propget, id(DISPID_TIMEELEMENT_SYNCMASTER)]
        HRESULT syncMaster([out, retval] VARIANT * b);
        [propput, id(DISPID_TIMEELEMENT_SYNCMASTER)]
        HRESULT syncMaster([in] VARIANT b);

        [propget, id(DISPID_TIMEELEMENT_TIMEACTION)]
        HRESULT timeAction([out, retval] BSTR * time);
        [propput, id(DISPID_TIMEELEMENT_TIMEACTION)]
        HRESULT timeAction([in] BSTR time);

        [propget, id(DISPID_TIMEELEMENT_TIMECONTAINER)]
        HRESULT timeContainer([out, retval] BSTR *);

        [propget, id(DISPID_TIMEELEMENT_VOLUME)]
        HRESULT volume([out, retval] VARIANT * val);
        [propput, id(DISPID_TIMEELEMENT_VOLUME)]
        HRESULT volume([in] VARIANT val);

        // Properties
        [propget, id(DISPID_TIMEELEMENT_CURRTIMESTATE)]
        HRESULT currTimeState([out, retval] ITIMEState ** TimeState);

        [propget, id(DISPID_TIMEELEMENT_TIMEALL)]
        HRESULT timeAll([out, retval] ITIMEElementCollection **allColl);

        [propget, id(DISPID_TIMEELEMENT_TIMECHILDREN)]
        HRESULT timeChildren([out, retval] ITIMEElementCollection **childColl);

        [propget, id(DISPID_TIMEELEMENT_TIMEPARENT)]
        HRESULT timeParent([out, retval] ITIMEElement ** parent);

        [propget, id(DISPID_TIMEELEMENT_ISPAUSED)]
        HRESULT isPaused([out, retval] VARIANT_BOOL * b);

        // Methods
        [id (DISPID_TIMEELEMENT_BEGINELEMENT)]
        HRESULT beginElement();

        [id (DISPID_TIMEELEMENT_BEGINELEMENTAT)]
        HRESULT beginElementAt([in] double parentTime);

        [id (DISPID_TIMEELEMENT_ENDELEMENT)]
        HRESULT endElement();

        [id (DISPID_TIMEELEMENT_ENDELEMENTAT)]
        HRESULT endElementAt([in] double parentTime);

        [id (DISPID_TIMEELEMENT_PAUSEELEMENT)]
        HRESULT pauseElement();

        [id (DISPID_TIMEELEMENT_RESET)]
        HRESULT resetElement();

        [id (DISPID_TIMEELEMENT_RESUMEELEMENT)]
        HRESULT resumeElement();

        [id (DISPID_TIMEELEMENT_SEEKACTIVETIME)]
        HRESULT seekActiveTime([in] double activeTime);
        
        [id (DISPID_TIMEELEMENT_SEEKSEGMENTTIME)]
        HRESULT seekSegmentTime([in] double segmentTime);
        
        [id (DISPID_TIMEELEMENT_SEEKTO)]
        HRESULT seekTo([in] LONG repeatCount, [in] double segmentTime);
        
        [id (DISPID_TIMEELEMENT_DOCUMENTTIMETOPARENTTIME)]
        HRESULT documentTimeToParentTime([in] double documentTime,
                                         [out, retval] double * parentTime);
        
        [id (DISPID_TIMEELEMENT_PARENTTIMETODOCUMENTTIME)]
        HRESULT parentTimeToDocumentTime([in] double parentTime,
                                         [out, retval] double * documentTime);
        
        [id (DISPID_TIMEELEMENT_PARENTTIMETOACTIVETIME)]
        HRESULT parentTimeToActiveTime([in] double parentTime,
                                       [out, retval] double * activeTime);
        
        [id (DISPID_TIMEELEMENT_ACTIVETIMETOPARENTTIME)]
        HRESULT activeTimeToParentTime([in] double activeTime,
                                       [out, retval] double * parentTime);
        
        [id (DISPID_TIMEELEMENT_ACTIVETIMETOSEGMENTTIME)]
        HRESULT activeTimeToSegmentTime([in] double activeTime,
                                       [out, retval] double * segmentTime);
        
        [id (DISPID_TIMEELEMENT_SEGMENTTIMETOACTIVETIME)]
        HRESULT segmentTimeToActiveTime([in] double segmentTime,
                                       [out, retval] double * activeTime);
        
        [id (DISPID_TIMEELEMENT_SEGMENTTIMETOSIMPLETIME)]
        HRESULT segmentTimeToSimpleTime([in] double segmentTime,
                                       [out, retval] double * simpleTime);
        
        [id (DISPID_TIMEELEMENT_SIMPLETIMETOSEGMENTTIME)]
        HRESULT simpleTimeToSegmentTime([in] double simpleTime,
                                       [out, retval] double * segmentTime);
        
        // Container attributes
        [propget, id(DISPID_TIMEELEMENT_ENDSYNC)]
        HRESULT endSync([out, retval] BSTR * es);
        [propput, id(DISPID_TIMEELEMENT_ENDSYNC)]
        HRESULT endSync([in] BSTR es);

        // Container Properties
        [propget, id(DISPID_TIMEELEMENT_ACTIVEELEMENTS)]
        HRESULT activeElements([out, retval] ITIMEActiveElementCollection **activeColl);

        [propget, id(DISPID_TIMEELEMENT_HASMEDIA)]
        HRESULT hasMedia([retval, out] VARIANT_BOOL * flag);

        // Container Methods
        [id (DISPID_TIMEELEMENT_NEXTELEMENT)]
        HRESULT nextElement();
        [id (DISPID_TIMEELEMENT_PREVELEMENT)]
        HRESULT prevElement();

        [propget, id(DISPID_TIMEELEMENT_UPDATEMODE)]
        HRESULT updateMode([out,retval] BSTR* updateMode);
        [propput, id(DISPID_TIMEELEMENT_UPDATEMODE)]
        HRESULT updateMode([in] BSTR updateMode);
    };

    //
    // ITIMEBodyElement
    //
    
    [
        object,
        uuid(8c90e348-ec0a-4229-90b0-e57d2ca45ccb),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEBodyElement : ITIMEElement
    {

    };

    [
        object,
        uuid(47a6972f-ae65-4a6b-ae63-d0c1d5307b58),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEMediaElement : ITIMEElement
    {
        // XML Attributes

        [propget, id(DISPID_TIMEMEDIAELEMENT_CLIPBEGIN)]
        HRESULT clipBegin([out, retval] VARIANT * time);
        [propput, id(DISPID_TIMEMEDIAELEMENT_CLIPBEGIN)]
        HRESULT clipBegin([in] VARIANT time);

        [propget, id(DISPID_TIMEMEDIAELEMENT_CLIPEND)]
        HRESULT clipEnd([out, retval] VARIANT * time);
        [propput, id(DISPID_TIMEMEDIAELEMENT_CLIPEND)]
        HRESULT clipEnd([in] VARIANT time);

        [propget, id(DISPID_TIMEMEDIAELEMENT_PLAYER)]
        HRESULT player([out, retval] VARIANT * id);
        [propput, id(DISPID_TIMEMEDIAELEMENT_PLAYER)]
        HRESULT player([in] VARIANT id);

        [propget, id(DISPID_TIMEMEDIAELEMENT_SRC)]
        HRESULT src([out, retval] VARIANT * url);
        [propput, id(DISPID_TIMEMEDIAELEMENT_SRC)]
        HRESULT src([in] VARIANT url);

        [propget, id(DISPID_TIMEMEDIAELEMENT_TYPE)]
        HRESULT type([out, retval] VARIANT * mimetype);
        [propput, id(DISPID_TIMEMEDIAELEMENT_TYPE)]
        HRESULT type([in] VARIANT mimetype);
 
        // Properties
        [propget, id(DISPID_TIMEMEDIAELEMENT_ABSTRACT)]
        HRESULT abstract([out, retval] BSTR *abs);
        
        [propget, id(DISPID_TIMEMEDIAELEMENT_AUTHOR)]
        HRESULT author([out, retval] BSTR *auth);
        
        [propget, id(DISPID_TIMEMEDIAELEMENT_COPYRIGHT)]
        HRESULT copyright([out, retval] BSTR *cpyrght);

        [propget, id(DISPID_TIMEMEDIAELEMENT_HASAUDIO)]
        HRESULT hasAudio([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAELEMENT_HASVISUAL)]
        HRESULT hasVisual([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAELEMENT_MEDIADUR)]
        HRESULT mediaDur([out, retval] double *dur);
        
        [propget, id(DISPID_TIMEMEDIAELEMENT_MEDIAHEIGHT)]
        HRESULT mediaHeight([out, retval] long *height);

        [propget, id(DISPID_TIMEMEDIAELEMENT_MEDIAWIDTH)]
        HRESULT mediaWidth([out, retval] long *width);
        
        [propget, id(DISPID_TIMEMEDIAELEMENT_PLAYEROBJECT)]
        HRESULT playerObject([out, retval] IDispatch **ppDisp);

        [propget, id(DISPID_TIMEMEDIAELEMENT_PLAYLIST)]
        HRESULT playList([out, retval] ITIMEPlayList** pPlayList);

        [propget, id(DISPID_TIMEMEDIAELEMENT_RATING)]
        HRESULT rating([out, retval] BSTR *rate);

        [propget, id(DISPID_TIMEMEDIAELEMENT_TITLE)]
        HRESULT title([out, retval] BSTR *name);

        [propget, id(DISPID_TIMEMEDIAELEMENT_HASPLAYLIST)]
        HRESULT hasPlayList([out, retval] VARIANT_BOOL * b);

        // Media Capabilities
        [propget, id(DISPID_TIMEMEDIAELEMENT_CANPAUSE)]
        HRESULT canPause([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAELEMENT_CANSEEK)]
        HRESULT canSeek([retval, out] VARIANT_BOOL * b);
    };

    [
        object,
        uuid(9EE29400-7EE6-453a-85B3-4EC28E0305B4),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEMediaElement2 : ITIMEMediaElement
    {

        [propget, id(DISPID_TIMEMEDIAELEMENT2_EARLIESTTIME)]
        HRESULT earliestMediaTime([out,retval] VARIANT * earliestMediaTime);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_LATESTTTIME)]
        HRESULT latestMediaTime([out,retval] VARIANT * latestMediaTime);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_MINBUFF)]
        HRESULT minBufferedMediaDur([out, retval] VARIANT * minBufferedMediaDur);
        [propput, id(DISPID_TIMEMEDIAELEMENT2_MINBUFF)]
        HRESULT minBufferedMediaDur([in] VARIANT minBufferedMediaDur);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_DLTOTAL)]
        HRESULT downloadTotal([out,retval] VARIANT * downloadTotal);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_DLCURRENT)]
        HRESULT downloadCurrent([out,retval] VARIANT * downloadCurrent);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_ISSTREAMED)]
        HRESULT isStreamed([out,retval] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_BUFPROG)]
        HRESULT bufferingProgress([out,retval] VARIANT * bufferingProgress);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_HASDLPROGRESS)]
        HRESULT hasDownloadProgress([out,retval] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_DLPROG)]
        HRESULT downloadProgress([out,retval] VARIANT * downloadProgress);

        [propget, id(DISPID_TIMEMEDIAELEMENT2_MIMETYPE)]
        HRESULT mimeType([out, retval] BSTR *mimeType);

        [id (DISPID_TIMEMEDIAELEMENT2_SEEKTOFRAME)]
        HRESULT seekToFrame([in] long frameNr);

        [id (DISPID_TIMEMEDIAELEMENT2_DECODEMIMETYPE)]
        HRESULT decodeMimeType([in] TCHAR * header, [in] long headerSize, [out] BSTR * mimeType);

        [propget, id(DISPID_TIMEMEDIAELEMENT_CURRFRAME)]
        HRESULT currentFrame([out, retval] long *currFrame);
        
    };

    [
        object,
        uuid(f383d66f-5e68-4fc2-b641-03672b543a49),
        dual,
        pointer_default(unique)
    ]
    interface ITIMETransitionElement : IDispatch
    {
        [propget, id(DISPID_TIMETRANSITIONELEMENT_TYPE)]
        HRESULT type([out, retval] VARIANT * type);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_TYPE)]
        HRESULT type([in] VARIANT type);

        [propget, id(DISPID_TIMETRANSITIONELEMENT_SUBTYPE)]
        HRESULT subType([out, retval] VARIANT * subtype);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_SUBTYPE)]
        HRESULT subType([in] VARIANT subtype);
        
        [propget, id(DISPID_TIMETRANSITIONELEMENT_DUR)]
        HRESULT dur([out, retval] VARIANT * dur);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_DUR)]
        HRESULT dur([in] VARIANT dur);

        [propget, id(DISPID_TIMETRANSITIONELEMENT_STARTPROGRESS)]
        HRESULT startProgress([out, retval] VARIANT * startProgress);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_STARTPROGRESS)]
        HRESULT startProgress([in] VARIANT startProgress);
    
        [propget, id(DISPID_TIMETRANSITIONELEMENT_ENDPROGRESS)]
        HRESULT endProgress([out, retval] VARIANT * endProgress);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_ENDPROGRESS)]
        HRESULT endProgress([in] VARIANT endProgress);

        [propget, id(DISPID_TIMETRANSITIONELEMENT_DIRECTION)]
        HRESULT direction([out, retval] VARIANT * direction);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_DIRECTION)]
        HRESULT direction([in] VARIANT direction);

        [propget, id(DISPID_TIMETRANSITIONELEMENT_REPEATCOUNT)]
        HRESULT repeatCount([out, retval] VARIANT * repeatCount);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_REPEATCOUNT)]
        HRESULT repeatCount([in] VARIANT repeatCount);

        [propget, id(DISPID_TIMETRANSITIONELEMENT_BEGIN)]
        HRESULT begin([out, retval] VARIANT * begin);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_BEGIN)]
        HRESULT begin([in] VARIANT begin);

        [propget, id(DISPID_TIMETRANSITIONELEMENT_END)]
        HRESULT end([out, retval] VARIANT * end);
        [propput, id(DISPID_TIMETRANSITIONELEMENT_END)]
        HRESULT end([in] VARIANT end);
    };

    [
        object,
        uuid(a74f14b1-b6a2-430a-a5e8-1f4e53f710fe),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEAnimationElement : ITIMEElement
    {
        [propget, id(DISPID_TIMEANIMATIONELEMENT_ATTRIBUTENAME)]
        HRESULT attributeName([out, retval] BSTR * attrib);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_ATTRIBUTENAME)]
        HRESULT attributeName([in] BSTR attrib);
 
        [propget, id(DISPID_TIMEANIMATIONELEMENT_BY)]
        HRESULT by([out, retval] VARIANT * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_BY)]
        HRESULT by([in] VARIANT val);
        
        [propget, id(DISPID_TIMEANIMATIONELEMENT_CALCMODE)]
        HRESULT calcMode([out, retval] BSTR * calcmode);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_CALCMODE)]
        HRESULT calcMode([in] BSTR calcmode);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_FROM)]
        HRESULT from([out, retval] VARIANT * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_FROM)]
        HRESULT from([in] VARIANT val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_KEYSPLINES)]
        HRESULT keySplines([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_KEYSPLINES)]
        HRESULT keySplines([in] BSTR val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_KEYTIMES)]
        HRESULT keyTimes([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_KEYTIMES)]
        HRESULT keyTimes([in] BSTR val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_TARGETELEMENT)]
        HRESULT targetElement([out, retval] BSTR * target);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_TARGETELEMENT)]
        HRESULT targetElement([in] BSTR target);
 
        [propget, id(DISPID_TIMEANIMATIONELEMENT_TO)]
        HRESULT to([out, retval] VARIANT * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_TO)]
        HRESULT to([in] VARIANT val);
 
        [propget, id(DISPID_TIMEANIMATIONELEMENT_VALUES)]
        HRESULT values([out, retval] VARIANT * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_VALUES)]
        HRESULT values([in] VARIANT val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_ORIGIN)]
        HRESULT origin([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_ORIGIN)]
        HRESULT origin([in] BSTR val);
 
        [propget, id(DISPID_TIMEANIMATIONELEMENT_PATH)]
        HRESULT path([out, retval] VARIANT * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_PATH)]
        HRESULT path([in] VARIANT val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_ADDITIVE)]
        HRESULT additive([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_ADDITIVE)]
        HRESULT additive([in] BSTR val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_ACCUMULATE)]
        HRESULT accumulate([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_ACCUMULATE)]
        HRESULT accumulate([in] BSTR val);

    };

    [
        object,
        uuid(29CE8661-BD43-421a-B616-E9B31F33A572),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEAnimationElement2 : ITIMEAnimationElement
    {

        [propget, id(DISPID_TIMEANIMATIONELEMENT_TYPE)]
        HRESULT type([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_TYPE)]
        HRESULT type([in] BSTR val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_SUBTYPE)]
        HRESULT subType([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_SUBTYPE)]
        HRESULT subType([in] BSTR val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_MODE)]
        HRESULT mode([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_MODE)]
        HRESULT mode([in] BSTR val);

        [propget, id(DISPID_TIMEANIMATIONELEMENT_FADECOLOR)]
        HRESULT fadeColor([out, retval] BSTR * val);
        [propput, id(DISPID_TIMEANIMATIONELEMENT_FADECOLOR)]
        HRESULT fadeColor([in] BSTR val);

	}

    [
        object,
        uuid(5459C83D-322B-44b3-8DAA-24C947E7B275),
        pointer_default(unique)
    ]
    interface IAnimationComposer : IUnknown
    {

        [propget] HRESULT attribute ([out, retval] BSTR *attributeName);

        HRESULT ComposerInit (IDispatch * composerSite, BSTR attributeName);
        HRESULT ComposerDetach (void);
        HRESULT UpdateFragments (void);
        HRESULT AddFragment (IDispatch *newAnimationFragment);
        HRESULT InsertFragment (IDispatch *newAnimationFragment, VARIANT index);
        HRESULT RemoveFragment (IDispatch *oldAnimationFragment);
        HRESULT EnumerateFragments (IEnumVARIANT **fragments);
        HRESULT GetNumFragments (long *fragmentCount);
    }

    [
        object,
        uuid(1A4F0E79-09CD-47f3-AFF1-483BF3A222DC),
        pointer_default(unique)
    ]
	interface IAnimationComposer2 : IAnimationComposer
	{
		HRESULT ComposerInitFromFragment (IDispatch * composerSite, BSTR attributeName, IDispatch *oneFragment);
	}

    [
        object,
        uuid(488FCB56-8FD6-4cda-A06A-5BB232930ECA),
        dual,
        pointer_default(unique)
    ]
    interface IAnimationComposerSite : IDispatch
    {
        [id(DISPID_SMILANIMATIONCOMPSITE_ADDFRAGMENT)]                  HRESULT AddFragment (BSTR attributeName, IDispatch *fragment);
        [id(DISPID_SMILANIMATIONCOMPSITE_REMOVEFRAGMENT)]               HRESULT RemoveFragment (BSTR attributeName, IDispatch *fragment);
        [id(DISPID_SMILANIMATIONCOMPSITE_INSERTFRAGMENT)]               HRESULT InsertFragment (BSTR attributeName, IDispatch *fragment, VARIANT index);
        [id(DISPID_SMILANIMATIONCOMPSITE_ENUMERATEFRAGMENTS)]           HRESULT EnumerateFragments (BSTR attributeName, IEnumVARIANT **fragments);
        [id(DISPID_SMILANIMATIONCOMPSITE_REGISTERFACTORY)]              HRESULT RegisterComposerFactory (VARIANT *factory);
        [id(DISPID_SMILANIMATIONCOMPSITE_UNREGISTER_FACTORY)]           HRESULT UnregisterComposerFactory (VARIANT *factory);
    };

    [
        object,
        uuid(8EF76C64-71CD-480f-96FC-BA2696E659BE),
        pointer_default(unique)
    ]
    interface IAnimationComposerSiteSink : IUnknown
    {
        void UpdateAnimations (void);
        void ComposerSiteDetach (void);
    };

    [
        object,
        uuid(29DF6387-30B4-4a62-891B-A9C5BE37BE88),
        pointer_default(unique)
    ]
    interface IAnimationRoot : IUnknown
    {
        HRESULT RegisterComposerSite (IUnknown *composerSite);
        HRESULT UnregisterComposerSite (IUnknown *composerSite);
    };

    [
        object,
        uuid(319DFD88-0AC6-4ab1-A19F-90223BA2DA16),
        dual,
        pointer_default(unique)
    ]
    interface IAnimationFragment : IDispatch
    {
        [propget, id(DISPID_SMILANIMATIONFRAGMENT_ELEMENT)] 
                HRESULT element([out, retval] IDispatch **htmlElement);
        [id(DISPID_SMILANIMATIONFRAGMENT_VALUE)] 
                HRESULT get_value([in] BSTR attributeName, [in] VARIANT origvalue, [in] VARIANT currentvalue, [out, retval] VARIANT *newvalue);
        [id(DISPID_SMILANIMATIONFRAGMENT_DETACHFROMCOMPOSER)]
        HRESULT DetachFromComposer (void);
    };  

    [
        object,
        uuid(02E29300-C758-49b4-9E11-C58BFE90558B),
        pointer_default(unique)
    ]
    interface IFilterAnimationInfo : IUnknown
    {
		HRESULT GetParameters	(VARIANT *params);
    };  

    [
        odl,
        oleautomation,
        dual,
        uuid(50abc224-6d53-4f83-9135-2440a41b7bc8),
    ]
    interface ITIMEElementCollection : IDispatch
    {
        [propput, id(DISPID_TIMEELEMENTCOLLECTION_LENGTH)]
        HRESULT length([in] long v);
        [propget, id(DISPID_TIMEELEMENTCOLLECTION_LENGTH)]
        HRESULT length([retval, out] long * p);
        [propget, id(DISPID_TIMEELEMENTCOLLECTION__NEWENUM), restricted, hidden]
        HRESULT _newEnum([retval, out] IUnknown** ppIUnknown);
        [id(DISPID_TIMEELEMENTCOLLECTION_ITEM)]
        HRESULT item([optional, in] VARIANT varName,
                     [optional, in] VARIANT varIndex,
                     [retval, out] IDispatch** ppDisp);
        [id(DISPID_TIMEELEMENTCOLLECTION_TAGS)]
        HRESULT tags([in] VARIANT varName, [retval, out] IDispatch** ppDisp);
    };

    //
    // ITIMEState (implemented by currTimeState object)
    //

    [
        object,
        oleautomation,
        dual,
        pointer_default(unique),
        uuid(DD5EC62A-9D77-4573-80A8-758594E69CEA)
    ]
    interface ITIMEState : IDispatch
    {
        [propget, id(DISPID_TIMESTATE_ACTIVEDUR)]
        HRESULT activeDur([retval, out] double * dur);

        [propget, id(DISPID_TIMESTATE_ACTIVETIME)]
        HRESULT activeTime([retval, out] double * time);

        [propget, id(DISPID_TIMESTATE_ISACTIVE)]
        HRESULT isActive([retval, out] VARIANT_BOOL * active);

        [propget, id(DISPID_TIMESTATE_ISON)]
        HRESULT isOn([retval, out] VARIANT_BOOL * on);

        [propget, id(DISPID_TIMESTATE_ISPAUSED)]
        HRESULT isPaused([retval, out] VARIANT_BOOL * paused);

        [propget, id(DISPID_TIMESTATE_ISMUTED)]
        HRESULT isMuted([retval, out] VARIANT_BOOL * muted);

        [propget, id(DISPID_TIMESTATE_PARENTTIMEBEGIN)]
        HRESULT parentTimeBegin([retval, out] double * time);

        [propget, id(DISPID_TIMESTATE_PARENTTIMEEND)]
        HRESULT parentTimeEnd([retval, out] double * time);

        [propget, id(DISPID_TIMESTATE_PROGRESS)]
        HRESULT progress([retval, out] double * progress);

        [propget, id(DISPID_TIMESTATE_REPEATCOUNT)]
        HRESULT repeatCount([retval, out] LONG * count);

        [propget, id(DISPID_TIMESTATE_SEGMENTDUR)]
        HRESULT segmentDur([retval, out] double * dur);

        [propget, id(DISPID_TIMESTATE_SEGMENTTIME)]
        HRESULT segmentTime([retval, out] double * time);

        [propget, id(DISPID_TIMESTATE_SIMPLEDUR)]
        HRESULT simpleDur([retval, out] double * dur);

        [propget, id(DISPID_TIMESTATE_SIMPLETIME)]
        HRESULT simpleTime([retval, out] double * time);

        [propget, id(DISPID_TIMESTATE_SPEED)]
        HRESULT speed([retval, out] float * speed);

        [propget, id(DISPID_TIMESTATE_STATE)]
        HRESULT state([retval, out] TimeState * timeState);

        [propget, id(DISPID_TIMESTATE_STATESTRING)]
        HRESULT stateString([retval, out] BSTR * state);

        [propget, id(DISPID_TIMESTATE_VOLUME)]
        HRESULT volume([retval, out] float * vol);
    }; // ITIMEState

    [
        object,
        uuid(2A6096D9-2CE0-47DC-A813-9099A2466309),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEPlayItem : IDispatch
    {
        [propget, id(DISPID_TIMEPLAYITEM_ABSTRACT)]
        HRESULT abstract([out, retval] BSTR *abs);

        [propget, id(DISPID_TIMEPLAYITEM_AUTHOR)]
        HRESULT author([out, retval] BSTR *auth);

        [propget, id(DISPID_TIMEPLAYITEM_COPYRIGHT)]
        HRESULT copyright([out, retval] BSTR *cpyrght);

        [propget, id(DISPID_TIMEPLAYITEM_DUR)]
        HRESULT dur([out, retval] double *dur);

        [propget, id(DISPID_TIMEPLAYITEM_INDEX)]
        HRESULT index([out, retval] long *index);

        [propget, id(DISPID_TIMEPLAYITEM_RATING)]
        HRESULT rating([out, retval] BSTR *rate);

        [propget, id(DISPID_TIMEPLAYITEM_SRC)]
        HRESULT src([out, retval] BSTR *src);

        [propget, id(DISPID_TIMEPLAYITEM_TITLE)]
        HRESULT title([out, retval] BSTR *title);

        // Methods
        [id(DISPID_TIMEPLAYITEM_SETACTIVE)]
        HRESULT setActive();
    };

    [
        object,
        uuid(4262CD38-6BDC-40A4-BC50-4CC50366E702),
        dual,
        pointer_default(unique)
    ]
    interface ITIMEPlayItem2 : ITIMEPlayItem
    {
        [propget, id(DISPID_TIMEPLAYITEM_BANNER)]
        HRESULT banner([out, retval] BSTR *banner);       
        
        [propget, id(DISPID_TIMEPLAYITEM_BANNERABSTRACT)]
        HRESULT bannerAbstract([out, retval] BSTR *abstract);
        
        [propget, id(DISPID_TIMEPLAYITEM_BANNERMOREINFO)]
        HRESULT bannerMoreInfo([out, retval] BSTR *moreInfo);
    };    

    [
        object,
        uuid(E9B75B62-DD97-4B19-8FD9-9646292952E0),
        dual,
        pointer_default(unique),
    ]
    interface ITIMEPlayList : IDispatch
    {
        [id(DISPID_TIMEPLAYLIST_ACTIVETRACK), propput] 
        HRESULT activeTrack([in] VARIANT vTrack); 
        [id(DISPID_TIMEPLAYLIST_ACTIVETRACK), propget] 
        HRESULT activeTrack([out, retval] ITIMEPlayItem **pPlayItem);

        [id(DISPID_TIMEPLAYLIST_DUR), propget] 
        HRESULT dur(double *dur); //returns the duration of the entire playlist if it is known or -1 if it is not.

        [id(DISPID_TIMEPLAYLIST_ITEM)] 
        HRESULT item([defaultvalue("0"), in] VARIANT varIndex,
                     [out, retval] ITIMEPlayItem **pPlayItem);            

        [id(DISPID_TIMEPLAYLIST_LENGTH), propget] 
        HRESULT length([out, retval] long* p);

        [id(DISPID_TIMEPLAYLIST_NEWENUM), propget, restricted, hidden] 
        HRESULT _newEnum([out, retval] IUnknown** p);

        [id(DISPID_TIMEPLAYLIST_NEXTTRACK)] 
        HRESULT nextTrack();

        [id(DISPID_TIMEPLAYLIST_PREVTRACK)] 
        HRESULT prevTrack();
    };

    [
        object,
        uuid(3AF7AB68-4F29-462C-AA6E-5872448899E3),
        dual,
        pointer_default(unique),
    ]
    interface ITIMEDVDPlayerObject : IDispatch
    {
        [id(DISPID_ITIMEDVDPLAYEROBJECT_UPPERBUTTONSEL)] HRESULT upperButtonSelect();
        [id(DISPID_ITIMEDVDPLAYEROBJECT_LOWERBUTTONSEL)] HRESULT lowerButtonSelect();
        [id(DISPID_ITIMEDVDPLAYEROBJECT_LEFTBUTTONSEL)] HRESULT leftButtonSelect();
        [id(DISPID_ITIMEDVDPLAYEROBJECT_RIGHTBUTTONSEL)] HRESULT rightButtonSelect();
        [id(DISPID_ITIMEDVDPLAYEROBJECT_BUTTONACTIVATE)] HRESULT buttonActivate();
        [id(DISPID_ITIMEDVDPLAYEROBJECT_GOTOMENU)] HRESULT gotoMenu();
    };

    [
        object,
        uuid(407954F5-2BAB-4CFA-954D-249F9FCE43A1),
        dual,
        pointer_default(unique),
    ]
    interface ITIMEDMusicPlayerObject : IDispatch
    {
        [propget, id(DISPID_ITIMEDMPLAYEROBJECT_HASDM)]
        HRESULT isDirectMusicInstalled([retval, out] VARIANT_BOOL * hasDM);
    };


    [
        object,
        uuid(cd51e446-3006-434f-90e2-e37e8fb8ca8f),
        hidden,
        pointer_default(unique)
    ]
    interface ITIMEFactory : IUnknown
    {
    }

    [
        uuid(17237A20-3ADB-48ec-B182-35291F115790)
    ]
    coclass TIMEFactory
    {
        [default] interface ITIMEFactory;
    };

    [
        object,
        uuid(BEEB3233-F71F-4683-8B05-9A5314C97DBC),
        pointer_default(unique)
    ]
    interface IAnimationComposerFactory : IUnknown
    {
        HRESULT FindComposer([in] IDispatch *targetElement, [in] BSTR attributeName, [out, retval] IAnimationComposer **animationComposer); 
    }

    [
        object,
        uuid(B4EA5681-ED72-4efe-BBD7-7C47D1325696),
        dual,
        hidden,
        pointer_default(unique)
    ]
    interface IAnimationComposerSiteFactory : IDispatch
    {
    }

    [
        object,
        uuid(bf0571ed-344f-4f58-82c7-7431ed0fd834),
        pointer_default(unique)
    ]
    interface ITIMEMediaPlayerSite : IUnknown
    {
        [propget, id(DISPID_TIMEMEDIAPLAYERSITE_TIMEELEMENT)]
        HRESULT timeElement([out, retval] ITIMEElement ** pElm);

        [propget, id(DISPID_TIMEMEDIAPLAYERSITE_TIMESTATE)]
        HRESULT timeState([out, retval] ITIMEState ** pState);

        [id(DISPID_TIMEMEDIAPLAYERSITE_REPORTERROR)]
        HRESULT reportError([in] HRESULT hr,
                            [in] BSTR errorString);
    }
    
    [
        object,
        uuid(ea4a95be-acc9-4bf0-85a4-1bf3c51e431c),
        pointer_default(unique)
    ]
    interface ITIMEMediaPlayer : IUnknown
    {
        [id(DISPID_TIMEMEDIAPLAYER_INIT)]
        HRESULT Init(ITIMEMediaPlayerSite * mpsite);
        [id(DISPID_TIMEMEDIAPLAYER_DETACH)]
        HRESULT Detach();

        [id(DISPID_TIMEMEDIAPLAYER_BEGIN)]
        HRESULT begin();
        [id(DISPID_TIMEMEDIAPLAYER_END)]
        HRESULT end();
        [id(DISPID_TIMEMEDIAPLAYER_RESUME)]
        HRESULT resume();
        [id(DISPID_TIMEMEDIAPLAYER_PAUSE)]
        HRESULT pause();
        [id(DISPID_TIMEMEDIAPLAYER_REPEAT)]
        HRESULT repeat();
        [id(DISPID_TIMEMEDIAPLAYER_RESET)]
        HRESULT reset();
        [id(DISPID_TIMEMEDIAPLAYER_SEEK)]
        HRESULT seek([in] double time);

        // Properties - w
        [propput, id(DISPID_TIMEMEDIAPLAYER_SRC)]
        HRESULT src([in] BSTR url);
        [propput, id(DISPID_TIMEMEDIAPLAYER_CLIPBEGIN)]
        HRESULT clipBegin([in] VARIANT b);
        [propput, id(DISPID_TIMEMEDIAPLAYER_CLIPEND)]
        HRESULT clipEnd([in] VARIANT e);

        // Properties - r/o
        [propget, id(DISPID_TIMEMEDIAPLAYER_ABSTRACT)]
        HRESULT abstract([out, retval] BSTR *abs);
        
        [propget, id(DISPID_TIMEMEDIAPLAYER_AUTHOR)]
        HRESULT author([out, retval] BSTR *auth);
        
        [propget, id(DISPID_TIMEMEDIAPLAYER_CANPAUSE)]
        HRESULT canPause([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAPLAYER_CANSEEK)]
        HRESULT canSeek([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAPLAYER_CLIPDUR)]
        HRESULT clipDur([out, retval] double * dur);

        [propget, id(DISPID_TIMEMEDIAPLAYER_COPYRIGHT)]
        HRESULT copyright([out, retval] BSTR *cpyrght);

        [propget, id(DISPID_TIMEMEDIAPLAYER_CURRTIME)]
        HRESULT currTime([out, retval] double * time);

        [propget, id(DISPID_TIMEMEDIAPLAYER_CUSTOM_OBJECT)]
        HRESULT customObject([out, retval] IDispatch ** disp);

        [propget, id(DISPID_TIMEMEDIAPLAYER_HASAUDIO)]
        HRESULT hasAudio([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAPLAYER_HASVISUAL)]
        HRESULT hasVisual([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAPLAYER_MEDIADUR)]
        HRESULT mediaDur([out, retval] double *dur);
        
        [propget, id(DISPID_TIMEMEDIAPLAYER_MEDIAHEIGHT)]
        HRESULT mediaHeight([out, retval] long *height);

        [propget, id(DISPID_TIMEMEDIAPLAYER_MEDIAWIDTH)]
        HRESULT mediaWidth([out, retval] long *width);
        
        [propget, id(DISPID_TIMEMEDIAPLAYER_PLAYLIST)]
        HRESULT playList([out, retval] ITIMEPlayList** pPlayList);

        [propget, id(DISPID_TIMEMEDIAPLAYER_RATING)]
        HRESULT rating([out, retval] BSTR *rate);

        [propget, id(DISPID_TIMEMEDIAPLAYER_STATE)]
        HRESULT state([out, retval] TimeState * ts);

        [propget, id(DISPID_TIMEMEDIAPLAYER_TITLE)]
        HRESULT title([out, retval] BSTR *name);

    };

    [
        object,
        uuid(ffaacfda-b374-4f22-ac9a-c5bb9437cb56),
        pointer_default(unique)
    ]
    interface ITIMEMediaPlayerAudio : IUnknown
    {
        // Properties - w
        [propput, id(DISPID_TIMEMEDIAPLAYERAUDIO_VOLUME)]
        HRESULT volume([in] float f);
        [propput, id(DISPID_TIMEMEDIAPLAYERAUDIO_MUTE)]
        HRESULT mute([in] VARIANT_BOOL m);

	};

    [
        object,
        uuid(b9987fca-7fbb-4015-bd3d-7418605514da),
        pointer_default(unique)
    ]
    interface ITIMEMediaPlayerNetwork : IUnknown
    {
        // Properties - r
        [propget, id(DISPID_TIMEMEDIAPLAYERNETWORK_HASDOWNLOADPROGRESS)]
        HRESULT hasDownloadProgress([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAPLAYERNETWORK_DOWNLOADPROGRESS)]
        HRESULT downloadProgress([out, retval] long * l);

        [propget, id(DISPID_TIMEMEDIAPLAYERNETWORK_ISBUFFERED)]
        HRESULT isBuffered([retval, out] VARIANT_BOOL * b);

        [propget, id(DISPID_TIMEMEDIAPLAYERNETWORK_BUFFERINGPROGRESS)]
        HRESULT bufferingProgress([out, retval] long * l);

	};

    [
        object,
        uuid(897a99e7-f386-45c8-b51b-3a25bbcbba69),
        pointer_default(unique)
    ]
    interface ITIMEMediaPlayerControl : IUnknown
    {
        [id(DISPID_TIMEMEDIAPLAYERCONTROL_GETCONTROL)]
        HRESULT getControl(IUnknown ** control);
    }

}

