开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
MovieManager.h
资源名称：fullMPCcode.rar　[点击查看]
上传用户：xjjlds
上传日期：2015-12-05
资源大小：22823k
文件大小：48k
源码类别：

多媒体编程

开发平台：

Visual C++

MovieManager.h：源码内容
  1. /*
  2.      File:       MovieManager.h
  3.  
  4.      Contains:   Interface for MovieManager component
  5.  
  6.      Version:    Technology: QuickTime 4.2
  7.                  Release:    QuickTime 6.0.2
  8.  
  9.      Copyright:  (c) 2000-2001 by Apple Computer, Inc., all rights reserved.
  10.  
  11.      Bugs?:      For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. */
  17. #ifndef __MOVIEMANAGER__
  18. #define __MOVIEMANAGER__
  20. #ifndef __MOVIES__
  21. #include "Movies.h"
  22. #endif
  24. #ifndef __QUICKTIMEVR__
  25. #include "QuickTimeVR.h"
  26. #endif
  28. #ifndef __COMPONENTS__
  29. #include "Components.h"
  30. #endif
  32. #ifndef __EVENTS__
  33. #include "Events.h"
  34. #endif
  36. #ifndef __MACTYPES__
  37. #include "MacTypes.h"
  38. #endif
  40. #ifndef __MACWINDOWS__
  41. #include "MacWindows.h"
  42. #endif
  47. #if PRAGMA_ONCE
  48. #pragma once
  49. #endif
  51. #ifdef __cplusplus
  52. extern "C" {
  53. #endif
  55. #if PRAGMA_IMPORT
  56. #pragma import on
  57. #endif
  59. #if PRAGMA_STRUCT_ALIGN
  60.     #pragma options align=mac68k
  61. #elif PRAGMA_STRUCT_PACKPUSH
  62.     #pragma pack(push, 2)
  63. #elif PRAGMA_STRUCT_PACK
  64.     #pragma pack(2)
  65. #endif
  67. typedef ComponentInstance               MovieManagerComponent;
  68. typedef void *                          ObjectRef;
  69. typedef void *                          ObjectSpec;
  70. typedef OSType                          MessageClass;
  71. typedef UInt32                          PropertyID;
  72. typedef UInt32                          MessageID;
  73. typedef OSType                          ValueFormat;
  74. typedef void *                          MessageData;
  75. /* == message class constants ==*/
  76. enum {
  77.     kMMgrGetPropertyClass       = FOUR_CHAR_CODE('getp'),
  78.     kMMgrSetPropertyClass       = FOUR_CHAR_CODE('setp'),
  79.     kMMgrSendCommandClass       = FOUR_CHAR_CODE('cmd ')
  80. };
  83. struct CharBuff {
  84.     UInt32                          length;
  85.     char *                          buff;
  86. };
  87. typedef struct CharBuff                 CharBuff;
  89. struct PropArg {
  90.     ValueFormat                     valueFormat;
  91.     void *                          value;                      /* data if <= 32 bits, otherwise pointer to the actual data */
  92. };
  93. typedef struct PropArg                  PropArg;
  95. struct PropertyParams {
  96.     UInt16                          paramCount;
  97.     UInt16                          flags;
  98.     PropArg                         args[8];
  99. };
  100. typedef struct PropertyParams           PropertyParams;
  101. /*
  102.    
  103.    struct with the same layout as a PropArg but with a union for the value field for ease of use 
  104. */
  106. struct PropArgU {
  107.     ValueFormat                     valueFormat;
  108.     union {
  109.         Boolean                         booleanVal;
  110.         SInt8                           byteVal;
  111.         SInt32                          longVal;
  112.         SInt16                          shortVal;
  113.         Fixed                           fixedVal;
  114.         Point                           pointVal;
  115.         QTFloatSingle                   float32Val;
  116.         QTFloatDouble *                 float64PtrVal;
  117.         void *                          voidVal;
  118.         StringPtr                       str255Val;
  119.         char *                          cStrVal;
  120.         CharBuff *                      charBuffVal;
  121.         RGBColor *                      rbgPtr;
  122.         Ptr                             ptrVal;
  123.         Handle                          textHandle;
  124.     }                                 value;
  125. };
  126. typedef struct PropArgU                 PropArgU;
  127. /*
  128.    
  129.    struct with the same layout as a PropertyParams but with an array of PropArgUs
  130. */
  132. struct PropertyParamsU {
  133.     UInt16                          paramCount;
  134.     UInt16                          flags;
  135.     PropArgU                        args[8];
  136. };
  137. typedef struct PropertyParamsU          PropertyParamsU;
  139. struct FindOffset {
  140.     TimeValue                       time;                       /* the movie time at which the text was found */
  141.     SInt32                          trackNum;                   /* number of the track in which the text was found */
  142.     SInt32                          offset;                     /* offset (in chars) of the text with the track's sample */
  143. };
  144. typedef struct FindOffset               FindOffset;
  145. /* == enums ==*/
  147. /* Movie Commands */
  148. enum {
  149.     kMMgrCmdAdd                 = FOUR_CHAR_CODE('add '),
  150.     kMMgrCmdAddScaled           = FOUR_CHAR_CODE('adsc'),
  151.     kMMgrCmdClear               = FOUR_CHAR_CODE('cler'),
  152.     kMMgrCmdCopy                = FOUR_CHAR_CODE('copy'),
  153.     kMMgrCmdCopyFrame           = FOUR_CHAR_CODE('cfrm'),
  154.     kMMgrCmdCut                 = FOUR_CHAR_CODE('cut '),
  155.     kMMgrCmdDelete              = FOUR_CHAR_CODE('delt'),
  156.     kMMgrCmdExportMovie         = FOUR_CHAR_CODE('expt'),
  157.     kMMgrCmdFindText            = FOUR_CHAR_CODE('find'),
  158.     kMMgrCmdFrameLoaded         = FOUR_CHAR_CODE('fram'),
  159.     kMMgrCmdGoBackAction        = FOUR_CHAR_CODE('gobk'),
  160.     kMMgrCmdIdle                = FOUR_CHAR_CODE('idle'),
  161.     kMMgrCmdLoadExporterSettings = FOUR_CHAR_CODE('lexp'),
  162.     kMMgrCmdMouseDown           = FOUR_CHAR_CODE('clik'),
  163.     kMMgrCmdMouseEnter          = FOUR_CHAR_CODE('entr'),
  164.     kMMgrCmdMouseExit           = FOUR_CHAR_CODE('exit'),
  165.     kMMgrCmdMouseTrigger        = FOUR_CHAR_CODE('trig'),
  166.     kMMgrCmdMouseUp             = FOUR_CHAR_CODE('cend'),
  167.     kMMgrCmdMovieLoaded         = FOUR_CHAR_CODE('load'),
  168.     kMMgrCmdNudge               = FOUR_CHAR_CODE('nudg'),
  169.     kMMgrCmdPaste               = FOUR_CHAR_CODE('pste'),
  170.     kMMgrCmdPause               = FOUR_CHAR_CODE('paus'),
  171.     kMMgrCmdPlay                = FOUR_CHAR_CODE('play'),
  172.     kMMgrCmdPreroll             = FOUR_CHAR_CODE('prol'),
  173.     kMMgrCmdReplace             = FOUR_CHAR_CODE('rplc'),
  174.     kMMgrCmdReverse             = FOUR_CHAR_CODE('rvrs'),
  175.     kMMgrCmdRewind              = FOUR_CHAR_CODE('rwnd'),
  176.     kMMgrCmdRotate              = FOUR_CHAR_CODE('rota'),
  177.     kMMgrCmdSave                = FOUR_CHAR_CODE('sve '),
  178.     kMMgrCmdSaveAs              = FOUR_CHAR_CODE('sas '),
  179.     kMMgrCmdSaveAsSelfContained = FOUR_CHAR_CODE('sass'),
  180.     kMMgrCmdSaveCopy            = FOUR_CHAR_CODE('scp '),
  181.     kMMgrCmdSaveCopySelfContained = FOUR_CHAR_CODE('scps'),
  182.     kMMgrCmdSaveExporterSettings = FOUR_CHAR_CODE('sexp'),
  183.     kMMgrCmdSaveSelfContained   = FOUR_CHAR_CODE('sves'),
  184.     kMMgrCmdShowDefaultView     = FOUR_CHAR_CODE('sdfl'),
  185.     kMMgrCmdShowExportDialog    = FOUR_CHAR_CODE('shoe'),
  186.     kMMgrCmdShowPoster          = FOUR_CHAR_CODE('spos'),
  187.     kMMgrCmdSkew                = FOUR_CHAR_CODE('skew'),
  188.     kMMgrCmdStep                = FOUR_CHAR_CODE('step'),
  189.     kMMgrCmdStepFwd             = FOUR_CHAR_CODE('stpf'),
  190.     kMMgrCmdStepRev             = FOUR_CHAR_CODE('stpr'),
  191.     kMMgrCmdStop                = FOUR_CHAR_CODE('stop'),
  192.     kMMgrCmdTrim                = FOUR_CHAR_CODE('trim'),
  193.     kMMgrCmdUndo                = FOUR_CHAR_CODE('undo')
  194. };
  197. /* Properties */
  198. enum {
  199.     kMMgrPropActionsEnabled     = FOUR_CHAR_CODE('a ok'),
  200.     kMMgrPropActiveTransport    = FOUR_CHAR_CODE('atrn'),
  201.     kMMgrPropAlbum              = FOUR_CHAR_CODE('゛lb'),
  202.     kMMgrPropAllowBalloonHelp   = FOUR_CHAR_CODE('balo'),
  203.     kMMgrPropAllowEditing       = FOUR_CHAR_CODE('edit'),
  204.     kMMgrPropAllowMultipleStreams = FOUR_CHAR_CODE('amss'),
  205.     kMMgrPropArtist             = FOUR_CHAR_CODE('@ART'),
  206.     kMMgrPropAttached           = FOUR_CHAR_CODE('atch'),
  207.     kMMgrPropAutoPlay           = FOUR_CHAR_CODE('play'),
  208.     kMMgrPropBackColor          = FOUR_CHAR_CODE('bclr'),
  209.     kMMgrPropBadge              = FOUR_CHAR_CODE('badg'),
  210.     kMMgrPropBitRate            = FOUR_CHAR_CODE('brte'),
  211.     kMMgrPropBottom             = FOUR_CHAR_CODE('botm'),
  212.     kMMgrPropBottomRight        = FOUR_CHAR_CODE('btrt'),
  213.     kMMgrPropChapterTrackRef    = FOUR_CHAR_CODE('chap'),
  214.     kMMgrPropChapterMode        = FOUR_CHAR_CODE('chmd'),
  215.     kMMgrPropChapterName        = FOUR_CHAR_CODE('@chp'),
  216.     kMMgrPropCharacteristics    = FOUR_CHAR_CODE('char'),
  217.     kMMgrPropCodecSequence      = FOUR_CHAR_CODE('cseq'),
  218.     kMMgrPropCommands           = FOUR_CHAR_CODE('cmds'),
  219.     kMMgrPropComments           = FOUR_CHAR_CODE('cmnt'),
  220.     kMMgrPropComponentVersion   = FOUR_CHAR_CODE('cvrs'),
  221.     kMMgrPropCompressMovieHeader = FOUR_CHAR_CODE('chdr'),
  222.     kMMgrPropConnectionSpeed    = FOUR_CHAR_CODE('cspd'),
  223.     kMMgrPropConverted          = FOUR_CHAR_CODE('cnvt'),
  224.     kMMgrPropCopyright          = FOUR_CHAR_CODE('ヽpy'),
  225.     kMMgrPropCursorID           = FOUR_CHAR_CODE('crid'),
  226.     kMMgrPropCurrNodeID         = FOUR_CHAR_CODE('cnod'),
  227.     kMMgrPropDataRefs           = FOUR_CHAR_CODE('dtrf'),
  228.     kMMgrPropDefaultNodeID      = FOUR_CHAR_CODE('dnod'),
  229.     kMMgrPropDescription        = FOUR_CHAR_CODE('ヾes'),
  230.     kMMgrPropDefaultRect        = FOUR_CHAR_CODE('drct'),
  231.     kMMgrPropDragEnabled        = FOUR_CHAR_CODE('drag'),
  232.     kMMgrPropDuration           = FOUR_CHAR_CODE('dura'),
  233.     kMMgrPropEnabled            = FOUR_CHAR_CODE('enab'),
  234.     kMMgrPropEndSelection       = FOUR_CHAR_CODE('ends'),
  235.     kMMgrPropEndTime            = FOUR_CHAR_CODE('endt'),
  236.     kMMgrPropExporter           = FOUR_CHAR_CODE('exp '),
  237.     kMMgrPropExporters          = FOUR_CHAR_CODE('exps'),
  238.     kMMgrPropFieldOfView        = FOUR_CHAR_CODE('fov '),
  239.     kMMgrPropFieldOfViewRange   = FOUR_CHAR_CODE('fovr'),
  240.     kMMgrPropFindTextCaseSensitive = FOUR_CHAR_CODE('fcse'),
  241.     kMMgrPropFindTextReverse    = FOUR_CHAR_CODE('frev'),
  242.     kMMgrPropFindTextStart      = FOUR_CHAR_CODE('fstt'),
  243.     kMMgrPropFindTextWrapAround = FOUR_CHAR_CODE('fwrp'),
  244.     kMMgrPropFlattenCrossplatform = FOUR_CHAR_CODE('flat'),
  245.     kMMgrPropForeColor          = FOUR_CHAR_CODE('fclr'),
  246.     kMMgrPropFormat             = FOUR_CHAR_CODE('frmt'),
  247.     kMMgrPropFoundTextOffset    = FOUR_CHAR_CODE('foff'),
  248.     kMMgrPropFrameObjects       = FOUR_CHAR_CODE('frob'),
  249.     kMMgrPropFrameRate          = FOUR_CHAR_CODE('frte'),
  250.     kMMgrPropFullCommandList    = FOUR_CHAR_CODE('fcmd'),
  251.     kMMgrPropFullName           = FOUR_CHAR_CODE('﹏am'),
  252.     kMMgrPropFullPropertyList   = FOUR_CHAR_CODE('fprp'),
  253.     kMMgrPropGraphicsMode       = FOUR_CHAR_CODE('mode'),
  254.     kMMgrPropHasChanged         = FOUR_CHAR_CODE('drty'),
  255.     kMMgrPropHeight             = FOUR_CHAR_CODE('hght'),
  256.     kMMgrPropHighQualityMode    = FOUR_CHAR_CODE('hqty'),
  257.     kMMgrPropHREF               = FOUR_CHAR_CODE('href'),
  258.     kMMgrPropHTTPProxy          = FOUR_CHAR_CODE('http'),
  259.     kMMgrPropHTTPTransport      = FOUR_CHAR_CODE('httt'),
  260.     kMMgrPropID                 = FOUR_CHAR_CODE('id  '),
  261.     kMMgrPropIdleFrequency      = FOUR_CHAR_CODE('idle'),
  262.     kMMgrPropImageCorrection    = FOUR_CHAR_CODE('icor'),
  263.     kMMgrPropImageName          = FOUR_CHAR_CODE('imnm'),
  264.     kMMgrPropImageNdx           = FOUR_CHAR_CODE('imnd'),
  265.     kMMgrPropImageQuality       = FOUR_CHAR_CODE('iqty'),
  266.     kMMgrPropInformation        = FOUR_CHAR_CODE('﹊nf'),
  267.     kMMgrPropIsRegistered       = FOUR_CHAR_CODE('regi'),
  268.     kMMgrPropIsVRMovie          = FOUR_CHAR_CODE('isvr'),
  269.     kMMgrPropLanguage           = FOUR_CHAR_CODE('lang'),
  270.     kMMgrPropLayer              = FOUR_CHAR_CODE('layr'),
  271.     kMMgrPropLeft               = FOUR_CHAR_CODE('left'),
  272.     kMMgrPropLinkDestination    = FOUR_CHAR_CODE('dest'),
  273.     kMMgrPropLoadState          = FOUR_CHAR_CODE('load'),
  274.     kMMgrPropLocation           = FOUR_CHAR_CODE('loc '),
  275.     kMMgrPropLockMessages       = FOUR_CHAR_CODE('lokm'),
  276.     kMMgrPropLockScreen         = FOUR_CHAR_CODE('loks'),
  277.     kMMgrPropLoop               = FOUR_CHAR_CODE('loop'),
  278.     kMMgrPropLoopIsPalindrome   = FOUR_CHAR_CODE('paln'),
  279.     kMMgrPropMask               = FOUR_CHAR_CODE('mask'),
  280.     kMMgrPropMatrix             = FOUR_CHAR_CODE('mtrx'),
  281.     kMMgrPropMaxTimeLoaded      = FOUR_CHAR_CODE('mtme'),
  282.     kMMgrPropMemCheckLevel      = FOUR_CHAR_CODE('dbmc'),
  283.     kMMgrPropMessages           = FOUR_CHAR_CODE('msg '),
  284.     kMMgrPropMIMEType           = FOUR_CHAR_CODE('mime'),
  285.     kMMgrPropMissingComponents  = FOUR_CHAR_CODE('miss'),
  286.     kMMgrPropMovie              = FOUR_CHAR_CODE('moov'),
  287.     kMMgrPropMute               = FOUR_CHAR_CODE('mute'),
  288.     kMMgrPropName               = FOUR_CHAR_CODE('name'),
  289.     kMMgrPropNextMovie          = FOUR_CHAR_CODE('next'),
  290.     kMMgrPropNoProxyHosts       = FOUR_CHAR_CODE('nprx'),
  291.     kMMgrPropNumber             = FOUR_CHAR_CODE('numb'),
  292.     kMMgrPropOriginalFormat     = FOUR_CHAR_CODE('ゝmt'),
  293.     kMMgrPropOriginalSource     = FOUR_CHAR_CODE('﹕rc'),
  294.     kMMgrPropOwner              = FOUR_CHAR_CODE('ownr'),
  295.     kMMgrPropPacketLoss         = FOUR_CHAR_CODE('loss'),
  296.     kMMgrPropPanAngle           = FOUR_CHAR_CODE('pan '),
  297.     kMMgrPropPanAngleRange      = FOUR_CHAR_CODE('panr'),
  298.     kMMgrPropPlaySelectionOnly  = FOUR_CHAR_CODE('psel'),
  299.     kMMgrPropPort               = FOUR_CHAR_CODE('port'),
  300.     kMMgrPropPreferredLoc       = FOUR_CHAR_CODE('ploc'),
  301.     kMMgrPropPreferredRate      = FOUR_CHAR_CODE('prte'),
  302.     kMMgrPropPreferredSoundVolume = FOUR_CHAR_CODE('pvol'),
  303.     kMMgrPropProperties         = FOUR_CHAR_CODE('prop'),
  304.     kMMgrPropRate               = FOUR_CHAR_CODE('rate'),
  305.     kMMgrPropReadOnly           = FOUR_CHAR_CODE('rwno'),
  306.     kMMgrPropRectangle          = FOUR_CHAR_CODE('rect'),
  307.     kMMgrPropRight              = FOUR_CHAR_CODE('rght'),
  308.     kMMgrPropRTSPProxy          = FOUR_CHAR_CODE('rtsp'),
  309.     kMMgrPropSaveDisabled       = FOUR_CHAR_CODE('save'),
  310.     kMMgrPropScale              = FOUR_CHAR_CODE('scal'),
  311.     kMMgrPropScaleMedia         = FOUR_CHAR_CODE('spsc'),
  312.     kMMgrPropScript             = FOUR_CHAR_CODE('scrp'),
  313.     kMMgrPropSeeAllFrames       = FOUR_CHAR_CODE('sall'),
  314.     kMMgrPropShowHotSpots       = FOUR_CHAR_CODE('show'),
  315.     kMMgrPropShowStreamStatsNames = FOUR_CHAR_CODE('snam'),
  316.     kMMgrPropSize               = FOUR_CHAR_CODE('size'),
  317.     kMMgrPropSOCKSProxy         = FOUR_CHAR_CODE('sock'),
  318.     kMMgrPropSoftware           = FOUR_CHAR_CODE('﹕wr'),
  319.     kMMgrPropSoundBalance       = FOUR_CHAR_CODE('sbal'),
  320.     kMMgrPropSoundBass          = FOUR_CHAR_CODE('sbas'),
  321.     kMMgrPropSoundOutputComponent = FOUR_CHAR_CODE('sout'),
  322.     kMMgrPropSoundTreble        = FOUR_CHAR_CODE('strb'),
  323.     kMMgrPropSoundVolume        = FOUR_CHAR_CODE('svol'),
  324.     kMMgrPropStartSelection     = FOUR_CHAR_CODE('strs'),
  325.     kMMgrPropStartTime          = FOUR_CHAR_CODE('strt'),
  326.     kMMgrPropStatus             = FOUR_CHAR_CODE('stts'),
  327.     kMMgrPropStreamStats        = FOUR_CHAR_CODE('stat'),
  328.     kMMgrPropSuppressHotSpotNames = FOUR_CHAR_CODE('hnam'),
  329.     kMMgrPropTargetMovieID      = FOUR_CHAR_CODE('tid '),
  330.     kMMgrPropTargetMovieName    = FOUR_CHAR_CODE('tnam'),
  331.     kMMgrPropText               = FOUR_CHAR_CODE('text'),
  332.     kMMgrPropTiltAngle          = FOUR_CHAR_CODE('tlt '),
  333.     kMMgrPropTiltAngleRange     = FOUR_CHAR_CODE('tltr'),
  334.     kMMgrPropTime               = FOUR_CHAR_CODE('time'),
  335.     kMMgrPropTimeScale          = FOUR_CHAR_CODE('tscl'),
  336.     kMMgrPropTop                = FOUR_CHAR_CODE('top '),
  337.     kMMgrPropTopLeft            = FOUR_CHAR_CODE('topl'),
  338.     kMMgrPropType               = FOUR_CHAR_CODE('type'),
  339.     kMMgrPropUDPTransport       = FOUR_CHAR_CODE('udpt'),
  340.     kMMgrPropURL                = FOUR_CHAR_CODE('url '),
  341.     kMMgrPropUseCustomCLUT      = FOUR_CHAR_CODE('clut'),
  342.     kMMgrPropUserData           = FOUR_CHAR_CODE('udat'),
  343.     kMMgrPropVariable           = FOUR_CHAR_CODE('var '),
  344.     kMMgrPropVersion            = FOUR_CHAR_CODE('vers'),
  345.     kMMgrPropVisible            = FOUR_CHAR_CODE('visi'),
  346.     kMMgrPropWidth              = FOUR_CHAR_CODE('widt')
  347. };
  350. /*
  351.    **
  352.    == object specification ==
  353. */
  354. enum {
  355.                                                                 /* ***/
  356.                                                                 /* obj->objClass*/
  357.     kObjClassQuickTime          = FOUR_CHAR_CODE('cQtm'),
  358.     kObjClassMovie              = FOUR_CHAR_CODE('cMoV'),
  359.     kObjClassWindow             = FOUR_CHAR_CODE('cwnd'),
  360.     kObjClassTrack              = FOUR_CHAR_CODE('ctrk'),
  361.     kObjClassSprite             = FOUR_CHAR_CODE('cspr'),
  362.     kObjClassHotSpot            = FOUR_CHAR_CODE('chsp'),
  363.     kObjClassNode               = FOUR_CHAR_CODE('cnde'),
  364.     kObjClassQTiObj             = FOUR_CHAR_CODE('cqti'),
  365.     kObjClassController         = FOUR_CHAR_CODE('cctr'),
  366.     kObjClassImage              = FOUR_CHAR_CODE('cimg'),
  367.     kObjClassScene              = FOUR_CHAR_CODE('cscn'),
  368.     kObjClassDataRefs           = FOUR_CHAR_CODE('data'),
  369.     kObjUserData                = FOUR_CHAR_CODE('udta'),
  370.     kObjClassEvery              = FOUR_CHAR_CODE('****'),       /* ** */
  371.                                                                 /* obj->objRefType*/
  372.     kByIndex                    = FOUR_CHAR_CODE('indx'),       /* formAbsolutePosition */
  373.     kByID                       = FOUR_CHAR_CODE('ID  '),       /* formUniqueID */
  374.     kByName                     = FOUR_CHAR_CODE('name'),       /* formName */
  375.     kByPosition                 = FOUR_CHAR_CODE('rele'),       /* formRelativePosition */
  376.     kByType                     = FOUR_CHAR_CODE('type'),       /* ** */
  377.                                                                 /* special values when obj->objRefVal == kByIndex */
  378.     kIndexFirst                 = 1,
  379.     kIndexAll                   = -1,
  380.     kIndexLast                  = -2,
  381.     kIndexMiddle                = -3,
  382.     kIndexAny                   = -4,                           /* ** */
  383.                                                                 /* values when obj->objRefVal == kByPosition */
  384.     kIndexThis                  = FOUR_CHAR_CODE('this'),
  385.     kIndexPrev                  = FOUR_CHAR_CODE('prev'),       /* kAEPrevious */
  386.     kIndexNext                  = FOUR_CHAR_CODE('next'),       /* kAENext */
  387.                                                                 /* ** */
  388.                                                                 /* obj->objModifier "special" track types (non-media types) */
  389.     kTrackTypeAny               = FOUR_CHAR_CODE('*trk'),
  390.     kTrackTypeQTVR              = FOUR_CHAR_CODE('vrtr'),
  391.     KTrackTypeMPEGVideo         = FOUR_CHAR_CODE('m1a '),
  392.     KTrackTypeMPEGAudeo         = FOUR_CHAR_CODE('m1v '),
  393.     kTrackTypeChapter           = FOUR_CHAR_CODE('chap'),       /* kTrackReferenceChapterList */
  394.     kTrackTypeAudio             = FOUR_CHAR_CODE('ears'),       /* AudioMediaCharacteristic */
  395.     kTrackTypeVisual            = FOUR_CHAR_CODE('eyes'),       /* VisualMediaCharacteristic */
  396.     kTrackTypeStreaming         = FOUR_CHAR_CODE('strm')        /* kQTSStreamMediaType*/
  397. };
  401. /* == movie manager object spec structures ==*/
  403. /*
  404.    **
  405.    == movie object spec ==
  406. */
  408. struct ExternalObjectSpec {
  409.     OSType                          objClass;                   /* type of object (movie, track, etc) */
  410.     OSType                          objModifier;                /* object modifier (track type, etc) */
  411.     OSType                          objRefType;                 /* how to interpret objRefVal (by name, by ID, etc) */
  412.     SInt32                          objRefVal;                  /* object identifier (ID, index, offset to name, etc) */
  413. };
  414. typedef struct ExternalObjectSpec       ExternalObjectSpec;
  415. typedef ExternalObjectSpec *            ExternalObjectSpecPtr;
  417. struct MovieObjectSpec {
  418.     SInt32                          count;
  419.     ExternalObjectSpec              objRef[1];
  420. };
  421. typedef struct MovieObjectSpec          MovieObjectSpec;
  422. typedef MovieObjectSpec *               MovieObjectSpecPtr;
  424. struct MovieObjectRecord {
  425.     SInt32                          data[1];
  426. };
  427. typedef struct MovieObjectRecord        MovieObjectRecord;
  429. typedef MovieObjectRecord *             MovieObjectPtr;
  430. /* == movie manager object reference structures ==*/
  432. /*
  433.    **
  434.    == forward struct declarations for recursively-defined structures
  435. */
  436. typedef struct MovieRef                 MovieRef;
  437. typedef MovieRef *                      MovieRefPtr;
  438. typedef struct TrackRef                 TrackRef;
  439. typedef TrackRef *                      TrackRefPtr;
  440. typedef struct SceneRef                 SceneRef;
  441. typedef SceneRef *                      SceneRefPtr;
  442. typedef struct SpriteRef                SpriteRef;
  443. typedef SpriteRef *                     SpriteRefPtr;
  444. typedef struct NodeRef                  NodeRef;
  445. typedef NodeRef *                       NodeRefPtr;
  446. typedef struct HotSpotRef               HotSpotRef;
  447. typedef HotSpotRef *                    HotSpotRefPtr;
  448. typedef struct GenericRef               GenericRef;
  449. typedef GenericRef *                    GenericRefPtr;
  450. /* header common to all movie object reference structures*/
  452. struct GenericRef {
  453.     GenericRefPtr                   parent;
  454.     GenericRefPtr                   child;
  455.     OSType                          objType;
  456. };
  459. struct MovieObjectRef {
  460.     void *                          reserved;
  461.     OSType                          targetType;
  462.     SInt32                          objectCount;
  463.     union {
  464.         GenericRefPtr                   generic;
  465.         MovieRefPtr                     movie;
  466.         TrackRefPtr                     track;
  467.         SceneRefPtr                     scene;
  468.         SpriteRefPtr                    sprite;
  469.         NodeRefPtr                      node;
  470.         HotSpotRefPtr                   hotSpot;
  471.     }                                 obj;
  472. };
  473. typedef struct MovieObjectRef           MovieObjectRef;
  474. typedef MovieObjectRef *                MovieObjectRefPtr;
  476. #define    MOVIE_OBJECT_REF_TYPE(ref)  ((ref) ? (ref)->obj.generic->objType : 0)
  479. struct MovieRef {
  480.     TrackRefPtr                     parent;                     /* track or NULL if is root movie*/
  481.     TrackRefPtr                     child;                      /* child track */
  482.     OSType                          objType;
  483.     Movie                           movie;
  484.     MovieController                 controller;
  485.     DoMCActionUPP                   mcActionFilterUPP;          /* UPP of MovieMedia movie controller's filter proc*/
  486.     void *                          mcActionRefcon;             /* refcon for same*/
  487. };
  490. struct TrackRef {
  491.     MovieRefPtr                     parent;                     /* parent movie */
  492.     GenericRefPtr                   child;                      /* child scene or node */
  493.     OSType                          objType;
  494.     UInt32                          flags;
  495.     OSType                          trackType;
  496.     Track                           track;
  497.     SInt32                          id;
  498.     SInt32                          index;
  499.     Media                           media;
  501.                                                                 /* VR only data*/
  502.     QTVRInstance                    vrInstance;
  503.     QTAtomContainer                 vrWorld;
  504. };
  507. struct SceneRef {
  508.     TrackRefPtr                     parent;                     /* parent track */
  509.     SpriteRefPtr                    child;                      /* child sprite */
  510.     OSType                          objType;
  511.     SInt32                          index;                      /* ID is the same as index*/
  512.     TimeValue                       startTime;
  513.     TimeValue                       duration;
  514.     SInt32                          currentSceneIndex;
  515. };
  518. struct SpriteRef {
  519.     SceneRefPtr                     parent;
  520.     GenericRefPtr                   child;                      /* NULL, sprites have no children */
  521.     OSType                          objType;
  522.     MediaHandler                    handler;
  523.     QTAtomID                        id;
  524.     SInt16                          index;
  525. };
  528. struct NodeRef {
  529.     TrackRefPtr                     parent;                     /* parent track */
  530.     HotSpotRefPtr                   child;                      /* NULL, */
  531.     OSType                          objType;
  532.     QTAtomContainer                 info;
  533.     QTAtomID                        id;
  534.     SInt16                          index;
  535.     UInt16                          flags;
  536. };
  539. struct HotSpotRef {
  540.     NodeRefPtr                      parent;                     /* parent node */
  541.     GenericRefPtr                   child;                      /* NULL, hotspots have no children */
  542.     OSType                          objType;
  543.     QTAtomID                        id;
  544.     SInt16                          index;
  545. };
  547. enum {
  548.     kReserved1                  = (1L << 0),
  549.     kReserved2                  = (1L << 1),
  550.     kHasAudioCharacteristics    = (1L << 2),
  551.     kHasVisualCharacteristics   = (1L << 3),
  552.     kHasTextCharacteristics     = (1L << 4),
  553.     kCanSendVideoCharacteristics = (1L << 5),
  554.     kProvidesActionsCharacteristics = (1L << 6),
  555.     kHasNonLinearCharacteristics = (1L << 7),
  556.     kHasCanStepCharacteristics  = (1L << 8),
  557.     kHasNoDurationCharacteristics = (1L << 9),                  /* not really "characteristics", but hey...*/
  558.     kHasSpriteCharacteristics   = (1L << 10),
  559.     kHasVRCharacteristics       = (1L << 11),
  560.     kHasStreamingCharacteristics = (1L << 12),
  561.     kHasMovieCharacteristics    = (1L << 13)
  562. };
  566. /* == data types ==*/
  568. enum {
  569.     kPtrToDataType              = (1L << 31),
  570.     dataType_Boolean            = FOUR_CHAR_CODE('bool'),
  571.     dataType_BooleanPtr         = (dataType_Boolean | kPtrToDataType),
  572.     dataType_UInt8              = FOUR_CHAR_CODE('ui8 '),
  573.     dataType_UInt8Ptr           = (dataType_Boolean | kPtrToDataType),
  574.     dataType_Int8               = FOUR_CHAR_CODE('i8  '),
  575.     dataType_Int8Ptr            = (dataType_Int8 | kPtrToDataType),
  576.     dataType_UInt16             = FOUR_CHAR_CODE('ui16'),
  577.     dataType_UInt16Ptr          = (dataType_UInt16 | kPtrToDataType),
  578.     dataType_Int16              = FOUR_CHAR_CODE('i16 '),
  579.     dataType_Int16Ptr           = (dataType_Int16 | kPtrToDataType),
  580.     dataType_UInt32             = FOUR_CHAR_CODE('ui32'),
  581.     dataType_UInt32Ptr          = (dataType_UInt32 | kPtrToDataType),
  582.     dataType_Int32              = FOUR_CHAR_CODE('i32 '),
  583.     dataType_Int32Ptr           = (dataType_Int32 | kPtrToDataType),
  584.     dataType_FourCharCode       = FOUR_CHAR_CODE('code'),
  585.     dataType_FourCharCodePtr    = (dataType_FourCharCode | kPtrToDataType),
  586.     dataType_RGBColor           = FOUR_CHAR_CODE('rgba'),
  587.     dataType_RGBColorPtr        = (dataType_RGBColor | kPtrToDataType),
  588.     dataType_Fixed              = FOUR_CHAR_CODE('fix '),
  589.     dataType_FixedPtr           = (dataType_Fixed | kPtrToDataType),
  590.     dataType_FloatSingle        = FOUR_CHAR_CODE('fsin'),
  591.     dataType_FloatSinglePtr     = (dataType_FloatSingle | kPtrToDataType),
  592.     dataType_FloatDouble        = FOUR_CHAR_CODE('fdbl'),
  593.     dataType_FloatDoublePtr     = (dataType_FloatDouble | kPtrToDataType),
  594.     dataType_QDPoint            = FOUR_CHAR_CODE('poin'),
  595.     dataType_QDPointPtr         = (dataType_QDPoint | kPtrToDataType),
  596.     dataType_FixedPoint         = FOUR_CHAR_CODE('fixp'),
  597.     dataType_FixedPointPtr      = (dataType_FixedPoint | kPtrToDataType),
  598.     dataType_QDRect             = FOUR_CHAR_CODE('rect'),
  599.     dataType_QDRectPtr          = (dataType_QDRect | kPtrToDataType),
  600.     dataType_QDRegion           = FOUR_CHAR_CODE('rgn '),
  601.     dataType_QDRegionPtr        = (dataType_QDRegion | kPtrToDataType),
  602.     dataType_PString            = FOUR_CHAR_CODE('pstr'),
  603.     dataType_PStringPtr         = (dataType_PString | kPtrToDataType),
  604.     dataType_CString            = FOUR_CHAR_CODE('cstr'),
  605.     dataType_CStringPtr         = (dataType_CString | kPtrToDataType),
  606.     dataType_CharBuff           = FOUR_CHAR_CODE('cbuf'),
  607.     dataType_CharBuffPtr        = (dataType_CharBuff | kPtrToDataType),
  608.     dataType_TextHandle         = FOUR_CHAR_CODE('text'),
  609.     dataType_TextHandlePtr      = (dataType_TextHandle | kPtrToDataType),
  610.     dataType_Matrix             = FOUR_CHAR_CODE('matr'),
  611.     dataType_MatrixPtr          = (dataType_Matrix | kPtrToDataType),
  612.     dataType_Alias              = FOUR_CHAR_CODE('alis'),
  613.     dataType_AliasPtr           = (dataType_Alias | kPtrToDataType),
  614.     dataType_MacDate            = FOUR_CHAR_CODE('date'),
  615.     dataType_MacDatePtr         = (dataType_MacDate | kPtrToDataType),
  616.     dataType_TimeValue          = FOUR_CHAR_CODE('time'),
  617.     dataType_TimeValuePtr       = (dataType_TimeValue | kPtrToDataType),
  618.     dataType_BCDVersion         = FOUR_CHAR_CODE('vers'),
  619.     dataType_BCDVersionPtr      = (dataType_BCDVersion | kPtrToDataType),
  620.     dataType_Opaque             = FOUR_CHAR_CODE('void'),
  621.     dataType_OpaquePtr          = (dataType_Opaque | kPtrToDataType),
  622.     dataType_GraphicsMode       = FOUR_CHAR_CODE('gmod'),
  623.     dataType_GraphicsModePtr    = (dataType_GraphicsMode | kPtrToDataType),
  624.     dataType_GraphicsModeRecord = FOUR_CHAR_CODE('gmrc'),
  625.     dataType_GraphicsModeRecordPtr = (dataType_GraphicsModeRecord | kPtrToDataType),
  626.     dataType_QTSProxyPref       = FOUR_CHAR_CODE('prxy'),
  627.     dataType_QTSProxyPrefPtr    = (dataType_QTSProxyPref | kPtrToDataType),
  628.     dataType_QTSTransportPref   = FOUR_CHAR_CODE('trns'),
  629.     dataType_QTSTransportPrefPtr = (dataType_QTSTransportPref | kPtrToDataType),
  630.     dataType_QTSNoProxyPref     = FOUR_CHAR_CODE('nprx'),
  631.     dataType_QTSNoProxyPrefPtr  = (dataType_QTSNoProxyPref | kPtrToDataType),
  632.     dataType_FindOffset         = FOUR_CHAR_CODE('find'),
  633.     dataType_FindOffsetPtr      = (dataType_FindOffset | kPtrToDataType)
  634. };
  637. /* == movie manager notification flags == */
  638. enum {
  639.     kNotifyBeforeMessageSend    = (1L << 0),                    /* notify before a message is sent to an object*/
  640.     kNotifyAfterMessageSend     = (1L << 1),                    /* notify after a message was successfully sent to an object*/
  641.     kNotifyOnHighLevelEvent     = (1L << 2),                    /* notify before high level events*/
  642.     kNotifyOnMouseEvent         = (1L << 3),                    /* notify before mouse up/down/enter/exit/trigger events*/
  643.     kNotifyOnMCActionEvent      = (1L << 4)                     /* notify before looking at mcAction events*/
  644. };
  647. /* == movie manager notification types ==*/
  648. enum {
  649.                                                                 /* ***/
  650.                                                                 /* notification types*/
  651.     kNotifyTypeHighLevelEvent   = FOUR_CHAR_CODE('high'),       /* hight level event (HighLevelEventRecord *)*/
  652.     kNotifyTypeMCAction         = FOUR_CHAR_CODE('mcac'),       /* mcAction notification (MMgrControllerEventRecord *)*/
  653.     kNotifyMouseEvent           = FOUR_CHAR_CODE('mous'),       /* mouse event*/
  654.     kNotifyTypePreMessageSend   = FOUR_CHAR_CODE('prms'),       /* message send (MovieObjectRef *)*/
  655.     kNotifyTypePostMessageSend  = FOUR_CHAR_CODE('poms')        /* */
  656. };
  658. /* == movie manager notification IDs ==*/
  659. enum {
  660.                                                                 /* ***/
  661.                                                                 /* "high level" events*/
  662.     kNotifyOpenMovie            = FOUR_CHAR_CODE('open'),
  663.     kNotifyCloseMovie           = FOUR_CHAR_CODE('clos'),
  664.     kNotifyEnteringNode         = FOUR_CHAR_CODE('vren'),       /* entering node, data = new node ID (SInt32)*/
  665.     kNotifyLeavingNode          = FOUR_CHAR_CODE('vrlv'),       /* leaving VR node, data = leave node data (LeaveNodeRecord *)*/
  666.                                                                 /* ?? */
  667.                                                                 /* ????? does it make sense to send these notifications? User could use the notification to set the*/
  668.                                                                 /* ?????  movieID/movieName property, which would then be returned...*/
  669.                                                                 /*@@@@@   kGetExternalMovieID,*/
  670.                                                                 /*@@@@@   kGetExternalMovieName,*/
  671.                                                                 /* ?????*/
  672.     kNotifyEdited               = FOUR_CHAR_CODE('edit'),       /* movie has been edited*/
  673.     kNotifyLinkToURL            = FOUR_CHAR_CODE('lurl'),       /* the movie wants to link to a url, data = URL (handle of C string)*/
  674.     kNotifyRateChanged          = FOUR_CHAR_CODE('rate'),       /* the movie's rate has changed, data = rate (Fixed)*/
  675.     kNotifyTimeChanged          = FOUR_CHAR_CODE('ctim'),       /* the movie's time has changed, data = new time (SInt32)*/
  676.     kNotifyVolumeChanged        = FOUR_CHAR_CODE('cvol'),       /* the movie's volume has changed, data = new volume (SInt32)*/
  677.     kNotifyShowStatusString     = FOUR_CHAR_CODE('stts'),       /* a movie status message, data = status string (handle of C string)*/
  678.     kNotifyShowMessageString    = FOUR_CHAR_CODE('smsg'),       /* a sprite message string (mcActionShowMessageString), data = string (StringPtr)*/
  679.     kNotifySpriteCustomAction   = FOUR_CHAR_CODE('scst'),       /* a sprite custom app wired event (kActionApplicationNumberAndString), data = params (SpriteDebugMessage *)*/
  680.     kNotifySpriteDebugStr       = FOUR_CHAR_CODE('sdbg'),       /* a sprite debugstr wired event (kActionDebugStr), param = string (stringPtr)*/
  681.                                                                 /* ***/
  682.                                                                 /* mouse event notification*/
  683.     kNotifyMouseEnter           = FOUR_CHAR_CODE('entr'),       /* mouse has entered a movie object, data = object ID (SInt32)*/
  684.     kNotifyMouseWithin          = FOUR_CHAR_CODE('mwin'),       /* mouse is still within a movie object, data = object ID (SInt32)*/
  685.     kNotifyMouseExit            = FOUR_CHAR_CODE('exit'),       /* mouse has left the building, data = object ID (SInt32)*/
  686.     kNotifyMouseDown            = FOUR_CHAR_CODE('clik'),       /* mouse clicked within a movie object, data = object ID (SInt32)*/
  687.     kNotifyMouseStillDown       = FOUR_CHAR_CODE('stld'),       /* mouse is still down within a movie object, data = object ID (SInt32)*/
  688.     kNotifyMouseTrigger         = FOUR_CHAR_CODE('trig'),       /* mouse released within the movie object it went down in, data = object ID (SInt32)*/
  689.     kNotifyMouseUp              = FOUR_CHAR_CODE('cend')        /* mouse released outside of the movie object it went down in, data = object ID (SInt32)*/
  690. };
  693. /*
  694.    **
  695.    == movie manager event record == 
  696. */
  698. struct MMgrEventRecord {
  699.     OSType                          objClass;                   /* class of event target object*/
  700.     SInt32                          when;                       /* ticks at time of event*/
  701.     Point                           where;                      /* local mouse loc at time of event*/
  702.     UInt32                          flags;
  703. };
  704. typedef struct MMgrEventRecord          MMgrEventRecord;
  705. typedef MMgrEventRecord *               MMgrEventRecordPtr;
  706. /*
  707.    **
  708.    == structure passed to notification proc for a controller filter event notification ==
  709. */
  711. struct MMgrControllerEventRecord {
  712.     void *                          params;                     /* param normally passed to controller filter for this action*/
  713.     SInt16                          action;                     /* action*/
  714. };
  715. typedef struct MMgrControllerEventRecord MMgrControllerEventRecord;
  716. typedef MMgrControllerEventRecord *     MMgrControllerEventRecordPtr;
  717. /*
  718.    **
  719.    == structure passed to notification proc for pre/post message send ==
  720. */
  722. struct MMgrMessageNotificationRecord {
  723.     MovieObjectRef *                targetObject;               /* resolved movie object target*/
  724.     MessageClass                    msgClass;                   /* message class*/
  725.     MessageID                       msgID;                      /* message ID*/
  726.     PropertyParams *                params;                     /* message params*/
  727. };
  728. typedef struct MMgrMessageNotificationRecord MMgrMessageNotificationRecord;
  729. typedef MMgrMessageNotificationRecord * MMgrMessageNotificationRecordPtr;
  730. /*
  731.    **
  732.    == movie manager hight level event notification record == 
  733. */
  735. struct HighLevelEventRecord {
  736.     OSType                          eventID;
  737.     void *                          data;                       /* event specific params*/
  738. };
  739. typedef struct HighLevelEventRecord     HighLevelEventRecord;
  741. /*
  742.    **
  743.    == structure passed to notification proc for a sprite kNotifySpriteCustomAction (kActionApplicationNumberAndString) notification ==
  744. */
  746. struct SpriteDebugMessage {
  747.     SInt32                          number;                     /* sprite action param 1, a long*/
  748.     Handle                          stringHandle;               /* sprite action param 2, a Pascal string*/
  749. };
  750. typedef struct SpriteDebugMessage       SpriteDebugMessage;
  751. typedef SpriteDebugMessage *            SpriteDebugMessagePtr;
  752. /*
  753.    **
  754.    == structure passed to notification proc upon leaving a VR node ==
  755. */
  757. struct LeaveNodeRecord {
  758.     UInt32                          fromNodeID;                 /* the id of the node we're about to leave*/
  759.     UInt32                          toNodeID;                   /* the id of the node we're about to enter*/
  760. };
  761. typedef struct LeaveNodeRecord          LeaveNodeRecord;
  762. typedef LeaveNodeRecord *               LeaveNodeRecordPtr;
  763. /* == movie manager errors == */
  764. enum {
  765.     errInvalidTrackType         = -2300,
  766.     errCurrentSceneOnly         = -2301,
  767.     errNoSuchScene              = -2302,
  768.     errCantCoerceValue          = -2303,
  769.     errPropNotSupported         = -2304,
  770.     errCmdNotSupported          = -2305,
  771.     errParamCountOutOfBounds    = -2306,
  772.     errNotImplementedYet        = -2307,
  773.     errBadLanguageForThisMovie  = -2308,
  774.     errReadOnly                 = -2319,
  775.     errInvalidTimeForThisMovie  = -2310,
  776.     errNoExporterSet            = -2311,
  777.     errMovieNotEditable         = -2312
  778. };
  780. /*
  781.    **
  782.    == messaging callback ==
  783. */
  785. typedef CALLBACK_API( OSErr , MovieManagerFilterProcPtr )(Movie movie, MovieController mc, OSType eventType, MMgrEventRecord *evt, void *evtData, void *refCon);
  786. typedef STACK_UPP_TYPE(MovieManagerFilterProcPtr)               MovieManagerFilterUPP;
  787. /* == selector ranges == */
  788. enum {
  789.     selectorRange_MooVMgr       = 0x0000
  790. };
  793. enum {
  794.     kMovieManagerCompType       = FOUR_CHAR_CODE('mngr'),
  795.     kMovieManagerSubType        = FOUR_CHAR_CODE('moov')
  796. };
  798. enum {
  799.     kMooVMgrSetMovieSelect      = selectorRange_MooVMgr + 1,
  800.     kMooVMgrGetMovieSelect      = 0x0002,
  801.     kMooVMgrSetMovieControllerSelect = 0x0003,
  802.     kMooVMgrGetMovieControllerSelect = 0x0004,
  803.     kMooVMgrObjectExistsSelect  = 0x0005,
  804.     kMooVMgrCountObjectsSelect  = 0x0006,
  805.     kMooVMgrSendMessageToObjectSelect = 0x0007,
  806.     kMooVMgrMapNameToIDSelect   = 0x0008,
  807.     kMooVMgrCoerceValueToTypeSelect = 0x0009,
  808.     kMooVMgrSetNotificationFlagsSelect = 0x000A,
  809.     kMooVMgrGetNotificationFlagsSelect = 0x000B,
  810.     kMooVMgrSetNotificationProcSelect = 0x000C,
  811.     kMooVMgrGetObjectProperty   = 0x000D,
  812.     kMooVMgrSetObjectProperty   = 0x000E
  813. };
  817. /* = standard component stuff = */
  819. #if CALL_NOT_IN_CARBON
  820. EXTERN_API( ComponentResult )
  821. MovieManagerOpen                (MovieManagerComponent  moovMgr,
  822.                                  ComponentInstance      self)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0xFFFF, 0x7000, 0xA82A);
  824. EXTERN_API( ComponentResult )
  825. MovieManagerClose               (MovieManagerComponent  moovMgr,
  826.                                  ComponentInstance      self)                               FIVEWORDINLINE(0x2F3C, 0x0004, 0xFFFE, 0x7000, 0xA82A);
  828. EXTERN_API( ComponentResult )
  829. MovieManagerCanDo               (MovieManagerComponent  moovMgr,
  830.                                  SInt16                 ftnNumber)                          FIVEWORDINLINE(0x2F3C, 0x0002, 0xFFFD, 0x7000, 0xA82A);
  832. EXTERN_API( ComponentResult )
  833. MovieManagerVersion             (MovieManagerComponent  moovMgr)                            FIVEWORDINLINE(0x2F3C, 0x0000, 0xFFFC, 0x7000, 0xA82A);
  835. EXTERN_API( ComponentResult )
  836. MovieManagerTarget              (MovieManagerComponent  moovMgr,
  837.                                  ComponentInstance      target)                             FIVEWORDINLINE(0x2F3C, 0x0004, 0xFFFA, 0x7000, 0xA82A);
  840. /* = initialization, hierarchy, editing = */
  842. EXTERN_API( ComponentResult )
  843. MovieManagerSetMovie            (MovieManagerComponent  moovMgr,
  844.                                  Movie                  movie)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0001, 0x7000, 0xA82A);
  846. EXTERN_API( ComponentResult )
  847. MovieManagerGetMovie            (MovieManagerComponent  moovMgr,
  848.                                  Movie *                movie)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x0002, 0x7000, 0xA82A);
  850. EXTERN_API( ComponentResult )
  851. MovieManagerSetMovieController  (MovieManagerComponent  moovMgr,
  852.                                  MovieController        controller)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0003, 0x7000, 0xA82A);
  854. EXTERN_API( ComponentResult )
  855. MovieManagerGetMovieController  (MovieManagerComponent  moovMgr,
  856.                                  MovieController *      controller)                         FIVEWORDINLINE(0x2F3C, 0x0004, 0x0004, 0x7000, 0xA82A);
  859. /* = movie objects = */
  861. EXTERN_API( ComponentResult )
  862. MovieManagerObjectExists        (MovieManagerComponent  moovMgr,
  863.                                  MovieObjectSpec *      objectSpec,
  864.                                  Boolean *              exists)                             FIVEWORDINLINE(0x2F3C, 0x0008, 0x0005, 0x7000, 0xA82A);
  866. EXTERN_API( ComponentResult )
  867. MovieManagerCountObjects        (MovieManagerComponent  moovMgr,
  868.                                  OSType                 countClass,
  869.                                  MovieObjectSpec *      objectSpec,
  870.                                  SInt32 *               count)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x0006, 0x7000, 0xA82A);
  873. /* = property/message = */
  875. EXTERN_API( ComponentResult )
  876. MovieManagerSendMessageToObject (MovieManagerComponent  moovMgr,
  877.                                  MovieObjectSpec *      objectSpec,
  878.                                  MessageClass           msgClass,
  879.                                  MessageID              msgID,
  880.                                  PropertyParams *       params)                             FIVEWORDINLINE(0x2F3C, 0x0010, 0x0007, 0x7000, 0xA82A);
  882. EXTERN_API( ComponentResult )
  883. MovieManagerMapNameToID         (MovieManagerComponent  moovMgr,
  884.                                  StringPtr              name,
  885.                                  OSType *               id)                                 FIVEWORDINLINE(0x2F3C, 0x0008, 0x0008, 0x7000, 0xA82A);
  887. EXTERN_API( ComponentResult )
  888. MovieManagerCoerceValueToType   (MovieManagerComponent  moovMgr,
  889.                                  PropArgU *             dst,
  890.                                  ValueFormat            dstType,
  891.                                  PropArgU *             src)                                FIVEWORDINLINE(0x2F3C, 0x000C, 0x0009, 0x7000, 0xA82A);
  893. /* = notification */
  894. EXTERN_API( ComponentResult )
  895. MovieManagerSetNotificationFlags (MovieManagerComponent  moovMgr,
  896.                                  UInt32                 flags,
  897.                                  UInt32                 flagsMask)                          FIVEWORDINLINE(0x2F3C, 0x0008, 0x000A, 0x7000, 0xA82A);
  899. EXTERN_API( ComponentResult )
  900. MovieManagerGetNotificationFlags (MovieManagerComponent  moovMgr,
  901.                                  UInt32 *               flags)                              FIVEWORDINLINE(0x2F3C, 0x0004, 0x000B, 0x7000, 0xA82A);
  903. EXTERN_API( ComponentResult )
  904. MovieManagerSetNotificationProc (MovieManagerComponent  moovMgr,
  905.                                  MovieManagerFilterUPP  callback,
  906.                                  const void *           refCon,
  907.                                  UInt32                 flags)                              FIVEWORDINLINE(0x2F3C, 0x000C, 0x000C, 0x7000, 0xA82A);
  910. /* = obsolete, to be removed after OS X beta*/
  911. EXTERN_API( ComponentResult )
  912. MovieManagerGetObjectProperty   (MovieManagerComponent  moovMgr,
  913.                                  MovieObjectSpec *      objectSpec,
  914.                                  PropertyID             propID,
  915.                                  PropertyParams *       params)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x000D, 0x7000, 0xA82A);
  917. EXTERN_API( ComponentResult )
  918. MovieManagerSetObjectProperty   (MovieManagerComponent  moovMgr,
  919.                                  MovieObjectSpec *      objectSpec,
  920.                                  PropertyID             propID,
  921.                                  PropertyParams *       params)                             FIVEWORDINLINE(0x2F3C, 0x000C, 0x000E, 0x7000, 0xA82A);
  926. /* selectors for component calls */
  927. enum {
  928.     kMovieManagerOpenSelect                    = -1,
  929.     kMovieManagerCloseSelect                   = -2,
  930.     kMovieManagerCanDoSelect                   = -3,
  931.     kMovieManagerVersionSelect                 = -4,
  932.     kMovieManagerTargetSelect                  = -6,
  933.     kMovieManagerSetMovieSelect                = 0x0001,
  934.     kMovieManagerGetMovieSelect                = 0x0002,
  935.     kMovieManagerSetMovieControllerSelect      = 0x0003,
  936.     kMovieManagerGetMovieControllerSelect      = 0x0004,
  937.     kMovieManagerObjectExistsSelect            = 0x0005,
  938.     kMovieManagerCountObjectsSelect            = 0x0006,
  939.     kMovieManagerSendMessageToObjectSelect     = 0x0007,
  940.     kMovieManagerMapNameToIDSelect             = 0x0008,
  941.     kMovieManagerCoerceValueToTypeSelect       = 0x0009,
  942.     kMovieManagerSetNotificationFlagsSelect    = 0x000A,
  943.     kMovieManagerGetNotificationFlagsSelect    = 0x000B,
  944.     kMovieManagerSetNotificationProcSelect     = 0x000C,
  945.     kMovieManagerGetObjectPropertySelect       = 0x000D,
  946.     kMovieManagerSetObjectPropertySelect       = 0x000E
  947. };
  948. #endif  /* CALL_NOT_IN_CARBON */
  950. #if OPAQUE_UPP_TYPES
  951. #if CALL_NOT_IN_CARBON
  952.     EXTERN_API(MovieManagerFilterUPP)
  953.     NewMovieManagerFilterUPP       (MovieManagerFilterProcPtr userRoutine);
  955.     EXTERN_API(void)
  956.     DisposeMovieManagerFilterUPP    (MovieManagerFilterUPP  userUPP);
  958.     EXTERN_API(OSErr)
  959.     InvokeMovieManagerFilterUPP    (Movie                   movie,
  960.                                     MovieController         mc,
  961.                                     OSType                  eventType,
  962.                                     MMgrEventRecord *       evt,
  963.                                     void *                  evtData,
  964.                                     void *                  refCon,
  965.                                     MovieManagerFilterUPP   userUPP);
  967. #endif  /* CALL_NOT_IN_CARBON */
  969. #else
  970.     enum { uppMovieManagerFilterProcInfo = 0x0003FFE0 };            /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
  971.     #define NewMovieManagerFilterUPP(userRoutine)                   (MovieManagerFilterUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppMovieManagerFilterProcInfo, GetCurrentArchitecture())
  972.     #define DisposeMovieManagerFilterUPP(userUPP)                   DisposeRoutineDescriptor(userUPP)
  973.     #define InvokeMovieManagerFilterUPP(movie, mc, eventType, evt, evtData, refCon, userUPP)  (OSErr)CALL_SIX_PARAMETER_UPP((userUPP), uppMovieManagerFilterProcInfo, (movie), (mc), (eventType), (evt), (evtData), (refCon))
  974. #endif
  975. /* support for pre-Carbon UPP routines: NewXXXProc and CallXXXProc */
  976. #define NewMovieManagerFilterProc(userRoutine)                  NewMovieManagerFilterUPP(userRoutine)
  977. #define CallMovieManagerFilterProc(userRoutine, movie, mc, eventType, evt, evtData, refCon) InvokeMovieManagerFilterUPP(movie, mc, eventType, evt, evtData, refCon, userRoutine)
  979. #if PRAGMA_STRUCT_ALIGN
  980.     #pragma options align=reset
  981. #elif PRAGMA_STRUCT_PACKPUSH
  982.     #pragma pack(pop)
  983. #elif PRAGMA_STRUCT_PACK
  984.     #pragma pack()
  985. #endif
  987. #ifdef PRAGMA_IMPORT_OFF
  988. #pragma import off
  989. #elif PRAGMA_IMPORT
  990. #pragma import reset
  991. #endif
  993. #ifdef __cplusplus
  994. }
  995. #endif
  997. #endif /* __MOVIEMANAGER__ */