Uses of Class
quicktime.std.StdQTException

Packages that use StdQTException
quicktime.qd   
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.util   
 

Uses of StdQTException in quicktime.qd
 

Methods in quicktime.qd that throw StdQTException
static QDGraphics QDGraphics.fromGraphicsExporter(GraphicsExporter ge)
          Call this method to obtain the QDGraphics of the object.
static int QDGraphics.getPixelSize(int pixelFormat)
          Returns the pixel size for a given pixel format.
static QDGraphics QDGraphics.fromGraphicsImporter(GraphicsImporter gi)
          Call this method to obtain the QDGraphics of the object.
static QDGraphics QDGraphics.fromMovie(Movie m)
          Your application can determine a movie's graphics world by calling the getGWorld method.
static QDGraphics QDGraphics.fromPresentation(Presentation p, Stream s)
          Your application can retrieve a Presentation's graphics world by calling the getGWorld method.
static QDGraphics QDGraphics.fromMovieController(MovieController mc)
          This method returns a movie controller's color graphics port.
static QDGraphics QDGraphics.fromSequenceGrabber(SequenceGrabber sg)
          Returns the QDGraphic context of the sequence grabber.
static QDGraphics QDGraphics.fromCSequence(CSequence c)
          This method determines the location of the previous image buffer allocated by the compressor.
static QDGraphics QDGraphics.fromDSequenceImage(DSequence d)
          This method helps you determine the location of the offscreen image buffer allocated by the decompressor.
static QDGraphics QDGraphics.fromDSequenceScreen(DSequence d)
          This method enables you to determine the location of the offscreen buffer allocated by the decompressor.
static PixMap PixMap.fromTrack(Track t)
          A PixMap object which describes the Matte of a Track.
static GDevice GDevice.fromSequenceGrabber(SequenceGrabber sg)
          Returns the current device of the sequence grabber.
 float GDevice.hasScale(int depth, float scale)
          Returns the closest possible scaling that a particular screen device can be set to in a given pixel depth
 float GDevice.getScale()
          Returns the current scale of the screen graphics device
 int GDevice.getFlags()
          Returns the current scale of the screen graphics device
 void GDevice.setScale(int scale, int flags)
          Sets the current scale of the screen graphics device
 

Uses of StdQTException in quicktime.sound
 

Methods in quicktime.sound that throw StdQTException
static SPBDevice SPBDevice.fromSoundChannel(SGSoundChannel sc)
          Get the Sound Input Driver

QuickTime::SGGetSoundInputDriver QuickTime::SGGetSoundInputDriver

 

Uses of StdQTException in quicktime.std
 

Methods in quicktime.std that throw StdQTException
static AtomContainer QTPreferences.getAccessKeys(java.lang.String keyType)
          This method returns all the application and system access keys of a specified access key type.
static void StdQTException.checkError(int err)
          This method will throw an exception if the incoming err argument is a non-zero value.
 

Uses of StdQTException in quicktime.std.anim
 

Methods in quicktime.std.anim that throw StdQTException
 void SpriteWorld.setBounds(QDRect bounds)
          Sets the bounds of the SpriteWorld by scaling its matrix.
 QDRect SpriteWorld.getBounds()
          Returns the current bounds of the SpriteWorld.
 void SpriteWorld.setClip(Region clipRgn)
          This method sets the sprite world's clip.
 void SpriteWorld.setGraphicsMode(GraphicsMode gMode)
          This method sets the Graphic's mode of the SpriteWorld.
 void SpriteWorld.setMatrix(Matrix matrix)
          This method sets the sprite world's matrix.
 int SpriteWorld.idle(int flagsIn)
          This method allows the sprite world to update and redraw the invalid portions of the sprite world.
 void SpriteWorld.invalidate(QDRect invalidArea)
          This method allows a rectangular area of the sprite world to be invalidated, which will force it to redraw the next time SpriteWorldIdle is called.
 void SpriteWorld.setFlags(int flags, int flagsMask)
          Set the flags for the sprite world.
 boolean Sprite.hitTest(int flags, QDPoint loc)
          This method tests if a point is inside a sprite.
 Matrix Sprite.getMatrix()
          This method gets the matrix property of this sprite.
 void Sprite.setMatrix(Matrix matrix)
          This method sets the matrix property of this sprite.
 ImageDescription Sprite.getImageDescription()
          This method gets the image description property of this sprite.
 java.awt.Dimension Sprite.getInitialSize()
          Deprecated. since QTJava 4.0
 QDDimension Sprite.getOriginalSize()
          This method returns the original width and height of the image currently being presented by the sprite.
 void Sprite.setImageDescription(ImageDescription idh)
          This method sets the image description property of this sprite.
 RawEncodedImage Sprite.getImageData()
          This method gets the image data property of this sprite.
 void Sprite.setImageData(EncodedImage data)
          This method sets the image data property of this sprite.
 boolean Sprite.setImageDataIfDifferent(EncodedImage data)
          This method sets the image data property of this sprite.
 boolean Sprite.getVisible()
          This method gets the visibility property of this sprite.
 void Sprite.setVisible(boolean visible)
          This method sets the visibility property of this sprite.
 int Sprite.getLayer()
          This method gets the layer property of this sprite.
 void Sprite.setLayer(int layer)
          This method sets the layer property of this sprite.
 GraphicsMode Sprite.getGraphicsMode()
          This method gets the graphics mode property of this sprite.
 void Sprite.setGraphicsMode(GraphicsMode gMode)
          This method sets the graphics mode property of this sprite.
 int Sprite.getImageDataSize()
          This method gets the size of the image data that a sprite is currently displaying.
 void Sprite.setImageDataSize(int size)
          This method sets the size of the image data that the sprite is currently displaying.
 

Uses of StdQTException in quicktime.std.clocks
 

Methods in quicktime.std.clocks that throw StdQTException
abstract  void QTCallBack.callMeWhen()
          Registers the callback.
 void TimeJumpCallBack.callMeWhen()
          Specifies the time when the callback sholud be called.
static TimeBase TimeBase.fromMovie(Movie m)
          This method allows you to get movie's TimeBase.
static TimeBase TimeBase.fromTunePlayer(TunePlayer tp)
          Returns the TunePlayer's current time Base.
static TimeBase TimeBase.fromPresentation(Presentation p)
          Returns the Presentation's current time Base.
static TimeBase TimeBase.fromSequenceGrabber(SequenceGrabber sg)
          Returns the SequenceGrabber's current time Base.
 TimeBase TimeBase.fromWallClock()
          Returns the Time Base of the Wall Clock
 void RateCallBack.callMeWhen()
          Makes the callback active.
 void ExtremesCallBack.callMeWhen()
          Specifies the time when the callback sholud be called.
 void TimeCallBack.callMeWhen()
          Specifies the time when the callback sholud be called.
 

Uses of StdQTException in quicktime.std.comp
 

Methods in quicktime.std.comp that throw StdQTException
 ComponentDescription ComponentIdentifier.getInfo()
          Returns all of the registration information for a component.
 

Constructors in quicktime.std.comp that throw StdQTException
Component(ComponentIdentifier comp)
          Given a component identifier it opens the specified component.
 

Uses of StdQTException in quicktime.std.image
 

Methods in quicktime.std.image that throw StdQTException
 void CDSequence.setTimeBase(TimeBase base)
          Set the time base for the CDSequence object.
 boolean CDSequence.busy()
          Your application may call this method to check the status of an asynchronous compression or decompression operation.
 boolean CDSequence.equivalentImageDescription(ImageDescription newDesc)
          Reports whether two image descriptions are the same.
 void CurvePath.insertPoint(QDPoint aPoint, int contourIndex, int pointIndex, boolean ptIsOnPath)
          This method is best for adding a single point to a path rather than large numbers of points to a path.
static ICMPixelFormatInfo ICMPixelFormatInfo.setPixelFormatInfo(int pixelFormat)
          Set the PixelFormat info.
static ICMPixelFormatInfo ICMPixelFormatInfo.getPixelFormatInfo(int pixelFormat)
          Get the PixelFormat info.
 void VectorStream.addZeroAtom()
          Used to add a kCurveEndAtom to a vector data stream.
 void VectorStream.addAtom(int atomType, byte[] atomData)
          Used to add an atom to a vector data stream.
 void VectorStream.addAtom(int atomType, int atomData)
          Used to add an atom to a vector data stream.
 void VectorStream.addAtom(boolean onCurve, QDPoint[] points)
          Used to add an atom of type kCurvePathAtom to a vector data stream.
 void VectorStream.removeAtom(int atomType)
          Used to remove and atom of given type ex.
 int GraphicsExporter.doExport()
          You can use the GraphicsExportDoExport function to perform an export operation.
 void GraphicsExporter.setInputPixmap(QDGraphics gworld)
          Sets the QDGraphics as the source for input images to graphics export component.
 int GraphicsExporter.getOutputOffset()
          Gets the output starting offset and maximum size limit.
 int GraphicsExporter.getOutputMaxSize()
          Gets the output starting offset and maximum size limit.
 boolean GraphicsExporter.getOutputTruncateFile()
          Gets the output starting offset and maximum size limit.
 byte[] GraphicsExporter.readInputData(int dataOffset, int dataSize)
          Used by format-specific graphics exporters when transcoding: Returns the number of bytes of original image data that can be read.
 void GraphicsExporter.GraphicsExportWriteOutputData(byte[] data, int dataSize)
          This function is used by format-specific graphics exporters to write output data.
 byte[] GraphicsExporter.GraphicsExportReadOutputData(int dataOffset, int dataSize)
          This function is used by format-specific graphics exporters to write output data.
 void GraphicsExporter.setExifEnabled(boolean enableExif)
          Sets whether or not the graphics exporter component should create Exif files.
 boolean GraphicsExporter.getExifEnabled()
          Returns the current Exif export setting.
 void GraphicsExporter.setThumbnailEnabled(boolean enableThumbnail, int maxThumbnailWidth, int maxThumbnailHeight)
          Sets whether or not the graphics exporter component should create an embedded thumbnail inside the exported file.
 boolean GraphicsExporter.getThumbnailEnabled()
          Returns the current thumbnail export settings.
 QDDimension GraphicsExporter.getThumbnailDimension()
          Returns the current thumbnail export settings.
static SGVideoCompressorInfo Compressor.fromSGVideoChannel(SGVideoChannel chan)
          Get a channelŐs current image-compression parameters.
static Compressor Compressor.findCodec(int cType, CodecComponent specCodec)
          determines which of the installed compressors has been chosen to field requests made using one of the special compressor identifiers.
 CompressedFrameInfo CSequence.compressFrame(QDGraphics src, QDRect srcRect, int flags, EncodedImage data)
          Your application calls this method to compress one of a sequence of frames.
 CompressedFrameInfo CSequence.compressFrame(QDGraphics src, QDRect srcRect, int flags, IntEncodedImage data)
          Your application calls this method to compress one of a sequence of frames.
 CompressedFrameInfo CSequence.compressFrame(QDGraphics src, QDRect srcRect, int flags, ByteEncodedImage data)
          Your application calls this method to compress one of a sequence of frames.
 CompressedFrameInfo CSequence.compressFrame(QDGraphics src, QDRect srcRect, int flags, RawEncodedImage data)
          Your application calls this method to compress one of a sequence of frames.
 int CSequence.getMaxCompressionSize(QDGraphics src)
          This method allows your application to determine the maximum size an image will be after compression for a given compression sequence.
 void CSequence.setQuality(int spatialQuality, int temporalQuality)
          This method allows you to adjust the spatial or temporal quality for the current sequence.
 void CSequence.setKeyFrameRate(int keyFrameRate)
          This method allows you to adjust the key frame rate for the current sequence.
 int CSequence.getKeyFrameRate()
          This method lets you determine the current key frame rate of a sequence.
 void CSequence.setFrameNumber(int frameNumber)
          This method informs the compressor in use for this sequence that frames are being compressed out of order.
 int CSequence.getFrameNumber()
          This method returns the current frame number of this sequence.
 void CSequence.setPrev(QDGraphics prev, QDRect prevRect)
          This method allows the application to set the pixel map and boundary rectangle used by the previous frame in temporal compression.
 QDGraphics CSequence.prevBuffer()
          This method determines the location of the previous image buffer allocated by the compressor.
 void CSequence.setDataRateParams(DataRateParams params)
          This method allows the application to set data rate parameters, which communicate information to compressors that can constrain compressed data in a particular sequence to a specific data rate.
 DataRateParams CSequence.getDataRateParams()
          This method obtains the data rate parameters previously set with the setCDataRateParams method.
 void CSequence.setPreferredPacketSize(int preferredPacketSize)
          Sets the preferred packet size for a sequence.
static ImageDescription ImageDescription.fromGraphicsExporter(GraphicsExporter ge)
          Determines the image description information.
static ImageDescription ImageDescription.fromGraphicsExporterCompressor(GraphicsExporter ge, AtomContainer ac)
          Returns the image description information.
static ImageDescription ImageDescription.fromGraphicsImporter(GraphicsImporter gi)
          Determines the image description information.
static ImageDescription ImageDescription.fromSprite(Sprite s)
          This method gets the image description property of this sprite.
 void ImageDescription.setCTable(ColorTable cTable)
          Update the custom color table for an image.
 int ImageDescription.countExtensionType(int idType)
          Counts the number of extensions of a given type.
 int ImageDescription.getNextExtensionType()
          Returns the next extension type.
 void ImageDescription.addExtension(int idType, QTHandle extension)
          Add the extended data of the image.
 void ImageDescription.removeExtension(int idType, int index)
          Removes a specified extension from an ImageDescription.
 QTHandle ImageDescription.getExtension(int idType, int index)
          Obtain the extended data for an image.
 void Matrix.transformPoints(QDPoint pt)
          transforms a set of QuickDraw points through a specified matrix.
 void Matrix.transformPoints(QDPoint[] pts)
          transforms a set of QuickDraw points through a specified matrix.
 void Matrix.transformRgn(Region r)
          applies a specified matrix to a region.
 int GXPaths.countPointsInPath(int contourIndex)
          This method is used to count the points along either one of a path's contours or all of its contours.
 void GXPaths.setPathPoint(int contourIndex, int pointIndex, QDPoint thePoint, boolean ptIsOnPath)
          This method is best for adding a single point to a path rather than large numbers of points to a path.
 PathPointInfo GXPaths.getPathPoint(int contourIndex, int pointIndex)
          This method is used to get a point from a path and to find out if the point is on the curve.
 QDPoint[] GXPaths.lengthToPoint(int index, int length)
          This method is used to get the point at a specified distance along a curve.
 long GXPaths.getLength(int index)
          This method is used to calculate the length of one of a path's contours or the sum of the lengths of all of its contours.
 float GXPaths.getPathPointToLength(int startDist, int endDist, QDPoint thePoint)
          This method is used to to get the length of a path between specified starting and ending distances that is nearest a point.
 NearestPointInfo GXPaths.getNearestPathPoint(QDPoint thePoint)
          This method is used to to find the closest point on a path to a specified point.
static Decompressor Decompressor.findCodec(int cType, CodecComponent specCodec)
          determines which of the installed decompressors has been chosen to field requests made using one of the special compressor identifiers.
static void QTImage.trim(ImageDescription desc, EncodedImage inData, EncodedImage outData, QDRect trimRect)
          Ajusts a compressed image to the boundaries defined by a QDRect specified by your application.
static void QTImage.decompress(EncodedImage data, ImageDescription desc, QDGraphics dst, QDRect dstRect, int mode)
          Decompresses a single frame image into a pixel map structure.
static void QTImage.decompress(EncodedImage data, ImageDescription desc, QDGraphics dst, QDRect srcRect, QDRect dstRect, int mode, Region mask)
          Decompresses a single frame image into a pixel map structure.
static void QTImage.fDecompress(EncodedImage data, ImageDescription desc, QDGraphics dst, QDRect srcRect, Matrix matrix, int mode, Region mask, PixMap matte, QDRect matteRect, int accuracy, CodecComponent codec)
          Decompresses a single frame image into a pixel map structure.
static int QTImage.getMaxCompressionSize(QDGraphics src, QDRect srcRect, int colorDepth, int quality, int cType, CodecComponent c)
          Determines the maximum size an image will be after compression.
static int QTImage.getCompressedSize(ImageDescription desc, EncodedImage data)
          Determines the size in bytes of a compressed image.
static int QTImage.getCompressionTime(QDGraphics src, QDRect srcRect, int colorDepth, int cType, CodecComponent c, int spatialQuality, int temporalQuality)
          Determines the estimated amount of time required to compress a given image.
static float QTImage.getSimilarity(QDGraphics src, QDRect srcRect, ImageDescription desc, EncodedImage data)
          Compares a compressed image to a picture stored in a pixel map and returns a value indicating the relative similarity of the two images.
 void GraphicsImporter.setDataReference(DataRef dataRef)
          Specifies the data reference that the graphics resides in.
 int GraphicsImporter.getDataReferenceType()
          Determines the type of the data reference that the graphics resides in.
 void GraphicsImporter.setDataHandle(QTHandleRef dataRef)
          Specifies the data handle that the graphics resides in.
 ImageDescription GraphicsImporter.getImageDescription()
          Determines the image description information.
 int GraphicsImporter.getDataOffset()
          Determines the data offset.
 int GraphicsImporter.getDataSize()
          Determines the data size.
 void GraphicsImporter.readData(EncodedImage data, int dataOffset, int dataSize)
          Reads image data.
 void GraphicsImporter.setClip(Region clipRgn)
          Defines the clipping region for drawing.
 void GraphicsImporter.setSourceRect(QDRect srcRect)
          Sets the source rectangle to use for an image.
 QDRect GraphicsImporter.getSourceRect()
          Determines the current source rectangle for an image.
 QDRect GraphicsImporter.getNaturalBounds()
          Determines the bounding rectangle of an image.
 void GraphicsImporter.draw()
          Draws an image.
 void GraphicsImporter.setMatrix(Matrix matrix)
          Defines the matrix to use for drawing.
 Matrix GraphicsImporter.getMatrix()
          Determines the matrix to be used for drawing.
 void GraphicsImporter.setBoundsRect(QDRect bounds)
          Defines the rectangle in which to draw an image.
 QDRect GraphicsImporter.getBoundsRect()
          Determines the bounding rectangle for drawing.
 void GraphicsImporter.setGraphicsMode(GraphicsMode graphicsMode)
          Sets the graphics mode and color for an image.
 GraphicsMode GraphicsImporter.getGraphicsMode()
          Determines the graphics mode for an image.
 void GraphicsImporter.setQuality(int quality)
          Sets the image quality value.
 int GraphicsImporter.getQuality()
          Determines the image quality value.
 int GraphicsImporter.getAliasedDataType()
          Determines the aliased data type.
 void GraphicsImporter.setGWorld(QDGraphics port, GDevice gdh)
          Call this method to give the client the QDGraphics object it should use to do its drawing.
 QDGraphics GraphicsImporter.getGWorld()
          Call this method to obtain the QDGraphics of the object.
 boolean GraphicsImporter.validate()
          Determines if the current graphics importer data reference contains valid image data.
 int GraphicsImporter.doesDrawAllPixels()
          Determines if the GraphicsImporter will draw all the pixels that are contained in the image data that it is presenting.
 AtomContainer GraphicsImporter.getMIMETypeList()
          Returns a list of MIME types supported by the graphics import component.
 AtomContainer GraphicsImporter.getExportImageTypeList()
          Returns information about available export formats.
 AtomContainer GraphicsImporter.getExportSettingsAsAtomContainer()
          Returns the Export settings as an Atom Container.
 void GraphicsImporter.setExportSettingsFromAtomContainer(AtomContainer qtAtomContainer)
          Export settings from a QuickTime atom container.
 void GraphicsImporter.setDataReferenceOffsetAndLimit(int offset, int limit)
          Specifies the data reference starting offset and data size limit.
 int[] GraphicsImporter.getDataReferenceOffsetAndLimit()
          Returns the data reference starting offset and data size limit.
 int GraphicsImporter.getImageCount()
          Returns the number of images in the image file.
 void GraphicsImporter.setImageIndex(int imageIndex)
          The default image index is 1.
 int GraphicsImporter.getImageIndex()
          Returns the current image index.
 Matrix GraphicsImporter.getDefaultMatrix()
          Returns the default matrix.
static int CodecInfo.codecVersion()
          determines the version of the installed image compression manager.
 CodecName CodecNameList.getNth(int n)
          Retrieves the nth element in the codec name list.
 void ImageSequenceDataSource.changedSourceData()
          Notifies the compressor that the image source data has changed.
 void ImageSequenceDataSource.setSourceData(EncodedImage data)
          The CDSequenceSetSourceData function is called to set data in a new frame to a specific source.
 void ImageSequenceDataSource.dispose()
          All data sources are diposed of with the sequence.
 int DSequence.decompressFrameS(EncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrameS(ByteEncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrameS(IntEncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrameS(RawEncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrame(EncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrame(ByteEncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrame(IntEncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrame(RawEncodedImage data, int inFlags)
          Your application calls this method to decompress one of a sequence of frames.
 int DSequence.decompressFrameWhen(ByteEncodedImage data, int inFlags, ICMFrameTime frameTime)
          Queues a frame for decompression and specifies the time at which decompression will begin.
 int DSequence.decompressFrameWhen(IntEncodedImage data, int inFlags, ICMFrameTime frameTime)
          Queues a frame for decompression and specifies the time at which decompression will begin.
 int DSequence.decompressFrameWhen(RawEncodedImage data, int inFlags, ICMFrameTime frameTime)
          Queues a frame for decompression and specifies the time at which decompression will begin.
 int DSequence.decompressFrameWhen(EncodedImage data, int inFlags, ICMFrameTime frameTime)
          Queues a frame for decompression and specifies the time at which decompression will begin.
 void DSequence.setGraphicsMode(GraphicsMode mode)
          This method sets the mode used when drawing the decompressed image.
 void DSequence.setTransferMode(int mode, QDColor opColor)
          This method sets the mode used when drawing the decompressed image.
 void DSequence.setSrcRect(QDRect srcRect)
          This method defines the portion of the image to decompress.
 void DSequence.setMatrix(Matrix matrix)
          This method assigns a mapping matrix to the sequence.
 Matrix DSequence.getMatrix()
          This method returns the matrix associated with the sequence
 void DSequence.setFlags(int flags, int flagsMask)
          This method sets the flags of the image sequence
 void DSequence.setMask(Region mask)
          This method assigns a clipping region to the sequence.
 void DSequence.setMatte(PixMap matte, QDRect matteRect)
          This method assigns a blend matte to the sequence.
 void DSequence.setAccuracy(int accuracy)
          This method adjusts the decompression accuracy for this sequence.
 QDGraphics DSequence.getImageBuffer()
          This method helps you determine the location of the offscreen image buffer allocated by the decompressor.
 QDGraphics DSequence.getScreenBuffer()
          This method enables you to determine the location of the offscreen buffer allocated by the decompressor.
 boolean DSequence.ptInData(EncodedImage data, QDPoint where)
          Tests to see if an image contains data at a given point.
 boolean DSequence.hitTestData(EncodedImage data, QDPoint where, int hitFlags)
          The HitTestDSequenceData function allows the calling application to perform hit testing on compressed data.
 void DSequence.flush()
          Stops a decompression sequence, aborting processing of any queued frames.
 void DSequence.invalidate(Region invalRgn)
          Notifies the Image Compression Manager that the destination port for the given image decompression sequence has been invalidated.
 void DSequence.shieldCursor()
          Hides the cursor during decompression operations.
 void DSequence.setTimeCode(TimeCodeDef timeCodeFormat, TimeCodeTime timeCodeTime)
          Sets the timecode value for the frame that is about to be decompressed.
 

Constructors in quicktime.std.image that throw StdQTException
CurvePath(Curve c)
          This method is used to create a new path.
CodecInfo(int cType, CodecComponent codec)
          Consturcts a CodecInfo.
 

Uses of StdQTException in quicktime.std.movies
 

Methods in quicktime.std.movies that throw StdQTException
static AtomContainer AtomContainer.fromGraphicsExporter(GraphicsExporter ge)
          Retrieves the current settings from the movie export component..
static AtomContainer AtomContainer.fromGraphicsExporterMIME(GraphicsExporter ge)
          Returns a list of MIME types supported by the graphics export component.
static AtomContainer AtomContainer.fromGraphicsImporterMIME(GraphicsImporter gi)
          Returns a list of MIME types supported by the graphics import component.
static AtomContainer AtomContainer.fromGraphicsImporterExportImage(GraphicsImporter gi)
          Returns information about available export formats.
static AtomContainer AtomContainer.fromGraphicsImporterExportSettings(GraphicsImporter gi)
          Returns the Export settings as an Atom Container.
static AtomContainer AtomContainer.fromMediaInput(Media m)
          This method returns you the input map of the media.
static AtomContainer AtomContainer.fromMediaProperty(Media m)
          Retrieves the properties from a media handler.
static AtomContainer AtomContainer.fromMovieExporter(MovieExporter me)
          Retrieves the current settings from the movie export component..
static AtomContainer AtomContainer.fromMovieImporterMIME(MovieImporter mi)
          Returns a list of MIME types supported by the movie import component.
static AtomContainer AtomContainer.fromMovieImporterSettings(MovieImporter mi)
          Retrieves the current settings from the movie import component..
static AtomContainer AtomContainer.fromThreeDMediaHandlerObject(ThreeDMediaHandler tdm)
          No QT Documentation.
static AtomContainer AtomContainer.fromThreeDMediaHandlerRenderer(ThreeDMediaHandler tdm)
          No QT Documentation.
static AtomContainer AtomContainer.fromCompressionDialog(CompressionDialog cd)
          Retrieves the current configuration from the dialog

QuickTime::SCGetSettingsAsAtomContainer()

 AtomData AtomContainer.getAtomData(Atom atom)
          Retrieves a pointer to the atom data for the specifiec leaf atom.
 int AtomContainer.getAtomDataSize(Atom atom)
          Retrieves a pointer to the atom data for the specifiec leaf atom.
 int AtomContainer.getNextChildType(Atom parentAtom, int currentChildType)
          This method allows you to retrieve the next atom data type in a specified atom's child list.
 int AtomContainer.countChildrenOfType(Atom parentAtom, int childType)
          This method allows you to determine the number of items of a given type in a parent atom's child list.
 Atom AtomContainer.findChildByIndex_Atom(Atom parentAtom, int atomType, int index)
          This method allows you to search for a particular atom within an atom's child list.
 int AtomContainer.findChildByIndex_id(Atom parentAtom, int atomType, int index)
          This method allows you to search for a particular atom within an atom's child list.
 Atom AtomContainer.findChildByID_Atom(Atom parentAtom, int atomType, int id)
          This method allows you to search for a particular atom within an atom's child list.
 int AtomContainer.findChildByID_index(Atom parentAtom, int atomType, int id)
          This method allows you to search for a particular atom within an atom's child list.
 Atom AtomContainer.nextChildAnyType(Atom parentAtom, Atom currentChild)
          This method allows you to retrieve all of a parent atom's children one by one, regardless of their type's and id's.
 void AtomContainer.setAtomData(Atom atom, QTHandleRef data)
          This method allows you to set a leaf atom's data.
 void AtomContainer.setAtomData(Atom atom, QTPointerRef data)
          This method allows you to set a leaf atom's data.
 void AtomContainer.setAtomData(Atom atom, byte[] data)
          This method allows you to set a leaf atom's data.
 void AtomContainer.setAtomData(Atom atom, QTByteObject data)
          This method allows you to set a leaf atom's data.
 void AtomContainer.setAtomData(Atom atom, int data)
          This method allows you to set a leaf atom's data.
 void AtomContainer.setAtomData(Atom atom, short data)
          This method allows you to set a leaf atom's data.
 void AtomContainer.setAtomData(Atom atom, byte data)
          This method allows you to set a leaf atom's data.
 int AtomContainer.copyAtomDataToPtr(Atom atom, boolean sizeOrLessOK, QTPointer data)
          This method returns a leaf atom's data to the buffer pointed to by the data object.
 byte[] AtomContainer.copyAtomDataToArray(Atom atom)
          Copies the atom data for the specifiec leaf atom.
 int AtomContainer.getAtomType(Atom atom)
          This method returns the type of a given atom.
 int AtomContainer.getAtomID(Atom atom)
          This method returns the id of a given atom.
 AtomContainer AtomContainer.copyAtom(Atom atom)
          This method allows a complete copy of an atom and all of its children to be extracted from its container and be placed in an new atom data structure.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index, QTByteObject data)
          This method creates a new child atom for parentAtom.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index, byte[] data)
          This method creates a new child atom for parentAtom.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index, QTPointerRef data)
          This method creates a new child atom for parentAtom.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index, QTHandleRef data)
          This method creates a new child atom for parentAtom.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index, int intValue)
          This method creates a new child atom for parentAtom.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index, short shortValue)
          This method creates a new child atom for parentAtom.
 Atom AtomContainer.insertChild(Atom parentAtom, int atomType, int id, int index, byte byteValue)
          This method creates a new child atom for parentAtom.
 void AtomContainer.insertChildren(Atom parentAtom, AtomContainer childrenContainer)
          This method inserts all of the atoms in childrenContainer as child atoms of the atom specified by the parentAtom.
 void AtomContainer.removeAtom(Atom atom)
          This method removes an atom and all of its children from an atom data structure.
 void AtomContainer.removeChildren(Atom atom)
          This method removes all of the children of an atom.
 void AtomContainer.replaceAtom(Atom targetAtom, AtomContainer replacementContainer, Atom replacementAtom)
          This method replaces an atom and all of its children with a different atom and all of its children.
 void AtomContainer.swapAtoms(Atom atom1, Atom atom2)
          This method swaps two atoms within an atomData structure.
 void AtomContainer.setAtomID(Atom atom, int newID)
          This method allows you to change the ID of an atom.
 void AtomContainer.iTextAddString(Atom parentAtom, int theRegionCode, java.lang.String theString)
          No QT Documentation.
 void AtomContainer.iTextRemoveString(Atom parentAtom, int theRegionCode, int flags)
          No QT Documentation.
 IStringInfo AtomContainer.iTextGetString(Atom parentAtom, int theRegionCode)
          No QT Documentation.
 Atom AtomContainer.getParent(Atom childAtom)
          This method returns the parent atom of the specified child atom
 void MovieController.setActionFilter(ActionFilter filter)
          Registers a class that can provide a filter function for any action the MovieController takes.
 void MovieController.setActionFilter(ActionFilter filter, boolean doIdle)
          Registers a class that can provide a filter function for any action the MovieController takes.
 void MovieController.removeActionFilter()
          Removes the current action filter from the MovieController.
 void MovieController.setMovie(Movie aMovie, QDGraphics movieWindow, QDPoint location)
          This method replaces the current movie controlled by the movie controller with a new movie.
 Movie MovieController.getMovie()
          This method allows you to get the movie associated with controller.
 void MovieController.removeMovie()
          This method allows you to remove the movie of the controller.
 void MovieController.draw()
          Your application should call the draw method in response to an update event The movie controller component updates the movie controller if the controller is in the same window with the Canvas object.
 boolean MovieController.click(QDPoint where, int modifiers)
          Your application should call the method when the user clicks in a movie controller window.
 boolean MovieController.key(int key, int modifiers)
          This method handles keyboard events for a movie controller.
 void MovieController.activate()
          This method activates the movie controller.
 void MovieController.deactivate()
          This method deactivates the movie controller.
 void MovieController.play(float rate)
          Your application can use this action to start or stop playing a movie.
 void MovieController.goToTime(TimeRecord time)
          Your application can use this action to goto a specific time.
 void MovieController.setVolume(float newVolume)
          Your application can use this action to set a movie's volume.
 float MovieController.getVolume()
          Your application can use this action to determine a movie's volume.
 void MovieController.step(int numberOfSteps)
          Your application can use this action to play a movie while skipping a specified number of frames at a time.
 void MovieController.setLooping(boolean looping)
          Your application can use this action to enable or disable looping for a movie.
 boolean MovieController.getLooping()
          Your application can use this action to determine whether a movie is looping.
 void MovieController.setLoopIsPalindrome(boolean looping)
          Your application can use this method to enable palindrome looping.
 boolean MovieController.getLoopIsPalindrome()
          Your application can use this action to determine whether palindrome looping is enabled for a movie.
 void MovieController.setGrowBoxBounds(QDRect limits)
          Your application can use this action to set the limits for grow box.
 void MovieController.setSelectionBegin(TimeRecord time)
          Your application can use this action to set the start time of a selection.
 void MovieController.setSelectionDuration(TimeRecord time)
          Your application can use this action to set the duration of a selection.
 void MovieController.setKeysEnabled(boolean enabled)
          Your application can use this action to enable or disable keystrokes for a movie.
 boolean MovieController.getKeysEnabled()
          Your application can use this action to determine whether keystrokes are enabled for a movie controller.
 void MovieController.setPlaySelection(boolean play)
          Your application can use this action to constrain playing to the current selection.
 boolean MovieController.getPlaySelection()
          Your application can use this action to determine whether a movie has been constrained to playing within its selection.
 void MovieController.setUseBadge(boolean useBadge)
          Your application can use this action to enable or disable a movie's playback badge.
 boolean MovieController.getUseBadge()
          Your application can use this action to determine whether a controller is using a badge.
 void MovieController.setFlags(int flags)
          Your application can use this action to set a movie's control flags.
 int MovieController.getFlags()
          Your application can use this action to retrieve a movie's control flags.
 void MovieController.setPlayEveryFrame(boolean play)
          Your application can use this action to instruct the movie controller to play every frame in a movie.
 boolean MovieController.getPlayEveryFrame()
          Your application can use this action to determine whether the movie controller has been instructed to play every frame in a movie.
 float MovieController.getPlayRate()
          Your application can use this action to determine a movie's playback rate.
 void MovieController.suspend()
          Indicates that a suspend event has been received.
 void MovieController.resume()
          Indicates that a resume event has been received.
 void MovieController.setControllerKeysEnabled(boolean enabled)
          This method allows your application to enable or disable responding to keys.
 QDRect MovieController.getTimeSliderRect()
          Your application can use this method to receive the QDRect specifying the location and size of the time slider.
 boolean MovieController.getDragEnabled()
          Your application can use this method to determine whether the movie controller has been instructed to enable drag & drop behavior.
 void MovieController.setDragEnabled(boolean enabled)
          Your application can use this method to enable drag & drop behavior.
 void MovieController.prerollAndPlay(float rate)
          Your application can use this method to start a movie.
 boolean MovieController.getCursorSettingEnabled()
          Your application can use this method to determine whether or not the movie controller is allowed to change the cursor.
 void MovieController.setCursorSettingEnabled(boolean enabled)
          Your application can use this method to specify whether or not the movie controller is allowed to change the cursor.
 void MovieController.setColorTable(ColorTable newCTable)
          Your application can use this method to assign a new color table to the controller

QuickTime::MCDoAction()

 void MovieController.controllerSizeChanged()
          Your application can use this method to indicate that the controller size has changed.
 void MovieController.badgeClick(boolean flag)
          Your application can use this method to switch badge clicking (false to ignore, true to process).
 void MovieController.movieEdited()
          Your application can use this method to indicate that the movie has been edited.
 void MovieController.forceTimeTableUpdate()
          Your application can use this method to force the update of the time table.
 boolean MovieController.clickAndHoldPoint(QDPoint point)
          Your application can use this method to test if point has click and hold action.
 boolean MovieController.isAttached()
          Your application can use this method to receive information whether the controller is attached or not.
 void MovieController.setBounds(QDRect newBoundsRect)
          This method lets you change the position and size of a movie controller.
 QDRect MovieController.getBounds()
          This method returns a movie controller's boundary rectangle.
 void MovieController.setPort(QDGraphics grafPtr)
          This method allows your application to set the graphics port for a movie controller.
 QDGraphics MovieController.getPort()
          This method returns a movie controller's color graphics port.
 void MovieController.setVisible(boolean visible)
          This method allows your application to control the visibility of a movie controller.
 boolean MovieController.getVisible()
          This method returns a value that indicates whether a movie controller is visible.
 void MovieController.movieChanged()
          This method lets you inform a movie controller component that your application has used the Movie Toolbox to change the characteristics of its associated movie.
 void MovieController.setDuration(int duration)
          This method allows your application to set a controller's duration in the case where a controller does not have a movie associated with it.
 int MovieController.getCurrentTime()
          This method returns the time value represented by the indicator on the movie controller's slider.
 int MovieController.getTimeScale()
          This method returns the time scale of the controller.
 void MovieController.activate(QDGraphics window, boolean activate)
          This method can be used in response to activate, deactivate, suspend, and resume events.
 void MovieController.enableEditing(boolean enabled)
          This method allows your application to enable and disable editing for a movie controller.
 boolean MovieController.isEditingEnabled()
          This method allows your application to determine whether editing is currently enabled for a movie controller.
 void MovieController.paste()
          This method inserts a specified movie at the current movie time in the movie associated with a specified controller.
 void MovieController.paste(Movie srcMovie)
          This method inserts a specified movie at the current movie time in the movie associated with a specified controller.
 void MovieController.clear()
          This method removes the current movie selection from the movie associated with a specified controller.
 void MovieController.undo()
          This method allows your application to discard the effects of the most recent edit operation.
 void MovieController.position(QDRect movieRect, QDRect controllerRect, int someFlags)
          This method allows you to control the position of a movie and its controller on the computer display.
 void MovieController.position(QDRect movieRect, int someFlags)
          This method allows you to control the position of a movie and its controller on the computer display.
 int MovieController.getControllerInfo()
          This method returns the current status of a movie controller and its associated movie.
 void MovieController.setClip(Region theClip)
          This method allows you to set a movie controller's clipping region.
 void MovieController.setMovieClip(Region theClip)
          This method allows you to set a movie's clipping region.
 boolean MovieController.inController(QDPoint thePt)
          This method allows your application to determine if a point is within the controller's control area.
 void MovieController.invalidate(QDGraphics window, Region invalidRgn)
          This method allows your application to invalidate portions of a movie controller.
 int Movie.addResource(OpenMovieFile fileOut, int resID, java.lang.String resourceName)
          This method adds a movie resource to a specified resource file.
 void Movie.updateResource(OpenMovieFile fileOut, int resID, java.lang.String resourceName)
          This method replaces the contents of a movie resource in a specified movie file.
 void Movie.removeResource(OpenMovieFile fileOut, int resID)
          This method removes a movie resource from a specified movie file.
 void Movie.setDrawingCompleteProc(int flags, MovieDrawingComplete proc)
          This allows you to assign a drawing-complete method to a movie.
 void Movie.removeDrawingCompleteProc()
          This allows you to remove a previously assigned drawing-complete method to a movie.
 void Movie.preroll(int time, float rate)
          This method allows your application to prepare a portion of a movie for playback.
 void Movie.prePreroll(int time, float rate)
          This method allows your application to prepare a portion of a movie for playback.
 void Movie.prePreroll(int time, float rate, MoviePrePreroll proc)
          This method allows your application to prepare a portion of a movie for playback.
 void Movie.abortPrePreroll(int err)
          This method aborts.
 void Movie.loadIntoRam(int time, int duration, int flags)
          This method loads a movie's data into memory.
 void Movie.setActive(boolean active)
          This method allows your application to activate and deactivate a movie.
 boolean Movie.getActive()
          This method returns a boolean value.
 void Movie.start()
          This method starts the movie playing from the current movie time, which is where the movie last stopped playing.
 void Movie.stop()
          This method stops the playback of a movie.
 void Movie.goToBeginning()
          This method repositions a movie to play from its start.
 void Movie.goToEnd()
          This method repositions a movie to play from its end.
 boolean Movie.isDone()
          This method allows you to determine if a particular movie has completely finished playing.
 boolean Movie.getPreviewMode()
          This method allows your application to determine whether a movie is in preview mode.
 void Movie.setPreviewMode(boolean usePreview)
          This method allows your application to place a movie into and out of preview mode.
 void Movie.showPoster()
          You can use showPoster method to display a movie's poster.
 void Movie.playPreview()
          This method plays a movie's preview.
 QDGraphics Movie.getGWorld()
          Your application can determine a movie's graphics world by calling the getGWorld method.
 void Movie.setGWorld(QDGraphics port, GDevice gdh)
          The setGWorld method allows your application to establish a movie's display coordinate system by setting the graphics world for displaying a movie.
 QDRect Movie.getNaturalBoundsRect()
          No QT Documentation.
 void Movie.update()
          This method allows your application to ensure that the Movie Toolbox properly displays your movie after it has been uncovered.
 void Movie.invalidateRegion(Region invalidRgn)
          This method invalidates part of the movie specified by the invalidRgn.
 QDRect Movie.getBounds()
          This method returns a movie's boundary rectangle, which is a rectangle that encompasses all of the movie's enabled tracks.
 QDRect Movie.getBox()
          This method returns a movie's boundary rectangle, which is a rectangle that encompasses all of the movie's enabled tracks.
 void Movie.setBounds(QDRect boxRect)
          This method sets a movie's boundary rectangle, or movie box, which is a rectangle that encompasses the spatial representation of all of the movie's enabled tracks.
 void Movie.setBox(QDRect boxRect)
          This method sets a movie's boundary rectangle, or movie box, which is a rectangle that encompasses the spatial representation of all of the movie's enabled tracks.
 void Movie.setDisplayClipRgn(Region theClip)
          This method allows your application to establish a movie's current display clipping region.
 void Movie.setClipRgn(Region theClip)
          This method allows your application to establish a movie's clipping region.
 void Movie.putIntoHandle(QTHandle intoThisHandle)
          This method creates a new movie resource for you.
 void Movie.putIntoDataFork(OpenMovieFile fileOut, int offset, int maxSize)
          This method allows you to store a movie in the data fork of a given file.
 int Movie.getCreationTime()
          This method returns a long integer that contains the movie's creation date and time information.
 int Movie.getModificationTime()
          This method returns a long integer that contains the movie's creation date and time information.
 int Movie.getTimeScale()
          This method returns the time scale of a movie.
 void Movie.setTimeScale(int timeScale)
          This method establishes a movie's time scale.
 int Movie.getDuration()
          This method returns the duration of a movie.
 float Movie.getRate()
          This method returns a movie's playback rate.
 void Movie.setRate(float rate)
          This method sets a movie's playback rate.
 float Movie.getPreferredRate()
          This method returns a movie's default playback rate.
 void Movie.setPreferredRate(float rate)
          This method allows your application to specify a movie's default playback rate.
 float Movie.getPreferredVolume()
          This method returns a movie's preferred volume setting.
 void Movie.setPreferredVolume(float volume)
          This method allows your application to set a movie's preferred volume setting.
 float Movie.getVolume()
          This method returns movie's current volume setting.
 void Movie.setVolume(float volume)
          This method allows your application to set a movie's current volume.
 Matrix Movie.getMatrix()
          This method allows allows your application to retrieve a movie's transformation matrix.
 void Movie.setMatrix(Matrix matrix)
          This method allows your application to set a movie's transformation matrix.
 TimeInfo Movie.getPreviewTime()
          This method returns the starting time and duration of the movie's preview.
 void Movie.setPreviewTime(TimeInfo previewTimeInfo)
          This method allows your application to define the starting time and duration of the movie's preview.
 void Movie.setPreviewTime(int previewTime, int previewDuration)
          This method allows your application to define the starting time and duration of the movie's preview.
 int Movie.getPosterTime()
          This method returns the poster's time in the movie.
 void Movie.setPosterTime(int posterTime)
          This method sets the poster time for the movie.
 TimeInfo Movie.getSelection()
          This method returns information about a movie's current selection.
 void Movie.setSelection(TimeInfo selectionTimeInfo)
          This method sets a movie's current selection.
 void Movie.setSelection(int selectionTime, int selectionDuration)
          This method sets a movie's current selection.
 void Movie.setActiveSegment(TimeInfo activeSegmentTimeInfo)
          This method allows your application to define a movie's active segment.
 TimeInfo Movie.getActiveSegment()
          This method allows your application to determine what portion of a movie is currently active for playing.
 int Movie.getTime()
          This method returns a movie's current time.
 void Movie.setTime(TimeRecord newtime)
          This method allows you to set a movie's current time.
 void Movie.setTimeValue(int newtime)
          This method allows your application to set a movie's time value.
 UserData Movie.getUserData()
          This method allows your application to obtain access to a movie's user data list.
 int Movie.getTrackCount()
          This method returns the number of tracks in a movie.
 void Movie.removeTrack(Track track)
          Removes a track from a movie.
 void Movie.setAutoTrackAlternatesEnabled(boolean enable)
          This method allows your application to enable and disable automatic track selection by the Movie Toolbox.
 void Movie.selectAlternates()
          This method allows your application to instruct the Movie Toolbox to select appropriate tracks immediately.
 TimeInfo Movie.getNextInterestingTime(int interestingTimeFlags, int[] mediaTypes, int time, float rate)
          This method searches for times of interest in a movie.
 void Movie.insertEmptySegment(int dstIn, int dstDuration)
          This method adds an empty segment to a movie.
 void Movie.insertSegment(Movie dstMovie, int srcIn, int srcDuration, int dstIn)
          The insertSegment method copies part of one movie to another.
 void Movie.deleteSegment(int startTime, int duration)
          This method removes a specified segment from a movie.
 void Movie.scaleSegment(int startTime, int oldDuration, int newDuration)
          This method changes the duration of a segment of a movie and then removes the current selection from the original movie.
 void Movie.pasteSelection(Movie srcMovie)
          This method places the tracks from one movie into another movie.
 void Movie.addSelection(Movie srcMovie)
          This method adds one or more tracks to a movie.
 void Movie.clearSelection()
          This method removes the segment of the movie that is defined by the current selection.
 void Movie.pasteHandle(QTHandle handle, int handleType, int flags, MovieImporter userComp)
          This method takes the contents of a specified handle, together with its type, and pastes it into a specified movie.
 void Movie.copySettings(Movie dstMovie)
          The copySettings method copies many settings from one movie to another, overwriting the destination settings in the process.
 void Movie.useEditState(MovieEditState anEditState)
          Your application can use this method to return a movie to its condition according to an edit state you created previously.
 int Movie.getDataSize(int startTime, int duration)
          This method allows your application to determine the size, in bytes, of the sample data in a segment of a movie.
 boolean Movie.pointInMovie(QDPoint pt)
          This method allows your application to determine whether a specified point lies in the region defined by a movie's final display boundary region after it has been clipped by the movie's display clipping region.
 void Movie.setLanguage(int language)
          This method allows your application to specify a movie's language.
 boolean Movie.hasChanged()
          This method allows your application to determine whether a movie has changed and needs to be saved.
 void Movie.clearChanged()
          This method sets the movie changed flag to indicate that the movie has not been changed.
 void Movie.setDefaultDataRef(DataRef newRef)
          This method sets the default data reference for the movie.
 void Movie.setColorTable(ColorTable ctab)
          This method allows your application to assign a color table to the movie.
 void Movie.setProgressProc()
          This method allows you to attach a progress function to a movie.
 void Movie.setProgressProc(MovieProgress mp)
          This method allows you to attach a progress function to a movie.
 void Movie.addExecuteWiredActionsProc(ExecutingWiredAction wa)
          This method allows you to intercept executing wired actions of this movie.
 void Movie.removeExecuteWiredActionsProc()
          This method allows you to remove the existing executing wired actions of this movie.
 void Movie.executeWiredActions(int flags, AtomContainer actions)
          This method executes specified wired actions associated with the movie
 QDRect Movie.getPosterBox()
          This method allows you to obtain a poster's boundary rectangle.
 void Movie.setPosterBox(QDRect boxRect)
          This method allows you to set a poster's boundary rectangle.
 void Movie.showInformation()
          This method displays a dialog giving information about the movie.
 void Movie.putOnScrap(int movieScrapFlags)
          This method allows your application to place a movie onto the scrap.
 void Movie.setPlayHints(int flags, int flagsMask)
          This method allows your application to provide information to the Movie Toolbox that can influence movie playback.
 TimeBase Movie.getTimeBase()
          This method allows you to get movie's TimeBase.
 void Movie.setMasterTimeBase(TimeBase tb, TimeRecord slaveZero)
          This method allows you to assign a master time base to a movie.
 void Movie.setMasterClock(Clock clockMeister, TimeRecord slaveZero)
          This method allows you to assign a clock component to a movie.
 boolean Movie.needsTimeTable()
          Determine whether a movie is being progressively downloaded..
 int Movie.maxLoadedTimeInMovie()
          Returns the duration of the part of a movie that has already been downloaded.
 void Movie.copyUserDataToMovie(Movie destMovie, boolean replace)
          Copies the user data in the movie to the destination movie
 void Movie.copyUserDataFromMovie(Movie srcMovie, boolean replace)
          Copies the user data from the specified movie into this movie
static void Movie.copyUserData(Movie srcMovie, Movie destMovie, int copyRule)
          Copies the user data from the specified movie into the destination movie
 void Movie.putDataRefIntoHandle(DataRef ref, QTHandle handle)
          QuickTime can handle public movie handles with self contained data references.
 Movie Movie.forDataRefFromHandle(DataRef dataRef, QTHandle publicHandle, int flags, MovieInfo info)
          QuickTime can handle public movie handles with self contained data references.
static int Movie.getTimeUntilNextTask(int scale)
          Allows the user to ask the QuickTime idle manager when idling routines such as movies.task() need to be called.
static void Movie.setNextTaskNeededSoonerCallback(NextTaskNeededSooner callback, int scale, int flags)
          Allows the user to specify one or more callback routines that will be called when QuickTime needs tasking.
static void Movie.removeNextTaskNeededSoonerCallback(NextTaskNeededSooner callback)
          Allows the user to remove a callback from the IdleManager that no longer needs servicing.
 void Movie.setMovieAnchorDataRef(DataRef dataRef)
          To resolve relative data references, a method was needed to determine the original location from which a movie was opened or imported.
 boolean Movie.isAnchorDefaultDataRef()
          If there is no anchor data reference associated with the movie the method returns true.
 void MultiMovieController.movieChanged(Movie changedMovie)
          This method lets you inform a movie controller component that your application has used the Movie Toolbox to change the characteristics of its associated movie.
 void MultiMovieController.setMovie(Movie aMovie, QDGraphics movieWindow, QDPoint location)
          This method adds a movie to the movie controller.
 void MultiMovieController.addMovie(Movie aMovie, QDGraphics movieWindow, QDPoint location)
          This method adds a movie to the movie controller.
 void MultiMovieController.removeAllMovies()
          This method allows you to remove all of the associated movies of a controller.
 void MultiMovieController.removeAMovie(Movie movie)
          This method allows you to remove the specified movie from the controller.
 void MultiMovieController.removeMovie()
          This method allows you to remove the movie of the controller.
 void Track.removeMedia()
          Removes a track's media.
 void Track.setGWorld(QDGraphics port, GDevice gdh)
          This method sets a new QDGraphics for the track.
 void Track.setClipRgn(Region theClip)
          This method allows your application to set the clipping region of a track.
 int Track.getID()
          This method allows your application to determine a track's unique track ID value.
 int Track.getCreationTime()
          This method returns a track's creation date.
 int Track.getModificationTime()
          This method returns a track's modification date.
 boolean Track.getEnabled()
          This method allows your application to determine whether a track is currently enabled.
 void Track.setEnabled(boolean enabled)
          This method allows your application to enable and disable a track.
 int Track.getUsage()
          This method allows your application to determine whether a track is used in a movie, its preview, its poster, or a combination of these.
 void Track.setUsage(int usage)
          This method allows your application to specify whether a track is used in a movie, its preview, its poster, or a combination of these.
 int Track.getDuration()
          This method returns the duration of a track.
 int Track.getOffset()
          This method allows your application to determine the time difference between the start of a track and the start of the movie that contains the track.
 void Track.setOffset(int movieOffsetTime)
          This method modifies the duration of the empty space that lies at the beginning of the track, thus changing the duration of the entire track.
 int Track.getLayer()
          This method allows your application to retrieve a track's layer.
 void Track.setLayer(int layer)
          This method allows your application to set a track's layer.
 void Track.setAlternate(Track alternateT)
          This method allows your application to add tracks to or remove tracks from alternate groups.
 float Track.getVolume()
          This method returns a track's current volume setting.
 void Track.setVolume(float volume)
          This method allows your application to set a track's current volume.
 Matrix Track.getMatrix()
          This method allows your application to retrieve a track's transformation matrix.
 void Track.setMatrix(Matrix matrix)
          This method allows your application to establish a track's transformation matrix.
 java.awt.Dimension Track.getDimensions()
          Deprecated. since QTJava 4.0 see getSize
 void Track.setDimensions(java.awt.Dimension d)
          Deprecated. as of QTJava 4.0 see setSize
 QDDimension Track.getSize()
          This method allows your application to determine a track's source, or display, rectangle.
 void Track.setSize(QDDimension d)
          This method allows your application to establish a track's source, or display, rectangle.
 UserData Track.getUserData()
          This method allows your application to obtain access to a track's user data list.
 java.lang.String Track.getName()
          This method allows your application to obtain access to a track's 'name' user data item.
 Matrix Track.getDisplayMatrix()
          This method returns the track's display matrix.
 void Track.setSoundLocalizationSettings(QTHandle newSettings)
          This method allows your application to set the sound localization settings for the track.
 Movie Track.getMovie()
          This method allows you to determine the movie that contains a specified track.
 TimeInfo Track.getNextInterestingTime(int interestingTimeFlags, int time, float rate)
          This method searches for times of interest in a track.
 void Track.insertMedia(int trackStart, int mediaTime, int mediaDuration, float mediaRate)
          This method inserts a reference to a media segment into a track.
 void Track.insertEmptySegment(int dstIn, int dstDuration)
          This method adds an empty segment to a track.
 void Track.deleteSegment(int startTime, int duration)
          This method removes a specified segment from a track.
 void Track.scaleSegment(int startTime, int oldDuration, int newDuration)
          This method changes the duration of a segment of a track.
 void Track.useEditState(TrackEditState state)
          This method returns a track to its condition according to an edit state you created previously.
 int Track.addReference(Track refTrack, int refType)
          This method allows you to add a new track reference to a track.
 void Track.deleteReference(int refType, int index)
          This method allows you to remove a track reference from a track.
 void Track.setReference(Track refTrack, int refType, int index)
          This method allows you to modify an existing track reference.
 int Track.getNextReferenceType(int refType)
          This method allows you to determine all of the track reference types that are defined for a given track.
 int Track.getReferenceCount(int refType)
          This method allows you to determine how many track references of a given type exist for a track.
 int Track.trackTimeToMediaTime(int value)
          This method allows your application to convert a track's time value to a time value that is appropriate to the track's media using the track's edit list.
 float Track.getEditRate(int atTime)
          This method returns the rate of the track edit of a specified track at an indicated time.
 int Track.getDataSize(int startTime, int duration)
          This method allows your application to determine the size, in bytes, of the sample data in a segment of a track.
 boolean Track.pointInMovie(QDPoint pt)
          This method allows your application to determine whether a specified point lies in the region defined by a track's display boundary region after it has been clipped by the movie's final display clipping region.
 void Track.setLoadSettings(LoadSettings settings)
          This method allows you to specify a portion of a track that is to be loaded into memory whenever it is played.
 LoadSettings Track.getLoadSettings()
          This method allows you to retrieve a track's preload information.
 void Track.insertSegment(Track dstTrack, int srcIn, int srcDuration, int dstIn)
          This method copies part of one track to another.
 void Track.copySettings(Track dstTrack)
          This method copies many settings from one track to another, overwriting the destination settings.
 void Track.loadIntoRam(int time, int duration, int flags)
          This method loads a track's data into memory.
 MovieImporter Track.isScrapMovie()
          Looks on the System scrap to find out if it can translate any of the track data into a movie.
 PixMap Track.getMatte()
          A PixMap object which describes the Matte of a Track.
 void Track.setMatte(PixMap pm)
          A PixMap object which will describe the Matte of a Track.
 void Track.copyUserDataToTrack(Track destTrack, boolean replace)
          Copies the user data in the track to the destination track
 void Track.copyUserDataFromTrack(Track srcTrack, boolean replace)
          Copies the user data from the specified track into this track
static void Track.copyUserData(Track srcTrack, Track destTrack, int copyRule)
          Copies the user data from the specified track into the destination track
static AtomData AtomData.fromVectorStream(Curve c, VectorStream vectorStream, int atomType)
          This method is used to find the first atom of a specified type within a vector data stream and get its data.
 java.awt.Dimension FullScreen.getMainScreenSize()
          Deprecated. as of QTJava 4.0 see getSizeOfMainScreen
 QDDimension FullScreen.getSizeOfMainScreen()
          Returns the current size in pixels of the main screen.
 java.awt.Dimension FullScreen.getScreenSize(GDevice gd)
          Deprecated. as of QTJava 4.0 see getSizeOfScreen
 QDDimension FullScreen.getSizeOfScreen(GDevice gd)
          Returns the current size in pixels of the screen that is associated with the specified GDevice.
 java.awt.Dimension FullScreen.preflightSize(GDevice gd, int width, int height)
          Deprecated. as of QTJava 4.0 see sizeOfScreen
 QDDimension FullScreen.getPreflightSize(GDevice gd, int width, int height)
          Returns the closest size to the specified size for the specified screen.
 java.awt.Dimension FullScreen.begin(int flags)
          Deprecated. as of QTJava 4.0 see beginFullScreen
 QDDimension FullScreen.beginFullScreen(int flags)
          This method converts the main screen to full screen mode by hiding menu bars, control strips, task bars, etc.
 java.awt.Dimension FullScreen.begin(GDevice gd, int desiredWidth, int desiredHeight, int flags)
          Deprecated. as of QTJava 4.0 see beginFullScreen
 QDDimension FullScreen.beginFullScreen(GDevice gd, int desiredWidth, int desiredHeight, int flags)
          This method converts the main screen to full screen mode.
 void FullScreen.endFullScreen()
          This method converts the main screen from full screen mode to normal mode.
 void FullScreen.end()
          This method converts the main screen from full screen mode to normal mode.
 

Constructors in quicktime.std.movies that throw StdQTException
EffectsList(int minSources, int maxSources, int getOptions)
          Create an effects list from the supplied parameters.
 

Uses of StdQTException in quicktime.std.movies.media
 

Methods in quicktime.std.movies.media that throw StdQTException
static SampleDescription SampleDescription.fromMovieImporter(MovieImporter mi)
          Determines the sample description of the component.
 void SampleDescription.setSize(int size)
          Resizes the SampleDescription to the specified size.
 void Media.setSampleDescription(int index, SampleDescription descH)
          This method lets you change the contents of a particular sample description of a specified media.
 DataHandler Media.getDataHandler(int index)
          This method allows you to determine a media's data handler.
 void Media.setDataHandler(int index, DataHandler dH)
          This method allows you to assign a data handler to a media.
 MediaHandler Media.getHandler()
          This method allows you to obtain a reference to a media handler component.
 void Media.setHandler(MediaHandler mH)
          This method allows you to assign a specific media handler to a track.
 int Media.getCreationTime()
          This method returns the creation date stored in the media.
 int Media.getModificationTime()
          This method returns a media's modification date.
 int Media.getTimeScale()
          This method allows your application to determine a media's time scale.
 void Media.setTimeScale(int timeScale)
          This method allows your application to set a media's time scale.
 int Media.getDuration()
          This method returns the duration of a media.
 int Media.getLanguage()
          This method returns a media's language or region code.
 void Media.setLanguage(int language)
          This method sets a media's language or region code.
 int Media.getQuality()
          This method returns a media's quality level value.
 void Media.setQuality(int quality)
          This method sets a media's quality level value.
 HandlerInfo Media.getHandlerDescription()
          This method allows your application to retrieve information about a media handler.
 UserData Media.getUserData()
          This method allows your application to obtain access to a media's user data list.
 AtomContainer Media.getInputMap()
          This method returns you the input map of the media.
 void Media.setInputMap(AtomContainer inputMap)
          This method allows you to set a new input map for a media.
 void Media.beginEdits()
          This method starts a media-editing session.
 void Media.endEdits()
          This method ends a media-editing session.
 void Media.setDefaultDataRefIndex(int index)
          This method allows your application to determine the default index for a media.
 HandlerInfo Media.getDataHandlerDescription(int index)
          This method allows your application to retrieve information about a media's data handler.
 int Media.getSampleDescriptionCount()
          This method returns the number of sample descriptions in a media.
 int Media.getSampleCount()
          This method allows you to determine the number of samples in a media.
 int Media.getSyncSampleCount()
          This method allows you to determine the number of samples in a media.
 TimeInfo Media.sampleNumToMediaTime(int logicalSampleNum)
          This method allows you to find the time at which a specified sample plays.
 SampleTimeInfo Media.timeToSampleNum(int time)
          This method allows you to find the sample that contains the data for a specified time.
 int Media.addSample(QTHandleRef data, int dataOffset, int dataSize, int durationPerSample, SampleDescription sampleDesc, int numberOfSamples, int sampleFlags)
          This method adds sample data and a description to a media object.
 int Media.addSampleReference(int dataOffset, int dataSize, int durationPerSample, SampleDescription sampleDesc, int numberOfSamples, int sampleFlags)
          This method allows your application to work with samples that have already been added to a movie data file.
 int Media.addSampleReference(SampleDescription sampleDescription, int numOfSamples, SampleReferenceVector sampleRefs)
          Allows your application to add groups of sample references to a movie data file.
 void Media.setPreferredChunkSize(int maxChunkSize)
          This method allows your application to specify a preferred chunk size for the media.
 int Media.getPreferredChunkSize()
          This method returns the preferred chunck size for the media.
 void Media.setShadowSync(int frameDiffSampleNum, int syncSampleNum)
          This method creates an association between the indicated frame difference sample and a specified self-contained sample in a given media.
 int Media.getShadowSync(int frameDiffSampleNum)
          This method returns the sample number of the shadow sync associated with a given frame difference sample number.
 TimeInfo Media.getNextInterestingTime(int interestingTimeFlags, int time, float rate)
          This method searches for times of interest in a media.
 int Media.getDataSize(int startTime, int duration)
          This method allows your application to determine the size, in bytes, of the sample data in a media segment.
 void Media.setDataRef(int index, DataRef dataReference)
          This method changes the file that the specified media identifies as the location for its data storage.
 void Media.setDataRefAttributes(int index, int dataRefAttributes)
          No QTDocumentation.
 int Media.addDataRef(DataRef dataReference)
          This method adds a data reference to a media.
 int Media.getDataRefCount()
          This method allows your application to determine the number of data references in a media.
 void Media.setPlayHints(int flags, int flagsMask)
          This method allows your application to provide information to the Movie Toolbox that can influence playback of a single media.
 int Media.getPlayHints(int flags, int flagsMask)
          Deprecated. these arguments are not used in this call see getPlayHints()
 int Media.getPlayHints()
          This method allows your application to get information from the Movie Toolbox that determines the current state of playback of a single media.
 void Media.setPropertyAtom(AtomContainer propertyAtom)
          No QT Documentation.
 AtomContainer Media.getPropertyAtom()
          Retrieves the properties from a media handler.
 void Media.loadIntoRam(int time, int duration, int flags)
          This method loads a media's data into memory.
 void Media.copyUserDataToMedia(Media destMedia, boolean replace)
          Copies the user data in the media to the destination media
 void Media.copyUserDataFromMedia(Media srcMedia, boolean replace)
          Copies the user data from the specified media into this media
static void Media.copyUserData(Media srcMedia, Media destMedia, int copyRule)
          Copies the user data from the specified media into the destination media
 MovieMediaHandler MovieMedia.getMovieHandler()
          This method allows you to obtain a reference to a media handler component.
 void VisualMediaHandler.setGraphicsMode(GraphicsMode graphicsMode)
          Allows you to set the graphics mode and blend color of the video media handler.
 GraphicsMode VisualMediaHandler.getGraphicsMode()
          Obtain the transfer mode and blend or transparent color values.
 boolean VisualMediaHandler.getTrackOpaque()
          Determine whether the visual media of the track has opaque drawing settings in its presentation.
 int VisualMediaHandler.hitTestForTargetRefCon(int flags, QDPoint loc)
          You can use to hit test a flash, sprite, text and 3D track and get a refCon for a button or symbol that was hit.
 boolean VisualMediaHandler.hitTestTargetRefCon(int targetRefCon, int flags, QDPoint loc)
          You can use to hit test a flash, sprite, text and 3D track for a given button or symbol.
 void VisualMediaHandler.setPublicInfo(int selector, QTPointer data)
          This routine is an accessor for the media handler's public info

QuickTime:MediaSetPublicInfo

 int TextMediaHandler.addTextSample(QTPointerRef text, int fontNumber, int fontSize, int textFace, QDColor textColor, QDColor backColor, int textJustification, QDRect textBox, int displayFlags, int scrollDelay, int hiliteStart, int hiliteEnd, QDColor rgbHiliteColor, int duration)
          This method adds a single block of styled text to an existing media.
 FoundTextInfo TextMediaHandler.findNextText(QTPointerRef text, int findFlags, int startTime)
          This method searches for text with a specified media handler starting at a given time.
 void TextMediaHandler.hiliteTextSample(int sampleTime, int hiliteStart, int hiliteEnd, QDColor hiliteColor)
          This method can specify selected text to be highlighted.
 void TextMediaHandler.setDropShadowOffset(QDPoint offset)
          This method allows you to specify the shadow offset for the text media.
 void TextMediaHandler.setDropShadowTranslucency(int translucency)
          This method allows you to specify the translucency value for the text shadows.
 SoundMediaHandler SoundMedia.getSoundHandler()
          This method allows you to obtain a reference to a media handler component.
 AtomContainer ThreeDMediaHandler.getNamedObjectList()
          No QT Documentation.
 AtomContainer ThreeDMediaHandler.getRendererList()
          No QT Documentation.
 float SoundMediaHandler.getBalance()
          Returns the balance of a sound media.
 void SoundMediaHandler.setBalance(float balance)
          Sets the balance of a sound media.
 boolean SoundMediaHandler.getSoundLevelMeteringEnabled()
          Gets Sound Level Meter state (Not Documented).
 void SoundMediaHandler.setSoundLevelMeteringEnabled(boolean enabled)
          Enables Sound Level Meter (Not Documented).
 LevelMeterInfo SoundMediaHandler.getSoundLevelMeterInfo()
          Gets Sound Level Meter state (Not Documented).
 MediaEQSpectrumBands SoundMediaHandler.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 SoundMediaHandler.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 SoundMediaHandler.setSoundBassAndTreble(int bass, int treble)
          Sets Sound Bass and Treble (Not Documented).
 int[] SoundMediaHandler.getSoundBassAndTreble()
          Gets Sound Bass and Treble (Not Documented).
 int[] SoundMediaHandler.getSoundEqualizerBandLevels(int count)
          Gets SoundEqualizer BandLevels .
 TunePlayer MusicMediaHandler.getIndexedTunePlayer(int index)
          Returns the TunePlayer that is responsible for rendering the music data that is contained within a particular music track.
 MusicMediaHandler MusicMedia.getMusicHandler()
          This method allows you to obtain a reference to a media handler component.
static UserData UserData.fromGraphicsExporter(GraphicsExporter ge)
          This method allows your application to obtain access to a GraphicsExporter user data list.
static UserData UserData.fromMovie(Movie m)
          This method allows your application to obtain access to a movie's user data list.
static UserData UserData.fromSequenceGrabber(SequenceGrabber sg)
          Retrieves the current settings of all channels used by the sequence grabber.
static UserData UserData.fromSGChannel(SGChannel chan)
          Retrieves the current settings of the SequenceGrabber channel.
static UserData UserData.fromTrack(Track t)
          This method allows your application to obtain access to a track's user data list.
static UserData UserData.fromMedia(Media m)
          This method allows your application to obtain access to a media's user data list.
static UserData UserData.fromTimeCoderSource(TimeCoder timeCoder, TimeCodeDescription tcd)
          This method allows your application to obtain access to a media's user data list.
 void UserData.addData(QTHandleRef data, int udType)
          This method allows your application to add an item to a user data list.
 void UserData.removeData(int udType, int index)
          This method removes an item from a user data list.
 int UserData.countType(int udType)
          This method allows you to determine the number of items of a given type in a user data list.
 int UserData.getNextType(int udType)
          This method allows you to retrieve the next user data type in a specified user data list.
 void UserData.setDataItem(QTPointerRef data, int udType, int index)
          This method allows your application to set an item in a user data list.
 void UserData.addText(QTHandleRef data, int udType, int index, int itlRegionTag)
          This method allows your application to place language-tagged text into an item in a user data list.
 void UserData.addText(java.lang.String dataStr, int udType, int index, int itlRegionTag)
          This method allows your application to place language-tagged text into an item in a user data list.
 void UserData.removeText(int udType, int index, int itlRegionTag)
          This method allows your application to remove language-tagged text from an item in a user data list.
 void UserData.copyFromUserData(UserData destUserData, boolean replace)
          Copies the user data to the destination user data object
 void UserData.copyToUserData(UserData srcUserData, boolean replace)
          Copies the user data from the specified user data object
static void UserData.copyUserData(UserData srcUserData, UserData destUserData, int copyRule)
          Copies the user data from the specified user data object into the destination user data object
 void VideoMediaHandler.resetStatistics()
          Use the ResetVideoMediaStatistics function to reset the video media handlerŐs counters before using GetVideoMediaStatistics to determine the frame rate of a movie.
 int VideoMediaHandler.getStallCount()
          No QTDocumentation.
 float MPEGMediaHandler.getBalance()
          Returns the balance of a sound media.
 void MPEGMediaHandler.setBalance(float balance)
          Sets the balance of a sound media.
 boolean MPEGMediaHandler.getSoundLevelMeteringEnabled()
          Gets Sound Level Meter state (Not Documented).
 void MPEGMediaHandler.setSoundLevelMeteringEnabled(boolean enabled)
          Enables Sound Level Meter (Not Documented).
 LevelMeterInfo MPEGMediaHandler.getSoundLevelMeterInfo()
          Gets Sound Level Meter state (Not Documented).
 MediaEQSpectrumBands MPEGMediaHandler.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 MPEGMediaHandler.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 MPEGMediaHandler.setSoundBassAndTreble(int bass, int treble)
          Sets Sound Bass and Treble (Not Documented).
 int[] MPEGMediaHandler.getSoundBassAndTreble()
          Gets Sound Bass and Treble (Not Documented).
 int[] MPEGMediaHandler.getSoundEqualizerBandLevels(int count)
          Gets SoundEqualizer BandLevels .
 void SpriteMediaHandler.setMatrix(int spriteID, Matrix matrix)
          This method allows you to specify the Matrix property of a sprite.
 void SpriteMediaHandler.setVisible(int spriteID, boolean visible)
          This method allows you to specify the visibility property of a sprite.
 void SpriteMediaHandler.setLayer(int spriteID, int layer)
          This method allows you to specify the layer property of a sprite.
 void SpriteMediaHandler.setGraphicsMode(int spriteID, GraphicsMode gMode)
          This method allows you to specify the graphics mode property of a sprite.
 void SpriteMediaHandler.setImageIndex(int spriteID, int index)
          This method allows you to specify the image index property of a sprite.
 Matrix SpriteMediaHandler.getMatrix(int spriteID)
          This method allows you to get the matrix property of a sprite.
 boolean SpriteMediaHandler.getVisible(int spriteID)
          This method allows you to get the visibility property of a sprite.
 int SpriteMediaHandler.getLayer(int spriteID)
          This method allows you to get the layer property of a sprite.
 GraphicsMode SpriteMediaHandler.getGraphicsMode(int spriteID)
          This method allows you to get the graphics mode property of a sprite.
 int SpriteMediaHandler.getImageIndex(int spriteID)
          This method allows you to get the image index property of a sprite.
 int SpriteMediaHandler.hitTestAllSprites(int flags, QDPoint loc)
          This method allows you to receive the index of the sprite which contains a specified point.
 boolean SpriteMediaHandler.hitTestOneSprite(int spriteID, int flags, QDPoint loc)
          Perform hit testing on the sprite specified by loc.
 int SpriteMediaHandler.countSprites()
          This method returns the number of sprites contained in the media.
 int SpriteMediaHandler.countImages()
          This method returns the number of images contained in the image pool of this media.
 int SpriteMediaHandler.getDisplayedSampleNumber()
          This method returns the sample number displayed currently.
 java.lang.String SpriteMediaHandler.getSpriteName(int spriteID)
          Returns the name of the sprite with the specified ID.
 java.lang.String SpriteMediaHandler.getImageName(int imageIndex)
          Returns the name of the sprite with the specified ID.
 int SpriteMediaHandler.spriteIndexToID(int spriteIndex)
          Return the ID of the sprite specified by spriteIndex.
 short SpriteMediaHandler.spriteIDtoIndex(int spriteID)
          Return the index of the sprite specified by spriteID.
 void SpriteMediaHandler.setActionVariable(int variableID, float value)
          Sets the value of the sprite track variable with the ID of the variable to the supplied value.
 float SpriteMediaHandler.getActionVariable(int variableID)
          Returns the value of the sprite track variable with specified ID.
 void SpriteMediaHandler.setActionVariableToString(int variableID, java.lang.String theString)
          Sets the value of the sprite track variable with the ID of the variable to the supplied theString.
 java.lang.String SpriteMediaHandler.getActionVariableAsString(int variableID)
          Returns the value as String of the sprite track variable with specified ID.
 int SpriteMediaHandler.getSpriteImageGroupID(int imageIndex)
          Returns a propert value for the image specified by imageIndex.
 QDPoint SpriteMediaHandler.getSpriteImageRegistrationPoint(int imageIndex)
          Returns a propert value for the image specified by imageIndex.
 void SpriteMediaHandler.newImage(DataRef dataRef, int imageID)
          Creates a new Sprite image.
 void SpriteMediaHandler.disposeImage(int imageIndex)
          Free memory allocated for image and removes image from track.
 FlashMediaHandler FlashMedia.getFlashHandler()
          This method allows you to obtain a reference to a media handler component.
 int MovieMediaHandler.getCurrentMoviePropertyDuration()
          This method retrieves the duration of the currently instantiated embedded movie
 int MovieMediaHandler.getCurrentMoviePropertyTimeScale()
          This method gets the time scale of the currently instantiated embedded movie
 QDRect MovieMediaHandler.getCurrentMoviePropertyNaturalBounds()
          This method gets the natural bounds of the currently instantiated embedded movie
 Matrix MovieMediaHandler.getCurrentMoviePropertyMatrix()
          This method gets the matrix of the currently instantiated embedded movie
 int[] MovieMediaHandler.getCurrentMoviePropertyTrackList()
          This method returns an array of all the track IDs associated with the currently instantiated embedded movie
 int MovieMediaHandler.getCurrentTrackPropertyMediaType(int trackID)
          This method gets the media type of the currently instantiated embedded movie
 void MovieMediaHandler.setChildMovieDataReference(int dataRefID, int dataRefType, DataRef dataRef)
          This method sets the data reference of the currently instantiated embedded movie
 void MovieMediaHandler.loadChildMovieFromDataReference(int dataRefID)
          This method loads the movie associated with a specific data reference
 ThreeDMediaHandler ThreeDMedia.getThreeDHandler()
          This method allows you to obtain a reference to a media handler component.
 VideoMediaHandler VideoMedia.getVideoHandler()
          This method allows you to obtain a reference to a media handler component.
 float StreamMediaHandler.getBalance()
          Returns the balance of a sound media.
 void StreamMediaHandler.setBalance(float balance)
          Sets the balance of a sound media.
 boolean StreamMediaHandler.getSoundLevelMeteringEnabled()
          Gets Sound Level Meter state (Not Documented).
 void StreamMediaHandler.setSoundLevelMeteringEnabled(boolean enabled)
          Enables Sound Level Meter (Not Documented).
 LevelMeterInfo StreamMediaHandler.getSoundLevelMeterInfo()
          Gets Sound Level Meter state (Not Documented).
 MediaEQSpectrumBands StreamMediaHandler.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 StreamMediaHandler.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.
 int[] StreamMediaHandler.getSoundEqualizerBandLevels(int count)
          Gets SoundEqualizer BandLevels .
 void StreamMediaHandler.setSoundBassAndTreble(int bass, int treble)
          Sets Sound Bass and Treble (Not Documented).
 int[] StreamMediaHandler.getSoundBassAndTreble()
          Gets Sound Bass and Treble (Not Documented).
 StreamMediaHandler StreamMedia.getStreamHandler()
          This method allows you to obtain a reference to a media handler component.
 void MusicDescription.setTuneHeader(MusicData mh)
          Sets the MusicHeader for the TunePlayer or MusicMedia insertion.
 SpriteMediaHandler SpriteMedia.getSpriteHandler()
          This method allows you to obtain a reference to a media handler component.
static DataRef DataRef.fromSequenceGrabber(SequenceGrabber sg)
          Determines the data reference that is currently assigned to a sequence grabber component.
static DataRef DataRef.fromSGOutput(SequenceGrabber sg, SGOutput output)


QuickTime::SGGetOutputDataReference(

 DataRef DataRef.fromMovieAnchor(Movie theMovie)
          To resolve relative data references, a method was needed to determine the original location from which a movie was opened or imported.
 void FlashMediaHandler.setPan(short xPercent, short yPercent)
          Pan by a percentage.Negative xPercent pans left, positive xPercent pans right.
 void FlashMediaHandler.setZoom(short factor)
          Zoom in or out by a percentage.
 void FlashMediaHandler.setZoomRect(int left, int top, int right, int bottom)
          Zoom in on a specified sub rectangle, this becomes the "Zoom Rectangle".
 QDRect FlashMediaHandler.getRefConBounds(int refCon)
          You can use mediaHitTestForTargetRefCon() to hit test a flash track and get a refCon for a button or symbol that was hit.
 int FlashMediaHandler.getRefConID(int refCon)
          A RefCon represents a flash button or symbol at runtime.
 int FlashMediaHandler.idToRefCon(int refConID)
          A RefCon represents a flash button or symbol at runtime.
 int FlashMediaHandler.getDisplayedFrameNumber()
          Get the currently displayed Flash Frame number.
 int FlashMediaHandler.frameNumberToMovieTime(int flashFrameNumber)
          Given a Flash Frame Number, get the corresponding movieTime.
 int FlashMediaHandler.frameLabelToMovieTime(QTPointerRef theLabel)
          Given a Flash frame's label, get the corresponding movieTime.
 java.lang.String FlashMediaHandler.getFlashVariable(java.lang.String path, java.lang.String name)
          Gets the value of a specified Flash action variable
 java.lang.String FlashMediaHandler.getSupportedSwfVersion()
          Gets the SwfVersion support by the Media handler
 void FlashMediaHandler.setFlashVariable(java.lang.String path, java.lang.String name, java.lang.String value, boolean updateFocus)
          Sets the specified Flash action variable to a value
 TimeCoder TimeCodeMedia.getTimeCodeHandler()
          This method allows you to obtain a reference to a media handler component.
 TextMediaHandler TextMedia.getTextHandler()
          This method allows you to obtain a reference to a media handler component.
 

Constructors in quicktime.std.movies.media that throw StdQTException
UserData()
          This constructor creates a UserData object.
UserData(QTHandle handle)
          This constructor creates a UserData object from a handle that is in the standard user data storage format.
DataHandler(DataRef dataRef, int flags)
          This constructor creates a DataHandler object for the specified data reference.
 

Uses of StdQTException in quicktime.std.music
 

Methods in quicktime.std.music that throw StdQTException
 void AtomicInstrument.pickEditInstrument(NoteAllocator na, java.lang.String prompt, int flags)
          Presents a user interface for modifying the AtomicInstrument.
 NoteChannel AtomicInstrument.newNoteChannel(NoteAllocator na, int flags)
          Make a new note channel for an atomic instrument.
 int NoteChannel.getIndexInfo()
          Returns the index of the NoteAllocator of the MusicComponent that is used by this NoteChannel.
 int NoteChannel.getPartInfo()
          Returns the part number within the NoteChannel's MusicComponent that corresponds to this channel.
 MusicComponent NoteChannel.getMusicComponent()
          Returns the Music component in use by the note channel.
 void NoteChannel.preroll()
          Will attempt to re-allocate the note channel if it was invalid previously.
 void NoteChannel.unroll()
          Marks a note channel as available to be stolen.
 void NoteChannel.reset()
          Turns off all currently sounding notes, and resets all controllers to their default values.
 void NoteChannel.setVolume(float volume)
          Sets the volume on the note channel.
 void NoteChannel.setBalance(int balance)
          Modifies the pan controller setting for the note channel.
 void NoteChannel.playNoteRaw(int pitch, int velocity)
          Plays a musical note with given pitch and velocity.
 void NoteChannel.playNoteCents(int noteNumber, int cents, int velocity)
          Plays a musical note with given pitch and velocity.
 void NoteChannel.playNote(float pitch, int velocity)
          Plays a musical note with given pitch and velocity.
 float NoteChannel.getController(int controllerNumber)
          Retrieves the current value for the specified controller The micro controller resolution is 128 steps (kMicroControllerResolution) per semitone.
 void NoteChannel.setControllerRaw(int controllerNumber, int controllerValue)
          Changes the specified controller to the specified value.
 void NoteChannel.setController(int controllerNumber, float controllerValue)
          Changes the specified controller to the specified value.
 int NoteChannel.getKnob(int knobNumber)
          Returns the value of a knob for the note channel.
 void NoteChannel.setKnob(int knobNumber, int knobValue)
          Sets the value of a knob for the note channel.
 int NoteChannel.findTone(ToneDescription td)
          Locate the best fitting instrument number for the given ToneDescription.
 void NoteChannel.setAtomicInstrument(AtomicInstrument instrument, int flags)
          Initialises a note channel with an atomic instrument.
 void NoteChannel.setInstrumentNumber(int instrumentNumber)
          Change the instrument setting to the specified instrument number.
 void NoteChannel.pickEditInstrument(java.lang.String prompt, int flags)
          Presents a user interface for changing the instrument used by the note channel.
 void NoteChannel.sendMIDI(MusicMIDIPacket mp)
          Get the NoteRequest that corresponds to this NoteChannel.
 void NoteChannel.setSoundLocalization(SoundLocalization slData)
          Passes sound localization data to a note channel.
 SynthesizerDescription MusicComponent.getDescription()
          Returns a structure describing the synthesizer controlled by the music component device.
 AtomicInstrument MusicComponent.getPartAtomicInstrument(int part, int flags)
          Returns the AtomicInstrument that is set for that part.
 int MusicComponent.getKnob(int knobID)
          Returns the value of the specified global synthesizer knob.
 void MusicComponent.setKnob(int knobID, int knobValue)
          Sets the value of a global knob for a synthesiser.
 java.lang.String MusicComponent.getPartName(int part)
          Returns a part's name.
 void MusicComponent.setPartName(int part, java.lang.String name)
          Sets a part's name.
 void MusicComponent.setMasterTune(float masterTune)
          Sets a value in semitones, which is the synthesizerŐs master tuning.
 float MusicComponent.getMasterTune()
          Returns a value in semitones, which is the synthesizerŐs master tuning.
 KnobDescription MusicComponent.getInstrumentKnobDescrption(int knobIndex)
          Returns a Instrument knob description for the specified knob index or knob ID for the MusicComponent.
 KnobDescription MusicComponent.getDrumKnobDescrption(int knobIndex)
          Returns a Drum knob description for the specified knob index or knob ID for the MusicComponent.
 KnobDescription MusicComponent.getKnobDescrption(int knobIndex)
          Returns a knob description for the specified global knob index or knob ID for the MusicComponent.
 int NoteAllocator.numNoteChannels()
          Returns the number of NoteChannels handled by the specific NoteAllocator instance.
 NoteChannel NoteAllocator.getIndNoteChannel(int index)
          Returns a new NoteChannel as indexed into the NoteAllocator instance.
 void NoteAllocator.task()
          Call periodically to allow the note allocator to perform tasks.
 void NoteAllocator.pickArrangement(java.lang.String prompt, Track track, java.lang.String songName)
          Displays a dialog to allow instrument selection.
 void NoteAllocator.copyrightDialog(Pict p, java.lang.String author, java.lang.String copyright, java.lang.String other, java.lang.String title)
          Displays a copyright dialog with information specific to a music device.
 int NoteAllocator.numMusicComponents()
          Return the number of MusicComponents that are registered with the note allocator.
 void NoteAllocator.registerMusicDevice(int synthType, java.lang.String name, SynthesizerConnections connections)
          Registers a music component with the NoteAllocator.
 void NoteAllocator.unregisterMusicDevice(int index)
          Removes a previously registered music component from the NoteAllocator.
 MusicComponentInfo NoteAllocator.getRegisteredMusicDevice(int index)
          Return information about music components that are registered with the note allocator.
 SynthesizerConnections NoteAllocator.getDefaultMIDIInput()
          Obtain external MIDI connection information about the MIDI device that is attached to the system and selected as the default MIDI input device.
 void NoteAllocator.setDefaultMIDIInput(SynthesizerConnections sc)
          Initializes an external MIDI device that is used to receive external MIDI information.
 void NoteAllocator.saveMusicConfiguration()
          Saves the current list of registered devices to the QuickTime default file.
 void NoteAllocator.loseDefaultMIDIInput()
          Removes the external default MIDI service procedure call, if previously defined by the useDefaultMIDIInput call.
 QTMIDIPort QTMIDIPortList.getPort(int index)
          Return a port at the specified (one based) index.
static TunePlayer TunePlayer.fromMusicMediaHandler(MusicMediaHandler mh, int index)
          Returns the TunePlayer that is responsible for rendering the music data that is contained within a particular music track.
 void TunePlayer.setHeader(MusicData header)
          Prepares the tune player to accept subsequent music event sequences by defining one or more parts to be used by sequence Note events.
 TimeBase TunePlayer.getTimeBase()
          Returns the TunePlayer's current time Base.
 void TunePlayer.setTimeScale(int scale)
          Sets the time scale used by the tune player.
 int TunePlayer.getTimeScale()
          Returns the current time scale of the tune player, in units-per-second.
 int TunePlayer.getNumberOfNoteChannels()
          Returns the number of note channels that the tune player is using.
 NoteChannel TunePlayer.getIndexedNoteChannel(int index)
          Returns the note channel at the specified index.
 void TunePlayer.queue(MusicData tune, float tuneRate, int tuneStartPosition, int tuneStopPosition, int queueFlags)
          Places a sequence of music events into a queue to be played.
 void TunePlayer.instant(TuneStatus tune, int tunePosition)
          Play the sequence of music events at a specified position.
 TuneStatus TunePlayer.getStatus()
          Returns an initialised structure describing the state of the tune player.
 void TunePlayer.stop()
          Stops a currently playing sequence.
 void TunePlayer.setVolume(float volume)
          Sets the volume for the entire sequence.
 float TunePlayer.getVolume()
          Returns the volume of the sequence.
 void TunePlayer.preroll()
          Prepares the tune player by attempting to reserve note channels for each part in the sequence.
 void TunePlayer.unroll()
          Releases any note channels that may have been allocated by previous calls to preroll.
 void TunePlayer.setNoteChannels(NoteChannel[] noteChannelList)
          Prepares the tune player to accept music event sequences by allocating specified note channels for them.
 void TunePlayer.setPartTranspose(int part, float transpose, int velocityShift)
          Modifies the pitch and velocity of every note of the specified part of a tune.
 void TunePlayer.setSofter(boolean softer)
          Adjusts the volume to play at a generally softer value that was the normal value for QT 2_1, otherwise sets the volume to a normal level.
 void TunePlayer.task()
          Call this method periodically to allow the tune player to perform tasks it must perform at foreground task time.
 void TunePlayer.setBalance(int balance)
          Modifies the pan controller setting for a tune player.
 void TunePlayer.setSoundLocalization(SoundLocalization data)
          Passes sound localisation data to the tune player.
 void TunePlayer.setHeaderWithSize(MusicData header, int size)
          Prepares the tune player to accept subsequence music events by defining one or more parts to be used.
 void TunePlayer.setPartMix(int partNumber, float volume, float balance, int mixFlags)
          Alters the volume and the balance of the specified part, with the flags specifying special conditions.
 MixStateInfo TunePlayer.getPartMix(int partNumber)
          Returns the current state of a part in a mix, its volume, balance, and mute/solo state.
 void ToneDescription.stuff(NoteAllocator na, int gmNumber)
          Initializes the calling ToneDescription instance with the details of the note channel specified by the gmNumber.
 void ToneDescription.pickInstrument(NoteAllocator na, java.lang.String prompt, int flags)
          Initialises the tone description structure through providing the user with a dialog that allows the user to choose the instrument.
 

Constructors in quicktime.std.music that throw StdQTException
ToneDescription(NoteAllocator na, int gmNumber)
          Initializes the ToneDescription instance with the appropriate instrument based on the specified gmNumber.
 

Uses of StdQTException in quicktime.std.qtcomponents
 

Methods in quicktime.std.qtcomponents that throw StdQTException
 int XMLElement.getIdentifier()
          get tokenized identifier of the element
 java.lang.String XMLElement.getName()
          get the name of the element if element was not recognized by the parser
 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
 void CompressionDialog.requestSettings()
          Displays the standard dialog box to the user for a single image or for sound.
 void CompressionDialog.setInfoState(QTHandleRef settings)
          Sets all of the settings for a dialog.
 void CompressionDialog.setInfoPreferences(int flags)
          Sets the current preferences for a dialog.
 int CompressionDialog.getInfoPreferences()
          Retrieves the current preferences for a dialog.
 AtomContainer CompressionDialog.getSettings()
          Retrieves the current configuration from the dialog

QuickTime__SCGetSettingsFromAtomContainer()

 void CompressionDialog.setInfoState(AtomContainer settings)
          Deprecated.  
 void CompressionDialog.setSettings(AtomContainer settings)
          Sets the current configuration for a dialog.
 void ImageCompressionDialog.defaultPixMapSettings(PixMap src, boolean motion)
          Allows you to derive default compression settings for an image that is stored in a pixel map.
 void ImageCompressionDialog.defaultPictSettings(Pict src, boolean motion)
          Allows you to derive default compression settings for an image that is stored in a Pict.
 void ImageCompressionDialog.defaultPictFileSettings(OpenFile src, boolean motion)
          Allows you to derive default compression settings for an image that is stored in a Pict File.
 void ImageCompressionDialog.requestImageSettings()
          Displays the standard dialog box to the user for a single image or for sound.
 void ImageCompressionDialog.requestSequenceSettings()
          Displays the standard dialog box to the user for a sequence of images.
 void ImageCompressionDialog.setInfoSpatialSettings(SpatialSettings settings)
          Sets the current spatial settings for a dialog.
 SpatialSettings ImageCompressionDialog.getInfoSpatialSettings()
          Gets the current spatial settings for a dialog.
 void ImageCompressionDialog.setInfoTemporalSettings(TemporalSettings settings)
          Sets the current temporal settings for a dialog.
 TemporalSettings ImageCompressionDialog.getInfoTemporalSettings()
          Gets the current temporal settings for a dialog.
 void ImageCompressionDialog.setInfoDataRateSettings(DataRateSettings settings)
          Sets the current data rate settings for a dialog.
 DataRateSettings ImageCompressionDialog.getInfoDataRateSettings()
          Gets the current data rate settings for a dialog.
 void ImageCompressionDialog.setInfoColorTable(ColorTable ctab)
          Sets the current color table or null to clear the current color table for a dialog.
 void ImageCompressionDialog.setTestImagePict(Pict testPict, QDRect testRect, int testFlags)
          Sets the dialog box's test image from a Pict.
 void ImageCompressionDialog.setTestImagePictFile(OpenFile testPict, QDRect testRect, int testFlags)
          Sets the dialog box's test image from a Pict file.
 void ImageCompressionDialog.setTestImagePixMap(PixMap testPixMap, QDRect testRect, int testFlags)
          Sets the dialog box's test image from a PixMap.
 void ImageCompressionDialog.setCompressFlags(int flags)
          Sets the compression flags.
 int ImageCompressionDialog.getCompressFlags()
          Gets the compression flags.
 float SoundCompressionDialog.getInfoSampleRate()
          Retrieves the current sample rate for a dialog.
 void SoundCompressionDialog.setInfoSampleRate(float rate)
          Sets the current sample rate for a dialog.
 int SoundCompressionDialog.getInfoSampleSize()
          Retrieves the current sample size for a dialog.
 void SoundCompressionDialog.setInfoSampleSize(int size)
          Sets the current sample size for a dialog.
 int SoundCompressionDialog.getInfoChannelCount()
          Retrieves the current channel count for a dialog.
 void SoundCompressionDialog.setInfoChannelCount(int n)
          Sets the current channel count for a dialog.
 void SoundCompressionDialog.setInfoCompression(int compType)
          Sets the current compression type for a dialog.
 int SoundCompressionDialog.getInfoCompression()
          Retrieves the current compression type for a dialog.
 void SoundCompressionDialog.setInfoCompressionList(int[] compTypes)
          Sets the current list of compression types for a dialog.
 int[] SoundCompressionDialog.getInfoCompressionList()
          Retrieves the current compression type list for a dialog.
 int XMLContent.getKind()
          get type of content
 java.lang.String XMLContent.getString()
          get string kind content
 void DataCodecDecompressor.decompress(QTPointerRef srcData, QTPointerRef dstData)
          The DataCodecDecompress function decompresses data using the specified compressor component.
 DataCodecInfo DataCodecCompressor.compress(QTPointerRef srcData, QTPointerRef dstData)
          Compress the specified data.
 int DataCodecCompressor.getCompressBufferSize(int srcSize)
          Returns the estimated maximum size of compressing the specified size bytes using this compressor.
 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.
 int XMLParser.addElement(java.lang.String elementName, int nameSpaceID, int elementID, int elementFlags)
          tell the parser of an element to be recognized in the specified namespace
 int XMLParser.addAttribute(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID)
          tell the parser of an attribute for the specified element in the specified namespace
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, int attributeValueKind, byte[] attributeValueKindInfo)
          tell the parser that the particular attribute of an element may have an additional kind of value, as specified by attributeValueKind and attributeValueKindInfo
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, java.lang.String attributeStringValue)
          tell the parser of an enumerated attribute, of type attributeValueKindCharString, for the specified element
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, int attributeValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindInteger value, as specified by attributeValueKind and attributeValueKindInfo
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, float attributePercentValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindPercent value, as specified by attributeValueKind and attributeValueKindInfo
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, boolean attributeBooleanValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindBoolean value, as specified by attributeValueKind and attributeValueKindInfo
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, byte attributeOnOffValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindOnOff value, as specified by attributeValueKind and attributeValueKindInfo
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, QDColor attributeColorValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindColor value, as specified by attributeValueKind and attributeValueKindInfo
 void XMLParser.addAttributeValueKind(int elementID, int attributeID, java.lang.String[] attributeList, boolean caseSensitive)
          tell the parser of an enumerated attribute, of type attributeValueKindEnum or attributeValueKindCaseSensEnum, for the specified element
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, int attributeValueKind, byte[] attributeValueKindInfo)
          tell the parser of an attribute, which may have a particular type of value, for the specified element
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, java.lang.String attributeValue)
          tell the parser of an attribute, of type attributeValueKindCharString, for the specified element
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, int attributeIntegerValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindInteger value, as specified by attributeValueKind and attributeValueKindInfo
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, float attributePercentValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindPercent value, as specified by attributeValueKind and attributeValueKindInfo
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, boolean attributeBooleanValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindBoolean value, as specified by attributeValueKind and attributeValueKindInfo
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, byte attributeOnOffValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindOnOff value, as specified by attributeValueKind and attributeValueKindInfo
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, QDColor attributeColorValue)
          tell the parser that the particular attribute of an element may have an additional attributeValueKindColor value, as specified by attributeValueKind and attributeValueKindInfo
 int XMLParser.addAttributeAndValue(int elementID, int nameSpaceID, java.lang.String attributeName, int attributeID, java.lang.String[] attributeList, boolean caseSensitive)
          tell the parser of an enumerated attribute, of type attributeValueKindEnum or attributeValueKindCaseSensEnum, for the specified element
 void XMLParser.addNameSpace(int nameSpaceID, java.lang.String nameSpaceURL)
          tell the parser of a namespace to be recognized
 int XMLParser.addNameSpace(java.lang.String nameSpaceURL)
          tell the parser of an identified namespace to be recognized
 void XMLParser.setOffsetAndLimit(int offset, int limit)
          specify the offset and limit for reading from the dataref to be used when parsing
 void XMLParser.setStartDocumentHandler(XMLStartDocProc proc)
          Set the callback handler for start document events
 void XMLParser.removeStartDocumentHandler()
          Remove the currently registered callback handler for start document events
 void XMLParser.setEndDocumentHandler(XMLEndDocProc proc)
          Set the callback handler for end document events
 void XMLParser.removeEndDocumentHandler()
          Remove the currently registered callback handler for end document events
 void XMLParser.setStartElementHandler(XMLStartElementProc proc)
          set the start element handler UPP for event parsing
 void XMLParser.removeStartElementHandler()
          Remove the currently registered start element proc.
 void XMLParser.setEndElementHandler(XMLEndElementProc proc)
          set the end element handler UPP for event parsing
 void XMLParser.removeEndElementHandler()
          Remove the currently registered end element proc.
 void XMLParser.setCommentHandler(XMLCommentProc proc)
          Set the callback handler for comment events
 void XMLParser.removeCommentHandler()
          Remove the currently registered callback handler for comment events
 void XMLParser.setCharDataHandler(XMLCharDataProc proc)
          Set the callback handler for character data events
 void XMLParser.removeCharDataHandler()
          Remove the currently registered callback handler for character data events.
 void XMLParser.setPreprocessorHandler(XMLPreprocessorProc proc)
          Set the callback handler for preprocessor instruction events
 void XMLParser.removePreprocessorHandler()
          Remove the currently registered callback handler for preprocessor instruction events
 int XMLParser.getParseErrorLine()
          Returns the line number the error if a file failed to parse properly
 java.lang.String XMLParser.getParseErrorDescription()
          Returns a more detailed description of the error if a file failed to parse properly
static TimeCoder TimeCoder.fromMedia(TimeCodeMedia m)
          This method allows you to obtain a reference to a media handler component.
 java.lang.String TimeCoder.timeCodeToString(TimeCodeDef tcdef, TimeCodeTime tct)
          Converts a time value into a string (HH:MM:SS:FF) - if the timecode uses a drop frame technique the separators are semi-colons (HH;MM;SS;FF).
 java.lang.String TimeCoder.timeCodeToString(TimeCodeDef tcdef, int counter)
          Converts a time value into a string (HH:MM:SS:FF) - if the timecode uses a drop frame technique the separators are semi-colons (HH;MM;SS;FF).
 int TimeCoder.toFrameNumber(TimeCodeTime tcrec, TimeCodeDef tcdef)
          Converts a time value into a frame number using specified definitions.
 TimeCodeTime TimeCoder.toTimeCode(int frameNumber, TimeCodeDef tcdef)
          Converts a frame number into a time value using specified definitions.
 void TimeCoder.setSourceRef(TimeCodeDescription tcd, QTHandleRef sref)
          Allows you to change the source information in the media sample.
 void TimeCoder.setUserDataSourceRef(TimeCodeDescription tcd, UserData udata)
          Allows you to change the source information in the media sample.
 void TimeCoder.setFlags(int flags, int flagsMask)
          Allows you to change the flags that affect how QT handles the timecode information.
 int TimeCoder.getFlags()
          Allows you to retrieve the timecode control flags.
 void TimeCoder.setDisplayOptions(TCTextOptions textOptions)
          Sets the current display options for text by the TimeCoder.
 TCTextOptions TimeCoder.getDisplayOptions()
          Returns the current display options for text by the TimeCoder.
static MovieImporter MovieImporter.fromTrack(Track t)
          Looks on the System scrap to find out if it can translate any of the track data into a movie.
 void MovieImporter.setSampleDuration(int duration, int scale)
          Specifies the duration for the component.
 void MovieImporter.setSampleDescription(SampleDescription desc, int mediaType)
          Specifies the SampleDescription and media type for the component.
 void MovieImporter.setDimensions(float width, float height)
          Specifies the dimensions for the component.
 void MovieImporter.setChunkSize(int chunkSize)
          Specifies the size to allocate for the component.
 void MovieImporter.setProgressProc(MovieProgress mp)
          This method establishes a MovieProgress object for the MovieImporter that will be called for you by the Movie Toolbox whenever it has to do a lengthy movie import process with this MovieImporter

QuickTime::MovieImportSetProgressProc

 void MovieImporter.removeProgressProc()
          This method removes a MovieProgress callback for the MovieImporter.
 void MovieImporter.setAuxiliaryData(QTHandleRef data, int handleType)
          Specifies the handle and its type for the component.
 void MovieImporter.setFromScrap(boolean fromScrap)
          Specifies the scrap for the component.
 void MovieImporter.setDuration(int duration)
          Specifies the duration for the component.
 int MovieImporter.getAuxiliaryDataType()
          Determines the data type for the component.
 int MovieImporter.getFileType()
          Determines the file type for the component.
 SampleDescription MovieImporter.getSampleDescription()
          Determines the sample description of the component.
 int MovieImporter.getMediaType()
          Determines the media type of the component.
 AtomContainer MovieImporter.getMIMETypeList()
          Returns a list of MIME types supported by the movie import component.
 void MovieImporter.setOffsetAndLimit(int offset, int limit)
          NO QT DOCUMENTATION.
 void MovieImporter.setImportSettingsFromAtomContainer(AtomContainer settings)
          Sets the movie import componentŐs current configuration from the passed settings data.
 AtomContainer MovieImporter.getImportSettingsFromAtomContainer()
          Retrieves the current settings from the movie import component..
 void MovieExporter.setProgressProc(MovieProgress mp)
          This method establishes a MovieProgress object for the MovieExporter that will be called for you by the Movie Toolbox whenever it has to do a lengthy movie export process with this MovieExporter

QuickTime::MovieExportSetProgressProc

 void MovieExporter.toDataRef(DataRef dataRef, Movie theMovie, Track onlyThisTrack, int startTime, int duration)
          Exports the movie's track data to the specified data reference for the movie export component.
 int MovieExporter.getAuxiliaryData(QTHandle dataH)
          Determines the data type for the component.
 void MovieExporter.setSampleDescription(SampleDescription desc, int mediaType)
          Specifies the SampleDescription and media type for the component.
 boolean MovieExporter.doUserDialog(Movie theMovie, Track onlyThisTrack, int startTime, int duration)
          Determines the data reference handle for the movie export component.
 int MovieExporter.getCreatorType()
          Determines the file type creator for the component.
 boolean MovieExporter.validate(Movie theMovie, Track onlyThisTrack)
          Use this method to determine whether the movie or track could be exported by this exporter.
 AtomContainer MovieExporter.getExportSettingsFromAtomContainer()
          Retrieves the current settings from the movie export component..
 void MovieExporter.setExportSettingsFromAtomContainer(AtomContainer settings)
          Sets the movie export componentŐs current configuration from the passed settings data.
 int MovieExporter.getExportFileNameExtension()
          Gets the movie export components current FileNameExtension.
 java.lang.String MovieExporter.getExportShortFileTypeString()
          No Documentation.
 int MovieExporter.getExportSourceMediaType()
          This routine returns an OSType value through its mediaType parameter, which is interpreted in exactly the same way that the componentManufacturer was previously interpreted.
 void XMLDoc.dispose()
          Disposes of a XMLDoc parse tree
 XMLElement XMLDoc.getRootElement()
          get the root element of the xml parse tree
 int XMLAttribute.getIdentifier()
          returns the tokenized identifier of the XMLAttribute if the attribute name was recognized by the parser
 java.lang.String XMLAttribute.getName()
          returns the attribute name of the XMLAttribute if not recognized by the parser
 int XMLAttribute.getValueKind()
          returns the valueKind of the XMLAttribute should be called before a getter for a particular type
 java.lang.String XMLAttribute.getValueString()
          returns the valueString of the XMLAttribute always available
 java.lang.String XMLAttribute.getCharString()
          returns the string of the XMLAttribute for valueKind attributeValueKindCharString
 int XMLAttribute.getInteger()
          returns the int value of the XMLAttribute for valueKind attributeValueKindInteger
 int XMLAttribute.getPercent()
          *jcs* Is this a integer percent or some weird Fixed / float rep ??? returns the percent value of the XMLAttribute for valueKind attributeValueKindPercent
 boolean XMLAttribute.getBoolean()
          returns the boolean value of the XMLAttribute for valueKind attributeValueKindBoolean
 boolean XMLAttribute.getOnOff()
          returns the boolean value of the XMLAttribute for valueKind attributeValueKindOnOff
 QDColor XMLAttribute.getRGBColor()
          returns a QDColor of the XMLAttribute for value kind attributeValueKindColor
 int XMLAttribute.getEnum()
          returns the enumerated value of the XMLAttribute for value kind attributeValueKindEnum or
 

Uses of StdQTException in quicktime.std.sg
 

Methods in quicktime.std.sg that throw StdQTException
 SGDeviceName SGDeviceList.getDeviceName(int whichOne)
          Returns the device name at the specified (0-based) index.
 void SGChannel.settingsDialog()
          Instructs the sequence grabber to display its settings dialog box to the user.
 void SGChannel.settingsDialog(int flags, Component[] panelList)
          Instructs the sequence grabber to display its settings dialog box to the user.
 void SGChannel.setDataSourceName(java.lang.String name, int scriptTag)
          Set the source identification information associated with a sequence grabber channel.
 SGDataSourceInfo SGChannel.getDataSourceName()
          Get the source identification information associated with a sequence grabber channel.
 void SGChannel.setSettings(UserData ud)
          Configure a SequenceGrabber channel based on the UserData passed in.
 UserData SGChannel.getSettings()
          Retrieves the current settings of the SequenceGrabber channel.
 void SGChannel.setUsage(int usage)
          Specifies how a channel is to be used by the SequenceGrabber component.
 int SGChannel.getUsage()
          Returns how the channel is being used by the SequenceGrabber component.
 void SGChannel.setPlayFlags(int playFlags)
          Allows you to influence the speed and quality with which the sequence grabber displays data from a channel.
 int SGChannel.getPlayFlags()
          Allows you to get the speed and quality with which the sequence grabber displays data from a channel.
 void SGChannel.setDevice(java.lang.String name)
          The method allows the sequence grabber to assign a device to your channel.
 SGDeviceList SGChannel.getDeviceList(int selectionFlags)
          Get the list of currently available Sound Input Driver names.
 int SGChannel.getTimeScale()
          This method allows you to retrieve a channelŐs time scale.
 void SGChannel.setOutput(SGOutput output)


QuickTime::SGSetChannelOutput

 void VisualChannel.setBounds(QDRect bounds)
          Allows you to specify a channel's display boundary rectangle.
 QDRect VisualChannel.getBounds()
          Allows you to get a channel's display boundary rectangle.
 void VisualChannel.setClip(Region theClip)
          Allows you to set a channel's clipping region.
 void VisualChannel.setMatrix(Matrix m)
          Allows you to set a channel's display transformation matrix.
 Matrix VisualChannel.getMatrix()
          Allows you to get a channel's display transformation matrix.
 void SGVideoChannel.setCompressorType(int compressorType)
          Set the type of Video Compressor

QuickTime::SGSetVideoCompressorType QuickTime::SGSetVideoCompressorType

 int SGVideoChannel.getCompressorType()
          Get the Video Compressor Type

QuickTime::SGGetVideoCompressorType QuickTime::SGGetVideoCompressorType

 void SGVideoChannel.setCompressor(int depth, int compressor, int spatialQuality, int temporalQuality, int keyFrameRate)
          Deprecated. see setCompressor which takes a Compressor parameter
 void SGVideoChannel.setCompressor(int depth, Compressor compressor, int spatialQuality, int temporalQuality, int keyFrameRate)
          Set a channelŐs current image-compression parameters.
 SGVideoCompressorInfo SGVideoChannel.getCompressor()
          Get a channelŐs current image-compression parameters.
 void SGVideoChannel.setDigitizerComponent(VideoDigitizer vdig)
          Allows you to assign a video digitizer component to a video channel.
 void SGVideoChannel.digitizerChanged()
          Allows you to notify the sequence grabber component whenever you change the configuration of a video channel's video digitizer.
 void SGVideoChannel.setVideoRect(QDRect r)
          Allows you to specify the portion of the source video image that is to be captured.
 QDRect SGVideoChannel.getVideoRect()
          Allows you to determine the portion of the source video image that is to be captured.
 QDRect SGVideoChannel.getSrcVideoBounds()
          Allows you to determine the size of the source video boundary rectangle.
 void SGVideoChannel.setFrameRate(float frameRate)
          The SGSetFrameRate function allows you to specify a video channelŐs frame rate for recording.
 float SGVideoChannel.getFrameRate()
          The SGGetFrameRate function allows you to retrieve a video channelŐs frame rate for recording.
 void AudioChannel.setVolume(float volume)
          Allows you to set a channel's sound volume setting.
 float AudioChannel.getVolume()
          Allows you to determine a channel's sound volume setting.
 void SGSoundChannel.setSoundInputParameters(int sampleSize, int numChannels, int compressionType)
          Set some parameters that relate to sound recording.
 SGChannelInfo SGSoundChannel.getSoundInputParameters()
          Get some parameters that relate to the current sound recording.
 void SGSoundChannel.setSoundInputRate(float rate)
          Set the Sound Input Rate

QuickTime::SGSetSoundInputRate QuickTime::SGSetSoundInputRate

 float SGSoundChannel.getSoundInputRate()
          Get the Sound Input Rate

QuickTime::SGGetSoundInputRate QuickTime::SGGetSoundInputRate

 SPBDevice SGSoundChannel.getInputDriver()
          Get the Sound Input Driver.
 void SGSoundChannel.setRecordChunkSize(int seconds)
          Set the buffer size for sound recording in seconds

QuickTime::SGSetSoundRecordChunkSize QuickTime::SGSetSoundRecordChunkSize

 int SGSoundChannel.getRecordChunkSize()
          Get the buffer size (in seconds) of the record buffer

QuickTime::SGGetSoundRecordChunkSize QuickTime::SGGetSoundRecordChunkSize

 void SGSoundChannel.setInputDriver(java.lang.String driverName)
          Set the Sound Input Driver, Automatically calls SGSoundInputDriverChanged

QuickTime::SGSetSoundInputDriver QuickTime::SGSetSoundInputDriver



QuickTime::SGSoundInputDriverChanged QuickTime::SGSoundInputDriverChanged

 int VideoDigitizer.getNumberOfInputs()
          Returns the number of input sources that a video digitizer component supports.
 void VideoDigitizer.setInput(int input)
          Allows applications to select an input video source for a video digitizer component.
 int VideoDigitizer.getInput()
          Returns the index that identifies the currently active input video source.
 void VideoDigitizer.setClipRgn(Region clipRegion)
          Allows you to define a clipping region.
 void VideoDigitizer.clearClipRgn(Region clipRegion)
          Allows you to disable all or part of a clipping region that was previously set.
 void VideoDigitizer.setClipState(boolean clipEnable)
          Allows your application to control whether clipping is enabled or disabled.
 boolean VideoDigitizer.getClipState()
          Allows your application to determine if clipping is enabled or not.
 DigitizerInfo VideoDigitizer.getDigitizerInfo()
          Allows your application to determine the capability and status information about a specified video digitizer component.
 int VideoDigitizer.getInputFormat(int input)
          Determines the format of the video signal provided by a specified video input source.
 void VideoDigitizer.setInputStandard(int input)
          Specifies the input signaling standard to digitize.
 ToneDescription SGMusicChannel.getInstrument()
          Gets the Instrument associates with a particular channel.
 void SGMusicChannel.setInstrument(ToneDescription td)
          Sets the Instrument associates with a particular channel.
 void SequenceGrabber.setGWorld(QDGraphics port, GDevice gdh)
          Establishes the graphics port and device for a sequence grabber.
 QDGraphics SequenceGrabber.getGWorld()
          Returns the QDGraphics of the sequence grabber.
 GDevice SequenceGrabber.getGWorldDevice()
          Returns the current device of the sequence grabber.
 void SequenceGrabber.disposeChannel(SGChannel c)
          Removes a channel from a sequence grabber component.
 SGOutput SequenceGrabber.newOutput(DataRef dataRef, int whereFlags)
          The SGNewOutput function creates a new sequence grabber output.
 void SequenceGrabber.writeExtendedMovieData(SGChannel c, int p, int len, long offset, SGOutput sgOut)
          Allows your channel component to add data to a movie.
 void SequenceGrabber.startPreview()
          Instructs the sequence grabber to begin processing data from its channels.
 void SequenceGrabber.startRecord()
          Instructs the sequence grabber component to begin collecting data from its channels.
 void SequenceGrabber.idle()
          Provides processing time to the sequence grabber component and its channel components.
 boolean SequenceGrabber.idleMore()
          Provides processing time to the sequence grabber component and its channel components.
 void SequenceGrabber.update(Region updateRgn)
          The SGUpdate function allows you to tell the sequence grabber that it must refresh its display.
 void SequenceGrabber.stop()
          Stops a preview or record operation.
 void SequenceGrabber.pause(int pause)
          You can suspend or restart a record or preview operation by calling the pause function.
 int SequenceGrabber.getPause()
          Specifies control information about the current operation to the sequence grabber component.
 void SequenceGrabber.prepare(boolean prepareForPreview, boolean prepareForRecord)
          Instructs the sequence grabber to get ready to begin a preview or record operation.
 void SequenceGrabber.release()
          Instructs the sequence grabber to release any system resources it allocated previously.
 void SequenceGrabber.setSettings(UserData ud)
          Configures a sequence grabber.
 UserData SequenceGrabber.getSettings()
          Retrieves the current settings of all channels used by the sequence grabber.
 void SequenceGrabber.setDataRef(DataRef dataRef, int whereFlags)
          Determines control information flags for the current operation.
 DataRef SequenceGrabber.getDataRef()
          Determines the data reference that is currently assigned to a sequence grabber component.
 int SequenceGrabber.getDataRefFlags()
          Determines the data reference flags that control the record operation.
 void SequenceGrabber.setMaximumRecordTime(int ticks)
          Allows you to set the time limit for recording.
 int SequenceGrabber.getMaximumRecordTime()
          Allows you to retrieve the time limit you have set for recording.
 int SequenceGrabber.getStorageSpaceRemaining()
          Allows you to monitor the amount of space remaining for use during a record operation.
 int SequenceGrabber.getTimeRemaining()
          Allows you to obtain an estimate of the amount of recording time that remains for the current recording operation.
 boolean SequenceGrabber.isPreviewMode()
          Determines whether the particular sequence grabber is in preview mode.
 boolean SequenceGrabber.isRecordMode()
          Determines whether the particular sequence grabber is in Record mode.
 TimeBase SequenceGrabber.getTimeBase()
          Returns the SequenceGrabbers's current time Base.
 int SequenceGrabber.getIndChannelType(int index)
          Allows you to obtain info on the channel type currently in use by a sequence grabber component.
 void SequenceGrabber.setDataProc(SGDataProc proc)
          Specify a data function for use by the sequence grabber.
 void SequenceGrabber.removeDataProc()
          Remove the currently registered data proc.
 void SGOutput.setMaximumOffset(long maxOffset)


QuickTime::SGSetOutputMaximumOffset

 long SGOutput.getMaximumOffset()


QuickTime::SGGetOutputMaximumOffset

 void SGOutput.setOutputFlags(int whereFlags)


QuickTime::SGSetOutputFlags

 void SGOutput.setChannel(SGChannel c)


QuickTime::SGSetChannelOutput

 long SGOutput.getDataStorageSpaceRemaining()


QuickTime::SGGetDataOutputStorageSpaceRemaining

 SGOutput SGOutput.getNextOutput()


QuickTime::SGGetOutputNextOutput(

 void SGOutput.setNextOutput(SGOutput nextOutput)


QuickTime::SGSetOutputNextOutput(

 DataRef SGOutput.getDataReference()


QuickTime::SGGetOutputDataReference(

 void SGTextChannel.setFontName(java.lang.String fontName)
          sets the name of the font to be used to display text.
 void SGTextChannel.setFontSize(int fontSize)
          sets the size of the font to be used to display text.
 void SGTextChannel.setForeColor(QDColor theColor)
          sets foreground text color.
 void SGTextChannel.setBackColor(QDColor theColor)
          sets background text color.
 void SGTextChannel.setJustification(int just)
          sets text justification.
 int SGTextChannel.getReturnToSpaceValue()
          Gets the text return to space value.
 void SGTextChannel.setReturnToSpaceValue(int rettospace)
          Sets the text return to space value.
 

Constructors in quicktime.std.sg that throw StdQTException
SGVideoChannel(SequenceGrabber owner)
          Creates a sequence grabber channel and assigns a channel component to the channel.
SGSoundChannel(SequenceGrabber owner)
          Creates a sequence grabber channel and assigns a channel component to the channel.
SGMusicChannel(SequenceGrabber owner)
          Creates a sequence grabber music channel and assigns a channel component to the channel.
SGOutput(SequenceGrabber owner, DataRef dataRef, int whereFlags)
          The SGNewOutput function creates a new sequence grabber output.
SGTextChannel(SequenceGrabber owner)
          Creates a sequence grabber channel text and assigns a channel component to the channel.
 

Uses of StdQTException in quicktime.util
 

Methods in quicktime.util that throw StdQTException
static QTHandle QTHandle.fromImageDescription(ImageDescription sd, int idType, int index)
          Retrieve application specific info from a ImageDescription object

QuickTime::GetImageDescriptionExtension QuickTime::GetImageDescriptionExtension

static QTPointerRef QTPointer.fromGraphicsExporter(GraphicsExporter ge)
          The buffer that contains the sound data.
static RawEncodedImage RawEncodedImage.fromSprite(Sprite s)
          This method gets the image data property of this sprite.