Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## quicktime.std.movies
Class Movie

    java.lang.Object
      |
      +--quicktime.QTObject
            |
            +--quicktime.std.movies.Movie

All Implemented Interfaces:
  quicktime.jdirect.InterfaceLib, quicktime.jdirect.PrimitivesLib, quicktime.jdirect.QuickTimeLib, quicktime.jdirect.QuickTimeVRLib, com.apple.jdirect.SharedLibrary, quicktime.jdirect.SharedLibrary

public final class Movie
extends QTObject
implements quicktime.jdirect.QuickTimeLib, quicktime.jdirect.QuickTimeVRLib

The Movie class implements methods for the corresponding QuickTime structure. A QuickTime movie can consist of data in sequences from different forms, such as analog video and CD-ROM. The movie is not the medium; it is the organizing principle.

A QuickTime movie may contain several Tracks. Each track refers to a single media type that contains references to the movie data, which may be stored as images or sounds on various kinds of storage media.

Movie objects can be made from various sources that contain existing QuickTime movie data, such as memory, files, urls. To make a movie from an existing movie source you use the from... class calls. If you wish to make a new movie that you will construct yourself you use the movie constructor.

If an application installs either a MovieProgress or MovieDrawingComplete callback, then it must remove these callbacks when it has finished with them to allow the native structures used in these callbacks to be properly disposed.

Fields inherited from interface quicktime.jdirect.QuickTimeLib
`JDirect_MacOSX, libraryInstance, name`

Fields inherited from interface quicktime.jdirect.QuickTimeVRLib
`JDirect_MacOSX, libraryInstance`

Constructor Summary
`Movie()` This method creates a new movie in memory.
`Movie(int flags)` This method creates a new movie in memory.

Method Summary
`void` | `abortPrePreroll(int err)` This method aborts.
`Track` | `addEmptyTrack(Track srcTrack, DataRef dataRef)` This method adds an empty track to the movie.
`void` | `addExecuteWiredActionsProc(ExecutingWiredAction wa)` This method allows you to intercept executing wired actions of this movie.
`int` | `addResource(OpenMovieFile fileOut, int resID, java.lang.String resourceName)` This method adds a movie resource to a specified resource file.
`void` | `addSelection(Movie srcMovie)` This method adds one or more tracks to a movie.
`Track` | `addTrack(float width, float height, float trackVolume)` Create a track in a movie.
`void` | `clearChanged()` This method sets the movie changed flag to indicate that the movie has not been changed.
`void` | `clearSelection()` This method removes the segment of the movie that is defined by the current selection.
`int` | `convertToFile(QTFile outputFile, int fileType, int creator, int scriptTag)` This method converts this movie into a specified file and type.
`int` | `convertToFile(QTFile outputFile, int fileType, int creator, int scriptTag, int flags)` This method converts this movie into a specified file and type.
`int` | `convertToFile(Track onlyTrack, QTFile outputFile, int fileType, int creator, int scriptTag)` This method converts this movie into a specified file and type.
`int` | `convertToFile(Track onlyTrack, QTFile outputFile, int fileType, int creator, int scriptTag, int flags, MovieExporter userComp)` This method converts this movie into a specified file and type.
`Movie` | `copySelection()` This method creates a new movie that contains the original movie's current selection.
`void` | `copySettings(Movie dstMovie)` The copySettings method copies many settings from one movie to another, overwriting the destination settings in the process.
`static Movie` | `createMovieFile(QTFile pathName, int fCreator, int flags)` Creates a Movie object and the file as specified by the QTFile.
`Movie` | `cutSelection()` This method creates a new movie that contains the original movie's current selection.
`void` | `deleteSegment(int startTime, int duration)` This method removes a specified segment from a movie.
`void` | `executeWiredActions(int flags, AtomContainer actions)` This method executes specified wired actions associated with the movie
`int` | `flatten(int movieFlattenFlags, QTFile fileOut, int creator, int scriptTag, int createQTFileFlags, int resID, java.lang.String resName)` This method creates a new movie file containing a specified movie.
`Movie` | `flattenData(int movieFlattenFlags, QTFile fileOut, int creator, int scriptTag, int createQTFileFlags)` This method creates a new movie file and creates a new movie that contains all of its movie data.
`Movie` | `flattenData(int movieFlattenFlags, QTHandle handle)` This method creates a new movie that contains all of its movie data loaded into memory.
`static Movie` | `fromDataFork(OpenFile fileIn, int fileOffset, int flags, MovieInfo info)` This method enables you to retrieve a movie that is stored anywhere in the data fork of a specified file.
`static Movie` | `fromDataRef(DataRef defaultDataRef, int flags)` This method enables you to retrieve a movie from any data reference.
`static Movie` | `fromFile(OpenMovieFile fileIn)` This method creates a movie in memory from a resource that is stored in a movie file.
`static Movie` | `fromFile(OpenMovieFile fileIn, int flags, MovieInfo info)` This method creates a movie in memory from a resource that is stored in a movie file.
`static Movie` | `fromHandle(QTHandle hand)` This method creates a movie in memory from a movie resource or a handle you obtained from the PutMovieIntoHandle function.
`static Movie` | `fromHandle(QTHandle hand, int flags, MovieInfo info)` This method creates a movie in memory from a movie resource or a handle you obtained from the PutMovieIntoHandle function.
`static Movie` | `fromScrap(int newMovieFlags)` This method allows your application to create a movie from the contents of the scrap.
`static Movie` | `fromSequenceGrabber(SequenceGrabber sg)` Determines a reference to the movie that contains the data collected during a record operation.
`boolean` | `getActive()` This method returns a boolean value.
`TimeInfo` | `getActiveSegment()` This method allows your application to determine what portion of a movie is currently active for playing.
`QDRect` | `getBounds()` This method returns a movie's boundary rectangle, which is a rectangle that encompasses all of the movie's enabled tracks.
`Region` | `getBoundsRgn()` This method allows your application to determine a movie's boundary region.
`QDRect` | `getBox()` This method returns a movie's boundary rectangle, which is a rectangle that encompasses all of the movie's enabled tracks.
`Region` | `getClipRgn()` This method allows your application to determine a movie's clipping region.
`ColorTable` | `getColorTable()` This method allows your application to get the color table of the movie.
`int` | `getCreationTime()` This method returns a long integer that contains the movie's creation date and time information.
`int` | `getDataSize(int startTime, int duration)` This method allows your application to determine the size, in bytes, of the sample data in a segment of a movie.
`DataRef` | `getDefaultDataRef()` This method allows your application to get the default data reference for the movie.
`Region` | `getDisplayBoundsRgn()` This method allows your application to determine a movie's display boundary region.
`Region` | `getDisplayClipRgn()` This method allows your application to determine a movie's current display clipping region.
`int` | `getDuration()` This method returns the duration of a movie.
`QDGraphics` | `getGWorld()` Your application can determine a movie's graphics world by calling the getGWorld method.
`Track` | `getIndTrack(int index)` This method allows your application to determine the track identifier of a track given the track's index value.
`Track` | `getIndTrackType(int index, int trackType, int flags)` This method allows your application to determine the track identifier of a track given a track type and an index value.
`Matrix` | `getMatrix()` This method allows allows your application to retrieve a movie's transformation matrix.
`int` | `getModificationTime()` This method returns a long integer that contains the movie's creation date and time information.
`QDRect` | `getNaturalBoundsRect()` No QT Documentation.
`TimeInfo` | `getNextInterestingTime(int interestingTimeFlags, int[] mediaTypes, int time, float rate)` This method searches for times of interest in a movie.
`Track` | `getNextTrackForCompositing(Track theTrack)` No QT Documentation.
`Pict` | `getPict(int time)` This method creates a picture from the specified movie at the specified time.
`QDRect` | `getPosterBox()` This method allows you to obtain a poster's boundary rectangle.
`Pict` | `getPosterPict()` This method creates a picture that contains a movie's poster.
`int` | `getPosterTime()` This method returns the poster's time in the movie.
`float` | `getPreferredRate()` This method returns a movie's default playback rate.
`float` | `getPreferredVolume()` This method returns a movie's preferred volume setting.
`boolean` | `getPreviewMode()` This method allows your application to determine whether a movie is in preview mode.
`TimeInfo` | `getPreviewTime()` This method returns the starting time and duration of the movie's preview.
`Track` | `getPrevTrackForCompositing(Track theTrack)` No QT Documentation.
`Track` | `getQTVRTrack(int index)` The QTVRGetQTVRTrack function returns a track for the QTVR track that has the index specified by the index parameter in the QuickTime movie specified by the theMovie parameter.
`float` | `getRate()` This method returns a movie's playback rate.
`Region` | `getSegmentDisplayBoundsRgn(int time, int duration)` This method allows your application to determine a movie's display boundary region during a specified segment.
`TimeInfo` | `getSelection()` This method returns information about a movie's current selection.
`StatusInfo` | `getStatus()` This method searches for errors in all the enabled tracks of the movie.
`int` | `getTime()` This method returns a movie's current time.
`TimeBase` | `getTimeBase()` This method allows you to get movie's TimeBase.
`int` | `getTimeScale()` This method returns the time scale of a movie.
`Track` | `getTrack(int trackID)` This method allows your application to determine the track identifier of a track given the track's ID value.
`int` | `getTrackCount()` This method returns the number of tracks in a movie.
`TimeRecord` | `getTRTime()` This method returns a movie's current time as a TimeRecord object.
`UserData` | `getUserData()` This method allows your application to obtain access to a movie's user data list.
`float` | `getVolume()` This method returns movie's current volume setting.
`void` | `goToBeginning()` This method repositions a movie to play from its start.
`void` | `goToEnd()` This method repositions a movie to play from its end.
`boolean` | `hasChanged()` This method allows your application to determine whether a movie has changed and needs to be saved.
`void` | `insertEmptySegment(int dstIn, int dstDuration)` This method adds an empty segment to a movie.
`void` | `insertSegment(Movie dstMovie, int srcIn, int srcDuration, int dstIn)` The insertSegment method copies part of one movie to another.
`void` | `invalidateRegion(Region invalidRgn)` This method invalidates part of the movie specified by the invalidRgn.
`boolean` | `isDone()` This method allows you to determine if a particular movie has completely finished playing.
`void` | `loadIntoRam(int time, int duration, int flags)` This method loads a movie's data into memory.
`int` | `maxLoadedTimeInMovie()` Returns the duration of the part of a movie that has already been downloaded.
`boolean` | `needsTimeTable()` Determine whether a movie is being progressively downloaded..
`MovieEditState` | `newEditState()` You can create an edit state by calling the NewMovieEditState function.
`Track` | `newTrack(float width, float height, float trackVolume)` Create a track in a movie.
`void` | `pasteHandle(QTHandle handle, int handleType, int flags, MovieImporter userComp)` This method takes the contents of a specified handle, together with its type, and pastes it into a specified movie.
`void` | `pasteSelection(Movie srcMovie)` This method places the tracks from one movie into another movie.
`void` | `playPreview()` This method plays a movie's preview.
`boolean` | `pointInMovie(QDPoint pt)` This method allows your application to determine whether a specified point lies in the region defined by a movie's final display boundary region after it has been clipped by the movie's display clipping region.
`void` | `prePreroll(int time, float rate)` This method allows your application to prepare a portion of a movie for playback.
`void` | `prePreroll(int time, float rate, MoviePrePreroll proc)` This method allows your application to prepare a portion of a movie for playback.
`void` | `preroll(int time, float rate)` This method allows your application to prepare a portion of a movie for playback.
`void` | `putIntoDataFork(OpenMovieFile fileOut, int offset, int maxSize)` This method allows you to store a movie in the data fork of a given file.
`void` | `putIntoHandle(QTHandle intoThisHandle)` This method creates a new movie resource for you.
`QTHandle` | `putIntoTypedHandle(Track targetTrack, int handleType, int start, int dur, int flags, MovieExporter userComp)` This method takes a movie (or a single track from within that movie) and converts it into a handle of a specified type.
`void` | `putOnScrap(int movieScrapFlags)` This method allows your application to place a movie onto the scrap.
`void` | `removeDrawingCompleteProc()` This allows you to remove a previously assigned drawing-complete method to a movie.
`void` | `removeExecuteWiredActionsProc()` This method allows you to remove the existing executing wired actions of this movie.
`void` | `removeResource(OpenMovieFile fileOut, int resID)` This method removes a movie resource from a specified movie file.
`void` | `removeTrack(Track track)` Removes a track from a movie.
`void` | `scaleSegment(int startTime, int oldDuration, int newDuration)` This method changes the duration of a segment of a movie and then removes the current selection from the original movie.
`SearchResult` | `searchText(QTPointer text, int searchFlags, int searchTime, int searchOffset)` This method allows you to search for text in a movie.
`SearchResult` | `searchText(QTPointer text, int searchFlags, Track searchTrack, int searchTime, int searchOffset)` This method allows you to search for text in a movie.
`void` | `selectAlternates()` This method allows your application to instruct the Movie Toolbox to select appropriate tracks immediately.
`void` | `setActive(boolean active)` This method allows your application to activate and deactivate a movie.
`void` | `setActiveSegment(TimeInfo activeSegmentTimeInfo)` This method allows your application to define a movie's active segment.
`void` | `setAutoTrackAlternatesEnabled(boolean enable)` This method allows your application to enable and disable automatic track selection by the Movie Toolbox.
`void` | `setBounds(QDRect boxRect)` This method sets a movie's boundary rectangle, or movie box, which is a rectangle that encompasses the spatial representation of all of the movie's enabled tracks.
`void` | `setBox(QDRect boxRect)` This method sets a movie's boundary rectangle, or movie box, which is a rectangle that encompasses the spatial representation of all of the movie's enabled tracks.
`void` | `setClipRgn(Region theClip)` This method allows your application to establish a movie's clipping region.
`void` | `setColorTable(ColorTable ctab)` This method allows your application to assign a color table to the movie.
`void` | `setDefaultDataRef(DataRef newRef)` This method sets the default data reference for the movie.
`void` | `setDisplayClipRgn(Region theClip)` This method allows your application to establish a movie's current display clipping region.
`void` | `setDrawingCompleteProc(int flags, MovieDrawingComplete proc)` This allows you to assign a drawing-complete method to a movie.
`void` | `setGWorld(QDGraphics port, GDevice gdh)` The setGWorld method allows your application to establish a movie's display coordinate system by setting the graphics world for displaying a movie.
`void` | `setLanguage(int language)` This method allows your application to specify a movie's language.
`void` | `setMasterClock(Clock clockMeister, TimeRecord slaveZero)` This method allows you to assign a clock component to a movie.
`void` | `setMasterTimeBase(TimeBase tb, TimeRecord slaveZero)` This method allows you to assign a master time base to a movie.
`void` | `setMatrix(Matrix matrix)` This method allows your application to set a movie's transformation matrix.
`void` | `setPlayHints(int flags, int flagsMask)` This method allows your application to provide information to the Movie Toolbox that can influence movie playback.
`void` | `setPosterBox(QDRect boxRect)` This method allows you to set a poster's boundary rectangle.
`void` | `setPosterTime(int posterTime)` This method sets the poster time for the movie.
`void` | `setPreferredRate(float rate)` This method allows your application to specify a movie's default playback rate.
`void` | `setPreferredVolume(float volume)` This method allows your application to set a movie's preferred volume setting.
`void` | `setPreviewMode(boolean usePreview)` This method allows your application to place a movie into and out of preview mode.
`void` | `setPreviewTime(int previewTime, int previewDuration)` This method allows your application to define the starting time and duration of the movie's preview.
`void` | `setPreviewTime(TimeInfo previewTimeInfo)` This method allows your application to define the starting time and duration of the movie's preview.
`void` | `setProgressProc()` This method allows you to attach a progress function to a movie.
`void` | `setProgressProc(MovieProgress mp)` This method allows you to attach a progress function to a movie.
`void` | `setRate(float rate)` This method sets a movie's playback rate.
`void` | `setSelection(int selectionTime, int selectionDuration)` This method sets a movie's current selection.
`void` | `setSelection(TimeInfo selectionTimeInfo)` This method sets a movie's current selection.
`void` | `setTime(TimeRecord newtime)` This method allows you to set a movie's current time.
`void` | `setTimeScale(int timeScale)` This method establishes a movie's time scale.
`void` | `setTimeValue(int newtime)` This method allows your application to set a movie's time value.
`void` | `setVolume(float volume)` This method allows your application to set a movie's current volume.
`void` | `showInformation()` This method displays a dialog giving information about the movie.
`void` | `showPoster()` You can use showPoster method to display a movie's poster.
`void` | `start()` This method starts the movie playing from the current movie time, which is where the movie last stopped playing.
`void` | `stop()` This method stops the playback of a movie.
`void` | `task(int maxMilliSecToUse)` The moviesTask method services this movie.
`static void` | `taskAll(int maxMilliSecToUse)` The moviesTask method services all of the currently active movies.
`java.lang.String` | `toString()` Print information about this object.
`void` | `update()` This method allows your application to ensure that the Movie Toolbox properly displays your movie after it has been uncovered.
`void` | `updateResource(OpenMovieFile fileOut, int resID, java.lang.String resourceName)` This method replaces the contents of a movie resource in a specified movie file.
`void` | `useEditState(MovieEditState anEditState)` Your application can use this method to return a movie to its condition according to an edit state you created previously.

Methods inherited from class quicktime.QTObject
`disposeQTObject, equals, ID`

Methods inherited from class java.lang.Object
`getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### Movie

    public Movie()
          throws QTException

  This method creates a new movie in memory. The Movie Toolbox initializes the data structures for the new movie, which contains no tracks. It supplies default settings of the movie being inactive and will select enabled tracks from track groups.
  QuickTime::NewMovie()

  ### Movie

      public Movie(int flags)
            throws QTException

    This method creates a new movie in memory. The Movie Toolbox initializes the data structures for the new movie, which contains no tracks. It supplies default settings of the movie being active and will select enabled tracks from track groups.
    QuickTime::NewMovie()
  Parameters:
    `flags` - flags to control settings when creating the movie.

Method Detail

### taskAll

    public static void taskAll(int maxMilliSecToUse)
                        throws QTException

  The moviesTask method services all of the currently active movies. You should call moviesTask as often as possible.
  QuickTime::MoviesTask()

  Parameters:
    `maxMilliSecToUse` - Determines the maximum number of milliseconds that MoviesTask can work before returning.

### createMovieFile

    public static Movie createMovieFile(QTFile pathName,
                                        int fCreator,
                                        int flags)
                                 throws QTException

  Creates a Movie object and the file as specified by the QTFile. This call will not open the created movie file.
  QuickTime::CreateMovieFile()

  Parameters:
    `pathName` - specifies the complete pathName of the file that is to be created.
    `fCreator` - Specifies the creator of the file.
    `flags` - Specifies the behaviour when creating the file.
  Returns:
    QTFile object that specifies the newly created movie file.

### fromSequenceGrabber

    public static Movie fromSequenceGrabber(SequenceGrabber sg)

  Determines a reference to the movie that contains the data collected during a record operation. You can use this movie identifier with Movie Toolbox functions.
  QuickTime::SGGetMovie

  Returns:
    The Movie or null if there is no movie.
  See Also:
    `SequenceGrabber.getMovie()`

### fromScrap

    public static Movie fromScrap(int newMovieFlags)
                           throws QTException

  This method allows your application to create a movie from the contents of the scrap.
  QuickTime::NewMovieFromScrap()

  Parameters:
    `newMovieFlags` - Controls the operation of this method.

### fromFile

    public static Movie fromFile(OpenMovieFile fileIn)
                          throws QTException

  This method creates a movie in memory from a resource that is stored in a movie file. Your application specifies the movie file with the opened file represented by the OpenMovieFile object. Once you have opened a movie file and loaded a movie, your application can proceed to work with the movie.
  QuickTime::NewMovieFromFile()

  Parameters:
    `fileIn` - identifies the open movie file from which the movie is to be loaded.

### fromFile

    public static Movie fromFile(OpenMovieFile fileIn,
                                 int flags,
                                 MovieInfo info)
                          throws QTException

  This method creates a movie in memory from a resource that is stored in a movie file. Your application specifies the movie file with the opened file represented by the OpenMovieFile object. Once you have opened a movie file and loaded a movie, your application can proceed to work with the movie.
  QuickTime::NewMovieFromFile()

  Parameters:
    `fileIn` - identifies the open movie file stream from which the movie is to be loaded.
    `flags` - controls the operation of this method.
    `info` - a MovieInfo object to receive state information about the movie.

### fromHandle

    public static Movie fromHandle(QTHandle hand)
                            throws QTException

  This method creates a movie in memory from a movie resource or a handle you obtained from the PutMovieIntoHandle function.
  QuickTime::NewMovieFromHandle()

  Parameters:
    `hand` - contains a handle to the movie resource from which the movie is to be loaded.

### fromHandle

    public static Movie fromHandle(QTHandle hand,
                                   int flags,
                                   MovieInfo info)
                            throws QTException

  This method creates a movie in memory from a movie resource or a handle you obtained from the PutMovieIntoHandle function.
  QuickTime::NewMovieFromHandle()

  Parameters:
    `hand` - contains a handle to the movie resource from which the movie is to be loaded.
    `flags` - controls the operation of this method.
    `info` - a MovieInfo object to receive state information about the movie.

### fromDataFork

    public static Movie fromDataFork(OpenFile fileIn,
                                     int fileOffset,
                                     int flags,
                                     MovieInfo info)
                              throws QTException,
                                     QDException

  This method enables you to retrieve a movie that is stored anywhere in the data fork of a specified file.
  QuickTime::NewMovieFromDataFork()

  Parameters:
    `fileIn` - The open movie file stream.
    `fileOffset` - Specifies the starting file offset of the atom in the data fork of the file specified by the fRefNum parameter.
    `flags` - controls the operation of this method.
    `info` - a MovieInfo object to receive state information about the movie.

### fromDataRef

    public static Movie fromDataRef(DataRef defaultDataRef,
                                    int flags)
                             throws QTException

  This method enables you to retrieve a movie from any data reference.
  QuickTime::NewMovieFromDataRef()

  Parameters:
    `defaultDataRef` - a DataRef object specifying the data reference this method will load the movie from.
    `flags` - Controls the operation of this method. NOTE: it is a good idea to use the flag newMovieAsyncOK (defined in StdQTConstants4) to prevent the VM from blocking (in the case of no network connection, or a bad URL)

### addResource

    public int addResource(OpenMovieFile fileOut,
                           int resID,
                           java.lang.String resourceName)
                    throws StdQTException

  This method adds a movie resource to a specified resource file.
  QuickTime::AddMovieResource()

  Parameters:
    `fileOut` - Identifies the open writable movie file stream to which the resource is to be added.
    `resID` - Contains a pointer to a field that contains the resource ID number for the new resource. If the field referred to by the resId parameter is set to 0, the Movie Toolbox assigns a unique resource ID number to the new resource.
    `resourceName` - a String object that contains the name of the movie resource. If you set the resourceName parameter to null, the toolbox creates an unnamed resource.

### updateResource

    public void updateResource(OpenMovieFile fileOut,
                               int resID,
                               java.lang.String resourceName)
                        throws StdQTException

  This method replaces the contents of a movie resource in a specified movie file.
  QuickTime::UpdateMovieResource()

  Parameters:
    `fileOut` - Specifies the open writable movie file stream for the movie to be updated.
    `resID` - Specifies the resource number for the movie.
    `resourceName` - Points to a new name for the resource. If you do not want to change the resource's name, set this parameter to null.

### removeResource

    public void removeResource(OpenMovieFile fileOut,
                               int resID)
                        throws StdQTException

  This method removes a movie resource from a specified movie file.
  QuickTime::RemoveMovieResource()

  Parameters:
    `fileOut` - Specifies the open writable movie file stream for the movie to be removed.
    `resID` - Specifies the resource number for the movie.

### task

    public void task(int maxMilliSecToUse)
              throws QTException

  The moviesTask method services this movie. You should call moviesTask as often as possible.
  QuickTime::MoviesTask()

  Parameters:
    `maxMilliSecToUse` - Determines the maximum number of milliseconds that MoviesTask can work before returning.

### setDrawingCompleteProc

    public void setDrawingCompleteProc(int flags,
                                       MovieDrawingComplete proc)
                                throws StdQTException

  This allows you to assign a drawing-complete method to a movie. The Movie Toolbox calls this function based upon guidelines you establish when you assign the method to the movie.
  QuickTime::SetMovieDrawingCompleteProc()

  Parameters:
    `flags` - flags that control under what conditions the proc is called
    `proc` - the object that will be called when drawing is complete
  See Also:
    `QTCallBack`

### removeDrawingCompleteProc

    public void removeDrawingCompleteProc()
                                   throws StdQTException

  This allows you to remove a previously assigned drawing-complete method to a movie.
  QuickTime::SetMovieDrawingCompleteProc()

### preroll

    public void preroll(int time,
                        float rate)
                 throws StdQTException

  This method allows your application to prepare a portion of a movie for playback.
  QuickTime::PrerollMovie()

  Parameters:
    `time` - Contains the starting time of the movie segment to play.
    `rate` - Specifies the rate at which you anticipate playing the movie. Positive values indicate forward rates and negative values indicate reverse rates.

### prePreroll

    public void prePreroll(int time,
                           float rate)
                    throws StdQTException

  This method allows your application to prepare a portion of a movie for playback. This call is used when using a remote movie to establish network connections.
  QuickTime::PrePrerollMovie()
  Parameters:
    `time` - Contains the starting time of the movie segment to play.
    `rate` - Specifies the rate at which you anticipate playing the movie. Positive values indicate forward rates and negative values indicate reverse rates.

### prePreroll

    public void prePreroll(int time,
                           float rate,
                           MoviePrePreroll proc)
                    throws StdQTException

  This method allows your application to prepare a portion of a movie for playback. This call is used when using a remote movie to establish network connections.
  QuickTime::PrePrerollMovie()
  Parameters:
    `time` - Contains the starting time of the movie segment to play.
    `rate` - Specifies the rate at which you anticipate playing the movie. Positive values indicate forward rates and negative values indicate reverse rates.
    `proc` - the MoviePrePreroll object that will be invoked by this call. This can be null.

### abortPrePreroll

    public void abortPrePreroll(int err)
                         throws StdQTException

  This method aborts. This call is used when using a remote movie to establish network connections. This version of the pre-preroll is Asynchronous and the Supplied MoviePrePreroll proc will be called back when the movie is pre-preRolled
  QuickTime::AbortPrePrerollMovie()
  Parameters:
    `time` - Contains the starting time of the movie segment to play.
    `rate` - Specifies the rate at which you anticipate playing the movie. Positive values indicate forward rates and negative values indicate reverse rates.

### loadIntoRam

    public void loadIntoRam(int time,
                            int duration,
                            int flags)
                     throws StdQTException

  This method loads a movie's data into memory. If the movie does not fit, the method throws an error.
  QuickTime::LoadMovieIntoRam()

  Parameters:
    `time` - Allows you to specify a portion of the movie to load. The time parameter contains the starting time of the movie segment to load.
    `duration` - Allows you to specify a portion of the movie to load. The time parameter contains the starting time of the movie segment to load. The duration parameter specifies the length of the segment to load.
    `flags` - Gives you explicit control over what is loaded into memory and how long to keep it around.

### setActive

    public void setActive(boolean active)
                   throws StdQTException

  This method allows your application to activate and deactivate a movie.
  QuickTime::SetMovieActive()

  Parameters:
    `active` - Activates or deactivates the movie. Set this parameter to true to activate the movie; set this parameter to false to deactivate the movie.

### getActive

    public boolean getActive()
                      throws StdQTException

  This method returns a boolean value. The method returns true if the movie is active and false if the movie is not active.
  QuickTime::GetMovieActive()

### start

    public void start()
               throws StdQTException

  This method starts the movie playing from the current movie time, which is where the movie last stopped playing. Before playing the movie, the Movie Toolbox makes the movie active, prerolls the movie, and sets the movie to its preferred playback rate.
  QuickTime::StartMovie()

### stop

    public void stop()
              throws StdQTException

  This method stops the playback of a movie.
  QuickTime::StopMovie()

### goToBeginning

    public void goToBeginning()
                       throws StdQTException

  This method repositions a movie to play from its start.
  QuickTime::GoToBeginningOfMovie()

### goToEnd

    public void goToEnd()
                 throws StdQTException

  This method repositions a movie to play from its end.
  QuickTime::GoToEndOfMovie()

### isDone

    public boolean isDone()
                   throws StdQTException

  This method allows you to determine if a particular movie has completely finished playing.
  QuickTime::IsMovieDone()

### getPreviewMode

    public boolean getPreviewMode()
                           throws StdQTException

  This method allows your application to determine whether a movie is in preview mode. If a movie is in preview mode, only the movie's preview can be displayed.
  QuickTime::GetMoviePreviewMode()

### setPreviewMode

    public void setPreviewMode(boolean usePreview)
                        throws StdQTException

  This method allows your application to place a movie into and out of preview mode. When a movie is in preview mode, only those tracks identified as preview tracks are serviced.
  QuickTime::SetMoviePreviewMode()

### showPoster

    public void showPoster()
                    throws StdQTException

  You can use showPoster method to display a movie's poster. The movie poster uses the movie's matrix and display clipping characteristics.
  QuickTime::ShowMoviePoster()

### playPreview

    public void playPreview()
                     throws StdQTException

  This method plays a movie's preview.
  QuickTime::PlayMoviePreview()

### getGWorld

    public QDGraphics getGWorld()
                         throws StdQTException

  Your application can determine a movie's graphics world by calling the getGWorld method.
  QuickTime::GetMovieGWorld()

  Returns:
    The current destination graphics port

### setGWorld

    public void setGWorld(QDGraphics port,
                          GDevice gdh)
                   throws StdQTException

  The setGWorld method allows your application to establish a movie's display coordinate system by setting the graphics world for displaying a movie.
  QuickTime::SetMovieGWorld()

  Parameters:
    `port` - the new graphics port or null to use current port
    `gdh` - the graphics device or null to use the current device

### getNaturalBoundsRect

    public QDRect getNaturalBoundsRect()
                                throws StdQTException

  No QT Documentation.
  QuickTime::GetMovieNaturalBoundsRect()

### getNextTrackForCompositing

    public Track getNextTrackForCompositing(Track theTrack)
                                     throws QTException

  No QT Documentation.
  QuickTime::GetNextTrackForCompositing()

### getPrevTrackForCompositing

    public Track getPrevTrackForCompositing(Track theTrack)
                                     throws QTException

  No QT Documentation.
  QuickTime::GetPrevTrackForCompositing()

### getPict

    public Pict getPict(int time)
                 throws QTException

  This method creates a picture from the specified movie at the specified time. This function uses only those movie tracks that are currently enabled and would therefore be used in playback. Your application may call this function even if the movie is inactive.
  QuickTime::GetMoviePict()

  Parameters:
    `time` - contains the time from which the image is taken.
  Returns:
    a Pict

### getPosterPict

    public Pict getPosterPict()
                       throws QTException

  This method creates a picture that contains a movie's poster. returns a PicHandle object for the image.
  QuickTime::GetMoviePosterPict()

  Returns:
    a Pict

### update

    public void update()
                throws StdQTException

  This method allows your application to ensure that the Movie Toolbox properly displays your movie after it has been uncovered.
  QuickTime::UpdateMovie()

### invalidateRegion

    public void invalidateRegion(Region invalidRgn)
                          throws StdQTException

  This method invalidates part of the movie specified by the invalidRgn. The invalidated part will be drawn next time MoviesTask is called.
  QuickTime::InvalidateMovieRegion()

  Parameters:
    `invalidRgn` - a Region object to specify the invalid part of the movie.

### getBounds

    public QDRect getBounds()
                     throws StdQTException

  This method returns a movie's boundary rectangle, which is a rectangle that encompasses all of the movie's enabled tracks. The movie box is in the coordinate system of the movie's graphics world and defines the movie's boundaries over the entire duration of the movie. The movie's boundary rectangle defines the size and shape of the movie before the Movie Toolbox applies the display clipping region.
  QuickTime::GetMovieBox()

  Returns:
    The movie's boundary rectangle

### getBox

    public QDRect getBox()
                  throws StdQTException

  This method returns a movie's boundary rectangle, which is a rectangle that encompasses all of the movie's enabled tracks. The movie box is in the coordinate system of the movie's graphics world and defines the movie's boundaries over the entire duration of the movie. The movie's boundary rectangle defines the size and shape of the movie before the Movie Toolbox applies the display clipping region.
  QuickTime::GetMovieBox()

  Returns:
    The movie's boundary rectangle

### setBounds

    public void setBounds(QDRect boxRect)
                   throws StdQTException

  This method sets a movie's boundary rectangle, or movie box, which is a rectangle that encompasses the spatial representation of all of the movie's enabled tracks. The movie box is in the display coordinate system.
  QuickTime::SetMovieBox()

  Parameters:
    `boxRect` - the coordinates of the new boundary rectangle.

### setBox

    public void setBox(QDRect boxRect)
                throws StdQTException

  This method sets a movie's boundary rectangle, or movie box, which is a rectangle that encompasses the spatial representation of all of the movie's enabled tracks. The movie box is in the display coordinate system.
  QuickTime::SetMovieBox()

  Parameters:
    `boxRect` - the coordinates of the new boundary rectangle.

### getDisplayClipRgn

    public Region getDisplayClipRgn()
                             throws QTException

  This method allows your application to determine a movie's current display clipping region.
  QuickTime::GetMovieDisplayClipRgn()

  Returns:
    a Region object.

### setDisplayClipRgn

    public void setDisplayClipRgn(Region theClip)
                           throws StdQTException

  This method allows your application to establish a movie's current display clipping region.
  QuickTime::SetMovieDisplayClipRgn()

  Parameters:
    `theClip` - a Region object.

### getClipRgn

    public Region getClipRgn()
                      throws QTException

  This method allows your application to determine a movie's clipping region.
  QuickTime::GetMovieClipRgn()

  Returns:
    a Region object.

### setClipRgn

    public void setClipRgn(Region theClip)
                    throws StdQTException

  This method allows your application to establish a movie's clipping region.
  QuickTime::SetMovieClipRgn()
  Parameters:
    `theClip` - a Region object specifying the new clip region.

### getDisplayBoundsRgn

    public Region getDisplayBoundsRgn()
                               throws QTException

  This method allows your application to determine a movie's display boundary region. The display boundary region encloses all of a movie's enabled tracks after the track matrix, track clip, movie matrix, and movie clip have been applied to all of the movie's tracks. This region is in the display coordinate system of the movie's graphics world.
  QuickTime::GetMovieDisplayBoundsRgn()

  Returns:
    a Region object specifying the display boundary region.

### getBoundsRgn

    public Region getBoundsRgn()
                        throws QTException

  This method allows your application to determine a movie's boundary region. This region is in the movie's display coordinate system. The movie boundary region encloses all of a movie's tracks after the union of the track clip and the track matrix has been applied to all the movie's tracks (but not to the movie itself).
  QuickTime::GetMovieBoundsRgn()

  Returns:
    a Region object specifying the movie boundary region.

### putIntoHandle

    public void putIntoHandle(QTHandle intoThisHandle)
                       throws StdQTException

  This method creates a new movie resource for you. You can use this handle to store a QuickTime movie in a specialized storage format.
  QuickTime::PutMovieIntoHandle()

  Parameters:
    `intoThisHandle` - Specifies the handle where the movie will be placed into.

### putIntoDataFork

    public void putIntoDataFork(OpenMovieFile fileOut,
                                int offset,
                                int maxSize)
                         throws StdQTException

  This method allows you to store a movie in the data fork of a given file.
  QuickTime::PutMovieIntoDataFork()

  Parameters:
    `fileOut` - Specifies the open writable movie file stream where the movie will be placed into.
    `offset` - Indicates where the movie should be written.
    `maxSize` - Indicates the largest number of bytes that may be written.

### getCreationTime

    public int getCreationTime()
                        throws StdQTException

  This method returns a long integer that contains the movie's creation date and time information.
  QuickTime::GetMovieCreationTime()

  Returns:
    the creation time.

### getModificationTime

    public int getModificationTime()
                            throws StdQTException

  This method returns a long integer that contains the movie's creation date and time information.
  QuickTime::GetMovieModificationTime()

  Returns:
    the modification time.

### getTimeScale

    public int getTimeScale()
                     throws StdQTException

  This method returns the time scale of a movie.
  QuickTime::GetMovieTimeScale()

  Returns:
    the time scale.

### setTimeScale

    public void setTimeScale(int timeScale)
                      throws StdQTException

  This method establishes a movie's time scale.
  QuickTime::SetMovieTimeScale()

  Parameters:
    `timeScale` - Specifies the movie's new time scale.

### getDuration

    public int getDuration()
                    throws StdQTException

  This method returns the duration of a movie.
  QuickTime::GetMovieDuration()
  return the duration.

### getRate

    public float getRate()
                  throws StdQTException

  This method returns a movie's playback rate.
  QuickTime::GetMovieRate()

  Returns:
    the playback rate.

### setRate

    public void setRate(float rate)
                 throws StdQTException

  This method sets a movie's playback rate.
  QuickTime::SetMovieRate()

  Parameters:
    `rate` - Specifies the rate.

### getPreferredRate

    public float getPreferredRate()
                           throws StdQTException

  This method returns a movie's default playback rate.
  QuickTime::GetMoviePreferredRate()

  Returns:
    the preferred rate.

### setPreferredRate

    public void setPreferredRate(float rate)
                          throws StdQTException

  This method allows your application to specify a movie's default playback rate.
  QuickTime::SetMoviePreferredRate()

  Parameters:
    `rate` - Specifies the rate.

### getPreferredVolume

    public float getPreferredVolume()
                             throws StdQTException

  This method returns a movie's preferred volume setting.
  QuickTime::GetMoviePreferredVolume()

  Returns:
    the preferred volume.

### setPreferredVolume

    public void setPreferredVolume(float volume)
                            throws StdQTException

  This method allows your application to set a movie's preferred volume setting.
  QuickTime::SetMoviePreferredVolume()

  Parameters:
    `volume` - Specifies the preferred volume setting of the movie.

### getVolume

    public float getVolume()
                    throws StdQTException

  This method returns movie's current volume setting.
  QuickTime::GetMovieVolume()

  Returns:
    the volume.

### setVolume

    public void setVolume(float volume)
                   throws StdQTException

  This method allows your application to set a movie's current volume.
  QuickTime::SetMovieVolume()

  Parameters:
    `volume` - Specifies the current volume setting of the movie.

### getMatrix

    public Matrix getMatrix()
                     throws StdQTException

  This method allows allows your application to retrieve a movie's transformation matrix.
  QuickTime::GetMovieMatrix()

  Returns:
    a Matrix object.

### setMatrix

    public void setMatrix(Matrix matrix)
                   throws StdQTException

  This method allows your application to set a movie's transformation matrix. The Movie Toolbox uses a movie's matrix to map a movie from its display coordinate system to its graphics world.
  QuickTime::SetMovieMatrix()

  Parameters:
    `matrix` - the matrix to set

### getPreviewTime

    public TimeInfo getPreviewTime()
                            throws StdQTException

  This method returns the starting time and duration of the movie's preview.
  QuickTime::GetMoviePreviewTime()

  Returns:
    a TimeInfo object.

### setPreviewTime

    public void setPreviewTime(TimeInfo previewTimeInfo)
                        throws StdQTException

  This method allows your application to define the starting time and duration of the movie's preview.
  QuickTime::SetMoviePreviewTime()

  Parameters:
    `previewTimeInfo` - a TimeInfo object.

### setPreviewTime

    public void setPreviewTime(int previewTime,
                               int previewDuration)
                        throws StdQTException

  This method allows your application to define the starting time and duration of the movie's preview.
  QuickTime::SetMoviePreviewTime()

### getPosterTime

    public int getPosterTime()
                      throws StdQTException

  This method returns the poster's time in the movie.
  QuickTime::GetMoviePosterTime()

  Returns:
    the poster's time.

### setPosterTime

    public void setPosterTime(int posterTime)
                       throws StdQTException

  This method sets the poster time for the movie.
  QuickTime::SetMoviePosterTime()

  Parameters:
    `posterTime` - the poster time.

### getSelection

    public TimeInfo getSelection()
                          throws StdQTException

  This method returns information about a movie's current selection.
  QuickTime::GetMovieSelection()

  Returns:
    a TimeInfo object specifying the movie's selection.

### setSelection

    public void setSelection(TimeInfo selectionTimeInfo)
                      throws StdQTException

  This method sets a movie's current selection.
  QuickTime::SetMovieSelection()

  Parameters:
    `selectionTimeInfo` - a TimeInfo object specifying the time information for movie's new selection.

### setSelection

    public void setSelection(int selectionTime,
                             int selectionDuration)
                      throws StdQTException

  This method sets a movie's current selection.
  QuickTime::SetMovieSelection()

  Parameters:
    `selectionTime` - Contains a time value specifying the starting point of the current selection.
    `selectionDuration` - Contains a time value that specifies the duration of the current selection.

### setActiveSegment

    public void setActiveSegment(TimeInfo activeSegmentTimeInfo)
                          throws StdQTException

  This method allows your application to define a movie's active segment.
  QuickTime::SetMovieActiveSegment()

  Parameters:
    `activeSegmentTimeInfo` - a TimeInfo object specifying the time information of the active segment.

### getActiveSegment

    public TimeInfo getActiveSegment()
                              throws StdQTException

  This method allows your application to determine what portion of a movie is currently active for playing.
  QuickTime::GetMovieActiveSegment()

  Returns:
    a TimeInfo object specifying the active segment of the movie.

### getTime

    public int getTime()
                throws StdQTException

  This method returns a movie's current time.
  QuickTime::GetMovieTime()

  Returns:
    the movie's current time.

### getTRTime

    public TimeRecord getTRTime()
                         throws QTException

  This method returns a movie's current time as a TimeRecord object.
  QuickTime::GetMovieTime()

  Returns:
    the movie's current time as a TimeRecord object.

### setTime

    public void setTime(TimeRecord newtime)
                 throws StdQTException

  This method allows you to set a movie's current time.
  QuickTime::SetMovieTime()

  Parameters:
    `newtime` - A TimeRecord object specifying the new time for the movie.

### setTimeValue

    public void setTimeValue(int newtime)
                      throws StdQTException

  This method allows your application to set a movie's time value.
  QuickTime::SetMovieTimeValue()

  Parameters:
    `newTime` - Specifies the movie's new time value. .

### getUserData

    public UserData getUserData()
                         throws StdQTException

  This method allows your application to obtain access to a movie's user data list.
  QuickTime::GetMovieUserData()

  Returns:
    a reference to the movie's user data list.

### getTrackCount

    public int getTrackCount()
                      throws StdQTException

  This method returns the number of tracks in a movie.
  QuickTime::GetMovieTrackCount()

  Returns:
    the number of tracks in a movie.

### getTrack

    public Track getTrack(int trackID)
                   throws QTException

  This method allows your application to determine the track identifier of a track given the track's ID value.
  QuickTime::GetMovieTrack()

  Parameters:
    `trackID` - ID value of the track (from Track.getID())
  Returns:
    a Track object for the trackID.

### getIndTrack

    public Track getIndTrack(int index)
                      throws QTException

  This method allows your application to determine the track identifier of a track given the track's index value.
  QuickTime::GetMovieIndTrack()

  Parameters:
    `index` - index value of the track in the movie (Moive.getTrackCount())
  Returns:
    a Track object for the specified index.

### getIndTrackType

    public Track getIndTrackType(int index,
                                 int trackType,
                                 int flags)
                          throws QTException

  This method allows your application to determine the track identifier of a track given a track type and an index value.
  QuickTime::GetMovieIndTrackType()

  Parameters:
    `index` - Specifies the index value of the track for this operation. This is not that same as the track's index value in the movie. Rather, this parameter is an index into the set of tracks that meet your other selection criteria.
    `trackType` - Contains either a media type or a media characteristic value.
    `flags` - Contains flags that control the search operation.
  Returns:
    a Track object for the specified index with in the tracks with the specified track type.

### removeTrack

    public void removeTrack(Track track)
                     throws StdQTException

  Removes a track from a movie.
  QuickTime::DisposeMovieTrack()

  Parameters:
    `track` - the track to remove from this movie.

### setAutoTrackAlternatesEnabled

    public void setAutoTrackAlternatesEnabled(boolean enable)
                                       throws StdQTException

  This method allows your application to enable and disable automatic track selection by the Movie Toolbox.
  QuickTime::SetAutoTrackAlternatesEnabled()

  Parameters:
    `enable` - Controls automatic track selection.

### selectAlternates

    public void selectAlternates()
                          throws StdQTException

  This method allows your application to instruct the Movie Toolbox to select appropriate tracks immediately.
  QuickTime::SelectMovieAlternates()

### getNextInterestingTime

    public TimeInfo getNextInterestingTime(int interestingTimeFlags,
                                           int[] mediaTypes,
                                           int time,
                                           float rate)
                                    throws StdQTException

  This method searches for times of interest in a movie.
  QuickTime::GetMovieNextInterestingTime()

  Parameters:
    `interestingTimeFlags` - Specifies the search criteria.
    `mediaTypes` - Specifies an array of media types
    `time` - Specifies a time value that establishes the starting point for the search.
    `rate` - Contains the search direction.
  Returns:
    a TimeInfo object specifying the interesting time.

### insertEmptySegment

    public void insertEmptySegment(int dstIn,
                                   int dstDuration)
                            throws StdQTException

  This method adds an empty segment to a movie.
  QuickTime::InsertEmptyMovieSegment()

### insertSegment

    public void insertSegment(Movie dstMovie,
                              int srcIn,
                              int srcDuration,
                              int dstIn)
                       throws StdQTException

  The insertSegment method copies part of one movie to another.
  QuickTime::InsertMovieSegment()

  Parameters:
    `dstMovie` - Specifies the destination movie for this operation. Specifies the start of the segment in the source movie. Specifies the duration of the segment in the source movie. Contains a time value specifying where the segment is to be inserted.

### deleteSegment

    public void deleteSegment(int startTime,
                              int duration)
                       throws StdQTException

  This method removes a specified segment from a movie.
  QuickTime::DeleteMovieSegment()

  Parameters:
    `startTime` - Contains a time value specifying the starting point of the segment to be deleted.
    `duration` - Contains a time value that specifies the duration of the segment to be deleted.

### scaleSegment

    public void scaleSegment(int startTime,
                             int oldDuration,
                             int newDuration)
                      throws StdQTException

  This method changes the duration of a segment of a movie and then removes the current selection from the original movie.
  QuickTime::ScaleMovieSegment()

  Parameters:
    `startTime` - Specifies the start of the segment.
    `oldDuration` - Specifies the duration of the segment in the source movie.
    `newDuration` - Specifies the new duration of the segment.

### cutSelection

    public Movie cutSelection()
                       throws QTException

  This method creates a new movie that contains the original movie's current selection.
  QuickTime::CutMovieSelection()

  Returns:
    a new Movie object that contains the original movie's current selection.

### copySelection

    public Movie copySelection()
                        throws QTException

  This method creates a new movie that contains the original movie's current selection.
  QuickTime::CopyMovieSelection()

  Returns:
    a new Movie object that contains the original movie's current selection.

### pasteSelection

    public void pasteSelection(Movie srcMovie)
                        throws StdQTException

  This method places the tracks from one movie into another movie.
  QuickTime::PasteMovieSelection()

  Parameters:
    `srcMovie` - Specifies the source movie for this operation.

### addSelection

    public void addSelection(Movie srcMovie)
                      throws StdQTException

  This method adds one or more tracks to a movie.
  QuickTime::AddMovieSelection()

  Parameters:
    `srcMovie` - Specifies the source movie for this operation.

### clearSelection

    public void clearSelection()
                        throws StdQTException

  This method removes the segment of the movie that is defined by the current selection.
  QuickTime::ClearMovieSelection()

### pasteHandle

    public void pasteHandle(QTHandle handle,
                            int handleType,
                            int flags,
                            MovieImporter userComp)
                     throws StdQTException

  This method takes the contents of a specified handle, together with its type, and pastes it into a specified movie.
  QuickTime::PasteHandleIntoMovie()

  Parameters:
    `handle` - Specifies the handle to be pasted into the movie indicated by the handleType parameter.
    `handleType` - Indicates the data type of the handle specified in the h parameter.
    `flags` - Specifies a constant that further refines conditions of the paste operation.
    `userComp` - Specifies the component or an instance of the component that is to perform the conversion of the data into a QuickTime movie.

### putIntoTypedHandle

    public QTHandle putIntoTypedHandle(Track targetTrack,
                                       int handleType,
                                       int start,
                                       int dur,
                                       int flags,
                                       MovieExporter userComp)
                                throws QTException

  This method takes a movie (or a single track from within that movie) and converts it into a handle of a specified type.
  QuickTime::PutMovieIntoTypedHandle()

  Parameters:
    `targetTrack` - Specifies the track to convert.
    `handleType` - Indicates the type of the new data.
    `start` - Specifies the start time of the segment of the movie or track to be converted.
    `dur` - Specifies the duration of the segment of the movie or track to be converted.
    `flags` - Indicates condition of the conversion. Set this parameter to 0.
    `userComp` - Indicates a component or component instance of the movie export component you want to perform the conversion. Otherwise, set this parameter to 0 for the Movie Toolbox to choose the appropriate component.
  Returns:
    a QTHandle object.

### copySettings

    public void copySettings(Movie dstMovie)
                      throws StdQTException

  The copySettings method copies many settings from one movie to another, overwriting the destination settings in the process.
  QuickTime::CopyMovieSettings()

  Parameters:
    `dstMovie` - Specifies the destination movie for this operation.

### addEmptyTrack

    public Track addEmptyTrack(Track srcTrack,
                               DataRef dataRef)
                        throws QTException

  This method adds an empty track to the movie. The type of the track and its data reference is specified by the parameters.
  QuickTime::AddEmptyTrackToMovie()

  Parameters:
    `srcTrack` - Specifies the Track object that will be used to determine the type and properties of the empty track.
    `dataRef` - Specifies the default data reference for the empty track.
  Returns:
    a Track object.

### newTrack

    public Track newTrack(float width,
                          float height,
                          float trackVolume)
                   throws QTException

  Create a track in a movie.
  QuickTime::NewMovieTrack()

  Parameters:
    `width` - Specifies the width of the track, in pixels.
    `height` - Specifies the height of the track, in pixels.
    `trackVolume` - Specifies the volume setting of the track.

### addTrack

    public Track addTrack(float width,
                          float height,
                          float trackVolume)
                   throws QTException

  Create a track in a movie.
  QuickTime::NewMovieTrack()

  Parameters:
    `width` - Specifies the width of the track, in pixels.
    `height` - Specifies the height of the track, in pixels.
    `trackVolume` - Specifies the volume setting of the track.

### newEditState

    public MovieEditState newEditState()
                                throws QTException

  You can create an edit state by calling the NewMovieEditState function.
  QuickTime::NewMovieEditState()

  Returns:
    a movie's current edit state

### useEditState

    public void useEditState(MovieEditState anEditState)
                      throws StdQTException

  Your application can use this method to return a movie to its condition according to an edit state you created previously.
  QuickTime::UseMovieEditState()

  Parameters:
    `anEditState` - Specifies the edit state for this operation.

### getDataSize

    public int getDataSize(int startTime,
                           int duration)
                    throws StdQTException

  This method allows your application to determine the size, in bytes, of the sample data in a segment of a movie.
  QuickTime::GetMovieDataSize()

  Parameters:
    `startTime` - Contains a time value specifying the starting point of the segment.
    `duration` - Contains a time value that specifies the duration of the segment.
  Returns:
    the data size.

### pointInMovie

    public boolean pointInMovie(QDPoint pt)
                         throws StdQTException

  This method allows your application to determine whether a specified point lies in the region defined by a movie's final display boundary region after it has been clipped by the movie's display clipping region.
  QuickTime::PtInMovie()

  Parameters:
    `pt` - Specifies the point to be checked.
  Returns:
    whether the point is in the movie or not.

### setLanguage

    public void setLanguage(int language)
                     throws StdQTException

  This method allows your application to specify a movie's language.
  QuickTime::SetMovieLanguage()

  Parameters:
    `language` - Specifies the movie's language or region code.

### hasChanged

    public boolean hasChanged()
                       throws StdQTException

  This method allows your application to determine whether a movie has changed and needs to be saved.
  QuickTime::HasMovieChanged()

  Returns:
    whether the movie has changed or not.

### clearChanged

    public void clearChanged()
                      throws StdQTException

  This method sets the movie changed flag to indicate that the movie has not been changed.
  QuickTime::ClearMovieChanged()

### setDefaultDataRef

    public void setDefaultDataRef(DataRef newRef)
                           throws StdQTException

  This method sets the default data reference for the movie.
  QuickTime::SetMovieDefaultDataRef()

  Parameters:
    `newRef` - Specifies the default data reference object.

### getDefaultDataRef

    public DataRef getDefaultDataRef()
                              throws QTException

  This method allows your application to get the default data reference for the movie.
  QuickTime::GetMovieDefaultDataRef()

  Returns:
    a DataRef object specifiying the default data reference for the movie.

### setColorTable

    public void setColorTable(ColorTable ctab)
                       throws StdQTException

  This method allows your application to assign a color table to the movie.
  QuickTime::SetMovieColorTable()

  Parameters:
    `ctab` - Specifies the new color table.

### getColorTable

    public ColorTable getColorTable()
                             throws QTException

  This method allows your application to get the color table of the movie.
  QuickTime::GetMovieColorTable()

  Returns:
    a ColorTable object specifiying the current color table.

### flatten

    public int flatten(int movieFlattenFlags,
                       QTFile fileOut,
                       int creator,
                       int scriptTag,
                       int createQTFileFlags,
                       int resID,
                       java.lang.String resName)
                throws QTException

  This method creates a new movie file containing a specified movie.
  QuickTime::FlattenMovie()

  Parameters:
    `movieFlattenFlags` - Controls the process of adding movie data to the new movie file.
    `fileOut` - Contains writable movie file for the movie to be created.
    `creator` - Specifies the creator value for the new file.
    `scriptTag` - Specifies the script in which the movie file should be created.
    `createQTFileFlags` - Controls file creation options.
    `resId` - Contains the resource ID number for the new resource.
    `resName` - A String with the name of the movie resource. If you set the resName parameter to null, the toolbox creates an unnamed resource.
  Returns:
    the resource ID number of the new resource

### flattenData

    public Movie flattenData(int movieFlattenFlags,
                             QTFile fileOut,
                             int creator,
                             int scriptTag,
                             int createQTFileFlags)
                      throws QTException

  This method creates a new movie file and creates a new movie that contains all of its movie data.
  QuickTime::FlattenMovieData()

  Parameters:
    `movieFlattenFlags` - Controls the process of adding movie data to the new movie file.
    `fileOut` - Contains writable movie file for the movie to be created.
    `creator` - Specifies the creator value for the new file.
    `scriptTag` - Specifies the script in which the movie file should be created.
    `createQTFileFlags` - Controls file creation options.
  Returns:
    a Movie object for the new movie.

### flattenData

    public Movie flattenData(int movieFlattenFlags,
                             QTHandle handle)
                      throws QTException

  This method creates a new movie that contains all of its movie data loaded into memory. The handle must be the size of the movie's data (see getDataSize() method).
  QuickTime::FlattenMovieData()

  Parameters:
    `movieFlattenFlags` - Controls the process of adding movie data to the new movie file.
    `handle` - the handle that is used to contain the new movie's data for the new movie that is returned.
  Returns:
    a Movie object for the new movie.

### setProgressProc

    public void setProgressProc()
                         throws StdQTException

  This method allows you to attach a progress function to a movie. Currently it assigns the default progress proc to the movie.
  QuickTime::SetMovieProgressProc()

### setProgressProc

    public void setProgressProc(MovieProgress mp)
                         throws StdQTException

  This method allows you to attach a progress function to a movie.
  QuickTime::SetMovieProgressProc()

  Parameters:
    `mp` - the new MovieProgress object

### addExecuteWiredActionsProc

    public void addExecuteWiredActionsProc(ExecutingWiredAction wa)
                                    throws StdQTException

  This method allows you to intercept executing wired actions of this movie.

  Parameters:
    `wa` - the new ExecutingWiredActions object

### removeExecuteWiredActionsProc

    public void removeExecuteWiredActionsProc()
                                       throws StdQTException

  This method allows you to remove the existing executing wired actions of this movie.

### executeWiredActions

    public void executeWiredActions(int flags,
                                    AtomContainer actions)
                             throws StdQTException

  This method executes specified wired actions associated with the movie

  Parameters:
    `flags` - execution flags

### searchText

    public SearchResult searchText(QTPointer text,
                                   int searchFlags,
                                   Track searchTrack,
                                   int searchTime,
                                   int searchOffset)
                            throws QTException

  This method allows you to search for text in a movie.
  QuickTime::MovieSearchText()

  Parameters:
    `text` - Specifies the text to be searched.
    `searchFlags` - controls the operation of this method.
    `searchTrack` - Specifes the track which you want to limit the search to that track.
    `searchTime` - Specifes the starting time for the search
    `searchOffset` - Specifes the offset in media samples. Search will begin from that offset.
  Returns:
    a SearchResult object.

### searchText

    public SearchResult searchText(QTPointer text,
                                   int searchFlags,
                                   int searchTime,
                                   int searchOffset)
                            throws QTException

  This method allows you to search for text in a movie.
  QuickTime::MovieSearchText()

  Parameters:
    `text` - Specifies th etext to be searched.
    `searchFlags` - controls the operation of this method.
    `searchTime` - Specifes the starting time for the search
    `searchOffset` - Specifes the offset in media samples. Search will begin from that offset.
  Returns:
    a SearchResult object.

### getPosterBox

    public QDRect getPosterBox()
                        throws StdQTException

  This method allows you to obtain a poster's boundary rectangle.
  QuickTime::GetPosterBox()

  Returns:
    a Rectangle object specifying the poster box for the movie.

### setPosterBox

    public void setPosterBox(QDRect boxRect)
                      throws StdQTException

  This method allows you to set a poster's boundary rectangle.
  QuickTime::SetPosterBox()

  Parameters:
    `boxRect` - a Rectangle object specifying the poster box for the movie.

### getSegmentDisplayBoundsRgn

    public Region getSegmentDisplayBoundsRgn(int time,
                                             int duration)
                                      throws QTException

  This method allows your application to determine a movie's display boundary region during a specified segment.
  QuickTime::GetMovieSegmentDisplayBoundsRgn()

  Parameters:
    `time` - Specifies the starting time of the movie segment to consider.
    `duration` - Specifies the length of the segment to consider.
  Returns:
    a Region object.

### getStatus

    public StatusInfo getStatus()
                         throws QTException

  This method searches for errors in all the enabled tracks of the movie.
  QuickTime::GetMovieStatus()

  Returns:
    a StatusInfo object specifying the first found problem track. Nothing is returned if there is no problem track.

### showInformation

    public void showInformation()
                         throws StdQTException

  This method displays a dialog giving information about the movie.
  QuickTime::ShowMovieInformation()

### putOnScrap

    public void putOnScrap(int movieScrapFlags)
                    throws StdQTException

  This method allows your application to place a movie onto the scrap.
  QuickTime::PutMovieOnScrap()

  Parameters:
    `movieScrapFlags` - Flags that control the operation.

### setPlayHints

    public void setPlayHints(int flags,
                             int flagsMask)
                      throws StdQTException

  This method allows your application to provide information to the Movie Toolbox that can influence movie playback.
  QuickTime::SetMoviePlayHints()

  Parameters:
    `flags` - Specifies the optimizations that can be used with this movie.
    `flagsMask` - Indicates which flags in the flags parameter are to be considered in this operation.

### getTimeBase

    public TimeBase getTimeBase()
                         throws StdQTException

  This method allows you to get movie's TimeBase.
  QuickTime::GetMovieTimeBase()

  Returns:
    a TimeBase object for movie's timebase

### setMasterTimeBase

    public void setMasterTimeBase(TimeBase tb,
                                  TimeRecord slaveZero)
                           throws StdQTException

  This method allows you to assign a master time base to a movie.
  QuickTime::SetMovieMasterTimeBase()

  Parameters:
    `tb` - Specifies the master time base to be assigned to this movie.
    `slaveZero` - Specifies the time, in the time scale of the master time base, that corresponds to a 0 time value for the movie.

### setMasterClock

    public void setMasterClock(Clock clockMeister,
                               TimeRecord slaveZero)
                        throws StdQTException

  This method allows you to assign a clock component to a movie.
  QuickTime::SetMovieMasterClock()

  Parameters:
    `clockMeisterSpecifies` - the clock component to be assigned to this movie.
    `slaveZero` - Contains the time, in the clock's time scale, that corresponds to a 0 time value for the movie.

### convertToFile

    public int convertToFile(Track onlyTrack,
                             QTFile outputFile,
                             int fileType,
                             int creator,
                             int scriptTag)
                      throws QTException

  This method converts this movie into a specified file and type.
  QuickTime::ConvertMovieToFile()

  Parameters:
    `onlyTrack` - Specifies the track within the source movie for this conversion operation. To specify all tracks, set the value of this parameter to null.
    `outputFile` - Specifies the destination file.
    `fileType` - Specifies the data type of the destination file for the movie.
    `creator` - Specifies the creator value for the output file if it is a new one.
    `scriptTag` - Specifies the script into which the movie should be converted if the output file is a new one.
  Returns:
    the resource id of the movie created.

### convertToFile

    public int convertToFile(QTFile outputFile,
                             int fileType,
                             int creator,
                             int scriptTag)
                      throws QTException

  This method converts this movie into a specified file and type.
  QuickTime::ConvertMovieToFile()

  Parameters:
    `outputFile` - Specifies the destination file.
    `fileType` - Specifies the data type of the destination file for the movie.
    `creator` - Specifies the creator value for the output file if it is a new one.
    `scriptTag` - Specifies the script into which the movie should be converted if the output file is a new one.
  Returns:
    the resource id of the movie created.

### convertToFile

    public int convertToFile(QTFile outputFile,
                             int fileType,
                             int creator,
                             int scriptTag,
                             int flags)
                      throws QTException

  This method converts this movie into a specified file and type.
  QuickTime::ConvertMovieToFile()

  Parameters:
    `outputFile` - Specifies the destination file.
    `fileType` - Specifies the data type of the destination file for the movie.
    `creator` - Specifies the creator value for the output file if it is a new one.
    `scriptTag` - Specifies the script into which the movie should be converted if the output file is a new one.
    `flags` - the appropriate flags for this operation
  Returns:
    the resource id of the movie created.

### convertToFile

    public int convertToFile(Track onlyTrack,
                             QTFile outputFile,
                             int fileType,
                             int creator,
                             int scriptTag,
                             int flags,
                             MovieExporter userComp)
                      throws QTException

  This method converts this movie into a specified file and type.
  QuickTime::ConvertMovieToFile()

  Parameters:
    `onlyTrack` - Specifies the track within the source movie for this conversion operation. To specify all tracks, set the value of this parameter to null.
    `outputFile` - Specifies the destination file.
    `fileType` - Specifies the data type of the destination file for the movie.
    `creator` - Specifies the creator value for the output file if it is a new one.
    `scriptTag` - Specifies the script into which the movie should be converted if the output file is a new one.
    `flags` - the appropriate flags for this operation
    `userComp` - A ComponentIdentifier of type 'spit' that will be opened and used by this call to export the Movie
  Returns:
    the resource id of the movie created.

### getQTVRTrack

    public Track getQTVRTrack(int index)
                       throws QTException

  The QTVRGetQTVRTrack function returns a track for the QTVR track that has the index specified by the index parameter in the QuickTime movie specified by the theMovie parameter. If there is no such track, QTVRGetQTVRTrack returns the value null.
  QuickTime::QTVRGetQTVRTrack()

  Parameters:
    `index` - this value indicates the nth VR Track to return. QT3.0 only supports one VR track so this value should be set to 1.

### toString

    public java.lang.String toString()

  Print information about this object.
  Overrides:
    `toString` in class `QTObject`
  Returns:
    a string representing this Movie object

### needsTimeTable

    public final boolean needsTimeTable()
                                 throws StdQTException

  Determine whether a movie is being progressively downloaded..
  QuickTime::QTMovieNeedsTimeTable()
  Returns:
    a boolean if movie is being progressively downloaded

### maxLoadedTimeInMovie

    public final int maxLoadedTimeInMovie()
                                   throws StdQTException

  Returns the duration of the part of a movie that has already been downloaded.
  QuickTime::GetMaxLoadedTimeInMovie()

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD