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 MovieController

    java.lang.Object
      |
      +--quicktime.QTObject
            |
            +--quicktime.std.comp.ComponentIdentifier
                  |
                  +--quicktime.std.comp.Component
                        |
                        +--quicktime.std.movies.MovieController

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

Direct Known Subclasses:
  MultiMovieController

public class MovieController
extends Component
implements quicktime.jdirect.QuickTimeLib

The MovieController class implements the corresponding data structure of the Movie Toolbox. MovieController allows your application to play and control movies with a standard interface. You obtain this identifier from the Component Manager's OpenComponent or OpenDefaultComponent function, or from the NewMovieController function (described on page 2-29 of Inside Macintosh: QuickTime Components).

If an application installs an ActionFilter callback, then it must remove this callback when it has finished with it to allow the native structures used in this callback to be properly disposed.

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

Constructor Summary
`MovieController(int subType, Movie theMovie, QDGraphics window, QDPoint location)` This method constructs a MovieController object for a given subType.
`MovieController(Movie itsMovie)` This method locates a movie controller component for you and assigns a movie to that controller.
`MovieController(Movie itsMovie, int someFlags)` This method locates a movie controller component for you and assigns a movie to that controller.

Method Summary
`void` | `activate()` This method activates the movie controller.
`void` | `activate(QDGraphics window, boolean activate)` This method can be used in response to activate, deactivate, suspend, and resume events.
`void` | `badgeClick(boolean flag)` Your application can use this method to switch badge clicking (false to ignore, true to process).
`void` | `clear()` This method removes the current movie selection from the movie associated with a specified controller.
`boolean` | `click(QDPoint where, int modifiers)` Your application should call the method when the user clicks in a movie controller window.
`boolean` | `clickAndHoldPoint(QDPoint point)` Your application can use this method to test if point has click and hold action.
`void` | `controllerSizeChanged()` Your application can use this method to indicate that the controller size has changed.
`Movie` | `copy()` This method returns a copy of the current movie selection from the movie associated with a specified controller.
`Movie` | `cut()` This method returns a copy of the current movie selection from the movie associated with a specified controller and then removes the current movie selection from the source movie.
`void` | `deactivate()` This method deactivates the movie controller.
`void` | `draw()` Your application should call the draw method in response to an update event The movie controller component updates the movie controller if the controller is in the same window with the Canvas object.
`Region` | `drawBadge(Region movieRgn, boolean returnBadgeRgn)` This method allows you to display a controller's badge.
`void` | `enableEditing(boolean enabled)` This method allows your application to enable and disable editing for a movie controller.
`void` | `forceTimeTableUpdate()` Your application can use this method to force the update of the time table.
`QDRect` | `getBounds()` This method returns a movie controller's boundary rectangle.
`Region` | `getBoundsRgn()` This method returns the actual region occupied by the controller and its movie, if the movie is attached to the controller.
`Region` | `getClip()` This method allows you to obtain information describing a movie controller's clipping regions.
`int` | `getControllerInfo()` This method returns the current status of a movie controller and its associated movie.
`int` | `getCurrentTime()` This method returns the time value represented by the indicator on the movie controller's slider.
`boolean` | `getCursorSettingEnabled()` Your application can use this method to determine whether or not the movie controller is allowed to change the cursor.
`boolean` | `getDragEnabled()` Your application can use this method to determine whether the movie controller has been instructed to enable drag & drop behavior.
`int` | `getFlags()` Your application can use this action to retrieve a movie's control flags.
`boolean` | `getKeysEnabled()` Your application can use this action to determine whether keystrokes are enabled for a movie controller.
`boolean` | `getLooping()` Your application can use this action to determine whether a movie is looping.
`boolean` | `getLoopIsPalindrome()` Your application can use this action to determine whether palindrome looping is enabled for a movie.
`Movie` | `getMovie()` This method allows you to get the movie associated with controller.
`boolean` | `getPlayEveryFrame()` Your application can use this action to determine whether the movie controller has been instructed to play every frame in a movie.
`float` | `getPlayRate()` Your application can use this action to determine a movie's playback rate.
`boolean` | `getPlaySelection()` Your application can use this action to determine whether a movie has been constrained to playing within its selection.
`QDGraphics` | `getPort()` This method returns a movie controller's color graphics port.
`QDDimension` | `getRequiredSize()` This returns the actual size of the controller itself - how many pixels high and wide that the controller takes up.
`TimeRecord` | `getSelectionBegin()` Your application can use this method to receive the start time of a selection.
`TimeRecord` | `getSelectionDuration()` Your application can use this method to receive the duration of a selection.
`int` | `getTimeScale()` This method returns the time scale of the controller.
`QDRect` | `getTimeSliderRect()` Your application can use this method to receive the QDRect specifying the location and size of the time slider.
`boolean` | `getUseBadge()` Your application can use this action to determine whether a controller is using a badge.
`boolean` | `getVisible()` This method returns a value that indicates whether a movie controller is visible.
`float` | `getVolume()` Your application can use this action to determine a movie's volume.
`Region` | `getWindowRgn(QDGraphics window)` This method allows your application to determine the window region that is actually in use by a controller and its movie.
`void` | `goToTime(TimeRecord time)` Your application can use this action to goto a specific time.
`void` | `idle()` This method performs idle processing for a movie controller.
`boolean` | `inController(QDPoint thePt)` This method allows your application to determine if a point is within the controller's control area.
`void` | `invalidate(QDGraphics window, Region invalidRgn)` This method allows your application to invalidate portions of a movie controller.
`boolean` | `isAttached()` Your application can use this method to receive information whether the controller is attached or not.
`boolean` | `isEditingEnabled()` This method allows your application to determine whether editing is currently enabled for a movie controller.
`boolean` | `key(int key, int modifiers)` This method handles keyboard events for a movie controller.
`void` | `linkToURL(java.lang.String url)` Your application can use this method to set a URL.
`void` | `movieChanged()` This method lets you inform a movie controller component that your application has used the Movie Toolbox to change the characteristics of its associated movie.
`void` | `movieEdited()` Your application can use this method to indicate that the movie has been edited.
`void` | `paste()` This method inserts a specified movie at the current movie time in the movie associated with a specified controller.
`void` | `paste(Movie srcMovie)` This method inserts a specified movie at the current movie time in the movie associated with a specified controller.
`void` | `play(float rate)` Your application can use this action to start or stop playing a movie.
`void` | `position(QDRect movieRect, int someFlags)` This method allows you to control the position of a movie and its controller on the computer display.
`void` | `position(QDRect movieRect, QDRect controllerRect, int someFlags)` This method allows you to control the position of a movie and its controller on the computer display.
`void` | `prerollAndPlay(float rate)` Your application can use this method to start a movie.
`void` | `removeActionFilter()` Removes the current action filter from the MovieController.
`void` | `removeMovie()` This method allows you to remove the movie of the controller.
`void` | `resume()` Indicates that a resume event has been received.
`void` | `setActionFilter(ActionFilter filter)` Registers a class that can provide a filter function for any action the MovieController takes.
`void` | `setActionFilter(ActionFilter filter, boolean doIdle)` Registers a class that can provide a filter function for any action the MovieController takes.
`void` | `setAttached(boolean attached)` Your application can use this method to make the controller attached or detached.
`void` | `setBounds(QDRect newBoundsRect)` This method lets you change the position and size of a movie controller.
`void` | `setClip(Region theClip)` This method allows you to set a movie controller's clipping region.
`void` | `setColorTable(ColorTable newCTable)` Your application can use this method to assign a new color table to the controller QuickTime::MCDoAction()
`void` | `setControllerKeysEnabled(boolean enabled)` This method allows your application to enable or disable responding to keys.
`void` | `setCursorSettingEnabled(boolean enabled)` Your application can use this method to specify whether or not the movie controller is allowed to change the cursor.
`void` | `setDragEnabled(boolean enabled)` Your application can use this method to enable drag & drop behavior.
`void` | `setDuration(int duration)` This method allows your application to set a controller's duration in the case where a controller does not have a movie associated with it.
`void` | `setFlags(int flags)` Your application can use this action to set a movie's control flags.
`void` | `setGrowBoxBounds(QDRect limits)` Your application can use this action to set the limits for grow box.
`void` | `setKeysEnabled(boolean enabled)` Your application can use this action to enable or disable keystrokes for a movie.
`void` | `setLooping(boolean looping)` Your application can use this action to enable or disable looping for a movie.
`void` | `setLoopIsPalindrome(boolean looping)` Your application can use this method to enable palindrome looping.
`void` | `setMovie(Movie aMovie, QDGraphics movieWindow, QDPoint location)` This method replaces the current movie controlled by the movie controller with a new movie.
`void` | `setMovieClip(Region theClip)` This method allows you to set a movie's clipping region.
`void` | `setPlayEveryFrame(boolean play)` Your application can use this action to instruct the movie controller to play every frame in a movie.
`void` | `setPlaySelection(boolean play)` Your application can use this action to constrain playing to the current selection.
`void` | `setPort(QDGraphics grafPtr)` This method allows your application to set the graphics port for a movie controller.
`void` | `setSelectionBegin(TimeRecord time)` Your application can use this action to set the start time of a selection.
`void` | `setSelectionDuration(TimeRecord time)` Your application can use this action to set the duration of a selection.
`void` | `setUseBadge(boolean useBadge)` Your application can use this action to enable or disable a movie's playback badge.
`void` | `setVisible(boolean visible)` This method allows your application to control the visibility of a movie controller.
`void` | `setVolume(float newVolume)` Your application can use this action to set a movie's volume.
`void` | `step(int numberOfSteps)` Your application can use this action to play a movie while skipping a specified number of frames at a time.
`void` | `suspend()` Indicates that a suspend event has been received.
`void` | `undo()` This method allows your application to discard the effects of the most recent edit operation.

Methods inherited from class quicktime.std.comp.Component
`count`

Methods inherited from class quicktime.std.comp.ComponentIdentifier
`find, find, getInfo, toString`

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

### MovieController

    public MovieController(Movie itsMovie)
                    throws QTException

  This method locates a movie controller component for you and assigns a movie to that controller. This function always creates a controller that is visible and attached to a movie.
  QuickTime::NewMovieController()
Parameters:
  `itsMovie` - Identifies the movie to be associated with the movie controller.

### MovieController

    public MovieController(Movie itsMovie,
                           int someFlags)
                    throws QTException

  This method locates a movie controller component for you and assigns a movie to that controller. This function always creates a controller that is attached to a movie.
  QuickTime::NewMovieController()
Parameters:
  `itsMovie` - Identifies the movie to be associated with the movie controller.
  `someFlags` - Contains flags that control the operation.

### MovieController

    public MovieController(int subType,
                           Movie theMovie,
                           QDGraphics window,
                           QDPoint location)
                    throws QTException

  This method constructs a MovieController object for a given subType. It attaches the controller to the specifed movie in the specifed window.
  QuickTime::MCNewAttachedController()
Parameters:
  `subType` - the sub type of the MovieController.kType component that you wish to open
  `theMovie` - Specifies the movie to be associated with the movie controller.
  `window` - Identifies the window in which the movie is to be displayed. This may NOT be null.
  `location` - Specifies the upper-left corner of the movie within the window specified by the w parameter.

Method Detail

### getRequiredSize

    public final QDDimension getRequiredSize()

  This returns the actual size of the controller itself - how many pixels high and wide that the controller takes up. This size is independent of the actual display size of the movie and the controller and represents the default number of pixels that are required in horizontal and vertical dimensions to display the actual controller.
  Returns:
    the minimum size for the controller

### idle

    public final void idle()
                    throws QTException

  This method performs idle processing for a movie controller. This idle processing includes calling the Movie Toolbox's MoviesTask function for each movie that is associated with the controller.
  QuickTime::MCIdle()

### setActionFilter

    public final void setActionFilter(ActionFilter filter)
                               throws StdQTException

  Registers a class that can provide a filter function for any action the MovieController takes. By default the filter will not be called with idle actions. If the filter is null the current idleFilter will be removed.
  QuickTime::MCSetActionFilterWithRefCon()

  Parameters:
    `filter` - the filter that you use
  See Also:
    `QTCallBack`

### setActionFilter

    public final void setActionFilter(ActionFilter filter,
                                      boolean doIdle)
                               throws StdQTException

  Registers a class that can provide a filter function for any action the MovieController takes. If the filter is null the current idleFilter will be removed.
  QuickTime::MCSetActionFilterWithRefCon()

  Parameters:
    `filter` - the filter that you use
    `idleFlag` - if true the filter will also be called with idle actions, otherwise false.
  See Also:
    `QTCallBack`

### removeActionFilter

    public final void removeActionFilter()
                                  throws StdQTException

  Removes the current action filter from the MovieController.
  QuickTime::MCSetActionFilterWithRefCon()

### setMovie

    public void setMovie(Movie aMovie,
                         QDGraphics movieWindow,
                         QDPoint location)
                  throws StdQTException

  This method replaces the current movie controlled by the movie controller with a new movie. When calling this method, you must supply a valid QDGraphics object for the movieWindow parameter. To remove a movie, call removeMovie. To control multiple movies, use the MultiMovieController class.
  QuickTime::MCSetMovie()

  Parameters:
    `aMovie` - Identifies the movie to be associated with the movie controller.
    `movieWindow` - Identifies the window in which the movie is to be displayed. This may NOT be null unless the movie is also null.
    `location` - Specifies the upper-left corner of the movie within the window specified by the movieWindow parameter.
  See Also:
    `MultiMovieController`

### getMovie

    public final Movie getMovie()
                         throws StdQTException

  This method allows you to get the movie associated with controller.
  QuickTime::MCGetIndMovie()

  Returns:
    a Movie object.

### removeMovie

    public void removeMovie()
                     throws StdQTException

  This method allows you to remove the movie of the controller.
  QuickTime::MCRemoveMovie()

### draw

    public final void draw()
                    throws StdQTException

  Your application should call the draw method in response to an update event The movie controller component updates the movie controller if the controller is in the same window with the Canvas object. The controller component updates the movie associated with the controller only if the movie is contained in the frame of the Canvas object.
  QuickTime::MCDraw()

### click

    public final boolean click(QDPoint where,
                               int modifiers)
                        throws StdQTException

  Your application should call the method when the user clicks in a movie controller window.
  QuickTime::MCClick()

  Parameters:
    `where` - a QDPoint indicating the location of the click
    `modifiers` - specifies java-defined modifier flags for the event

### key

    public final boolean key(int key,
                             int modifiers)
                      throws StdQTException

  This method handles keyboard events for a movie controller. You can call this method only if you have enabled keystroke processing in the controller. By default, keystroke processing is turned off when you create a movie controller. You can enable and disable keystroke processing using the setKeysEnabled method.
  QuickTime::MCKey()

  Parameters:
    `key` - specifies the java-defined keystroke
    `modifiers` - specifies java-defined modifier flags for the event

### activate

    public final void activate()
                        throws StdQTException

  This method activates the movie controller.
  QuickTime::MCDoAction()

### deactivate

    public final void deactivate()
                          throws StdQTException

  This method deactivates the movie controller.
  QuickTime::MCDoAction()

### play

    public final void play(float rate)
                    throws StdQTException

  Your application can use this action to start or stop playing a movie.
  QuickTime::MCDoAction()

  Parameters:
    `rate` - Is a fixed value that indicates the rate of play. Values greater than 0 correspond to forward rates; values less than 0 play the movie backward. A value of 0 stops the movie.

### goToTime

    public final void goToTime(TimeRecord time)
                        throws StdQTException

  Your application can use this action to goto a specific time.
  QuickTime::MCDoAction()

  Parameters:
    `time` - Specifies the time to go.

### setVolume

    public final void setVolume(float newVolume)
                         throws StdQTException

  Your application can use this action to set a movie's volume.
  QuickTime::MCDoAction()

  Parameters:
    `rate` - Is a 16-bit, fixed-point number that indicates the relative volume of the movie. Volume values range from Ð1.0 to 1.0. Negative values play no sound but preserve the absolute value of the volume setting.

### getVolume

    public final float getVolume()
                          throws StdQTException

  Your application can use this action to determine a movie's volume.
  QuickTime::MCDoAction()

  Returns:
    a 16-bit, fixed-point number that indicates the relative volume of the movie. Volume values range from Ð1.0 to 1.0. Negative values play no sound but preserve the absolute value of the volume setting.

### step

    public final void step(int numberOfSteps)
                    throws StdQTException

  Your application can use this action to play a movie while skipping a specified number of frames at a time.
  QuickTime::MCDoAction()

  Parameters:
    `numberOfSteps` - value that specifies the number of steps (that is, the frames and the play direction). Positive values step the movie forward the specified number of frames; negative values step the movie backward. A value of 0 steps the movie forward one frame.

### setLooping

    public final void setLooping(boolean looping)
                          throws StdQTException

  Your application can use this action to enable or disable looping for a movie.
  QuickTime::MCDoAction()

  Parameters:
    `looping` - a value of true indicates that looping is to be enabled.

### getLooping

    public final boolean getLooping()
                             throws StdQTException

  Your application can use this action to determine whether a movie is looping.
  QuickTime::MCDoAction()

  Returns:
    true if looping is enabled for the movie that is assigned to this controller. Otherwise, it is false.

### setLoopIsPalindrome

    public final void setLoopIsPalindrome(boolean looping)
                                   throws StdQTException

  Your application can use this method to enable palindrome looping. Palindrome looping causes a movie to play alternately forward and backward. Looping must also be enabled for palindrome looping to take effect.
  QuickTime::MCDoAction()

  Parameters:
    `looping` - The parameter data must contain a Boolean valueÑa value of true indicates that palindrome looping is to be enabled.

### getLoopIsPalindrome

    public final boolean getLoopIsPalindrome()
                                      throws StdQTException

  Your application can use this action to determine whether palindrome looping is enabled for a movie. Looping must also be enabled for palindrome looping to take effect.
  QuickTime::MCDoAction()

  Returns:
    true if palindrome looping is enabled for the movie that is assigned to this controller. Otherwise, it is false.

### setGrowBoxBounds

    public final void setGrowBoxBounds(QDRect limits)
                                throws StdQTException

  Your application can use this action to set the limits for grow box.
  QuickTime::MCDoAction()

  Parameters:
    `limits` - Specifies the new limits.

### setSelectionBegin

    public final void setSelectionBegin(TimeRecord time)
                                 throws StdQTException

  Your application can use this action to set the start time of a selection.
  QuickTime::MCDoAction()

  Parameters:
    `time` - Specifies the start time.

### setSelectionDuration

    public final void setSelectionDuration(TimeRecord time)
                                    throws StdQTException

  Your application can use this action to set the duration of a selection.
  QuickTime::MCDoAction()

  Parameters:
    `time` - Specifies the start time.

### setKeysEnabled

    public final void setKeysEnabled(boolean enabled)
                              throws StdQTException

  Your application can use this action to enable or disable keystrokes for a movie. By default, keystroke processing is disabled.
  QuickTime::MCDoAction()

  Parameters:
    `enabled` - a value of true indicates that keystrokes are to be enabled.

### getKeysEnabled

    public final boolean getKeysEnabled()
                                 throws StdQTException

  Your application can use this action to determine whether keystrokes are enabled for a movie controller.
  QuickTime::MCDoAction()

  Returns:
    true if keystrokes are enabled for the movie that is assigned to this controller. Otherwise, it is false.

### setPlaySelection

    public final void setPlaySelection(boolean play)
                                throws StdQTException

  Your application can use this action to constrain playing to the current selection.
  QuickTime::MCDoAction()

  Parameters:
    `play` - a value of true indicates that playing within the current selection is to be enabled.

### getPlaySelection

    public final boolean getPlaySelection()
                                   throws StdQTException

  Your application can use this action to determine whether a movie has been constrained to playing within its selection.
  QuickTime::MCDoAction()

  Returns:
    true if playing is constrained to the current selection. Otherwise, it sets the value to false.

### setUseBadge

    public final void setUseBadge(boolean useBadge)
                           throws StdQTException

  Your application can use this action to enable or disable a movie's playback badge. If a controller's badge is enabled, then the badge is displayed whenever the controller is not visible. When the controller is visible, the badge is not displayed. If the badge is disabled, the badge is never displayed.
  QuickTime::MCDoAction()

  Parameters:
    `useBadge` - a value of true indicates that the playback badge is to be enabled.

### getUseBadge

    public final boolean getUseBadge()
                              throws StdQTException

  Your application can use this action to determine whether a controller is using a badge. If a controller's badge is enabled, then the badge is displayed whenever the controller is not visible. When the controller is visible, the badge is not displayed. If the badge is disabled, the badge is never displayed.
  QuickTime::MCDoAction()

  Returns:
    true if the controller is using a badge. Otherwise, it is false.

### setFlags

    public final void setFlags(int flags)
                        throws StdQTException

  Your application can use this action to set a movie's control flags.
  QuickTime::MCDoAction()

  Parameters:
    `flags` - an integer that contains the new control flag values.

### getFlags

    public final int getFlags()
                       throws StdQTException

  Your application can use this action to retrieve a movie's control flags.
  QuickTime::MCDoAction()

  Returns:
    movie's control flags into.

### setPlayEveryFrame

    public final void setPlayEveryFrame(boolean play)
                                 throws StdQTException

  Your application can use this action to instruct the movie controller to play every frame in a movie. In this case, the movie controller may play the movie at a slower rate than you specify with the play() method. However, the controller does not play the movie faster than the movie rate. In addition, the controller does not play the movie's sound tracks.
  QuickTime::MCDoAction()

  Parameters:
    `play` - a value of true instructs the controller to play every frame in the movie, even if that means playing the movie at a slower rate than you previously specified.

### getPlayEveryFrame

    public final boolean getPlayEveryFrame()
                                    throws StdQTException

  Your application can use this action to determine whether the movie controller has been instructed to play every frame in a movie. You tell the controller to play every frame by using the setPlayEveryFrame method, which is described earlier in this section.
  QuickTime::MCDoAction()

  Returns:
    true if the controller has been instructed to play every frame in the movie. Otherwise, the controller sets the value to false.

### getPlayRate

    public final float getPlayRate()
                            throws StdQTException

  Your application can use this action to determine a movie's playback rate. You set the playback rate when you start a movie playing by using the play() method.
  QuickTime::MCDoAction()

  Returns:
    The movie controller returns the movie's playback rate. Values greater than 0 correspond to forward rates; values less than 0 play the movie backward. A value of 0 indicates that the movie is stopped.

### suspend

    public final void suspend()
                       throws StdQTException

  Indicates that a suspend event has been received. There is no parameter.
  QuickTime::MCDoAction()

### resume

    public final void resume()
                      throws StdQTException

  Indicates that a resume event has been received. There is no parameter.
  QuickTime::MCDoAction()

### setControllerKeysEnabled

    public final void setControllerKeysEnabled(boolean enabled)
                                        throws StdQTException

  This method allows your application to enable or disable responding to keys.
  QuickTime::MCDoAction()

### getTimeSliderRect

    public final QDRect getTimeSliderRect()
                                   throws StdQTException

  Your application can use this method to receive the QDRect specifying the location and size of the time slider.
  QuickTime::MCDoAction()

  Returns:
    A QDRect object specifying the location and size of the time slider.

### getDragEnabled

    public final boolean getDragEnabled()
                                 throws StdQTException

  Your application can use this method to determine whether the movie controller has been instructed to enable drag & drop behavior.
  QuickTime::MCDoAction()

  Returns:
    true if the controller has been instructed to enable drag & drop. Otherwise, it is false.

### setDragEnabled

    public final void setDragEnabled(boolean enabled)
                              throws StdQTException

  Your application can use this method to enable drag & drop behavior.
  QuickTime::MCDoAction()

  Parameters:
    `enabled` - a value of true indicates that the drag & drop behavior is to be enabled.

### getSelectionBegin

    public final TimeRecord getSelectionBegin()
                                       throws QTException

  Your application can use this method to receive the start time of a selection.
  QuickTime::MCDoAction()

  Returns:
    A TimeRecord object specifying the start time of a selection.

### getSelectionDuration

    public final TimeRecord getSelectionDuration()
                                          throws QTException

  Your application can use this method to receive the duration of a selection.
  QuickTime::MCDoAction()

  Returns:
    A TimeRecord object specifying the duration of a selection.

### prerollAndPlay

    public final void prerollAndPlay(float rate)
                              throws StdQTException

  Your application can use this method to start a movie. this method makes sure that movie is prerolled before it starts playing.
  QuickTime::MCDoAction()

  Parameters:
    `rate` - a value indicating the rate of the movie playback.

### getCursorSettingEnabled

    public final boolean getCursorSettingEnabled()
                                          throws StdQTException

  Your application can use this method to determine whether or not the movie controller is allowed to change the cursor.
  QuickTime::MCDoAction()

  Returns:
    true if the controller is allowed to set the cursor. Otherwise, it is false.

### setCursorSettingEnabled

    public final void setCursorSettingEnabled(boolean enabled)
                                       throws StdQTException

  Your application can use this method to specify whether or not the movie controller is allowed to change the cursor.
  QuickTime::MCDoAction()

  Parameters:
    `enabled` - a value of true indicates that the movie controller is allowed to change the cursor.

### setColorTable

    public final void setColorTable(ColorTable newCTable)
                             throws StdQTException

  Your application can use this method to assign a new color table to the controller
  QuickTime::MCDoAction()

  Parameters:
    `newCTable` - Specifies the new color table

### controllerSizeChanged

    public final void controllerSizeChanged()
                                     throws StdQTException

  Your application can use this method to indicate that the controller size has changed.
  QuickTime::MCDoAction()

### badgeClick

    public final void badgeClick(boolean flag)
                          throws StdQTException

  Your application can use this method to switch badge clicking (false to ignore, true to process).
  QuickTime::MCDoAction()

  Parameters:
    `flag` - true to process (the default), false to ignore.

### movieEdited

    public final void movieEdited()
                           throws StdQTException

  Your application can use this method to indicate that the movie has been edited.
  QuickTime::MCDoAction()

### forceTimeTableUpdate

    public final void forceTimeTableUpdate()
                                    throws StdQTException

  Your application can use this method to force the update of the time table.
  QuickTime::MCDoAction()

### linkToURL

    public final void linkToURL(java.lang.String url)
                         throws QTException

  Your application can use this method to set a URL.
  QuickTime::MCDoAction()

  Parameters:
    `url` - the URL that is used to create a DataReference.

### clickAndHoldPoint

    public final boolean clickAndHoldPoint(QDPoint point)
                                    throws StdQTException

  Your application can use this method to test if point has click and hold action.
  QuickTime::MCDoAction()

  Parameters:
    `point` - (local coordinates).
  Returns:
    true if point has click & hold action (e.g., VR object movie autorotate spot)

### setAttached

    public final void setAttached(boolean attached)
                           throws QTException

  Your application can use this method to make the controller attached or detached.
  QuickTime::MCSetControllerAttached()

  Parameters:
    `attached` - Specifies the new state. true if attached.

### isAttached

    public final boolean isAttached()
                             throws StdQTException

  Your application can use this method to receive information whether the controller is attached or not.
  QuickTime::MCIsControllerAttached()

  Returns:
    true if the controller is attached.

### setBounds

    public final void setBounds(QDRect newBoundsRect)
                         throws StdQTException

  This method lets you change the position and size of a movie controller. A controller's boundary rectangle encloses the control portion of the controller. In addition, in cases where the movie is attached to the this.component, the boundary rectangle also encloses the movie. Note that changing the size of the boundary rectangle may result in the movie being resized as well, if the movie is attached to the controller.
  QuickTime::MCSetControllerBoundsRect()

  Parameters:
    `newBoundsRect` - Identifies the new boundary rectangle.

### getBounds

    public final QDRect getBounds()
                           throws StdQTException

  This method returns a movie controller's boundary rectangle. This rectangle reflects the size and location of the controller even if the controller is currently hidden. If the controller is detached from its movie, the rectangle encompasses only the this.component, not the movie. If the controller is attached to its movie, the rectangle encompasses both the controller and the movie.
  QuickTime::MCGetControllerBoundsRect()

  Returns:
    a QDRect object specifying the boundary rectangle.

### setPort

    public final void setPort(QDGraphics grafPtr)
                       throws StdQTException

  This method allows your application to set the graphics port for a movie controller. You can use this function to place a movie and its associated movie controller in different graphics ports. If you are using an attached this.component, both the controller and the movie's graphics ports are changed. If you are using a detached this.component, this function changes only the graphics port of the control portion of the controller. You must use the Movie Toolbox's SetMovieGWorld function followed by the MCMovieChanged function to change other portions.
  QuickTime::MCSetControllerPort()

  Parameters:
    `grafPtr` - Points to the new graphics port for the movie controller. This may NOT be null.

### getPort

    public final QDGraphics getPort()
                             throws StdQTException

  This method returns a movie controller's color graphics port.
  QuickTime::MCGetControllerPort()

  Returns:
    A QDGraphics object representing the controller's graf port.

### setVisible

    public final void setVisible(boolean visible)
                          throws StdQTException

  This method allows your application to control the visibility of a movie controller.
  QuickTime::MCSetVisible()

  Parameters:
    `visible` - Specifies the action for this function. Set the visible parameter to true to cause the controller to be visible. Set this parameter to false to make the controller invisible.

### getVisible

    public final boolean getVisible()
                             throws StdQTException

  This method returns a value that indicates whether a movie controller is visible.
  QuickTime::MCGetVisible()

  Returns:
    whether the controller visible or not.

### getBoundsRgn

    public final Region getBoundsRgn()
                              throws QTException

  This method returns the actual region occupied by the controller and its movie, if the movie is attached to the controller.
  QuickTime::MCGetControllerBoundsRgn()

  Returns:
    a Region object specifying the boundary region for this controller.

### getWindowRgn

    public final Region getWindowRgn(QDGraphics window)
                              throws QTException

  This method allows your application to determine the window region that is actually in use by a controller and its movie.
  QuickTime::MCGetWindowRgn()

  Parameters:
    `window` - Specifies the window. This may NOT be null.
  Returns:
    a Region object specifying the window region.

### movieChanged

    public final void movieChanged()
                            throws StdQTException

  This method lets you inform a movie controller component that your application has used the Movie Toolbox to change the characteristics of its associated movie.
  QuickTime::MCMovieChanged()

  Parameters:
    `changedMovie` - Specifies the changed movie.

### setDuration

    public final void setDuration(int duration)
                           throws StdQTException

  This method allows your application to set a controller's duration in the case where a controller does not have a movie associated with it.
  QuickTime::MCSetDuration()

  Parameters:
    `duration` - Specifies the duration for the controller.

### getCurrentTime

    public final int getCurrentTime()
                             throws StdQTException

  This method returns the time value represented by the indicator on the movie controller's slider.
  QuickTime::MCGetCurrentTime()

  Returns:
    the time value that corresponds to the current setting of the indicator on the movie controller's slider.

### getTimeScale

    public final int getTimeScale()
                           throws StdQTException

  This method returns the time scale of the controller.
  QuickTime::MCGetCurrentTime()

  Returns:
    the time scale for the controller.

### activate

    public final void activate(QDGraphics window,
                               boolean activate)
                        throws StdQTException,
                               QDException

  This method can be used in response to activate, deactivate, suspend, and resume events.
  QuickTime::MCActivate()

  Parameters:
    `window` - Specifies the window in which the event has occurred. This may NOT be null.
    `activate` - Indicates the nature of the event. Set this parameter to true for activate and resume events. Set it to false for deactivate and suspend events.

### enableEditing

    public final void enableEditing(boolean enabled)
                             throws StdQTException

  This method allows your application to enable and disable editing for a movie controller.
  QuickTime::MCEnableEditing()

  Parameters:
    `enabled` - Specifies whether to enable or disable editing for the controller.

### isEditingEnabled

    public final boolean isEditingEnabled()
                                   throws StdQTException

  This method allows your application to determine whether editing is currently enabled for a movie controller.
  QuickTime::MCIsEditingEnabled()

  Returns:
    a value indicating the current edit state of the controller.

### copy

    public final Movie copy()
                     throws QTException

  This method returns a copy of the current movie selection from the movie associated with a specified controller.
  QuickTime::MCCopy()

  Returns:
    a copy of the current movie selection from the movie associated with a specified controller.

### cut

    public final Movie cut()
                    throws QTException

  This method returns a copy of the current movie selection from the movie associated with a specified controller and then removes the current movie selection from the source movie.
  QuickTime::MCCut()

  Returns:
    a copy of the current movie selection.

### paste

    public final void paste()
                     throws StdQTException

  This method inserts a specified movie at the current movie time in the movie associated with a specified controller. This will paste the data that is found currently on the scrap
  QuickTime::MCPaste()

### paste

    public final void paste(Movie srcMovie)
                     throws StdQTException

  This method inserts a specified movie at the current movie time in the movie associated with a specified controller.
  QuickTime::MCPaste()

  Parameters:
    `srcMovie` - Specifies the movie to be inserted into the current selection in the movie associated with the movie controller.

### clear

    public final void clear()
                     throws StdQTException

  This method removes the current movie selection from the movie associated with a specified controller.
  QuickTime::MCClear()

### undo

    public final void undo()
                    throws StdQTException

  This method allows your application to discard the effects of the most recent edit operation.
  QuickTime::MCUndo()

### position

    public final void position(QDRect movieRect,
                               QDRect controllerRect,
                               int someFlags)
                        throws StdQTException

  This method allows you to control the position of a movie and its controller on the computer display.
  QuickTime::MCPositionController()

  Parameters:
    `movieRect` - Specifies the coordinates of the movie's boundary rectangle.
    `controllerRect` - Specifies the coordinates of the controller's boundary rectangle.
    `someFlags` - If you set these flags to 0, the movie controller component centers the movie in the rectangle specified by movieRect and scales the movie to fit in that rectangle. You may control how the movie is drawn by setting one or more of the flags to 1.

### position

    public final void position(QDRect movieRect,
                               int someFlags)
                        throws StdQTException

  This method allows you to control the position of a movie and its controller on the computer display.
  QuickTime::MCPositionController()

  Parameters:
    `movieRect` - Specifies the coordinates of the movie's boundary rectangle.
    `someFlags` - If you set these flags to 0, the movie controller component centers the movie in the rectangle specified by movieRect and scales the movie to fit in that rectangle. You may control how the movie is drawn by setting one or more of the following flags to 1.

### getControllerInfo

    public final int getControllerInfo()
                                throws StdQTException

  This method returns the current status of a movie controller and its associated movie.
  QuickTime::MCGetControllerInfo()

  Returns:
    the current status and capabilities of the controller.

### setClip

    public final void setClip(Region theClip)
                       throws StdQTException

  This method allows you to set a movie controller's clipping region.
  QuickTime::MCSetClip()

  Parameters:
    `theClip` - A Region that defines the controller's clipping region.

### getClip

    public final Region getClip()
                         throws QTException

  This method allows you to obtain information describing a movie controller's clipping regions.
  QuickTime::MCGetClip()

  Returns:
    the clipping region of the entire movie controller

### setMovieClip

    public final void setMovieClip(Region theClip)
                            throws StdQTException

  This method allows you to set a movie's clipping region.
  QuickTime::MCSetClip()

  Parameters:
    `theClip` - A Region that defines the movie's clipping region.

### drawBadge

    public final Region drawBadge(Region movieRgn,
                                  boolean returnBadgeRgn)
                           throws QTException

  This method allows you to display a controller's badge.
  QuickTime::MCDrawBadge()

  Parameters:
    `movieRgn` - Specifies the boundary region of the controller's movie.
  Returns:
    A Region that gives information about the location of the badge.

### inController

    public final boolean inController(QDPoint thePt)
                               throws StdQTException

  This method allows your application to determine if a point is within the controller's control area.
  QuickTime::MCPtInController()

  Returns:
    true if the point is in the controller's control area.

### invalidate

    public final void invalidate(QDGraphics window,
                                 Region invalidRgn)
                          throws StdQTException,
                                 QDException

  This method allows your application to invalidate portions of a movie controller.
  QuickTime::MCInvalidate()

  Parameters:
    `window` - Specifies the window where the invalid region is in. This may NOT be null.
    `invalidRgn` - Specifies the invalid region.

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