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, quicktime.jdirect.SharedLibrary, com.apple.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.