Uses of Class
quicktime.qd.QDRect

Packages that use QDRect
quicktime.qd   
quicktime.std.anim   
quicktime.std.image   
quicktime.std.movies   
quicktime.std.movies.media   
quicktime.std.qtcomponents   
quicktime.std.sg   
quicktime.util   
quicktime.vr   
 

Uses of QDRect in quicktime.qd
 

Methods in quicktime.qd that return QDRect
 QDRect Pict.getPictFrame()
          Returns the picture frame rectangle referenced of the Pict.
 QDRect Polygon.getPolyBBox()
          Returns a copy of the bounding rectangle of the Polygon.
 QDRect Polygon.getBounds()
          Returns a copy of the bounding rectangle of the Polygon.
 QDRect QDGraphics.getPortRect()
          The port rectangle that defines a subset of the pixel map to be used for drawing.
 QDRect QDGraphics.getBounds()
          The port rectangle that defines a subset of the pixel map to be used for drawing.
 QDRect PixMap.getBounds()
          The boundary rectangle, which links the local coordinate system of a graphics port to QuickDraw's global coordinate system and defines the area of the bit image into which QuickDraw can draw.
static QDRect QDRect.fromArray(byte[] rectBytes, int flag)
          Creates a QDRect from an array of bytes.
 QDRect QDRect.intersection(QDRect r)
          Computes the intersection of two QDRects, returning the largets rect that encompasses both rects.
 QDRect QDRect.union(QDRect r)
          Computes the union of two QDRects, returning the smallest Rect that is the union of the two QDRects.
 QDRect QDRect.copy()
          Returns a copy of the QDRect with the correct return type.
 QDRect GDevice.getBounds()
          Returns the global Bounds associated with this gDevice
 QDRect Region.getRgnBBox()
          Returns a copy of the bounding rectangle of the Region.
 QDRect Region.getBounds()
          Returns a copy of the bounding rectangle of the Region.
 QDRect OpenCPicParams.getSrcRect()
          Gets the bounding rectangle of the picture.
 

Methods in quicktime.qd with parameters of type QDRect
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.fromSequenceGrabber(SequenceGrabber sg, QDRect bounds, int offscreenDepth, int grabPictFlags)
          Provides a simple interface to obtain a QuickDraw picture from a sequence grabber component.
 void Pict.draw(QDGraphics cg, QDRect frameRect)
          To draw a picture on any type of output device.
 void Pict.drawTrimmed(QDGraphics cg, QDRect frameRect, Region trimMask, int doDither)
          Allows the drawing of an image that is stored as a picture.
 Pict QDGraphics.makeThumbnail(QDRect src, int colorDepth)
          Creates an 80-by-80 pixel thumbnail picture from the pixmap associated with this QDGraphics.
 void QDGraphics.clipRect(QDRect r)
          To change the clipping region of this QDGraphics, use the ClipRect procedure.
 void QDGraphics.frameArc(QDRect area, int startAngle, int arcAngle)
          Using Pen size of the graphics pen for the current graphics port, FrameArc draws an arc of the oval bounded by the rectangle that you specify in the area parameter.
 void QDGraphics.paintArc(QDRect area, int startAngle, int arcAngle)
          Using the pen mode of the current graphics port, PaintArc draws a wedge of the oval bounded by the rectangle that you specify in the area parameter.
 void QDGraphics.eraseArc(QDRect area, int startAngle, int arcAngle)
          EraseArc draws a wedge of the oval bounded by the rectangle that you specify in the area parameter with the background pattern for the current graphics port.
 void QDGraphics.invertArc(QDRect area, int startAngle, int arcAngle)
          InvertArc inverts the pixels enclosed by a wedge of the oval bounded by the rectangle that you specify in the area parameter.
 void QDGraphics.frameRoundRect(QDRect area, int ovalWidth, int ovalHeight)
          Using the Pen size of the graphics pen for the current graphics port, FrameRoundRect draws an outline just inside the rounded rectangle bounded by the rectangle that you specify in the area parameter.
 void QDGraphics.paintRoundRect(QDRect area, int ovalWidth, int ovalHeight)
          Using Pen mode of the graphics pen for the current graphics port, the PaintRoundRect procedure draws the interior of the rounded rectangle bounded by the rectangle that you specify in the area parameter.
 void QDGraphics.eraseRoundRect(QDRect area, int ovalWidth, int ovalHeight)
          EraseRoundRect draws the interior of the rounded rectangle bounded by the rectangle that you specify in the area parameter with the background settings of the current graphics port.
 void QDGraphics.invertRoundRect(QDRect area, int ovalWidth, int ovalHeight)
          The InvertRoundRect procedure inverts the pixels enclosed by the rounded rectangle bounded by the rectangle that you specify in the area parameter.
 void QDGraphics.frameOval(QDRect area)
          Using the Pen mode, and size of the graphics pen for the current graphics port, the FrameOval procedure draws an outline just inside the oval with the bounding rectangle that you specify in the area parameter.
 void QDGraphics.paintOval(QDRect area)
          Using the pen mode for the current graphics port, the PaintOval procedure draws the interior of an oval just inside the bounding rectangle that you specify in the area parameter.
 void QDGraphics.eraseOval(QDRect area)
          Using the background pattern for the current graphics port and the patCopy pattern mode, the EraseOval procedure draws the interior of an oval just inside the bounding rectangle that you specify in the area parameter.
 void QDGraphics.invertOval(QDRect area)
          The InvertOval procedure inverts the pixels enclosed by an oval just inside the bounding rectangle that you specify in the area parameter.
 void QDGraphics.frameRect(QDRect area)
          Using the pen size of the graphics pen for the current graphics port, the FrameRect procedure draws an outline just inside the rectangle that you specify in the area parameter.
 void QDGraphics.eraseRect(QDRect area)
          Erases the specified rect with the current back color.
 void QDGraphics.paintRect(QDRect area)
          Paints the specified rect with the current foreground color.
 boolean QDRect.isDifferentSize(QDRect rect)
          Returns true if the QDRect argument is a different size.
 boolean QDRect.isDifferentOrigin(QDRect rect)
          Returns true if the QDRect argument has a different origin.
 boolean QDRect.intersects(QDRect r)
          Checks if two QDRects intersect.
 QDRect QDRect.intersection(QDRect r)
          Computes the intersection of two QDRects, returning the largets rect that encompasses both rects.
 QDRect QDRect.union(QDRect r)
          Computes the union of two QDRects, returning the smallest Rect that is the union of the two QDRects.
static GDevice GDevice.getMax(QDRect globalRect)
          Returns the graphic device with the greatest pixel depth.
 void Region.rect(QDRect r)
          Resets the mathematical structure to the specified rectangle.
 Region Region.sect(QDRect r)
          Calculates the intersection of this region and the incoming QDRect and creates a new region representing that structure.
 Region Region.union(QDRect rect)
          Calculates the union of this region and the incoming rect, and creates a new region representing that structure.
 boolean Region.rectIn(QDRect srcRect)
          Checks whether the specified rectangle intersects the region.
 void Region.map(QDRect srcRect, QDRect dstRect)
          Takes the implicit region with one rectangle, maps and scales it to another rectangle.
 

Constructors in quicktime.qd with parameters of type QDRect
QDGraphics(ImageCompressionDialog d, QDRect rp, int flags)
          Creates an offscreen QDGraphics based on the current compression settings.
QDGraphics(QDRect bounds)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
QDGraphics(int pixelFormat, QDRect bounds)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
QDGraphics(int pixelFormat, QDRect bounds, int flags)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
QDGraphics(int pixelFormat, QDRect bounds, ColorTable cTable, GDevice aGDevice, int flags)
          An offscreen graphics world in Color QuickDraw contains a GWorld - and its handles to associated PixMap and ColorTables - that describe an offscreen graphics port.
Region(QDRect r)
          Allocates a new region specified by a rectangle.
OpenCPicParams(QDRect srcRect, float hRes, float vRes)
          The OpenCPicParams as a new object.
OpenCPicParams(QDRect srcRect)
          The OpenCPicParams as a new object.
 

Uses of QDRect in quicktime.std.anim
 

Methods in quicktime.std.anim that return QDRect
 QDRect SpriteWorld.getBounds()
          Returns the current bounds of the SpriteWorld.
 

Methods in quicktime.std.anim with parameters of type QDRect
 void SpriteWorld.setBounds(QDRect bounds)
          Sets the bounds of the SpriteWorld by scaling its matrix.
 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.
 

Uses of QDRect in quicktime.std.image
 

Methods in quicktime.std.image that return QDRect
 QDRect GraphicsExporter.getInputImageDimensions()
          Used by format-specific graphics exporters, especially when doing standalone export: Returns the dimensions of the input image.
 QDRect ImageDescription.getBounds()
          Return a QDRect that describes the width and height of the Image the description describes.
 QDRect GraphicsImporter.getSourceRect()
          Determines the current source rectangle for an image.
 QDRect GraphicsImporter.getNaturalBounds()
          Determines the bounding rectangle of an image.
 QDRect GraphicsImporter.getBoundsRect()
          Determines the bounding rectangle for drawing.
 QDRect GraphicsImporter.getDefaultSourceRect()
          Returns the default source rect, if one is stored in the image.
 QDRect GraphicsImporter.getDestRect()
          Returns the destination rectangle.
 

Methods in quicktime.std.image with parameters of type QDRect
 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.
 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.
 boolean Matrix.transformDRect(QDRect r)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
 boolean Matrix.transformDRect(QDRect r, QDPoint[] points)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
 boolean Matrix.transformRect(QDRect r)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
 boolean Matrix.transformRect(QDRect r, QDPoint[] points)
          transforms the upper left and lower right points of a rectangle through a specified matrix.
 void Matrix.rect(QDRect srcRect, QDRect dstRect)
          creates a matrix that performs a translate and scale operation as described by the relationship between two rectangles.
 void Matrix.map(QDRect fromRect, QDRect toRect)
          alters an existing matrix so that it defines a transformation from one rectangle to another.
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.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.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.setSourceRect(QDRect srcRect)
          Sets the source rectangle to use for an image.
 void GraphicsImporter.setBoundsRect(QDRect bounds)
          Defines the rectangle in which to draw an image.
 void GraphicsImporter.setDestRect(QDRect destRect)
          Sets the destination rectangle.
 void DSequence.setSrcRect(QDRect srcRect)
          This method defines the portion of the image to decompress.
 void DSequence.setMatte(PixMap matte, QDRect matteRect)
          This method assigns a blend matte to the sequence.
 

Constructors in quicktime.std.image with parameters of type QDRect
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 QDRect in quicktime.std.movies
 

Methods in quicktime.std.movies that return QDRect
 QDRect MovieController.getTimeSliderRect()
          Your application can use this method to receive the QDRect specifying the location and size of the time slider.
 QDRect MovieController.getBounds()
          This method returns a movie controller's boundary rectangle.
 QDRect Movie.getNaturalBoundsRect()
          No QT Documentation.
 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.
 QDRect Movie.getPosterBox()
          This method allows you to obtain a poster's boundary rectangle.
 

Methods in quicktime.std.movies with parameters of type QDRect
 boolean ActionFilter.execute(MovieController mc, QDRect rect)
          This method should be overridden to handle the following actions: mcActionSetGrowBoxBounds mcActionGetTimeSliderRect
 void MovieController.setGrowBoxBounds(QDRect limits)
          Your application can use this action to set the limits for grow box.
 void MovieController.setBounds(QDRect newBoundsRect)
          This method lets you change the position and size of a movie controller.
 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.
 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.setPosterBox(QDRect boxRect)
          This method allows you to set a poster's boundary rectangle.
 

Constructors in quicktime.std.movies with parameters of type QDRect
TweenData(QDRect start, QDRect end)
          Allocates a TweenData object of type kTweenTypeQDRect from QDRect start and end values
 

Uses of QDRect in quicktime.std.movies.media
 

Methods in quicktime.std.movies.media that return QDRect
 QDRect TextDescription.getDefaultTextBox()
           
 QDRect MovieMediaHandler.getCurrentMoviePropertyNaturalBounds()
          This method gets the natural bounds of the currently instantiated embedded movie
 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.
 

Methods in quicktime.std.movies.media with parameters of type QDRect
 void TextDescription.setDefaultTextBox(QDRect textBox)
           
 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.
 

Uses of QDRect in quicktime.std.qtcomponents
 

Methods in quicktime.std.qtcomponents with parameters of type QDRect
 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.
 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.
 QDGraphics ImageCompressionDialog.newGWorld(QDRect rp, int flags)
          Creates an offscreen QDGraphics based on the current compression settings.
 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 QDRect in quicktime.std.sg
 

Methods in quicktime.std.sg that return QDRect
 QDRect VisualChannel.getBounds()
          Allows you to get a channel's display boundary rectangle.
 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.
 

Methods in quicktime.std.sg with parameters of type QDRect
 void VisualChannel.setBounds(QDRect bounds)
          Allows you to specify a channel's display boundary rectangle.
 void SGVideoChannel.setVideoRect(QDRect r)
          Allows you to specify the portion of the source video image that is to be captured.
 Pict SequenceGrabber.grabPict(QDRect bounds, int offscreenDepth, int grabPictFlags)
          Provides a simple interface to obtain a QuickDraw picture from a sequence grabber component.
 

Uses of QDRect in quicktime.util
 

Methods in quicktime.util with parameters of type QDRect
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 QDRect in quicktime.vr
 

Methods in quicktime.vr that return QDRect
 QDRect QTVRHotSpotInfo.getHotSpotRect()
          returns the hotSpotRect
 

Methods in quicktime.vr with parameters of type QDRect
 void QTVRHotSpotInfo.setHotSpotRect(QDRect hotSpotRect)
          set the hotSpotRect