Uses of Class
quicktime.QTException

Packages that use QTException
quicktime   
quicktime.io   
quicktime.qd   
quicktime.qd3d   
quicktime.sound   
quicktime.std   
quicktime.std.anim   
quicktime.std.clocks   
quicktime.std.comp   
quicktime.std.image   
quicktime.std.movies   
quicktime.std.movies.media   
quicktime.std.music   
quicktime.std.qtcomponents   
quicktime.std.sg   
quicktime.streaming   
quicktime.util   
quicktime.vr   
 

Uses of QTException in quicktime
 

Subclasses of QTException in quicktime
 class QTUnknownOSException
           
 

Methods in quicktime that throw QTException
 void QTObject.disposeQTObject()
          This call will dispose the underlying QuickTime object that is associated with the QTJava object.
static void QTSession.initialize(int flag)
          This call will open a QTSession and perform any initialisations of the QT environment.
static void QTSession.initialize(int flag, java.lang.Class signedClass)
          This call will open a QTSession and perform any initialisations of the QT environment.
static void QTSession.initializeVR()
          This call will initialize QTVR.
static void QTSession.initialize3D()
           
static void QTSession.open()
          This call will open a QTSession and perform any initialisations of the QTML environment.
static void QTSession.open(int initFlag)
          This call will open a QTSession and perform any initialisations of the QTML environment.
static void QTSession.open(int majorVersion, int minorVersion, int initFlag)
          This call will open a QTSession and perform any initialisations of the QTML environment.
static void QTSession.open(java.lang.Class signedClass)
          This call will open a QTSession and perform any initialisations of the QTML environment.
static void QTSession.open(int initFlag, java.lang.Class signedClass)
          This call will open a QTSession and perform any initialisations of the QTML environment.
static void QTSession.open(int majorVersion, int minorVersion, int initFlag, java.lang.Class signedClass)
          This call will open a QTSession and perform any initialisations of the QTML environment.
static boolean QTSession.isQD3DAvailable()
          Determine whether it is safe to call a QuickDraw 3D API.
static boolean QTSession.isQTVRAvailable()
          Determine whether it is safe to call a QuickTime VR API.
static int QTSession.gestalt(int selector)
          This call will do a gestalt check.
static void QTSession.enterMovies()
          Before you call any Movie Toolbox functions, you must initialize the toolbox

QuickTime::EnterMovies()

static void QTException.checkError(int err)
          This method will throw an exception if the incoming err argument is a non-zero value.
 

Constructors in quicktime with parameters of type QTException
QTRuntimeException(QTException e)
          Creates a QTRuntimeException
 

Uses of QTException in quicktime.io
 

Subclasses of QTException in quicktime.io
 class QTIOException
          A General catch all class that is used to signal errors that occur from QT calls
 

Methods in quicktime.io that throw QTException
static QTFile QTFile.fromGraphicsImporter(GraphicsImporter g)
          Determines the file that the graphics resides in.
static GraphicsImporterInfo QTFile.fromGraphicsImporter(GraphicsImporter g, QTFile inDefaultSpec, java.lang.String prompt)
          Presents a dialog box letting the user save an image in a foreign file format.
static QTFile QTFile.fromGraphicsExporterInput(GraphicsExporter g)
          Determines the file that is the source of input images to the Graphics exporter.
static QTFile QTFile.fromGraphicsExporterOutput(GraphicsExporter g)
          Determines the file that is the destination of Output images to the Graphics exporter.
static QTFile QTFile.fromSequenceGrabber(SequenceGrabber s)
          Allows you to determine the movie file that is currently assigned to a sequence grabber component.
static QTFile QTFile.fromSynthesizerConnections(SynthesizerConnections conns)
          Return a QTFile (or null if none) of a sound bank file that is used by a MusicComponent as specified in that component's SynthesizerConnections
static QTFile QTFile.resolveAlias(AliasHandle alias)
          This method will take an alias and will resolve it, returning the full path name of the resolved file.
static QTFile QTFile.standardGetFilePreview(int[] fileTypes)
          Present a standard open file panel to the user to retrieve a file.
 void QTFile.convertToMovieFile(QTFile outputFile, int fCreator, int inFlags)
          This method takes a specified file and converts it to a movie file.
 void QTFile.convertToMovieFile(QTFile outputFile, int fCreator, int inFlags, MovieImporter mic)
          This method takes a specified file and converts it to a movie file.
 void QTFile.convertToMovieFile(QTFile outputFile, int fCreator, int flags, MovieImporter mic, MovieProgress mp)
          This method takes a specified file and converts it to a movie file.
 void QTFile.createShortcutMovieFile(int creator, int scriptTag, int createMovieFileFlags, DataRef targetDataRef)
          Creates a short cut movie file as specified by this QTFile.
 AliasHandle QTFile.newAlias(boolean minimal)
          Creates an alias record that describes the specified target.
 AliasHandle QTFile.relativeAlias(QTFile relativeToFile, boolean minimal)
          Creates a relative alias record that describes the specified target with respect to the given file.
static OpenMovieFile OpenMovieFile.asRead(QTFile f)
          Open the specified movie file for reading.
static OpenMovieFile OpenMovieFile.asWrite(QTFile f)
          Open the specified movie file for writing.
static AliasHandle AliasHandle.fromDataRef(DataRef dr)
          Converts an aliasDataRef type DataRef into an AliasHandle.
 QTFile AliasHandle.resolve()
          This method will take an alias and will resolve it, returning the full path name of the resolved file.
static OpenFile OpenFile.asRead(QTFile f)
          Open the specified file for reading.
static OpenFile OpenFile.asWrite(QTFile f)
          Open the specified file for writing.
 

Uses of QTException in quicktime.qd
 

Subclasses of QTException in quicktime.qd
 class NativeGraphicsException
          This exception is thrown if the NativeGraphics environment is not initialized when you try to get the QDGraphics from the java.awt.Canvas
 class QDException
          A General catch all class that is used to signal errors that occur from QT calls
 

Methods in quicktime.qd that throw QTException
static Pict Pict.thumbnailFromQDGraphics(QDGraphics qd, QDRect src, int colorDepth)
          Creates an 80-by-80 pixel thumbnail picture from the pixmap associated with this QDGraphics.
static Pict Pict.fromTrack(Track t, int time)
          This method creates a QuickDraw picture from the specified track at the specified time.
static Pict Pict.fromMovie(Movie m, int time)
          This method creates a picture from the specified movie at the specified time.
static Pict Pict.fromMovie(Movie m)
          This method creates a picture that contains a movie's poster.
static Pict Pict.fromPresentation(Presentation p, Stream s)
          This method creates a picture that contains a representation of the presentation returns a PicHandle object for the image.
static Pict Pict.fromSequenceGrabber(SequenceGrabber sg, QDRect bounds, int offscreenDepth, int grabPictFlags)
          Provides a simple interface to obtain a QuickDraw picture from a sequence grabber component.
static Pict Pict.fromGraphicsImporter(GraphicsImporter gi)
          Creates a new Pict containing the image currently in use by this import component.
static Pict Pict.fromGraphicsExporter(GraphicsExporter ge)
          Creates a new Pict containing the image currently in use by this import component.
static Pict Pict.fromImageCompressionDialog(ImageCompressionDialog icd, Pict src)
          Compresses a Pict returning a new Pict.
static Pict Pict.fromFile(java.io.File file)
          Opens a PICT that is stored in the file.
static Pict Pict.open(QDGraphics port, OpenCPicParams params)
          Use OpenCPicture to begin defining a picture, collecting all of your subsequent drawing commands in this record.
 Pict Pict.compress(int quality, int cType)
          This allows your application to compress a single-frame image stored as a picture.
 Pict Pict.fCompress(int colorDepth, int quality, int doDither, int compressAgain, int cType, int codec)
          This allows your application to compress a single-frame image with more variance that stored as a picture.
 void Pict.draw(QDGraphics cg, QDRect frameRect)
          To draw a picture on any type of output device.
 void Pict.drawTrimmed(QDGraphics cg, QDRect frameRect, Region trimMask, int doDither)
          Allows the drawing of an image that is stored as a picture.
 Pict Pict.makeThumbnail(int colorDepth)
          This allows your application to create an 80-by-80 pixel thumbnail picture from a specified picture.
 void QDDrawer.draw(QDGraphics g)
          A class can draw efficiently on the supplied QDGraphics when this method is called on the QDDrawer object by the QDGraphics.beginDraw method.
 Polygon Polygon.copy()
          Copies the mathematical structure of the implicit Polygon into a newly created Polygon.
 void QDGraphics.beginDraw(QDDrawer d)
          This method should be used when a number of drawing methods need to be invoked on this QDGraphics object.
 Pict QDGraphics.makeThumbnail(QDRect src, int colorDepth)
          Creates an 80-by-80 pixel thumbnail picture from the pixmap associated with this QDGraphics.
 Region QDGraphics.getVisClipRgn()
          This method returns intersection of visRgn and clipRgn of the port.
 Region QDGraphics.getClip()
          This method returns the clip Region of the port.
static ColorTable ColorTable.fromImageDescription(ImageDescription id)
          Get the custom color table for an image.
static ColorTable ColorTable.fromMovie(Movie m)
          This method allows your application to get the color table of the movie.
static ColorTable ColorTable.fromCompressionDialog(ImageCompressionDialog d)
          Gets the current color table or null to clear the current color table for a dialog.
static Region Region.fromGraphicsImporter(GraphicsImporter gi)
          Determines the current clipping region.
static Region Region.fromGraphicsImporterDefault(GraphicsImporter gi)
          Determines the default clipping region.
static Region Region.fromMovieDisplayClip(Movie m)
          This method allows your application to determine a movie's current display clipping region.
static Region Region.fromMovieDisplayBounds(Movie m)
          This method allows your application to determine a movie's display boundary region.
static Region Region.fromMovieClip(Movie m)
          This method allows your application to determine a movie's clipping region.
static Region Region.fromPresentationClip(Presentation p, Stream s)
          This method allows your application to determine a Presentation's clipping region.
static Region Region.fromMovieBounds(Movie m)
          This method allows your application to determine a movie's boundary region.
static Region Region.fromMovieSegment(Movie m, int time, int duration)
          This method allows your application to determine a movie's display boundary region during a specified segment.
static Region Region.fromMovieControllerBounds(MovieController mc)
          This method returns the actual region occupied by the controller and its movie, if the movie is attached to the controller.
static Region Region.fromMovieControllerWindow(MovieController mc, QDGraphics window)
          This method allows your application to determine the window region that is actually in use by a controller and its movie.
static Region Region.fromMovieControllerClip(MovieController mc)
          This method allows you to obtain information describing a movie controller's clipping regions.
static Region Region.fromMovieControllerBadge(MovieController mc, Region movieRgn, boolean returnBadgeRgn)
          This method allows you to display a controller's badge.
static Region Region.fromTrackClip(Track t)
          This method allows your application to determine the clipping region of a track.
static Region Region.fromTrackDisplay(Track t)
          This method allows your application to determine the region a track occupies in a movie's graphics world.
static Region Region.fromTrackMovieBounds(Track t)
          This method allows your application to determine the region the track occupies in a movie's boundary region.
static Region Region.fromTrackBounds(Track t)
          This method allows the media to limit the size of the track boundary rectangle.
static Region Region.fromTrackSegment(Track t, int time, int duration)
          This method allows your application to determine the region a track occupies in a movie's graphics world during a specified segment.
static Region Region.fromVideoChannel(VisualChannel vc)
          Allows you to retrieve a channels clipping region.
 Region Region.copy()
          Copies the mathematical structure of the implicit region into a newly created region.
 Region Region.sect(Region regionB)
          Calculates the intersection of two regions and creates a new region representing that structure.
 Region Region.sect(QDRect r)
          Calculates the intersection of this region and the incoming QDRect and creates a new region representing that structure.
 Region Region.union(Region regionB)
          Calculates the union of two regions and creates a new region representing that structure.
 Region Region.union(QDRect rect)
          Calculates the union of this region and the incoming rect, and creates a new region representing that structure.
 Region Region.diff(Region regionB)
          Calculates the subtracts the specified explicit region from the implicit region and creates a new region representing that structure.
 Region Region.xor(Region regionB)
          Calculates the difference between the union and intersection of two regions and creates a new region representing that structure.
 

Constructors in quicktime.qd that throw QTException
Pict(byte[] pictBytes)
          Create a Pict object from an array of bytes.
Polygon(QDGraphics g)
          Allocates a new empty Polygon.
QDGraphics(ImageCompressionDialog d, QDRect rp, int flags)
          Creates an offscreen QDGraphics based on the current compression settings.
QDGraphics(ImageDescription id, int flags)
          Creates an offscreen QDGraphics object from the width, height, depth, and color table of a specified image description structure.
QDGraphics(QDRect bounds)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
QDGraphics(int pixelFormat, QDRect bounds)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
QDGraphics(int pixelFormat, QDRect bounds, int flags)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
QDGraphics(int pixelFormat, QDRect bounds, ColorTable cTable, GDevice aGDevice, int flags)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
Region()
          Allocates a new empty region.
Region(QDRect r)
          Allocates a new region specified by a rectangle.
Region(PixMap pMap)
          Converts a specified BitMap or PixMap to a region.
 

Uses of QTException in quicktime.qd3d
 

Subclasses of QTException in quicktime.qd3d
 class QD3DException
          A General catch all class that is used to signal errors that occur from QT calls
 

Uses of QTException in quicktime.sound
 

Subclasses of QTException in quicktime.sound
 class SoundException
          A General catch all class that is used to signal errors that occur from QT calls
 

Methods in quicktime.sound that throw QTException
 TimeRecord ExtScheduledSoundHeader.getStartTime()
           
 QTPointerRef SndHandle.getSoundData()
          Return a Pointer to the sound data that is contained within the SndHandle.
 void SndHandle.appendSoundData(QTPointerRef buffer)
          Appends the sound buffer to the end of this handle.
 void SndHandle.appendSoundBuffer(int bufferSize)
          Appends the specified number of bytes to the SoundHandle after the header.
 void SndHandle.setSoundData(QTPointerRef buffer)
          Sets the internal buffer Pointer of this sound header to the incomding buffer.
 

Constructors in quicktime.sound that throw QTException
ExtScheduledSoundHeader(QTPointerRef data, int numChannels, float rate, int sampleSizeBits, int format)
          Create an ExtScheduledSoundHeader object when the sample data format is uncompressed.
ExtScheduledSoundHeader(QTPointerRef data, int numChannels, float rate, int numFrames, int sampleSizeBits, int format, int compressionID, int packetSize)
          Create an ExtScheduledSoundHeader object for use when the sample data is compressed.
ExtScheduledSoundHeader(QTPointerRef data, int numChannels, float rate, int numFrames, int sampleSizeBits, int format, int compressionID, int packetSize, TimeRecord startTime, int extendedFlags)
          Create an ExtScheduledSoundHeader object for the scheduled sound calls.
SndCommand(int cmd)
          Creates a SndCommand object and performs initialization
SndCommand(int cmd, int param1, int param2)
          Creates a SndCommand object and performs initialization
SndHandle()
          Construct an empty handle that must be initialized by the setupHeader call.
SndHandle(int size, boolean clear)
          Construct an empty handle that must be initialized by the setupHeader call.
SndHandle(int numChannels, float sampleRate, int sampleSize, int compressionType)
          Construct a sound resource for containing sampled sound that can be used to record and play sound.
SndHandle(int numChannels, float sampleRate, int sampleSize, int compressionType, int baseNote)
          Construct a sound resource for containing sampled sound that can be used to record and play sound.
SndChannel()
          Opens a new SndChannel and allocates memory to store the commands that will control the operation of the sound channel.
SndChannel(int synth, int init)
          Opens a new SndChannel and allocates memory to store the commands that will control the operation of the sound channel.
SndChannel(SoundCallBack callback)
          Opens a new SndChannel and allocates memory to store the commands that will control the operation of the sound channel.
SndChannel(int synth, int init, SoundCallBack callback)
          Opens a new SndChannel and allocates memory to store the commands that will control the operation of the sound channel.
 

Uses of QTException in quicktime.std
 

Subclasses of QTException in quicktime.std
 class StdQTException
          A General catch all class that is used to signal errors that occur from QT calls
 

Methods in quicktime.std that throw QTException
static void QTPreferences.registerAccessKey(java.lang.String keyType, int flags, java.lang.String accessKey)
          This method registers an access key.
static void QTPreferences.registerAccessKey(java.lang.String keyType, int flags, QTHandleRef accessKey)
          This method registers an access key.
static void QTPreferences.unregisterAccessKey(java.lang.String keyType, int flags, java.lang.String accessKey)
          This method removes an access key.
static void QTPreferences.unregisterAccessKey(java.lang.String keyType, int flags, QTHandleRef accessKey)
          This method removes an access key.
static AtomContainer QTPreferences.getPreference(int preferenceType)
          This method retrieves the preference value associated with a specific preference type.
static void QTPreferences.setPreference(int preferenceType, AtomContainer prefAtom)
          This method sets the preference value associated with a specific preference type.
 

Uses of QTException in quicktime.std.anim
 

Methods in quicktime.std.anim that throw QTException
 Sprite SpriteWorld.hitTest(int flags, QDPoint loc)
          This method is used to determine if a sprite exists at a certain location.
 

Constructors in quicktime.std.anim that throw QTException
SpriteWorld(QDGraphics port, QDGraphics spriteLayer, QDColor backgroundColor, QDGraphics background)
          This constructor creates a new sprite world.
Sprite(SpriteWorld itsSpriteWorld, ImageDescription idh, EncodedImage imageData, Matrix matrix, boolean visible, int layer)
          This constructor creates a new Sprite object for a specified sprite world.
 

Uses of QTException in quicktime.std.clocks
 

Methods in quicktime.std.clocks that throw QTException
 TimeRecord TimeBase.getTRTime()
          This allows your application to obtain the current time value from a time base in the default scale of the time base.
 TimeRecord TimeBase.getTRTime(int scale)
          This allows your application to obtain the current time value from a time base.
 TimeRecord TimeBase.getTRStartTime()
          This allows you to determine the start time of a time base in the default scale of the time base.
 TimeRecord TimeBase.getTRStartTime(int scale)
          This allows you to determine the start time of a time base.
 TimeRecord TimeBase.getTRStopTime()
          This allows you to determine the stop time of a time base in the default scale of the time base.
 TimeRecord TimeBase.getTRStopTime(int scale)
          This allows you to determine the stop time of a time base in the default scale of the time base.
 TimeRecord Clock.getTime()
          Allows your application to obtain the current time according to the specified clock.
 

Constructors in quicktime.std.clocks that throw QTException
TimeJumpCallBack(TimeBase tb)
          This allows your application to obtain a new callback.
TimeBase()
          This allows your application to obtain a new time base.
TimeRecord()
          This record is an empty record that will need to be filled out by passing it into calls.
TimeRecord(int scale, long value)
          Create a TimeRecord with the supplied values for scale and time value.
Clock(int subType)
          Opens the specified component,'clok', with the given subType.
RateCallBack(TimeBase tb, float rate, int flags)
          Creates a new callback event that will invoke its Callback object when the rate of the specified timebase reaches a certain value.
ExtremesCallBack(TimeBase tb, int flags)
          This allows your application to obtain a new callback.
TimeCallBack(TimeBase tb, int scale, int value, int flags)
          This allows your application to obtain a new callback.
 

Uses of QTException in quicktime.std.comp
 

Methods in quicktime.std.comp that throw QTException
static ComponentIdentifier ComponentIdentifier.find(ComponentDescription desc)
          Determine the next Component as specified.
static ComponentIdentifier ComponentIdentifier.find(ComponentIdentifier comp, ComponentDescription desc)
          Determine the next Component as specified.
 

Constructors in quicktime.std.comp that throw QTException
Component(int type, int subType)
          Opens the specified component.
 

Uses of QTException in quicktime.std.image
 

Methods in quicktime.std.image that throw QTException
 void VectorStream.addPathAtom(QTHandle pathData)
          Used to add a path to a vector data stream.
 void VectorStream.addAtom(QDColor col)
          Used to add kCurveARGBColorAtom atom to a vector data stream.
 void VectorStream.addAtom(QDColor[] grColors)
          Used to add an atom of type kCurveGradientRecordAtom to a vector data stream.
 AtomData VectorStream.getAtomData(int atomType)
          This method is used to find the first atom of a specified type within a vector data stream and get its data.
 void GraphicsExporter.doStandaloneExport()
          If both CanTranscode and CanUseCompressor reply false , the base graphics exporter makes this call of the format-specific exporter to perform the call.
 void GraphicsExporter.setInputDataReference(DataRef dataRef, ImageDescription desc)
          Sets the specified DataRef as the source for input images to graphics export component.
 DataRef GraphicsExporter.getInputDataReference()
          Gets the DataRef of the source for input images to graphics export component.
 void GraphicsExporter.setInputFile(QTFile theFile, ImageDescription desc)
          Sets the specified QTFile as the source for input images to graphics export component.
 QTFile GraphicsExporter.getInputFile()
          Gets the file that is the source for input images to graphics export component.
 void GraphicsExporter.setInputHandle(QTHandle h, ImageDescription desc)
          Sets the data handle as the source for input images to graphics export component.
 QTHandle GraphicsExporter.getInputHandle()
          Determines the data reference that is the source for input images to graphics export component.
 void GraphicsExporter.setInputPtr(QTPointerRef p, ImageDescription desc)
          Sets the data handle reference as the source for input images to graphics export component.
 QTPointerRef GraphicsExporter.getInputPtr()
          Determines the data reference that is the source for input images to graphics export component.
 void GraphicsExporter.setInputGraphicsImporter(GraphicsImporter grip)
          Sets the GraphicsImporter as the source for input images to graphics export component.
 GraphicsImporter GraphicsExporter.getInputGraphicsImporter()
          Determines the GraphicsImporter that is the source for input images to graphics export component.
 void GraphicsExporter.setInputPicture(Pict picture)
          Sets the Pict as the source for input images to graphics export component.
 Pict GraphicsExporter.getInputPicture()
          Determines the Pict that is the source for input images to graphics export component.
 void GraphicsExporter.setInputGWorld(QDGraphics gworld)
          Sets the QDGraphics as the source for input images to graphics export component.
 QDGraphics GraphicsExporter.getInputGWorld()
          Determines the QDGraphics that is the source for input images to graphics export component.
 PixMap GraphicsExporter.getInputPixmap()
          Determines the QDGraphics that is the source for input images to graphics export component.
 void GraphicsExporter.setOutputDataReference(DataRef dataRef)
          Used to specify destination for output images.
 DataRef GraphicsExporter.getOutputDataReference()
          Gets the DataRef of the destination for output images.
 void GraphicsExporter.setOutputFile(QTFile theFile)
          Sets the specified QTFile as the destination for output images.
 QTFile GraphicsExporter.getOutputFile()
          Gets the file that is the destination for output images.
 void GraphicsExporter.setOutputHandle(QTHandleRef h)
          Sets the data handle as the destination for output images.
 QTHandle GraphicsExporter.getOutputHandle()
          Determines the data reference that is the destination for output images.
 void GraphicsExporter.setOutputOffsetAndMaxSize(int offset, int maxSize, boolean truncateFile)
          Specifies the output starting offset and maximum size limit.
 void GraphicsExporter.setOutputFileTypeAndCreator(int fileType, int fileCreator)
          Specifies the output starting offset and maximum size limit.
 int GraphicsExporter.getOutputFileType()
          Gets the Output file type.
 int GraphicsExporter.getOutputFileCreator()
          Gets the Output file Creator.
 boolean GraphicsExporter.mayExporterReadInputData()
          Used by format-specific graphics exporters when transcoding: Asks whether the image source is in a form that can be read.
 int GraphicsExporter.getInputDataSize()
          Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
 ImageDescription GraphicsExporter.getInputImageDescription()
          Used by format-specific graphics exporters, especially when doing standalone export: Returns the number of bytes of original image data that can be read.
 QDRect GraphicsExporter.getInputImageDimensions()
          Used by format-specific graphics exporters, especially when doing standalone export: Returns the dimensions of the input image.
 int GraphicsExporter.getInputImageDepth()
          Used by format-specific graphics exporters, especially when doing standalone export: Returns the depth of the input image.
 void GraphicsExporter.drawInputImage(QDGraphics gw, QDRect srcRect, QDRect destRect)
          Used by format-specific graphics exporters, especially when doing standalone export: Draws a rectangular portion of the input image.
 void GraphicsExporter.setInputOffsetAndLimit(int offset, int limit)
          Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
 int GraphicsExporter.getInputOffset()
          Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
 int GraphicsExporter.getInputLimit()
          Only applicable when the input is a data reference, file, handle or ptr: Specifies the portion of an input data reference, file, handle or pointer that a graphics exporter is permitted to read.
 void GraphicsExporter.requestSettings()
          These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
 void GraphicsExporter.setSettingsFromAtomContainer(AtomContainer qtAtomContainer)
          These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
 AtomContainer GraphicsExporter.getSettingsAsAtomContainer()
          These functions are used for obtaining graphics exporter settings and displaying a settings dialog box.
 QTHandle GraphicsExporter.getSettingsAsText()
          This function is used for obtaining graphics exporter settings and displaying a settings dialog box.
 java.lang.String GraphicsExporter.getDefaultFileNameExtension()
          Returns the suggested file name extension.
 AtomContainer GraphicsExporter.getMIMETypeList()
          Returns MIME types and other information about the graphics format.
 java.lang.String GraphicsExporter.getDefaultFileType()
          Returns the default file Type for the new image file format.
 java.lang.String GraphicsExporter.getDefaultFileCreator()
          Returns file creator for the new image file format.
 boolean GraphicsExporter.canTranscode()
          Format-specific exporters may delegate this call; the base graphics exporter's implementation gives a reply of false .Use this call to ask a graphics exporter whether it can transcode the current input with the current settings.
 void GraphicsExporter.doTranscode()
          The base graphics exporter makes this call of the format-specific graphics exporter to perform a transcoding export.
 GECompressorInfo GraphicsExporter.canUseCompressor()
          The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
 ImageDescription GraphicsExporter.doUseCompressor(AtomContainer ac)
          The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
 void GraphicsExporter.setDontRecompress(boolean dontRecompress)
          Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
 boolean GraphicsExporter.getDontRecompress()
          Requests that the original compressed data not be decompressed and recompressed, but be copied (possibly with modifications) through to the output file.
 void GraphicsExporter.setInterlaceStyle(int interlaceStyle)
          Defines the interlace style.
 int GraphicsExporter.getInterlaceStyle()
          Returns the interlace style.
 void GraphicsExporter.setMetaData(UserData userData)
          Defines supplemental data, such as textual copyright information.
 UserData GraphicsExporter.getMetaData()
          Returns supplemental data, such as textual copyright information.
 void GraphicsExporter.setTargetDataSize(int targetDataSize)
          Defines a desired maximum data size and asks for a quality that does not exceed that size.
 int GraphicsExporter.getTargetDataSize()
          Specifies a desired maximum data size and asks for a quality that does not exceed that size.
 void GraphicsExporter.setCompressionMethod(int compressionMethod)
          Defines the compression method to use.
 int GraphicsExporter.getCompressionMethod()
          Defines the compression method to use.
 void GraphicsExporter.setCompressionQuality(int spatialQuality)
          Defines the compression quality.
 int GraphicsExporter.getCompressionQuality()
          Defines the compression quality to use.
 void GraphicsExporter.setResolution(int horizontalResolution, int verticalResolution)
          Defines the resolution to save and store.
 int GraphicsExporter.getHorizontalResolution()
          Gets the resolution to saved and stored.
 int GraphicsExporter.getVerticalResolution()
          Defines the compression quality to use.
 void GraphicsExporter.setDepth(int depth)
          Defines the depth to use.
 int GraphicsExporter.getDepth()
          Defines the depth to use.
static QTImage ImageDescription.fromImageCompressionDialog(ImageCompressionDialog icd, QDGraphics src, QDRect srcRect)
          Compresses a frame that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data and an image description.
static ImageDescription ImageDescription.getJavaDefaultPixelDescription(int width, int height)
          Create an ImageDescription structure that describes the default Java pixel format.
static ImageDescription ImageDescription.forEffect(int effectType)
          Create an ImageDescription for an Effect Type.
 ColorTable ImageDescription.getCTable()
          Get the custom color table for an image.
 QDGraphics ImageDescription.newGWorld(int flags)
          Creates an offscreen QDGraphics object from the width, height, depth, and color table of a specified image description structure.
 void Matrix.transformDPoints(QDPoint dpt)
          Transforms a set of fixed points through a specified matrix.
 void Matrix.transformDPoints(QDPoint[] dpts)
          Transforms a set of fixed points through a specified matrix.
 boolean Matrix.transformDRect(QDRect r)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
 boolean Matrix.transformDRect(QDRect r, QDPoint[] points)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
 boolean Matrix.transformRect(QDRect r)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
 boolean Matrix.transformRect(QDRect r, QDPoint[] points)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
static ImageDescription QTImage.compress(QDGraphics src, QDRect srcRect, int quality, int cType, EncodedImage data)
          Compresses a single frame image that is currently stored as a pixel map.
static ImageDescription QTImage.fCompress(QDGraphics src, QDRect srcRect, int colorDepth, int quality, int cType, CodecComponent c, ColorTable clut, int flags, EncodedImage data)
          Compresses a single frame image that is currently stored as a pixel map.
static ImageDescription QTImage.convert(ImageDescription srcDD, EncodedImage srcData, int colorDepth, ColorTable clut, int accuracy, int quality, int cType, CodecComponent codec, EncodedImage dstData)
          Converts the format of a compressed image.
static GraphicsImporter GraphicsImporter.fromGraphicsExporter(GraphicsExporter ge)
          Determines the GraphicsImporter that is the source for input images to graphics export component

QuickTime::GraphicsExportGetInputGraphicsImporter

 void GraphicsImporter.setDataFile(QTFile fileIn)
          Specifies the file that the graphics resides in.
 QTFile GraphicsImporter.getDataFile()
          Determines the file that the graphics resides in.
 QTHandle GraphicsImporter.getDataHandle()
          Determines the data reference that the graphics resides in.
 Region GraphicsImporter.getClip()
          Determines the current clipping region.
 void GraphicsImporter.saveAsPicture(QTFile file, int scriptTag)
          Creates a QuickDraw picture file.
 void GraphicsImporter.saveAsQuickTimeImageFile(QTFile file, int scriptTag)
          Creates a QuickDraw image file.
 QTHandle GraphicsImporter.getAliasedDataReference()
          Determines the aliased data reference.
 Pict GraphicsImporter.getAsPicture()
          Creates a new Pict containing the image currently in use by this import component.
 UserData GraphicsImporter.getMetaData(GraphicsImporter gi)
          Gets metadata from an image file and adds it to a user data structure.
 void GraphicsImporter.exportImageFile(int fileType, int fileCreator, QTFile theFile, int scriptTag)
          Saves an image in a foreign file format.
 GraphicsImporterInfo GraphicsImporter.doExportImageFileDialog(QTFile inDefaultSpec, java.lang.String prompt)
          Presents a dialog box letting the user save an image in a foreign file format.
 Region GraphicsImporter.getDefaultClip()
          Returns the default matrix.
 GraphicsMode GraphicsImporter.getDefaultGraphicsMode()
          Returns the default graphics mode, if one is stored in the image.
 QDRect GraphicsImporter.getDefaultSourceRect()
          Returns the default source rect, if one is stored in the image.
 void GraphicsImporter.setDestRect(QDRect destRect)
          Sets the destination rectangle.
 QDRect GraphicsImporter.getDestRect()
          Returns the destination rectangle.
 void GraphicsImporter.setFlags(int flags)
          Sets the current flags.
 int GraphicsImporter.getFlags()
          Returns the current flags..
 

Constructors in quicktime.std.image that throw QTException
Curve()
          Opens the specified QTVector component subtype kVectorCodecType.
VectorStream(Curve c)
          Used to create an empty vector data stream.
GraphicsExporter(int subType)
          Opens the specified graphics export component,'grex', with the given subType.
CSequence(QDGraphics src, QDRect srcRect, int cType, CodecComponent codec, int spatialQuality, int temporalQuality, int keyFrameRate, int flags)
          Creating an instance of this class signals the beginning of the process of compressing a sequence of frames.
CSequence(QDGraphics src, QDRect srcRect, int colorDepth, int cType, CodecComponent codec, int spatialQuality, int temporalQuality, int keyFrameRate, ColorTable clut, int flags)
          Creating an instance of this class signals the beginning of the process of compressing a sequence of frames.
ImageDescription(int format)
          Create an ImageDescription structure
ImageDescription(PixMap pixmap)
          Create an ImageDescription from a PixMap.
Matrix(QDPoint[] source, QDPoint[] dest)
          Construct a Matrix that is a delta matrix between the two sets of 4 points.
GraphicsImporter(int subType)
          Opens the specified graphics import component,'grip', with the given subType.
GraphicsImporter(QTFile file)
          Determines and opens the graphics import component to use for the given file.
GraphicsImporter(QTFile file, int flags)
          Determines and opens the graphics import component to use for the given file.
GraphicsImporter(DataRef dataRef)
          Determines and opens the component to use for the given data reference and data type.
GraphicsImporter(DataRef dataRef, int flags)
          Locates and opens a graphics importer component that can be used to draw the specified dataRef.
CodecNameList(int show)
          Retrieve a list of installed compressor components or a list of installed compressor types.
ImageSequenceDataSource(CDSequence seq, int sourceType, int sourceInputNumber, QTHandleRef dataDescription)
          Creates a new data source for an ImageSequence.
ImageSequenceDataSource(CDSequence seq, int sourceType, int sourceInputNumber)
          This will retrieve a previously created data source for an ImageSequence.
DSequence(ImageDescription desc, QDGraphics port, QDRect srcRect, Matrix matrix, Region mask, int flags, int accuracy, CodecComponent codec)
          Creating an instance of this class signals the beginning of the process of decompressing a sequence of frames.
DSequence(ImageDescription desc, EncodedImage data, QDGraphics port, QDRect srcRect, Matrix matrix, Region mask, int flags, int accuracy, CodecComponent codec)
          This constructor allows you to pass a compressed sample so the codec can perform preflighting before the first decompressFrame call.
 

Uses of QTException in quicktime.std.movies
 

Methods in quicktime.std.movies that throw QTException
static GECompressorInfo AtomContainer.fromGraphicsExporterCompressor(GraphicsExporter ge)
          The base graphics exporter makes this call of the format-specific graphics exporter to ask whether the current export operation should be done by using an image compressor.
 QTHandle AtomContainer.copyAtomDataToHandle(Atom atom)
          This method returns a leaf atom's data.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index)
          This method creates a new empty child atom for parentAtom.
 void MovieController.idle()
          This method performs idle processing for a movie controller.
 TimeRecord MovieController.getSelectionBegin()
          Your application can use this method to receive the start time of a selection.
 TimeRecord MovieController.getSelectionDuration()
          Your application can use this method to receive the duration of a selection.
 void MovieController.linkToURL(java.lang.String url)
          Your application can use this method to set a URL.
 void MovieController.setAttached(boolean attached)
          Your application can use this method to make the controller attached or detached.
 Region MovieController.getBoundsRgn()
          This method returns the actual region occupied by the controller and its movie, if the movie is attached to the controller.
 Region MovieController.getWindowRgn(QDGraphics window)
          This method allows your application to determine the window region that is actually in use by a controller and its movie.
 Movie MovieController.copy()
          This method returns a copy of the current movie selection from the movie associated with a specified controller.
 Movie MovieController.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.
 Region MovieController.getClip()
          This method allows you to obtain information describing a movie controller's clipping regions.
 Region MovieController.drawBadge(Region movieRgn, boolean returnBadgeRgn)
          This method allows you to display a controller's badge.
static void Movie.taskAll(int maxMilliSecToUse)
          The moviesTask method services all of the currently active movies.
static Movie Movie.createMovieFile(QTFile pathName, int fCreator, int flags)
          Creates a Movie object and the file as specified by the QTFile.
static Movie Movie.fromScrap(int newMovieFlags)
          This method allows your application to create a movie from the contents of the scrap.
static Movie Movie.fromFile(OpenMovieFile fileIn)
          This method creates a movie in memory from a resource that is stored in a movie file.
static Movie Movie.fromFile(OpenMovieFile fileIn, int flags, MovieInfo info)
          This method creates a movie in memory from a resource that is stored in a movie file.
static Movie Movie.fromHandle(QTHandle hand)
          This method creates a movie in memory from a movie resource or a handle you obtained from the PutMovieIntoHandle function.
static Movie Movie.fromHandle(QTHandle hand, int flags, MovieInfo info)
          This method creates a movie in memory from a movie resource or a handle you obtained from the PutMovieIntoHandle function.
static Movie Movie.fromDataFork(OpenFile fileIn, int fileOffset, int flags, MovieInfo info)
          This method enables you to retrieve a movie that is stored anywhere in the data fork of a specified file.
static Movie Movie.fromDataRef(DataRef defaultDataRef, int flags)
          This method enables you to retrieve a movie from any data reference.
 void Movie.task(int maxMilliSecToUse)
          The moviesTask method services this movie.
 Track Movie.getNextTrackForCompositing(Track theTrack)
          No QT Documentation.
 Track Movie.getPrevTrackForCompositing(Track theTrack)
          No QT Documentation.
 Pict Movie.getPict(int time)
          This method creates a picture from the specified movie at the specified time.
 Pict Movie.getPosterPict()
          This method creates a picture that contains a movie's poster.
 Region Movie.getDisplayClipRgn()
          This method allows your application to determine a movie's current display clipping region.
 Region Movie.getClipRgn()
          This method allows your application to determine a movie's clipping region.
 Region Movie.getDisplayBoundsRgn()
          This method allows your application to determine a movie's display boundary region.
 Region Movie.getBoundsRgn()
          This method allows your application to determine a movie's boundary region.
 TimeRecord Movie.getTRTime()
          This method returns a movie's current time as a TimeRecord object.
 Track Movie.getTrack(int trackID)
          This method allows your application to determine the track identifier of a track given the track's ID value.
 Track Movie.getIndTrack(int index)
          This method allows your application to determine the track identifier of a track given the track's index value.
 Track Movie.getIndTrackType(int index, int trackType, int flags)
          This method allows your application to determine the track identifier of a track given a track type and an index value.
 Movie Movie.cutSelection()
          This method creates a new movie that contains the original movie's current selection.
 Movie Movie.copySelection()
          This method creates a new movie that contains the original movie's current selection.
 QTHandle Movie.putIntoTypedHandle(Track targetTrack, int handleType, int start, int dur, int flags, MovieExporter userComp)
          This method takes a movie (or a single track from within that movie) and converts it into a handle of a specified type.
 Track Movie.addEmptyTrack(Track srcTrack, DataRef dataRef)
          This method adds an empty track to the movie.
 Track Movie.newTrack(float width, float height, float trackVolume)
          Create a track in a movie.
 Track Movie.addTrack(float width, float height, float trackVolume)
          Create a track in a movie.
 MovieEditState Movie.newEditState()
          You can create an edit state by calling the NewMovieEditState function.
 DataRef Movie.getDefaultDataRef()
          This method allows your application to get the default data reference for the movie.
 ColorTable Movie.getColorTable()
          This method allows your application to get the color table of the movie.
 int Movie.flatten(int movieFlattenFlags, QTFile fileOut, int creator, int scriptTag, int createQTFileFlags, int resID, java.lang.String resName)
          This method creates a new movie file containing a specified movie.
 Movie Movie.flattenData(int movieFlattenFlags, QTFile fileOut, int creator, int scriptTag, int createQTFileFlags)
          This method creates a new movie file and creates a new movie that contains all of its movie data.
 Movie Movie.flattenData(int movieFlattenFlags, QTHandle handle)
          This method creates a new movie that contains all of its movie data loaded into memory.
 SearchResult Movie.searchText(QTPointer text, int searchFlags, Track searchTrack, int searchTime, int searchOffset)
          This method allows you to search for text in a movie.
 SearchResult Movie.searchText(QTPointer text, int searchFlags, int searchTime, int searchOffset)
          This method allows you to search for text in a movie.
 Region Movie.getSegmentDisplayBoundsRgn(int time, int duration)
          This method allows your application to determine a movie's display boundary region during a specified segment.
 StatusInfo Movie.getStatus()
          This method searches for errors in all the enabled tracks of the movie.
 int Movie.convertToFile(Track onlyTrack, QTFile outputFile, int fileType, int creator, int scriptTag)
          This method converts this movie into a specified file and type.
 int Movie.convertToFile(QTFile outputFile, int fileType, int creator, int scriptTag)
          This method converts this movie into a specified file and type.
 int Movie.convertToFile(QTFile outputFile, int fileType, int creator, int scriptTag, int flags)
          This method converts this movie into a specified file and type.
 int Movie.convertToFile(Track onlyTrack, QTFile outputFile, int fileType, int creator, int scriptTag, int flags, MovieExporter userComp)
          This method converts this movie into a specified file and type.
 Track Movie.getQTVRTrack(int index)
          The QTVRGetQTVRTrack function returns a track for the QTVR track that has the index specified by the index parameter in the QuickTime movie specified by the theMovie parameter.
 Movie Movie.flattenDataToDataRef(DataRef dataRef, int movieFlattenFlags, int creator, int scriptTag, int createMovieFileFlags)
          This method creates a new movie file containing a specified movie.
 Movie MultiMovieController.getIndMovie(int index)
          This method allows you to get the movie at a specified index among the associated movies of a controller.
static AtomContainer ParameterDialog.showParameterDialog(AtomContainer effectsList, int dialogOptions)
          This call shows the dialog with the specified parameters.
static AtomContainer ParameterDialog.showParameterDialog(EffectsList effectsList, int dialogOptions, AtomContainer parameters, java.lang.String title, Pict[] pictArray)
          This call shows the effects parameter dialog with the specified parameters.
static int ParameterDialog.getEffectsSpeed(AtomContainer parameters)
          This call returns the speed of the effect, expressed in frames-per-second
static Track Track.fromMedia(Media m)
          This method allows you to determine the track that uses a specified media.
static MovieImportInfo Track.fromMovieImporterFile(MovieImporter mi, QTFile fileIn, Movie theMovie, Track targetTrack, int atTime, int inFlags)
          Allows the MovieToolbox to import data from a file using the movie import component.
static MovieImportInfo Track.fromMovieImporterHandle(MovieImporter mi, QTHandleRef dataRef, Movie theMovie, Track targetTrack, int atTime, int inFlags)
          Allows the MovieToolbox to import data from a handle using the movie import component.
static MovieImportInfo Track.fromMovieImporterDataRef(MovieImporter mi, DataRef dataRef, Movie theMovie, Track targetTrack, int atTime, int inFlags)
          Determines information revelant to the movie import component.
 Media Track.getMedia()
          Returns a Media class that corresponds to the media that contains a track's data.
 Pict Track.getPict(int time)
          This method creates a QuickDraw picture from the specified track at the specified time.
 Region Track.getClipRgn()
          This method allows your application to determine the clipping region of a track.
 Region Track.getDisplayBoundsRgn()
          This method allows your application to determine the region a track occupies in a movie's graphics world.
 Region Track.getMovieBoundsRgn()
          This method allows your application to determine the region the track occupies in a movie's boundary region.
 Region Track.getBoundsRgn()
          This method allows the media to limit the size of the track boundary rectangle.
 Track Track.getAlternate()
          This method allows your application to determine all the tracks in an alternate group.
 void Track.setName(java.lang.String name)
          This method allows your application to set a track's 'name' user data item.
 QTHandle Track.getSoundLocalizationSettings()
          This method returns the sound localization settings for the track.
 TrackEditState Track.newEditState()
          You can create an edit state by calling the NewTrackEditState function.
 Track Track.getReference(int refType, int index)
          This method allows you to retrieve the track identifier contained in an existing track reference.
 Region Track.getSegmentDisplayBoundsRgn(int time, int duration)
          This method allows your application to determine the region a track occupies in a movie's graphics world during a specified segment.
 Track ResolvedQTEventSpec.getTargetTrack()
          Return the Track associated with the event
 

Constructors in quicktime.std.movies that throw QTException
AtomContainer()
          Create a new disposable AtomContainer.
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.
MovieController(int subType, Movie theMovie, QDGraphics window, QDPoint location)
          This method constructs a MovieController object for a given subType.
Movie()
          This method creates a new movie in memory.
Movie(int flags)
          This method creates a new movie in memory.
MultiMovieController(Movie itsMovie)
          This constructor locates a movie controller component for you and assigns a movie to that controller.
MultiMovieController(Movie itsMovie, int someFlags)
          This constructor locates a movie controller component for you and assigns a movie to that controller.
MultiMovieController(int subType, Movie theMovie, QDGraphics window, QDPoint location)
          This constructor creates a MovieController object for a given subType.
TweenData(short start, short end)
          Allocates a TweenData object of type kTweenTypeShort from short start and end values
TweenData(int start, int end)
          Allocates a TweenData object of type kTweenTypeLong from int start and end values
TweenData(int tweenType, float start, float end)
          Allocates a TweenData object of type kTweenTypeFixed or kTweenTypeQTFloatSingle from float start and end values
TweenData(double start, double end)
          Allocates a TweenData object of type kTweenTypeQTFloatDouble from double start and end values
TweenData(QDPoint start, QDPoint end)
          Allocates a TweenData object of type kTweenTypePoint from QDPoint start and end values
TweenData(QDRect start, QDRect end)
          Allocates a TweenData object of type kTweenTypeQDRect from QDRect start and end values
TweenData(Matrix start, Matrix end)
          Allocates a TweenData object of type kTweenTypeMatrix from Matrix start and end values
TweenData(QDColor start, QDColor end)
          Allocates a TweenData object of type kTweenTypeRGBColor from QDColor start and end values
TweenData(QDColor start, QDColor end, int graphicsMode)
          Allocates a TweenData object of type kTweenTypeGraphicsModeWithRGBColor from QDColor start and end values and a graphics mode Only the QDColor fields are interpolated.
TweenData(float startX, float startY, float endX, float endY)
          Allocates a TweenData object of type kTweenTypeFixedPoint from float start and end x and y values
 

Uses of QTException in quicktime.std.movies.media
 

Methods in quicktime.std.movies.media that throw QTException
static Media Media.newFromType(int mediaType, Track track, int timeScale, DataRef dataRef)
          Creates a media struct for the specified Track object.
static Media Media.fromTrack(Track theTrack)
          Returns a Media class that corresponds to the media that contains a track's data.
static Media Media.getTrackMedia(Track theTrack)
          Returns a Media class that corresponds to the media that contains a track's data.
 SampleDescription Media.getSampleDescription(int index)
          This method allows you to retrieve a sample description from a media.
 Track Media.getTrack()
          This method allows you to determine the track that uses a specified media.
 MediaSample Media.getSample(int maxSizeToGrow, int time, int maxNumberOfSamples)
          This method returns a sample from a movie data file.
 SampleInfo Media.getSampleReference(int time, int maxNumberOfSamples)
          This method allows your application to obtain reference information about samples that are stored in a movie data file.
 SampleReferenceInfo Media.getSampleReferences(int time, int maxNumberOfSamples)
          This method allows your application to obtain reference information about samples that are stored in a movie data file.
 DataRef Media.getDataRef(int index)
          This method returns a copy of a specified data reference.
 void TextDescription.setDefaultFontName(java.lang.String fName)
           
 java.lang.String TextDescription.getDefaultFontName()
           
 QTPointer VisualMediaHandler.getPublicInfo(int selector)
          This routine is an accessor for the media handler's public info

QuickTime:MediaGetPublicInfo

 SoundDescription SoundMedia.getSoundDescription(int index)
          This method allows you to retrieve a sample description from a media.
 void SampleReferenceVector.insert(SampleReference el, int pos)
          Inserts a SampleReference into the vector at specified position.
 SampleReference SampleReferenceVector.get(int pos)
          Get a SampleReference at specified position.
 MusicDescription MusicMedia.getMusicDescription(int index)
          This method allows you to retrieve a sample description from a media.
 QTHandle UserData.putIntoHandle()
          This method returns a handle which contains a publicly parseable form of the user data.
 QTHandle UserData.getData(int udType, int index)
          This method returns a specified user data item.
 QTPointer UserData.getDataItem(int dataSize, int udType, int index)
          This method returns a specified user data item.
 QTHandle UserData.getText(int udType, int index, short itlRegionTag)
          Deprecated. since QTJava 4, see getTextAsString
 java.lang.String UserData.getTextAsString(int udType, int index, int itlRegionTag)
          This method allows your application to retrieve language-tagged text from an item in a user data list.
 float AudioMediaHandler.getBalance()
          Returns the balance of audio media.
 void AudioMediaHandler.setBalance(float balance)
          Sets the balance of audio media.
 boolean AudioMediaHandler.getSoundLevelMeteringEnabled()
          Gets Sound Level Meter state (Not Documented).
 void AudioMediaHandler.setSoundLevelMeteringEnabled(boolean enabled)
          Enables Sound Level Meter (Not Documented).
 LevelMeterInfo AudioMediaHandler.getSoundLevelMeterInfo()
          Gets Sound Level Meter state (Not Documented).
 MediaEQSpectrumBands AudioMediaHandler.getSoundEqualizerBands(int count)
          Pass in the count of bands you expect to get back, it would return the the actual value of bands available with the freq.
 void AudioMediaHandler.setSoundEqualizerBands(MediaEQSpectrumBands spectrumInfo)
          Pass in the count of bands you expect to get back, it would return the the actual value of bands available with array of freq.
 void AudioMediaHandler.setSoundBassAndTreble(int bass, int treble)
          Sets Sound Bass and Treble (Not Documented).
 int[] AudioMediaHandler.getSoundBassAndTreble()
          Gets Sound Bass and Treble (Not Documented).
 int[] AudioMediaHandler.getSoundEqualizerBandLevels(int count)
          Gets SoundEqualizer BandLevels .
 ImageDescription SpriteMediaHandler.getIndImageDescription(int imageIndex)
          This method returns the image description for the image specified by the index.
 FlashDescription FlashMedia.getFlashDescription(int index)
          This method allows you to retrieve a sample description from a media.
 void QTVRSampleDescription.setVRWorld(AtomContainer newVRWorld)
           
 AtomContainer QTVRSampleDescription.getVRWorld()
           
 TimeRecord MovieMediaHandler.getCurrentMoviePropertyTime()
          This method gets the time record associated with the currently instantiated embedded movie
 DataRef MovieMediaHandler.getChildMovieDataReference(int dataRefID, int dataRefIndex)
          This method gets the data reference of the currently instantiated embedded movie
 ThreeDDescription ThreeDMedia.getThreeDDescription(int index)
          This method allows you to retrieve a sample description from a media.
 ImageDescription VideoMedia.getImageDescription(int index)
          This method allows you to retrieve a sample description from a media.
 StreamDescription StreamMedia.getStreamDescription(int index)
          This method allows you to retrieve a sample description from a media.
 MusicData MusicDescription.getTuneHeader()
          Returns a copy of the TuneHeader MusicHeader data
 SpriteDescription SpriteMedia.getSoundDescription(int index)
          Deprecated.  
 SpriteDescription SpriteMedia.getSpriteDescription(int index)
          This method allows you to retrieve a sample description from a media.
static DataRef DataRef.fromGraphicsExporterInputDataRef(GraphicsExporter ge)
          This method returns a copy of a data reference.
static DataRef DataRef.fromGraphicsExporterOutputDataRef(GraphicsExporter ge)
          This method returns a copy of a data reference.
static DataRef DataRef.fromMovie(Movie m)
          This method allows your application to get the default data reference for the movie.
static DataRef DataRef.fromMedia(Media m, int index)
          This method returns a copy of a specified data reference.
 java.lang.String DataRef.getUniversalResourceLocator()
          Returns a string representating the location of this object.
 void SoundDescription.addExtension(QTHandleRef extension, int idType)
          Add application specific info to a Sound Description object

QuickTime::AddSoundDescriptionExtension

 void SoundDescription.removeExtension(int idType)
          Remove application specific info from a Sound Description object

QuickTime::RemoveSoundDescriptionExtension

 QTHandle SoundDescription.getExtension(int idType)
          Retrieve application specific info from a Sound Description object

QuickTime::GetSoundDescriptionExtension

 TimeCodeDescription TimeCodeMedia.getTimeCodeDescription(int index)
          This method allows you to retrieve a sample description from a media.
 TextDescription TextMedia.getTextDescription(int index)
          This method allows you to retrieve a sample description from a media.
 

Constructors in quicktime.std.movies.media that throw QTException
SampleDescription(int format)
          This constructor creates an empty SampleDescription object.
TweenMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
TweenMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
TextDescription()
          This constructor makes a new TextDescription object.
StreamDescription()
          This constructor makes a new StreamDescription object.
StreamDescription(int mediaType)
          This constructor makes a new StreamDescription object.
MPEGMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
MPEGMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
MovieMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
MovieMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
SampleReference()
          Create a Sample Reference object from the SampleReferenceVector
SampleReference(int dataOffset, int dataSize, int durationPerSample, int numberOfSamples, int sampleFlags)
          This constructor creates a SampleReference object.
SpriteDescription()
           
SoundMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
SoundMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
SampleReferenceVector(int numberOfElements)
          Creates a SampleReferenceVector which is an array of SampleReference objects.
MusicMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
MusicMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
FlashMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
FlashMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
QTVRSampleDescription(AtomContainer vrWorld)
          This constructor makes a new QTVRSampleDescription object.
QTVRSampleDescription()
          This constructor makes a new empty QTVRSampleDescription object.
ThreeDMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
ThreeDMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
QTVRMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
QTVRMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
VideoMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
VideoMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
StreamMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
StreamMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
BaseMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
BaseMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
MusicDescription()
          This constructor makes a new MusicDescription object.
SpriteMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
SpriteMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
DataRef(java.lang.String url)
          This constructor creates a DataRef that represents any URL.
DataRef(QTFile f)
          This constructor creates a DataRef that represents a QTFile.
DataRef(AliasHandle a)
          This constructor creates a DataRef that represents an AliasHandle.
DataRef(QTHandleRef handle)
          This constructor creates a DataRef that references the given QTHandle so the dataRefType is a handle DataRef ('hndl').
DataRef(QTHandleRef handle, int hintFlag, java.lang.String hintString)
          This constructor creates a DataRef that references the given QTHandle so the dataRefType is a handle DataRef ('hndl').
SoundDescription(int format)
          This constructor makes an empty SoundDescription object.
FlashDescription()
          This constructor makes a new SpriteDescription object.
ThreeDDescription(int format)
          This constructor makes an empty SoundDescription object.
TimeCodeMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
TimeCodeMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
TextMedia(Track itsTrack, int timeScale, DataRef dataRef)
          This constructor creates a media struct for the specified Track object.
TextMedia(Track itsTrack, int timeScale)
          This constructor creates a media struct for the specified Track object.
 

Uses of QTException in quicktime.std.music
 

Methods in quicktime.std.music that throw QTException
 void SynthesizerConnections.setSoundBankFile(QTFile soundBankFile)
          This is used to create a connections structure that describes a sound bank file (DLS or SF2) that will be used to supply sample information to a soft-synth music component.
 QTFile SynthesizerConnections.getSoundBankFile()
          Returns a QTFile that represents a sound bank file (DLS or SF2) that will be used to supply sample information to a soft-synth music component (or null if none set).
 NoteChannel AtomicInstrument.newNoteChannel(int flags)
          Make a new note channel for an atomic instrument.
 int MusicData.getMusicEvent(int offset)
          Returns the big endian ordered stuffed QuickTime music event at the specified number of ints into the MusicData.
 void MusicData.setMusicEvent(int offset, int musicData)
          Sets the big endian ordered stuffed QuickTime music event at the specified number of ints into the MusicData.
 long MusicData.getXMusicEvent(int offset)
          Returns the stuffed QuickTime extended music event at the specified number of ints into the MusicData.
 void MusicData.setXMusicEvent(int offset, long musicData)
          Sets the stuffed QuickTime extended music event at the specified number of ints into the MusicData.
 void MusicData.setNoteRequest(int offset, int partNumber, NoteRequest nr)
          Copies the NoteRequest data to the specified offset (numer of ints) into the MusicData.
 NoteRequest MusicData.getNoteRequest(int offset)
          Returns a NoteRequest object from the specified offset (numer of ints) into the MusicData.
 void MusicData.setAtomicInstrument(int offset, int partNumber, AtomicInstrument ai)
          Copies the AtomicInstrument data to the specified offset (numer of ints) into the MusicData.
 AtomicInstrument MusicData.getAtomicInstrument(int offset)
          Returns an AtomicInstrument from the specified offset (numer of ints) into the MusicData.
 NoteRequest NoteChannel.getNoteRequest()
          Get the NoteRequest that corresponds to this NoteChannel.
static NoteAllocator NoteAllocator.getDefault()
          Returns a system created NoteAllocator instance that can be used by applications.
 java.lang.String NoteAllocator.registerMusicDevice_SoundBank(QTFile soundBankFile)
          Registers a music component with the NoteAllocator, where the MusicComponent will use the supplied SoundBank for its sample data.
 QTMIDIPortList NoteAllocator.getMIDIInPorts()
          Get the MIDI input ports that are available to the NoteAllocator.
 QTMIDIPortList NoteAllocator.getMIDIOutPorts()
          Get the MIDI output ports that are available to the NoteAllocator.
 

Constructors in quicktime.std.music that throw QTException
SynthesizerConnections(QTFile soundBankFile)
          This is used to create a connections structure that describes a sound bank file (DLS or SF2) that will be used to supply sample information to a soft-synth music component.
AtomicInstrument()
          Create a new disposable and empty AtomContainer.
NoteRequestInfo(int poly)
          Create a NoteRequestInfo from the given polyphony value.
MusicData(int size)
          Create a MusicData object of the specified number of bytes.
SoundLocalization()
          This constructor creates an empty sound localisation
NoteChannel(int gmNumber, int poly)
          Creates a new NoteChannel object with the request instrument and polyphony.
NoteChannel(NoteRequest nr)
          Creates a new NoteChannel object using the default NoteAllocator

QuickTime::NANewNoteChannel

NoteChannel(NoteAllocator na, NoteRequest nr)
          Creates a new NoteChannel object.
NoteChannel(NoteAllocator na, int gmNumber)
          Creates a new NoteChannel object.
NoteRequest(int gmNumber, int poly)
          Create a NoteRequest from the given gmNumber instrument and polyphony values.
MusicComponent()
          Deprecated. should use NoteAllocator calls to get a MusicComponent Instance
MusicComponent(int subType)
          Deprecated. should use NoteAllocator calls to get a MusicComponent Instance
NoteAllocator()
          Opens the NoteAllocator component.
NoteAllocator(int subType)
          Opens the NoteAllocator component with a specified subType.
TunePlayer()
          Opens the TunePlayer component.
ToneDescription(int gmNumber)
          Initializes the ToneDescription instance with the appropriate instrument based on the specified gmNumber.
 

Uses of QTException in quicktime.std.qtcomponents
 

Methods in quicktime.std.qtcomponents that throw QTException
 void XMLCharDataProc.execute(java.lang.String charData)
          The method that is called by the XMLParser for parsing CharData events.
 int XMLElement.countAttributes()
          count of number of XMLAttribute items
 XMLAttribute[] XMLElement.getAttributes()
          get the attributes
 int XMLElement.countContents()
          count of number of XMLContent items
 XMLContent[] XMLElement.getContents()
          get the content items of the XMLElement
 QTHandleRef CompressionDialog.getInfoState()
          Retrieves all of the settings for a dialog.
 QTImage ImageCompressionDialog.compressImage(QDGraphics src, QDRect srcRect)
          Compresses an image that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data and an image description.
 Pict ImageCompressionDialog.compressPicture(Pict src)
          Compresses a Pict returning a new Pict.
 void ImageCompressionDialog.compressPictureFile(OpenFile src, OpenFile dest)
          Compresses a Pict contained in the src open Pict file into the destination open Pict file.
 SCSequence ImageCompressionDialog.compressSequenceBegin(QDGraphics src, QDRect srcRect)
          Creates a SCSequence object to begin compression of a sequence of images.
 ColorTable ImageCompressionDialog.getInfoColorTable()
          Gets the current color table or null to clear the current color table for a dialog.
 QDGraphics ImageCompressionDialog.newGWorld(QDRect rp, int flags)
          Creates an offscreen QDGraphics based on the current compression settings.
 void XMLCommentProc.execute(java.lang.String comment)
          The method that is called by the XMLParser for parsing Comment events.
 void XMLEndElementProc.execute(java.lang.String name)
          The method that is called by the XMLParser for parsing EndElement events.
 void XMLEndDocProc.execute()
          The method that is called by the XMLParser for parsing EndDocument events.
 void XMLStartDocProc.execute()
          The method that is called by the XMLParser for parsing the StartDocument event.
 SCInfo SCSequence.compressFrame(QDGraphics src, QDRect srcRect)
          Compresses a frame that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data.
 XMLElement XMLContent.getElement()
          get element kind content
 void XMLPreprocessorProc.execute(java.lang.String name, java.lang.String[] attributes)
          The method that is called by the XMLParser for parsing PreprocessorInstruction events.
 XMLDoc XMLParser.parse(DataRef dataRef, boolean allowUppercase, boolean allowUnquotedAttributeValues)
          parses the XML file pointed to by dataRef, returning a XMLParseTree parse tree
 XMLDoc XMLParser.parse(QTFile file, boolean allowUppercase, boolean allowUnquotedAttributeValues)
          Parses the XML file pointed to by file, returning a XMLDoc parse tree
 void XMLParser.eventParse(DataRef dataRef, boolean allowUppercase, boolean allowUnquotedAttributeValues)
          Parses the XML file pointed to by dataRef, using event-based parsing.
 void XMLParser.eventParse(QTFile file, boolean allowUppercase, boolean allowUnquotedAttributeValues)
          Parses the XML file pointed to by file, using event-based parsing.
 TimeCodeInfo TimeCoder.getCurrent()
          Determines the time code from the time code handler at the current time value.
 TimeCodeInfo TimeCoder.getAtTime(int mediaTime)
          Determines the time code from the time code handler.
 QTHandle TimeCoder.getSourceRef(TimeCodeDescription tcd)
          Deprecated. since QTJava 5.0
 UserData TimeCoder.getUserDataSourceRef(TimeCodeDescription tcd)
          Allows you to retrieve the source information from the time code media sample.
 MovieImportInfo MovieImporter.fromFile(QTFile fileIn, Movie theMovie, Track targetTrack, int atTime, int inFlags)
          Allows the MovieToolbox to import data from a file using the movie import component.
 MovieImportInfo MovieImporter.fromHandle(QTHandleRef dataRef, Movie theMovie, Track targetTrack, int atTime, int inFlags)
          Allows the MovieToolbox to import data from a handle using the movie import component.
 MovieImportInfo MovieImporter.fromDataRef(DataRef dataRef, Movie theMovie, Track targetTrack, int atTime, int inFlags)
          Determines information revelant to the movie import component.
 void MovieImporter.setMediaFile(AliasHandle alias)
          Allows an application to specify a media file that is to receive the imported movie data.
 boolean MovieImporter.doUserDialog(QTFile fileIn)
          Allows an application to request that your component display its user dialog box.
 boolean MovieImporter.doUserDialog(QTHandleRef theData)
          Specifies the use of.
 boolean MovieImporter.validate(QTFile fileIn)
          Determines the validity of the file to be imported.
 boolean MovieImporter.validate(QTHandleRef theData)
          Determines the validity of the data in the handle to be imported.
 void MovieExporter.toFile(QTFile theFile, Movie theMovie, Track onlyThisTrack, int startTime, int duration)
          This method is used to export movie data into a file.
 QTHandle MovieExporter.toHandle(Movie theMovie, Track onlyThisTrack, int startTime, int duration)
          Exports the movie's track data into a handle, returning the handle the data is exported too.
 XMLElement XMLDoc.getRootElement()
          get the root element of the xml parse tree
 void XMLStartElementProc.execute(java.lang.String name, java.lang.String[] attributes)
          The method that is called by the XMLParser for parsing StartElement events.
 

Constructors in quicktime.std.qtcomponents that throw QTException
ImageCompressionDialog()
          Opens the CompressionDialog component for an Image compression dialog.
SoundCompressionDialog()
          Opens the CompressionDialog component.
DataCodecDecompressor(int subType)
          Opens the specified data codec decompressor component, 'ddec', with the given subType.
DataCodecDecompressor(ComponentIdentifier comp)
          Given a component identifier it opens the specified component.
DataCodecCompressor(int subType)
          Opens the specified data codec compressor component, 'dcom', with the given subType.
DataCodecCompressor(ComponentIdentifier comp)
          Given a component identifier it opens the specified component.
XMLParser()
           
MovieImporter()
          Opens the specified movie import component,'eat ', with any subType.
MovieImporter(int subType)
          Opens the specified movie import component,'eat ', with the given subType.
MovieImporter(ComponentIdentifier comp)
          Given a component identifier it opens the specified component.
MovieImporter(DataRef dataRef, int flags)
          This returns an appropriate instance of the MovieImporter for the DataRef object.
MovieImporter(DataRef dataRef, int flags, java.lang.String fileExt)
          This returns an appropriate instance of the MovieImporter for the DataRef object.
MovieExporter(int subType)
          Opens the specified movie export component,'spit', with the given subType.
MovieExporter(ComponentIdentifier comp)
          Given a component identifier it opens the specified component.
TimeCodeDescription()
          This constructor makes an empty TimeCodeDescription object.
 

Uses of QTException in quicktime.std.sg
 

Methods in quicktime.std.sg that throw QTException
 SampleDescription SGChannel.getSampleDescription()
          This method allows you to retrieve a sample description from the SGChannel.
 Region VisualChannel.getClip()
          Allows you to retrieve a channels clipping region.
 ImageDescription SGVideoChannel.getImageDescription()
          This method allows you to retrieve a music sample description from the SGChannel.
 SoundDescription SGSoundChannel.getSoundDescription()
          This method allows you to retrieve a music sample description from the SGChannel.
 MusicDescription SGMusicChannel.getMusicDescription()
          This method allows you to retrieve a music sample description from the SGChannel.
 int SGDataProc.execute(SGChannel chan, QTPointerRef dataToWrite, int offset, int chRefCon, int time, int writeType)
          The method that is called by QuickTime to write the provided data.
 void SequenceGrabber.disposeOutput(SGOutput output)
          Disposes of an output associated with a sequence grabber.
 Pict SequenceGrabber.grabPict(QDRect bounds, int offscreenDepth, int grabPictFlags)
          Provides a simple interface to obtain a QuickDraw picture from a sequence grabber component.
 void SequenceGrabber.setDataOutput(QTFile movieFile, int whereFlags)
          Specifies the movie file for a record operation and other options that govern the operation.
 QTFile SequenceGrabber.getDataOutputFile()
          Allows you to determine the movie file that is currently assigned to a sequence grabber component.
 int SequenceGrabber.getDataOutputFlags()
          Allows you to determine the record control flags that is currently assigned to a sequence grabber component.
 SGChannel SequenceGrabber.getIndChannel(int index)
          Allows you to obtain the channel type currently in use by a sequence grabber component.
 void SGOutput.disposeQTObject()
          Disposes of an output associated with a sequence grabber.
 TextDescription SGTextChannel.getTextDescription()
          This method allows you to retrieve a music sample description from the SGChannel.
 

Constructors in quicktime.std.sg that throw QTException
VideoDigitizer()
          Opens the specified video component,'vidg', with any subType.
VideoDigitizer(int subType)
          Opens the specified video component,'vidg', with the given subType.
SequenceGrabber()
          Opens the specified movie export component,'barg', with any subType.
SequenceGrabber(int subType)
          Opens the specified movie export component,'barg', with the given subType.
SequenceGrabber(int type, int subType)
          Opens the specified Sequence grabber component based on the type and Subtype

QuickTime::OpenADefaultComponent



QuickTime::SGInitialize

 

Uses of QTException in quicktime.streaming
 

Methods in quicktime.streaming that throw QTException
 void Sourcer.setInfo(int selector, QTPointer data)
          General purpose routine for setting information associated with the Sourcer
 QTPointer Sourcer.getInfo(int selector)
          General purpose routine for retrieving information associated with the Sourcer
 void Sourcer.setCallbackParams(SourcerCallbackParams callbackParams)
          Sets the callback parameters associated with the sourcer
 SourcerCallbackParams Sourcer.getCallbackParams()
          Gets the callback parameters associated with the sourcer
 void Sourcer.setLoopParams(SourcerLoopParams loopParams)
          Sets the loop parameters associated with the sourcer
 SourcerLoopParams Sourcer.getLoopParams()
          Gets the loop parameters associated with the sourcer
 void Sourcer.setSourcerTrackParams(SourcerTrackParams SourcerTrackParams)
          Sets the track parameters associated with the sourcer
 SourcerTrackParams Sourcer.getSourcerTrackParams()
          Gets the track parameters associated with the sourcer
 int Sourcer.idle(long inTime, int flags)
          Idles the sourcer object
 void Sourcer.setEnable(boolean enabled)
          Enables (or disables) the sourcer object
 void Sourcer.setEnable(boolean enabled, int flags)
          Enables (or disables) the sourcer object
 boolean Sourcer.isEnable()
          Returns the enabled state of the sourcer
 boolean Sourcer.isEnable(int flags)
          Returns the enabled state of the sourcer
 void Sourcer.setTimeScale(int scale)
          Sets the time scale of the sourcer object
 int Sourcer.getTimeScale()
          Gets the time scale of the sourcer object
 void PresIdleParams.setStream(Stream s)
          This method sets the stream of the params object
 Stream PresIdleParams.getStream()
           
 void PresIdleParams.setMovieTimeToDisplay(long time)
          This method sets the movie time to display of the params object
 void PresIdleParams.setFlagsIn(int flags)
          This method sets the input flags of the prarms object
 int PresIdleParams.getFlagsOut()
          This method gets the output flags of the params object
 Presentation Stream.getPresentation()
          Retrieves the presentation object this stream is associated with
static Presentation Presentation.fromData(int dataType, QTPointerRef data, PresParams params)
          Creates a new presentation object from data
static Presentation Presentation.fromFile(QTFile file, PresParams params)
          (Not in carbon yet)
static Presentation Presentation.fromDataRef(DataRef ref, PresParams params)
          (Not in carbon yet)
 void Presentation.export(ExportParams params)
          This method exports the stream settings for all streams
 void Presentation.export(ExportParams params, Stream s)
          This method exports the stream settings
 void Presentation.setFlags(int flags, int mask)
          This method sets the flags associated with the presentation
 int Presentation.getFlags()
          This method retrieves the flags associated with the presentation
 TimeBase Presentation.getTimeBase()
          This method retrieves the time base associated with the presentation
 int Presentation.getTimeScale()
          This method retrieves the time scale associated with the presentation
 int Presentation.getTotalDataRate()
          This method retreives the total data rate for all streams
 boolean Presentation.hasCharacteristic(Stream s, int characteristic)
          This method returns true if the presentation has a specific characteristic
 void Presentation.preview()
          This method previews the presentation with all streams
 void Presentation.preview(long timeValue, float rate, int flags)
          This method previews the presentation with all streams
 void Presentation.preview(Stream s, long timeValue, float rate, int flags)
          This method previews the presentation
 void Presentation.preroll()
          This method previews all streams in the presentation with default parameters
 void Presentation.preroll(int timeValue, float rate, int flags)
          This method previews all streams in the presentation
 void Presentation.preroll(Stream s, int timeValue, float rate, int flags)
          This method previews the presentation with a specific stream
 void Presentation.preroll(Stream s, long timeValue, float rate, int flags)
          This method previews the presentation with a specific stream
 void Presentation.start()
          This method starts all streams associated with the presentation using no flags
 void Presentation.start(int flags)
          This method starts all streams associated with the presentation
 void Presentation.start(Stream s, int flags)
          This method starts the specific stream associated with the presentation
 void Presentation.invalidateRegion(Region updateRgn)
          The invalidate function allows you to tell the presentation that it must refresh its display
 void Presentation.skipTo(int timeValue)
          This method skips to a specific point in the presentation
 void Presentation.skipTo(long timeValue)
          This method skips to a specific point in the presentation (64 bit version)
 void Presentation.stop()
          This method stops the presentation of all streams
 void Presentation.stop(Stream s, int flags)
          This method stops the presentation of a specific stream
 Stream Presentation.getIndStream(int index)
          This method gets a stream owned by the presentation object from an index
 void Presentation.setPreferredRate(float rate, int flags)
          This method sets the preferred rate of the presentation
 float Presentation.getPreferredRate()
          This method gets the preferred rate of the presentation
 void Presentation.setEnable(Stream s, boolean enableMode)
          This method specifies whether the presentation is enabled
 boolean Presentation.getEnable(Stream s)
          This method returns true if the presentation is enabled
 void Presentation.setPresenting(Stream s, boolean inPresentingMode)
          This method toggles the presenter's presentation mode
 boolean Presentation.getPresenting(Stream s)
          This method returns the presenter's presentation mode
 void Presentation.setActiveSegment(Stream s, long startTime, long duration)
          This method sets the active segment of the presenter
 long Presentation.getActiveSegmentStart(Stream s)
          This method gets the start time of the active segment of the presenter
 long Presentation.getActiveSegmentDuration(Stream s)
          This method gets the duration of the active segment of the presenter
 void Presentation.setPlayHints(Stream s, int flags, int mask)
          This method sets the playing hints of the presenter
 int Presentation.getPlayHints(Stream s)
          This method gets the playing hints of the presenter
 void Presentation.setGWorld(Stream s, QDGraphics gWorld, GDevice gd)
          This method sets the GWorld of the presenter
 void Presentation.setGWorld(Stream s, QDGraphics gWorld)
          This method sets the GWorld of the presenter (uses the main device as the default GDevice)
 void Presentation.setGWorld(QDGraphics gWorld)
          This method sets the GWorld of the presenter (uses the main device as the default GDevice)
 QDGraphics Presentation.getGWorld(Stream s)
          This method retrieves the GWorld of the presenter
 QDGraphics Presentation.getGWorld()
          This method retrieves the GWorld of the presenter
 void Presentation.setClip(Stream s, Region rgn)
          This method sets the clipping region of the presenter
 Region Presentation.getClip(Stream s)
          This method retrieves the clipping region of the presenter
 void Presentation.setMatrix(Stream s, Matrix matrix)
          This method sets the matrix of the presenter
 Matrix Presentation.getMatrix(Stream s)
          This method gets the matrix of the presenter
 void Presentation.setDimensions(Stream s, float width, float height)
          This method sets the dimensions of the presenter
 void Presentation.setDimensions(Stream s, QDDimension dim)
          This method sets the dimensions of the presenter
 QDDimension Presentation.getDimensions(Stream s)
          This method gets the dimensions of the presenter
 void Presentation.setGraphicsMode(Stream s, int mode, QDColor opColor)
          This method sets the graphics mode of the presenter
 GraphicsMode Presentation.getGraphicsMode(Stream s)
          This method gets the graphics mode of the presenter
 Pict Presentation.getPicture(Stream s)
          This method gets the picture associated with the presenter
 void Presentation.setVolumes(Stream s, int leftVol, int rightVol)
          This method sets the right and left volumes of the presenter
 int Presentation.getRightVolume(Stream s)
          This method gets the right volume of the presenter
 int Presentation.getLeftVolume(Stream s)
          This method gets the left volume of the presenter
 void Presentation.addSource(Stream s, Component sourcer, int flags)
          Deprecated. use addSourcer()
 void Presentation.removeSource(Stream s, Component sourcer, int flags)
          Deprecated. use removeSourcer()
 void Presentation.addSourcer(Stream s, Sourcer sourcer, int flags)
          This method adds a source component to the presenter
 void Presentation.removeSourcer(Stream s, Sourcer sourcer, int flags)
          Deprecated.  
 Sourcer Presentation.getIndSourcer(Stream s, int index)
          This method returns a component at a given index associated with a specific stream
 void MediaParams.setFrequencyBands(QTPointer bands)
          Sets the frequency bands assoicated with the sound media
 void EditList.insert(EditEntry el, int pos)
          Inserts an EditEntry into the vector at specified position.
 EditEntry EditList.get(int pos)
          Get a EditEntry at specified position.
 

Constructors in quicktime.streaming that throw QTException
EditEntry()
          Create an EditEntry object
EditEntry(long duration, long startTime, float rate)
          This constructor creates an EditEntry Object
Sourcer(ComponentIdentifier compID)
          Creates a new Sourcer component from a specific component identifier
Sourcer(int sourcerType, int subType, int manufacturerType)
          Creates a new sourcer based on type, subType and manufacturer type
Sourcer(int sourcerType, int subType, int manufacturerType, SourcerInitParams initParams)
          Creates a new sourcer based on type, subType, manufacturer type, and optional init parameters
SettingsDialog(Presentation p)
          This method creates and displays a new settings dialog for all active streams
SettingsDialog(Presentation p, Stream s)
          This method creates and displays a new settings dialog for a specific stream
PresIdleParams()
          Create a PresIdleParams object
PresIdleParams(Stream s, long timeToDisplay, int flagsIn)
          This constructor creates an PresIdleParams Object
PushDataParams(int vers, SampleDescription sampleDesc, int seed, long time, long duration, QTPointer data)
          Constructs an PushDataParams object based on the native QTSPushDataParams structure
PushDataParams(int vers, SampleDescription sampleDesc, int seed, QTPointer data)
          Constructs an PushDataParams object based on the native QTSPushDataParams structure
Stream(Presentation pres, int dataType, QTPointerRef data)
          Create a new stream object
Stream(Presentation pres, int dataType, QTPointerRef data, int flags)
          Create a new stream object
SourcerInitParams(int flags, int dataType, QTPointer data)
          Constructs a version 1 SourcerInitParams object based on the native QTSourcerInitParams structure
SourcerInitParams(int vers, int flags, int dataType, QTPointer data)
          Constructs a SourcerInitParams object based on the native QTSourcerInitParams structure
PresParams(int scale, int flags, MediaParams params)
          Constructs a PresParams object
SourcerLoopParams(int loopFlags, int flagsMask, int numLoops)
          Constructs a SourcerLoopParams object based on the native QTSLoopParams structure
SourcerLoopParams(int vers, int flags, int loopFlags, int flagsMask, int numLoops)
          Constructs a SourcerLoopParams object based on the native QTSLoopParams structure
Presentation(NewPresentationParams params)
          Creates a new presentation object from the presentation parameters
MediaParams()
          Constructs the class with a reasonable default values: Width and Height are set to 0 Matrix is set to the Identity Matrix The gdHandle is set to the Main Device The graphicsMode is set to ditherCopy The opColor is set to black Right and left volumes are set to their maximums LevelMeteringEnabled is set to false
MediaParams(QDDimension dim, QDGraphics g)
          Creates a MediaParams object from a dimension and gWorld
MediaParams(QDDimension dim, Matrix matrix, QDGraphics g, int lVol, int rVol, int bassLvl, int trebLvl)
          Creates a MediaParams object
NewPresentationParams(int dataType, QTPointer data, EditList list)
          Create a NewPresentationParams object
SourcerTrackParams(int flags, Track track)
          Constructs a SourcerTrackParams object based on the native QTSSourcerTrackParams structure
SourcerTrackParams(int flags, Track track, long trackStartOffset, long duration, SourcerLoopParams loopParams)
          Constructs a SourcerTrackParams object based on the native QTSSourcerTrackParams structure
SourcerTrackParams(int version, int flags, Track track, long trackStartOffset, long duration, SourcerLoopParams loopParams)
          Constructs a SourcerTrackParams object based on the native QTSSourcerTrackParams structure
SourcerCallbackParams(int flags, StreamNotifyProc proc)
          Constructs an SourcerCallbackParams object based on the native SourcerCallbackParams structure
SourcerCallbackParams(int vers, int flags, StreamNotifyProc proc)
          Constructs an SourcerCallbackParams object based on the native SourcerCallbackParams structure
SourcerTimingParams(int flags, int timeScale, long presStartTime, long presEndTime, long presCurrTime, long localStartTime, long localEndTime, long localCurrTime)
          Constructs an SourcerTimingParams version 1 object based on the native QTSSourcerTimingParams structure
SourcerTimingParams(int vers, int flags, int timeScale, long presStartTime, long presEndTime, long presCurrTime, long localStartTime, long localEndTime, long localCurrTime)
          Constructs an SourcerTimingParams object based on the native QTSSourcerTimingParams structure
EditList(int numberOfElements)
          Creates a EditList which is an array of EditEntry objects.
 

Uses of QTException in quicktime.util
 

Subclasses of QTException in quicktime.util
 class UtilException
          A General catch all class that is used to signal errors that occur from QT calls
 

Methods in quicktime.util that throw QTException
static SCInfo QTHandleRef.fromSCSequence(SCSequence sc, QDGraphics src, QDRect srcRect)
          Compresses a frame that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data.
static QTHandleRef QTHandleRef.fromCompressionDialogState(CompressionDialog cd)
          Retrieves all of the settings for a dialog.
static QTHandle QTHandle.fromGraphicsExporterText(GraphicsExporter g)
          Determines the data handle that is the source for input images to graphics export component

QuickTime::GraphicsExportGetSettingsAsText

static QTHandle QTHandle.fromGraphicsExporterInput(GraphicsExporter g)
          Determines the data handle that is the source for input images to graphics export component

QuickTime::GraphicsExportGetInputHandle

static QTHandle QTHandle.fromGraphicsExporterOutput(GraphicsExporter g)
          Determines the data handle that is the source for input images to graphics export component

QuickTime::GraphicsExportGetOutputHandle

static QTHandle QTHandle.fromSoundDescription(SoundDescription sd, int idType)
          Retrieve application specific info from a Sound Description object

QuickTime::GetSoundDescriptionExtension

static QTHandle QTHandle.fromGraphicsImporterData(GraphicsImporter gi)
          Determines the data reference that the graphics resides in.
static QTHandle QTHandle.fromGraphicsImporterAlias(GraphicsImporter gi)
          Determines the aliased data reference.
static TimeCodeInfo QTHandle.fromTimeCoderTime(TimeCoder tc, int mediaTime)
          Determines the time code from the time code handler.
static TimeCodeInfo QTHandle.fromTimeCoderCurrent(TimeCoder tc)
          Determines the time code from the time code handler at the current time value.
static QTHandle QTHandle.fromTimeCoderSource(TimeCoder tc, TimeCodeDescription tcd)
          Allows you to retrieve the source information from the time code media sample.
static QTHandle QTHandle.fromTrack(Track t)
          This method returns the sound localization settings for the track.
static QTHandle QTHandle.fromEncodedImage(EncodedImage image)
          Returns EncodedImage data as a QTHandle.
static QTPointer QTPointer.fromEncodedImage(EncodedImage image)
          Returns EncodedImage data as a QTPointer.
 

Constructors in quicktime.util that throw QTException
QTHandle()
          Allocate a handle of minimum size for general use.
QTHandle(int size, boolean clear)
          Allocate a handle for general use.
QTHandle(byte[] byteArray)
          Construct a handle from input data.
QTHandle(QTPointerRef ptr, int offset, int size)
          This constructor is used to create a QTHandle object from a QTPointer.
QTHandle(QTHandleRef firstHandle, QTHandleRef secondHandle)
          Construct a handle from the concatenation of the two handles supplied.
QTPointer(int size, boolean clear)
          Allocate a pointer for general use.
QTPointer(byte[] byteArray)
          Construct a pointer from input data.
QTPointer(QTHandleRef hdl, int offset, int size)
          This constructor is used to create a QTPointer object from a Handle.
QTPointer(QTPointerRef firstPtr, QTPointerRef secondPtr)
          Construct a pointer from the concatenation of the two supplied pointers.
RawEncodedImage(byte[] bytes)
          This will return a RawEncodedImage object from a byte array.
RawEncodedImage(int[] ints)
          This will return a RawEncodedImage object from an int array.
RawEncodedImage(int[] ints, int rowBytes)
          This will return a RawEncodedImage object from an int array.
RawEncodedImage(int size, boolean clear)
          Allocate the specified amount of bytes for containing encoded image data.
RawEncodedImage(int size, boolean clear, int rowBytes)
          Allocate the specified amount of bytes for containing encoded image data.
StringHandle(java.lang.String str, int format)
          Construct a handle from a java String.
 

Uses of QTException in quicktime.vr
 

Subclasses of QTException in quicktime.vr
 class QTVRException
          A General catch all class that is used to signal errors that occur from QT calls
 

Methods in quicktime.vr that throw QTException
 int QTVRPanoImaging.getImagingProperty(int index)
          returns the imagingProperty
 void QTVRPanoImaging.setImagingProperty(int property, int index)
          set the imagingProperty
 void QTVRObjectSample.setMinFieldOfView(float minFieldOfView)
           
 void QTVRObjectSample.setFieldOfView(float fieldOfView)
           
 float QTVRInterceptRecord.getAngle()
          Returns the pan or tilt angle, depending on the selector.
 void QTVRInterceptRecord.setAngle(float angle)
          Sets the pan or tilt angle, depending on the selector.
 float QTVRInterceptRecord.getFieldOfView()
          Returns the field of view for the kQTVRSetFieldOfViewSelector.
 void QTVRInterceptRecord.setFieldOfView(float fieldOfView)
          Sets the field of view for the kQTVRSetFieldOfViewSelector.
 QDPoint QTVRInterceptRecord.getViewCenter()
          Returns the field of view for the kQTVRSetViewCenterSelector.
 void QTVRInterceptRecord.setViewCenter(QDPoint viewCenter)
          Sets the field of view for the kQTVRSetViewCenterSelector.
 int QTVRInterceptRecord.getHotSpotID()
          Gets the hot spot ID.
 void QTVRInterceptRecord.setHotSpotID(int hotSpotID)
          Sets the hot spot ID.
 int QTVRInterceptRecord.getHotSpotType()
          Gets the hot spot type.
 void QTVRInterceptRecord.setHotSpotType(int hotSpotType)
          Sets the hot spot type.
 Region QTVRInstance.getHotSpotRegion(int hotSpotID)
          The QTVRGetHotSpotRegion function returns, in the hotSpotRegion parameter, a handle to the region occupied by the hot spot, in the QuickTimeÊVR movie specified by the qtvr parameter, whose ID is specified by the hotSpotID parameter.
 

Constructors in quicktime.vr that throw QTException
QTVRNodeHeader(byte[] bytes)
          Creates a QTVRNodeHeader object from a byte array Used in cloning
QTVRTrackRefEntry(byte[] bytes)
          Creates a QTVRTrackRefEntry object from a byte array Used in cloning
QTVRPanoSample(byte[] bytes)
          Creates a QTVRPanoSample object from a byte array Used in cloning
QTVRString(java.lang.String string)
          Creates a QTVRString object from a String
QTVRString(byte[] bytes)
          Creates a QTVRString object from a byte array
QTVRCubicFace(byte[] bytes)
          Creates a QTVRCubicFace object from a byte array Used in cloning
QTVRLinkHotSpot(byte[] bytes)
          Creates a QTVRLinkHotSpot object from a byte array Used in cloning
QTVRWorldHeader(byte[] bytes)
          Creates a QTVRWorldHeader object from a byte array Used in cloning
QTVRPanoImaging(byte[] bytes)
          Creates a QTVRPanoImaging object from a byte array Used in cloning
QTVRAngleRange(byte[] bytes)
          Creates a QTVRAngleRange object from a byte array Used in cloning
QTVRObjectSample(byte[] bytes)
          Creates a QTVRObjectSample object from a byte array Used in cloning
QTVRCubicView(byte[] bytes)
          Creates a QTVRCubicView object from a byte array Used in cloning
QTVRNodeLocation(byte[] bytes)
          Creates a QTVRNodeLocation object from a byte array
QTVRHotSpotInfo(byte[] bytes)
          Creates a QTVRHotSpotInfo object from a byte array Used in cloning
QTVRInstance(Track qtvrTrack, MovieController mc)
          You can use the QTVRGetQTVRInstance function to get an instance of a QuickTime VR movie.