Uses of Class
quicktime.qd.QDGraphics

Packages that use QDGraphics
quicktime.qd   
quicktime.std.anim   
quicktime.std.image   
quicktime.std.movies   
quicktime.std.qtcomponents   
quicktime.std.sg   
quicktime.streaming   
quicktime.util   
quicktime.vr   
 

Uses of QDGraphics in quicktime.qd
 

Fields in quicktime.qd declared as QDGraphics
static QDGraphics QDGraphics.scratch
          This holds a reference to the scratchGWorld that you can use manually in calls such as Movie.setGWorld.
static QDGraphics QDGraphics.validScratch
          This holds a reference to the scratchGWorld that you can use as a temporary destination graphics and still be considered as a valid destination graphics by QTDrawable objects.
 

Methods in quicktime.qd that return QDGraphics
static QDGraphics QDGraphics.fromGraphicsExporter(GraphicsExporter ge)
          Call this method to obtain the QDGraphics of the object.
static QDGraphics QDGraphics.getPort()
          Returns the current QDGraphics.
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 QDGraphics QDGraphics.fromNativeGraphics(quicktime.qd.WinNativeGraphics ng)
          This will return a QDGraphics object from a native graphics object

QuickTime::GetNativeWindowPort
static QDGraphics QDGraphics.fromNativeGraphics(quicktime.qd.MacNativeGraphics ng)
          This will return a QDGraphics object from a native graphics object
abstract  QDGraphics NativeGraphics.getGWorld()
          This returns the QDGraphics that represents the native drawing surface that you get from java.
 

Methods in quicktime.qd with parameters of type QDGraphics
static Pict Pict.thumbnailFromQDGraphics(QDGraphics qd, QDRect src, int colorDepth)
          Creates an 80-by-80 pixel thumbnail picture from the pixmap associated with this QDGraphics.
static Pict Pict.open(QDGraphics port, OpenCPicParams params)
          Use OpenCPicture to begin defining a picture, collecting all of your subsequent drawing commands in this record.
 void Pict.draw(QDGraphics cg, QDRect frameRect)
          To draw a picture on any type of output device.
 void Pict.drawTrimmed(QDGraphics cg, QDRect frameRect, Region trimMask, int doDither)
          Allows the drawing of an image that is stored as a picture.
 void QDDrawer.draw(QDGraphics g)
          A class can draw efficiently on the supplied QDGraphics when this method is called on the QDDrawer object by the QDGraphics.beginDraw method.
static PixMap PixMap.fromQDGraphics(QDGraphics g)
          A PixMap object which describes the pixels in the QDGraphics.
static Region Region.fromMovieControllerWindow(MovieController mc, QDGraphics window)
          This method allows your application to determine the window region that is actually in use by a controller and its movie.
 void Region.open(QDGraphics graphics)
          Begins the recording of lines or frames in the specified QDGraphics that when closed will define a Region.
 

Constructors in quicktime.qd with parameters of type QDGraphics
SetGWorld(QDGraphics cg)
          Deprecated. QuickDraw uses a global "current graphics context".
SetGWorld(QDGraphics cg, GDevice gdh)
          Deprecated. QuickDraw uses a global "current graphics context".
Polygon(QDGraphics g)
          Allocates a new empty Polygon.
 

Uses of QDGraphics in quicktime.std.anim
 

Constructors in quicktime.std.anim with parameters of type QDGraphics
SpriteWorld(QDGraphics port, QDGraphics spriteLayer, QDColor backgroundColor, QDGraphics background)
          This constructor creates a new sprite world.
 

Uses of QDGraphics in quicktime.std.image
 

Methods in quicktime.std.image that return QDGraphics
 QDGraphics GraphicsExporter.getInputGWorld()
          Determines the QDGraphics that is the source for input images to graphics export component.
 QDGraphics CSequence.prevBuffer()
          This method determines the location of the previous image buffer allocated by the compressor.
 QDGraphics ImageDescription.newGWorld(int flags)
          Creates an offscreen QDGraphics object from the width, height, depth, and color table of a specified image description structure.
 QDGraphics GraphicsImporter.getGWorld()
          Call this method to obtain the QDGraphics of the object.
 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.
 

Methods in quicktime.std.image with parameters of type QDGraphics
 void GraphicsExporter.setInputGWorld(QDGraphics gworld)
          Sets the QDGraphics as the source for input images to graphics export component.
 void GraphicsExporter.setInputPixmap(QDGraphics gworld)
          Sets the QDGraphics as the source for input images to graphics export component.
 void GraphicsExporter.drawInputImage(QDGraphics gw, QDRect srcRect, QDRect destRect)
          Used by format-specific graphics exporters, especially when doing standalone export: Draws a rectangular portion of the input image.
 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.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.
static QTImage ImageDescription.fromImageCompressionDialog(ImageCompressionDialog icd, QDGraphics src, QDRect srcRect)
          Compresses a frame that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data and an image description.
static ImageDescription QTImage.compress(QDGraphics src, QDRect srcRect, int quality, int cType, EncodedImage data)
          Compresses a single frame image that is currently stored as a pixel map.
static ImageDescription QTImage.fCompress(QDGraphics src, QDRect srcRect, int colorDepth, int quality, int cType, CodecComponent c, ColorTable clut, int flags, EncodedImage data)
          Compresses a single frame image that is currently stored as a pixel map.
static 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.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.setGWorld(QDGraphics port, GDevice gdh)
          Call this method to give the client the QDGraphics object it should use to do its drawing.
 

Constructors in quicktime.std.image with parameters of type QDGraphics
CSequence(QDGraphics src, QDRect srcRect, int cType, CodecComponent codec, int spatialQuality, int temporalQuality, int keyFrameRate, int flags)
          Creating an instance of this class signals the beginning of the process of compressing a sequence of frames.
CSequence(QDGraphics src, QDRect srcRect, int colorDepth, int cType, CodecComponent codec, int spatialQuality, int temporalQuality, int keyFrameRate, ColorTable clut, int flags)
          Creating an instance of this class signals the beginning of the process of compressing a sequence of frames.
DSequence(ImageDescription desc, QDGraphics port, QDRect srcRect, Matrix matrix, Region mask, int flags, int accuracy, CodecComponent codec)
          Creating an instance of this class signals the beginning of the process of decompressing a sequence of frames.
DSequence(ImageDescription desc, EncodedImage data, QDGraphics port, QDRect srcRect, Matrix matrix, Region mask, int flags, int accuracy, CodecComponent codec)
          This constructor allows you to pass a compressed sample so the codec can perform preflighting before the first decompressFrame call.
 

Uses of QDGraphics in quicktime.std.movies
 

Methods in quicktime.std.movies that return QDGraphics
 QDGraphics MovieController.getPort()
          This method returns a movie controller's color graphics port.
 QDGraphics Movie.getGWorld()
          Your application can determine a movie's graphics world by calling the getGWorld method.
 

Methods in quicktime.std.movies with parameters of type QDGraphics
 void MovieController.setMovie(Movie aMovie, QDGraphics movieWindow, QDPoint location)
          This method replaces the current movie controlled by the movie controller with a new movie.
 void MovieController.setPort(QDGraphics grafPtr)
          This method allows your application to set the graphics port for a movie controller.
 Region MovieController.getWindowRgn(QDGraphics window)
          This method allows your application to determine the window region that is actually in use by a controller and its movie.
 void MovieController.activate(QDGraphics window, boolean activate)
          This method can be used in response to activate, deactivate, suspend, and resume events.
 void MovieController.invalidate(QDGraphics window, Region invalidRgn)
          This method allows your application to invalidate portions of a movie controller.
 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.
 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 Track.setGWorld(QDGraphics port, GDevice gdh)
          This method sets a new QDGraphics for the track.
 

Constructors in quicktime.std.movies with parameters of type QDGraphics
MovieController(int subType, Movie theMovie, QDGraphics window, QDPoint location)
          This method constructs a MovieController object for a given subType.
MultiMovieController(int subType, Movie theMovie, QDGraphics window, QDPoint location)
          This constructor creates a MovieController object for a given subType.
 

Uses of QDGraphics in quicktime.std.qtcomponents
 

Methods in quicktime.std.qtcomponents that return QDGraphics
 QDGraphics ImageCompressionDialog.newGWorld(QDRect rp, int flags)
          Creates an offscreen QDGraphics based on the current compression settings.
 

Methods in quicktime.std.qtcomponents with parameters of type QDGraphics
 QTImage ImageCompressionDialog.compressImage(QDGraphics src, QDRect srcRect)
          Compresses an image that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data and an image description.
 SCSequence ImageCompressionDialog.compressSequenceBegin(QDGraphics src, QDRect srcRect)
          Creates a SCSequence object to begin compression of a sequence of images.
 SCInfo SCSequence.compressFrame(QDGraphics src, QDRect srcRect)
          Compresses a frame that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data.
 

Uses of QDGraphics in quicktime.std.sg
 

Methods in quicktime.std.sg that return QDGraphics
 QDGraphics SequenceGrabber.getGWorld()
          Returns the QDGraphics of the sequence grabber.
 

Methods in quicktime.std.sg with parameters of type QDGraphics
 void SequenceGrabber.setGWorld(QDGraphics port, GDevice gdh)
          Establishes the graphics port and device for a sequence grabber.
 

Uses of QDGraphics in quicktime.streaming
 

Methods in quicktime.streaming that return QDGraphics
 QDGraphics Presentation.getGWorld(Stream s)
          This method retrieves the GWorld of the presenter
 QDGraphics Presentation.getGWorld()
          This method retrieves the GWorld of the presenter
 QDGraphics MediaParams.getGWorld()
          gets the graphics world of the video component
 

Methods in quicktime.streaming with parameters of type QDGraphics
 void Presentation.setGWorld(Stream s, QDGraphics gWorld, GDevice gd)
          This method sets the GWorld of the presenter
 void Presentation.setGWorld(Stream s, QDGraphics gWorld)
          This method sets the GWorld of the presenter (uses the main device as the default GDevice)
 void Presentation.setGWorld(QDGraphics gWorld)
          This method sets the GWorld of the presenter (uses the main device as the default GDevice)
 void MediaParams.setGWorld(QDGraphics g)
          Sets the offscreen graphics world used by the video media
 

Constructors in quicktime.streaming with parameters of type QDGraphics
MediaParams(QDDimension dim, QDGraphics g)
          Creates a MediaParams object from a dimension and gWorld
MediaParams(QDDimension dim, Matrix matrix, QDGraphics g, int lVol, int rVol, int bassLvl, int trebLvl)
          Creates a MediaParams object
 

Uses of QDGraphics in quicktime.util
 

Methods in quicktime.util with parameters of type QDGraphics
static SCInfo QTHandleRef.fromSCSequence(SCSequence sc, QDGraphics src, QDRect srcRect)
          Compresses a frame that is sourced by a PixMap from the supplied QDGraphics, returning the compressed data.
 

Uses of QDGraphics in quicktime.vr
 

Methods in quicktime.vr with parameters of type QDGraphics
 int QTVRImagingComplete.execute(QTVRInstance inst, QDGraphics qd)
          This method is called by MoviesTask when a QTVRInstance has completed rendering and is ready to be blitted to the screen.