Framework | Frameworks/QuickTime.framework |
Declared in | Aliases.h Components.h Dialogs.h IOHIDDescriptorParser.h IOMacOSTypes.h ImageCompression.h MacTypes.h Menus.h Movies.h OSTypes.h QDOffscreen.h QuickTimeComponents.h QuickdrawTypes.h |
This reference covers the data types common to multiple QuickTime frameworks.
Stores data for a QTCallBackProc.
struct CallBackRecord { long data[1]; };
Movies.h
Defines a complete drawing environment for color graphics operations.
struct CGrafPort { short device; PixMapHandle portPixMap; short portVersion; Handle grafVars; short chExtra; short pnLocHFrac; Rect portRect; RgnHandle visRgn; RgnHandle clipRgn; PixPatHandle bkPixPat; RGBColor rgbFgColor; RGBColor rgbBkColor; Point pnLoc; Point pnSize; short pnMode; PixPatHandle pnPixPat; PixPatHandle fillPixPat; short pnVis; short txFont; StyleField txFace; short txMode; short txSize; Fixed spExtra; long fgColor; long bkColor; short colrBit; short patStretch; Handle picSave; Handle rgnSave; Handle polySave; CQDProcsPtr grafProcs; };
device
Device-specific information that QuickDraw uses to achieve the best possible results when drawing text in the graphics port. There may be physical differences in the same logical font for different output devices, to ensure the highest-quality printing on the device being used. The default value of the device
field is 0, indicating the computer screen.
portPixMap
A handle to a PixMap
structure, which describes the pixels in this color graphics port.
portVersion
The highest 2 bits are permanently set to indicate that this is a CGrafPort
structure and the remainder
of the field contains the version number of Macintosh Color QuickDraw that created this structure. Currently initialized to 0xC000.
grafVars
A handle to a GrafVars
structure that contains additional graphics fields of color information. On initialization, black is assigned to the rgbOpColor
field of this structure, the default highlight color is assigned to the rgbHiliteColor
field, and all other fields are set to 0. For information about the GrafVars
structure, see Inside Macintosh: Imaging With QuickDraw.
chExtra
A number by which to widen every character, excluding spaces, in a line of text. This value is used in proportional spacing. The value in this field is in 4.12 fractional notation: 4 bits of signed integer followed by 12 bits of fraction. This value is multiplied by the value
in the txSize
field before it is used. By default, this field contains 0.
pnLocHFrac
The fractional horizontal pen position used when drawing text. The value in this field represents the low word of type Fixed
; in decimal, its initial value is 0.5.
portRect
The port rectangle that defines a subset of the pixel map to be used for drawing. All drawing done by the application occurs inside the port rectangle. The port rectangle (also called the content region) uses the local coordinate system defined by the boundary rectangle in the portPixMap
field of the PixMap
structure. The upper-left corner (which for a window is called the window origin) of the port rectangle usually has vertical and horizontal coordinates of 0. The port rectangle usually falls within the boundary rectangle, but it's not required to do so.
visRgn
The region of the graphics port that's actually visible on the screen; that is, the part of the window that's not covered by other windows. By default, the visible region is equivalent to the port rectangle. The visible region has no effect on images that aren't displayed on the screen.
clipRgn
A handle to the graphics port's clipping region, an arbitrary region that you can use to limit drawing to any region within the port rectangle. Unlike the visible region, the clipping region affects the image even if it isn't displayed on the screen. Initially the clip region is set to the rectangle -32768, -32768, 32767, 32767.
bkPixPat
A handle to a PixPat
structure that describes the background pixel pattern, initially set to white.
rgbFgColor
An RGBColor
structure that defines the requested foreground color. By default, the foreground color is black.
rgbBkColor
An RGBColor
structure that defines the requested background color. By default, the background color is white.
pnLoc
The point where QuickTime will begin drawing the next line, shape, or character. It can be anywhere on the coordinate plane; there are no restrictions on the movement or placement of the pen. The location of the graphics pen is a point in the graphics port's coordinate system, not a pixel in a pixel image. The upper-left corner of the pen is at the pen location; the graphics pen hangs below and to the right of this point. This field is initialized to 0,0.
pnSize
The vertical height and horizontal width of the graphics pen. The default size is a 1-by-1 pixel square; the vertical height and horizontal width can range from 0 by 0 to 32,767 by 32,767. If either the pen width or the pen height is 0, the pen does not draw. Heights or widths of less than 0 are undefined.
pnMode
The pattern mode, a Boolean operation that determines the how QuickTime transfers the pen pattern to the pixel map during drawing operations. See Graphics Transfer Modes
. When the graphics pen draws into a pixel map, QuickTime first determines what pixels in the pixel image are affected and finds their corresponding pixels in the pen pattern. It then does a pixel-by-pixel comparison based on the pattern mode, which specifies one of eight Boolean transfer operations to perform. QuickTime stores the resulting pixel in its proper place in the image. This field is initially set to patCopy
.
pnPixPat
A handle to a PixPat
structure that describes a pixel pattern that can be used like the ink in the graphics pen. This field is initially set to black.
fillPixPat
A handle to a PixPat
structure that describes the pixel pattern that's used to fill an area. This field is initially set to black. Notice that this is not in the same location as the fillPat
field in the GrafPort
structure.
pnVis
The graphics pen's visibility; that is, whether or not it draws on the screen. This field is initially set to 0 (visible).
txFont
A font number that identifies the font to be used in the graphics port. This field is initially set to 0, indicating the system font.
txFace
The character style
of the text, with values from the set defined by the Style
type, which includes such styles as bold, italic, and shaded. You can apply stylistic variations either alone or in combination. This field is initially set to plain text.
txMode
One of three Boolean source mode constants (see below) that determines the way characters are placed in the bit image. This mode functions much like a pattern mode specified in the pnMode
field; when drawing a character, QuickTime determines which pixels in the image are affected, does a pixel-by-pixel comparison based on the mode, and stores the resulting pixels in the image. This field is initially set to srcOr
. See these constants:
txSize
The text size in pixels. QuickTime uses this information to provide the bitmaps for text drawing. The txSize
value can be represented by the formula (size in points) x (device resolution) / 72 dpi. This field is initially set to the system font size.
spExtra
A number equal to the average number of pixels by which each space character should be widened to fill out a fully justified text line. This field is useful when a line of characters is to be aligned with both the left and the right
margin. This field is initially set to 0.
fgColor
The pixel value of the foreground color. This is the best available approximation in the color lookup table (CLUT) to the color specified in the rgbFgColor
field. This field is initially set to blackColor
; see Color Constants
.
bkColor
The pixel value of the background color. This is the best available approximation in the color lookup table (CLUT) to the color specified in the rgbBkColor
field. This field is initially set to whiteColor
; see Color Constants
.
colrBit
Reserved and set to 0.
patStretch
A value, initially set to 0, used during output to a printer to expand patterns if necessary. Your application should not change this value.
picSave
A handle to the state of the Macintosh picture definition. If no picture is open, this field contains NIL
; otherwise it contains a handle to information related to the picture definition. Your application shouldn't be concerned about exactly what information the handle leads to; you may, however, save the current value of this field, set the field to NIL
to disable the picture definition, and later restore it to the saved value to resume defining the picture.
rgnSave
A handle to the state of the region definition. If no region is open, this field contains NIL
; otherwise it contains a handle to information related to the region definition. Your application shouldn't be concerned about exactly what information the handle leads to; you may, however, save the current value of this field, set the field to NIL
to disable the region definition, and later restore it to the saved value to resume defining the region.
polySave
A handle to the state of the polygon definition. If no polygon is open, this field contains NIL
; otherwise it contains a handle to information related to the polygon definition. Your application shouldn't be concerned about exactly what information the handle leads to; you may, however, save the current value of this field, set the field to NIL
to disable the polygon definition, and later restore it to the saved value to resume defining the polygon.
grafProcs
An optional pointer to a CQDProcs
structure that your application can store into if you want to customize Color QuickDraw drawing routines or use Color QuickDraw in other advanced, highly specialized ways. This field is initially set to NIL
.
You can have many graphics ports open at once; each one has its own local coordinate system, pen pattern, background pattern, pen size and location, font and font style
, and pixel map in which drawing takes place. Several fields in this structure define your application's drawing area. All drawing in a graphics port occurs in the intersection of the graphics port's boundary rectangle and its port rectangle. Within that intersection, all drawing is cropped to the graphics port's visible region and its clipping region.
The CGrafPort
structure supersedes the earlier GrafPort
structure.
Quickdraw.h
Describes the capabilities of a compressor.
struct CodecInfo { Str31 typeName; short version; short revisionLevel; long vendor; long decompressFlags; long compressFlags; long formatFlags; UInt8 compressionAccuracy; UInt8 decompressionAccuracy; unsigned short compressionSpeed; unsigned short decompressionSpeed; UInt8 compressionLevel; UInt8 resvd; short minimumHeight; short minimumWidth; short decompressPipelineLatency; short compressPipelineLatency; long privateData; };
typeName
Indicates the compression algorithm used by the component; for example, 'Animation'. This Pascal string may be used to identify the compression algorithm to the user. The string always takes up 32 bytes no matter how long it is. The 32 bytes consist of 31 bytes plus one length byte. Apple assigns these type names. The value of this field should correspond to the value
of the typeName
field in the appropriate compressor name structure returned by GetCodecNameList
.
version
Indicates the version of compressed data this component supports. The contents of this field should indicate the most recent version of the compression algorithm that the component can understand.
revisionLevel
Indicates the version of the component; for example, 0x00010001 (1.0.1). Developers of compressors assign these version numbers.
vendor
Identifies the developer of the component; for example, 'appl'
. The value of this field corresponds to the manufacturer code or application signature assigned to the developer.
decompressFlags
Contains flags (see below) that specify the decompression capabilities of the component. Typically, these flags are of interest only to developers of image decompressors. See these constants:
codecInfoDoes1
codecInfoDoes2
codecInfoDoes4
codecInfoDoes8
codecInfoDoes16
codecInfoDoes32
codecInfoDoesDither
codecInfoDoesStretch
codecInfoDoesShrink
codecInfoDoesMask
codecInfoDoesTemporal
codecInfoDoesDouble
codecInfoDoesQuad
codecInfoDoesHalf
codecInfoDoesQuarter
codecInfoDoesRotate
codecInfoDoesHorizFlip
codecInfoDoesVertFlip
codecInfoHasEffectParameterList
codecInfoDoesBlend
codecInfoDoesWarp
codecInfoDoesRecompress
codecInfoDoesSpool
codecInfoDoesRateConstrain
compressFlags
Contains flags (see below) that specify the compression capabilities of the component. Typically, these flags are of interest only to developers of image compressors.
formatFlags
Contains flags (see below) that describe the possible format for compressed data produced by this component and the format of compressed files that the component can handle during decompression. Typically, these flags are of interest only to developers of compressor components. See these constants:
codecInfoDepth1
codecInfoDepth2
codecInfoDepth4
codecInfoDepth8
codecInfoDepth16
codecInfoDepth24
codecInfoDepth32
codecInfoDepth33
codecInfoDepth34
codecInfoDepth36
codecInfoDepth40
codecInfoStoresClut
codecInfoDoesLossless
codecInfoSequenceSensitive
compressionAccuracy
Indicates the relative accuracy of the compression algorithm employed by the component. Valid values for this field range from 0 to 255. A value of 0 means that the accuracy is unknown. Values from 1 to 255 provide a gauge for the relative accuracy of the compression algorithm; higher values indicate better accuracy. The Image Compression Manager examines this field to determine which compressor component can most accurately compress a given image. The compressionAccuracy
field can only approximate the accuracy of a compression algorithm. Typically, compression algorithms produce results of varying quality based on a variety of parameters, including image size and content. Since this information is not available until a compression request is issued, a precise measure of accuracy is not possible. However, the value
of this field should still give a rough idea of the accuracy of the supported algorithm.
decompressionAccuracy
Indicates the relative accuracy of the decompression algorithm employed by the component. Valid values for this field range from 0 to 255. A value of 0 means that the accuracy is unknown. Values from 1 to 255 indicate the relative accuracy of the decompression technique; higher values mean better accuracy. The Image Compression Manager examines this field to determine which decompressor component can most accurately decompress a given image. The decompressionAccuracy
field can only approximate the accuracy of a decompression algorithm. Typically, decompression algorithms produce results of varying quality based on a variety of parameters, including image size and content. Since this information is not available until a decompression request is issued, a precise measure of accuracy is not possible. However, the value
of this field should still give a rough idea of the accuracy of the supported algorithm.
compressionSpeed
Indicates the relative speed of the component for compression operations. Valid values for this field lie in the range from 0 to 65,535. A value of 0 means that the speed is unknown. Values from 1 to 65,535 correspond to the number of milliseconds the component requires to compress a 320-by-240 pixel image on a Macintosh II computer. The Image Compression Manager examines this field to determine which compressor component can most quickly compress a given image.
decompressionSpeed
Indicates the relative speed of the component for decompression operations. Valid values for this field lie in the range from 0 to 65,535. A value of 0 means that the speed is unknown. Values from 1 to 65,535 correspond to the number of milliseconds the component requires to decompress a 320-by-240 pixel image on a Macintosh II computer. The Image Compression Manager examines this field to determine which compressor component can most quickly decompress a given image.
compressionLevel
Indicates the relative compression achieved by this component. Valid values for this field lie in the range from 0 to 255. A value of 0 means that the compression level is unknown. Values from 1 to 255 map to percentage values of relative compression; lower values mean lesser compression. A value of 1 means no compression (0 percent); a value of 255 means maximum compression (100 percent). The Image Compression Manager examines this field to determine which available compressor component will yield the smallest resulting data for a given image. The compressionLevel
field can only approximate the effectiveness of a compression algorithm. Typically, compression algorithms produce results of varying quality based on a variety of parameters, including image size and content. Since this information is not available until a compression request is issued, a precise measure of compression is not possible. However, the value
of this field should still give a rough idea of the effectiveness of the supported algorithm.
resvd
Reserved; set to 0.
minimumHeight
Specifies the height in pixels of the smallest image the component can handle. Together with the minimumWidth
field, this field defines the block size for the component. The Image Compression Manager does not issue compression or decompression requests for images smaller than the block size.
minimumWidth
Specifies the width in pixels of the smallest image the component can handle. Together with the minimumHeight
field, this field defines the block size for the component. The Image Compression Manager does not issue compression or decompression requests for images smaller than the block size.
decompressPipelineLatency
Decompression pipeline latency in milliseconds, for asynchronous codecs.
compressPipelineLatency
Compression pipeline latency in milliseconds, for asynchronous codecs.
privateData
Reserved for future use. This field must be set to 0.
Contains the description of a codec.
The codecInfoHasEffectParameterList
constant was formerly codecInfoDoesSkew
.
GetCodecInfo
ImageCodecGetCodecInfo
ImageCompression.h
Undocumented
struct ComponentInstanceRecord { long data[1]; };
Undocumented
Components.h
Contains information about a retrieved Mac OS event.
struct EventRecord { EventKind what; UInt32 message; UInt32 when; Point where; EventModifiers modifiers; };
what
A constant (see below) that specifies the kind of event. See these constants:
message
Additional information (see below) associated with the event. The interpretation of this information depends on the event
type. See these constants:
when
The time when the event was posted, in ticks since system startup.
where
For low-level events and operating-system events, this field contains the location of the cursor at the time the event was posted (in global coordinates). For high-level events, it contains a second event specifier, the event ID. The event ID defines the particular type of event within the class of events defined by the message
field of the high-level event. For high-level events, you should interpret the where
field as having the data
type OSType
, not Point
.
modifiers
Contains information about the state of the modifier keys and the mouse button at the time the event was posted. For activate events, this field also indicates whether the window should be activated or deactivated. In System 7 it also indicates whether the mouse-down event caused your application to switch to the foreground. Each modifier key is represented by a specific bit in the modifiers
field of the event record structure. The modifier keys include the Option, Command, Caps Lock, Control, and Shift keys. If your application attaches special meaning to any of these keys in combination with other keys or when the mouse button is down, you can test the state of the modifiers
field to determine the action your application should take. For example, you can use this information to determine whether the user pressed the Command key and another key to make a menu choice.
ImageCodecIsStandardParameterDialogEvent
ModalFilterProc
ModalFilterYDProc
NativeEventToMacEvent
PreviewEvent
QTIsStandardParameterDialogEvent
SCModalFilterProc
SFModalFilterProc
WinEventToMacEvent
Events.h
Defines the position of a geometric point in fixed-point numbers.
struct FixedPoint { Fixed x; Fixed y; };
x
The x (horizontal) coordinate of the point.
y
The y (vertical) coordinate of the point.
CurveGetNearestPathPoint
CurveLengthToPoint
CurvePathPointToLength
TransformFixedPoints
TransformFixedRect
TransformRect
MacTypes.h
Identifies a Mac OS file or directory.
struct FSSpec { short vRefNum; long parID; StrFileName name; };
vRefNum
Volume reference number.
parID
Directory ID of parent directory.
name
Filename or directory name; a Str63 string on the Mac OS.
The FSSpec
structure provides a simple and standard format for specifying files and directories. You can pass that specification directly to any file-manipulation routines that accept FSSpec
records.
ConvertMovieToFile
GraphicsExportGetInputFile
GraphicsExportGetOutputFile
GraphicsImportDoExportImageFileDialog
GraphicsImportGetDataFile
NativePathNameToFSSpec
SGGetDataOutput
Files.h
Specifies an image compression alignment callback.
struct ICMAlignmentProcRecord { ICMAlignmentUPP alignmentProc; long alignmentRefCon; };
alignmentProc
Contains a Universal Procedure Pointer that accesses your ICMAlignmentProc
callback.
alignmentRefCon
Contains a reference constant for use by your callback.
This structure defines a pointer to an alignment function. You assign an alignment function by passing a pointer to this structure.
AlignScreenRect
AlignWindow
DragAlignedGrayRgn
DragAlignedWindow
SGGetAlignmentProc
ImageCompression.h
Specifies an image compression completion callback.
struct ICMCompletionProcRecord { ICMCompletionUPP completionProc; long completionRefCon; };
completionProc
Contains a Universal Procedure Pointer that accesses your ICMCompletionProc
callback.
completionRefCon
Contains a reference constant for use by your callback.
This structure governs whether you perform a compression asynchronously. If the completionProc
field in this structure is set to NIL
, perform the compression synchronously. If this field is not NIL
, it specifies an application completion function. Perform the compression asynchronously and call that completion function when your component is finished. If the completionProc
field in this structure has a value of -1, perform the operation asynchronously but do not call the application's completion function
CompressSequenceFrame
DecompressSequenceFrame
DecompressSequenceFrameS
DecompressSequenceFrameWhen
ICMDecompressComplete
ICMDecompressCompleteS
MediaQueueNonPrimarySourceData
MediaSetNonPrimarySourceData
SCCompressSequenceFrameAsync
TweenerDataProc
ImageCompression.h
Specifies an image compression data-loading function.
struct ICMDataProcRecord { ICMDataUPP dataProc; long dataRefCon; };
dataProc
Contains a pointer to your data-loading function.
dataRefCon
Contains a reference constant for use by your data-loading function.
If there is no data-loading function, the Image Compression Manager sets the dataProc
field to NIL
, and the entire image must be in memory at the location specified by the codecData
field of the ImageSubCodecDecompressRecord
structure.
FDecompressImage
GetCompressedImageSize
GetCompressedPixMapInfo
ImageCodecGetCompressedImageSize
ImageCodecTrimImage
SetCompressedPixMapInfo
SetDSequenceDataProc
TrimImage
ImageCompression.h
Specifies an image compression data-unloading callback.
struct ICMFlushProcRecord { ICMFlushUPP flushProc; long flushRefCon; };
flushProc
Contains a pointer to your data-unloading function.
flushRefCon
Contains a reference constant for use by your data-unloading function.
If there is not enough memory to store a compressed image, your application may provide a function that unloads some of the compressed data. This field contains a structure that identifies that data-unloading function. If the application did not provide a data-unloading function, the flushProc
field in this structure is set to NIL
. In this case, your component writes the entire compressed image into the memory location specified by the data
field
FCompressImage
ImageCodecTrimImage
SetCSequenceFlushProc
TrimImage
ImageCompression.h
Contains a frame's time information for scheduled asynchronous decompression operations.
struct ICMFrameTimeRecord { wide value; long scale; void * base; long duration; Fixed rate; long recordSize; long frameNumber; long flags; wide virtualStartTime; long virtualDuration; TimeValue64 decodeTime; };
value
Specifies the time at which the frame is to be displayed.
scale
Indicates the units for the frame's display time.
base
Refers to the time base.
duration
Specifies the duration for which the frame is to be displayed. This must be in the same units as specified by the scale
field. It is 0 if the duration is unknown.
rate
Indicates the time base's effective rate.
recordSize
Total number of bytes in this structure.
frameNumber
Number of frame; 0 if the frame number is not known.
flags
Flag (see below) to indicate if virtualStartTime
and virtualDuration
are valid. See these constants:
icmFrameTimeHasVirtualStartTimeAndDuration
icmFrameTimeHasDecodeTime
virtualStartTime
Conceptual start time.
virtualDuration
Conceptual duration.
decodeTime
Suggested decode time. Valid only if icmFrameTimeHasDecodeTime
is set in the flags
parameter.
ImageCompression.h
Specifies an image compression progress callback.
struct ICMProgressProcRecord { ICMProgressUPP progressProc; long progressRefCon; };
progressProc
Contains a pointer to your progress function.
progressRefCon
Contains a reference constant for use by your progress function.
During a compression operation, your compressor may occasionally call a function that the application provides in order to report your progress. This field contains a structure that identifies the progress function. If the progressProc
field in this structure is set to NIL
, the application has not supplied a progress function
DrawPictureFile
DrawTrimmedPicture
DrawTrimmedPictureFile
FCompressImage
FCompressPicture
FCompressPictureFile
FDecompressImage
GetCompressedPixMapInfo
GraphicsExportGetProgressProc
GraphicsExportSetProgressProc
GraphicsImportGetProgressProc
GraphicsImportSetProgressProc
ImageCodecTrimImage
MakeFilePreview
MakeThumbnailFromPicture
MakeThumbnailFromPictureFile
MakeThumbnailFromPixMap
PreviewMakePreview
SetCompressedPixMapInfo
SetSequenceProgressProc
TrimImage
ImageCompression.h
Contains a transformation matrix.
struct MatrixRecord { Fixed matrix[3][3]; };
GetMovieMatrix
GetTrackMatrix
GraphicsImportGetDefaultMatrix
MediaSetMatrix
TransformRgn
TranslateMatrix
VDSetPlayThruDestination
ImageCompression.h
Undocumented
struct MediaRecord { long data[1]; };
Movies.h
Undocumented
struct MovieRecord { long data[1]; };
Movies.h
Contains information about the dimensions and contents of a pixel image, as well as its storage format, depth, resolution, and color usage.
struct PixMap { Ptr baseAddr; short rowBytes; Rect bounds; short pmVersion; short packType; long packSize; Fixed hRes; Fixed vRes; short pixelType; short pixelSize; short cmpCount; short cmpSize; OSType pixelFormat; CTabHandle pmTable; void * pmExt; };
baseAddr
For an onscreen pixel image, a pointer to the first byte of the image. For optimal performance, this should be a multiple of 4. The baseAddr
field of the PixMap
record for an offscreen graphics world contains a handle instead of a pointer. Your application should never directly access the baseAddr
field of the PixMap
record for an offscreen graphics world.
rowBytes
The offset in bytes from one row of the image to the next. The value must be even, less than 0x4000, and for best performance it should be a multiple of 4. The high 2 bits of rowBytes
are used as flags. If bit 15 =1, the data structure pointed to is a PixMap
structure; otherwise it is a BitMap
structure.
bounds
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. By default, the boundary rectangle is the entire main screen. Do not use the value
of this field to determine the size of the screen; instead use the value
of the gdRect
field of the GDevice
structure for the screen.
pmVersion
The version number of Color QuickDraw that created this PixMap
structure. The value of pmVersion
is normally 0. If pmVersion
is 4, Color QuickDraw treats the PixMap
record's baseAddr
field as 32-bit clean. All other flags are private. Most applications never need to set this field
packType
The packing algorithm used to compress image data. Color QuickDraw currently supports a packType
of 0, which means no packing, and values of 1 to 4 for packing direct pixels.
packSize
The size of the packed image in bytes. When the packType
field contains the value
0, this field is always set to 0.
hRes
The horizontal resolution of the pixel image in pixels per inch. By default, this value is 0x00480000 (for 72 pixels per inch).
vRes
The vertical resolution of the pixel image in pixels per inch. By default, this value is 0x00480000 (for 72 pixels per inch).
pixelType
The storage format for a pixel image. Indexed pixels are indicated by a value of 0. Direct pixels are specified by a value of RGBDirect
, or 16. In the PixMap
record of the GDevice
structure for a direct device, this field is set to RGBDirect
when the screen depth is set.
pixelSize
The number of bits used to represent a pixel. Indexed pixels can have sizes of 1, 2, 4, and 8 bits; direct pixel sizes are 16 and 32 bits.
cmpCount
The number of components used to represent a color for a pixel. With indexed pixels, each pixel is a single value representing an index in a color table, and therefore this field contains the value 1; the index is the single component. With direct pixels, each pixel contains three components (one integer each for the intensities of red, green, and blue) so this field contains the value 3.
cmpSize
The size in bits of each component for a pixel. Color QuickDraw expects that the sizes of all components are the same, and that the value of the cmpCount
field multiplied by the value of the cmpSize
field is less than or equal to the value in the pixelSize
field.
For an indexed pixel value, which has only one component, the value of the cmpSize
field is the same as the value of the pixelSize
field; that is, 1, 2, 4, or 8. For direct pixels there are two additional possibilities. A 16-bit pixel, which has three components, has a cmpSize
value of 5; this leaves an unused high-order bit, which Color QuickDraw sets to 0. A 32-bit pixel, which has three components (red, green, and blue), has a cmpSize
value of 8; this leaves an unused high-order byte, which Color QuickDraw sets to 0.
If presented with a 32-bit image (for example, in the CopyBits
procedure) Color QuickDraw passes whatever bits are there, and it does not set the high byte to 0. Generally, therefore, your application should clear the memory for the image to 0 before creating a 16-bit or 32-bit image.
planeBytes
The offset in bytes from one drawing plane to the next
. This field is set to 0.
pmTable
A handle to a ColorTable
structure for the colors in this pixel map.
pmReserved
Reserved. This field must be set to 0 for future compatibility.
pixelFormat
The way the pixels are arranged; see Pixel Formats
.
pmTable
Color map for this structure.
pmExt
Handle
to a PixMapExtension
structure. Set to NIL
if there is no extension.
The pixel map for a window's color graphics port always consists of the pixel depth, color table, and boundary rectangle of the main screen, even if the window is created on or moved to an entirely different screen.
Earlier versions of this structure were different in the last three fields; see the C interface file for details.
Quickdraw.h
Defines the position of a point.
struct Point { short v; short h; };
v
The vertical coordinate of the point.
h
The horizontal coordinate of the point.
MacTypes.h
Records a user event for QuickTime.
struct QTEventRecord { long version; OSType eventType; Point where; long flags; };
version
Undocumented
eventType
Undocumented
where
The location of the cursor at the time the event was posted.
flags
Undocumented
This structure is used by the kActionSendQTEventToSprite
action.
ActionsProc
CallComponentExecuteWiredAction
MediaGetActionsForQTEvent
SpriteMediaGetSpriteActionsForQTEvent
Movies.h
Defines the size and location of a QuickDraw rectangle.
struct Rect { short top; short left; short bottom; short right; };
top
The vertical coordinate of the upper-left point of the rectangle.
left
The horizontal coordinate of the upper-left point of the rectangle.
bottom
The vertical coordinate of the lower-right point of the rectangle.
right
The horizontal coordinate of the lower-right point of the rectangle.
Quickdraw.h
Defines a color in the red-green-blue system.
struct RGBColor { unsigned short red; unsigned short green; unsigned short blue; };
red
The magnitude of the red component
green
The magnitude of the green component
blue
The magnitude of the blue component
GraphicsImportGetGraphicsMode
MediaGetGraphicsMode
SGSetTextForeColor
TextMediaAddTextSample
TextMediaHiliteTextSample
VDGetKeyColorRange
Quickdraw.h
Contains a time base.
struct TimeBaseRecord { long data[1]; };
Movies.h
Contains a time value with its scale and time base.
struct TimeRecord { CompTimeValue value; TimeScale scale; TimeBase base; };
value
Contains the time value. The time value defines either a duration or an absolute time by specifying the corresponding number of units of time. For durations, this is the number of time units in the period. For an absolute time, this is the number of time units since the beginning of the time coordinate system. The unit for this value is defined by the scale
field. The time value is expressed as a 64-bit integer quantity. This 64-bit quantity consists of two 32-bit integers and is defined by the Int64 data type.
scale
Contains the time
scale. This field specifies the number of units of time that pass each second. If you specify a value of 0, the time base uses its natural time scale.
base
Contains a reference to the time base. You obtain a time base by calling GetMovieTimeBase
or NewTimeBase
. If the time structure defines a duration, set this field to NIL
. Otherwise, this field must refer to a valid time base.
AddTime
ClockGetTime
GetMovieTime
GetTimeBaseStartTime
GetTimeBaseStatus
GetTimeBaseStopTime
GetTimeBaseTime
SetTimeBaseZero
SGGrabCompressComplete
SubtractTime
VDCompressDone
VDGetTimeCode
Movies.h
Provides the information needed to produce a specific musical sound.
struct ToneDescription { BigEndianOSType synthesizerType; Str31 synthesizerName; Str31 instrumentName; BigEndianLong instrumentNumber; BigEndianLong gmNumber; };
synthesizerType
A synthesizer type constant (see below). A value of 0 specifies that any type of synthesizer is acceptable. See these constants:
kSoftSynthComponentSubType
kGMSynthComponentSubType
synthesizerName
The name of the instrument to use.
instrumentName
The name of the instrument to use.
instrumentNumber
The instrument number of the instrument to use. This value, which must be in the range 1-262143, can specify General MIDI and GS instruments as well as other instruments. The instrument specified by this field is used if it is available; if not, the instrument specified by the gmNumber
field is used. If neither of the instruments specified by the instrumentNumber
or gmNumber
fields is available, the instrument specified by the instrumentName
field is used. Finally, if none of these fields specifies an instrument that is available, no tone is played.
gmNumber
The instrument number of a General MIDI or GS instrument to use if the instrument specified by the instrumentNumber
field is not available. This value, which must be in the range 1-16383, can specify only General MIDI and GS instruments. The instrument specified by the instrumentNumber
field is used if it is available; if not, the instrument specified by the gmNumber
field is used. If neither of the instruments specified by the instrumentNumber
or gmNumber
fields is available, the instrument specified by the instrumentName
field is used. Finally, if none of these fields specifies an instrument that is available, no tone is played.
The tune header in the QuickTime Music Architecture has a ToneDescription
structure for each instrument used. These structures are also used in the tone description atoms of atomic instruments.
MusicFindTone
NAFindNoteChannelTone
NAPickInstrument
NAStuffToneDescription
SGGetInstrument
SGSetInstrument
QuickTimeMusic.h
Contains a track.
struct TrackRecord { long data[1]; };
Movies.h
Contains user data.
struct UserDataRecord { long data[1]; };
Use NewUserData
to create this record and DisposeUserData
to dispose of it.
NewUserData
DisposeUserData
Movies.h
Stores a signed 64-bit value as a signed 32-bit integer and an unsigned 32-bit integer.
struct wide { // big-endian version SInt32 hi; UInt32 lo; }; struct wide { // little-endian version UInt32 lo; SInt32 hi; };
hi
The signed high-order 32-bit integer.
lo
The unsigned low-order 32-bit integer.
Endian.h
Abst_ActionsUPP
typedef STACK_UPP_TYPE(ActionsProcPtr) ActionsUPP;
Movies.h
Abst_AliasHandle
typedef AliasPtr * AliasHandle;
Aliases.h
Abst_AliasPtr
typedef AliasRecord * AliasPtr;
Aliases.h
Abst_ByteCount
typedef UInt32 ByteCount;
IOHIDDescriptorParser.h
Abst_CGrafPtr
typedef CGrafPort * CGrafPtr;
QuickdrawTypes.h
Abst_CodecQ
typedef unsigned long CodecQ;
ImageCompression.h
Abst_CodecType
typedef OSType CodecType;
ImageCompression.h
Abst_ComponentInstance
typedef ComponentInstanceRecord * ComponentInstance;
Components.h
Abst_ComponentResult
typedef long ComponentResult;
Components.h
Abst_CompressorComponent
typedef Component CompressorComponent;
ImageCompression.h
Abst_ConstStr255Param
typedef const unsigned char * ConstStr255Param;
MacTypes.h
Abst_CTabHandle
typedef CTabPtr * CTabHandle;
QuickdrawTypes.h
Abst_CTabPtr
typedef ColorTable * CTabPtr;
QuickdrawTypes.h
Abst_DataHandler
typedef ComponentInstance DataHandler;
Movies.h
Abst_DialogPtr
typedef WindowPtr DialogPtr;
QuickdrawTypes.h
Abst_DialogRef
typedef DialogPtr DialogRef;
Dialogs.h
Abst_DoMCActionUPP
typedef STACK_UPP_TYPE(DoMCActionProcPtr) DoMCActionUPP;
Movies.h
Abst_GDHandle
typedef GDPtr * GDHandle;
QuickdrawTypes.h
Abst_GDPtr
typedef GDevice * GDPtr;
QuickdrawTypes.h
Abst_GWorldFlags
typedef unsigned long GWorldFlags;
QDOffscreen.h
Abst_GWorldPtr
typedef CGrafPtr GWorldPtr;
QDOffscreen.h
Abst_ICMAlignmentProcRecordPtr
typedef ICMAlignmentProcRecord * ICMAlignmentProcRecordPtr;
ImageCompression.h
Abst_ICMCompletionProcRecordPtr
typedef ICMCompletionProcRecord * ICMCompletionProcRecordPtr;
ImageCompression.h
Abst_ICMConvertDataFormatUPP
typedef STACK_UPP_TYPE(ICMConvertDataFormatProcPtr) ICMConvertDataFormatUPP;
ImageCompression.h
Abst_ICMDataProcRecordPtr
typedef ICMDataProcRecord * ICMDataProcRecordPtr;
ImageCompression.h
Abst_ICMFlushProcRecordPtr
typedef ICMFlushProcRecord * ICMFlushProcRecordPtr;
ImageCompression.h
Abst_ICMMemoryDisposedUPP
typedef STACK_UPP_TYPE(ICMMemoryDisposedProcPtr) ICMMemoryDisposedUPP;
ImageCompression.h
Abst_ICMProgressProcRecordPtr
typedef ICMProgressProcRecord * ICMProgressProcRecordPtr;
ImageCompression.h
Abst_ImageDescriptionHandle
typedef ImageDescriptionPtr * ImageDescriptionHandle;
ImageCompression.h
Abst_ImageDescriptionPtr
typedef ImageDescription * ImageDescriptionPtr;
ImageCompression.h
Abst_ImageSequence
typedef long ImageSequence;
ImageCompression.h
Abst_ItemCount
typedef UInt32 ItemCount;
IOMacOSTypes.h
Abst_MatrixRecordPtr
typedef MatrixRecord * MatrixRecordPtr;
ImageCompression.h
Abst_Media
typedef MediaRecord * Media;
Movies.h
Abst_MediaHandler
typedef ComponentInstance MediaHandler;
Movies.h
Abst_MenuHandle
typedef MenuPtr * MenuHandle;
Menus.h
Abst_MenuRef
typedef MenuHandle MenuRef;
Menus.h
Abst_ModalFilterUPP
typedef STACK_UPP_TYPE(ModalFilterProcPtr) ModalFilterUPP;
Dialogs.h
Abst_Movie
typedef MovieRecord * Movie;
Movies.h
Abst_MovieController
typedef ComponentInstance MovieController;
Movies.h
Abst_MovieDrawingCompleteUPP
typedef STACK_UPP_TYPE(MovieDrawingCompleteProcPtr) MovieDrawingCompleteUPP;
Movies.h
Abst_MoviePrePrerollCompleteUPP
typedef STACK_UPP_TYPE(MoviePrePrerollCompleteProcPtr) MoviePrePrerollCompleteUPP;
Movies.h
Abst_MoviePreviewCallOutUPP
typedef STACK_UPP_TYPE(MoviePreviewCallOutProcPtr) MoviePreviewCallOutUPP;
Movies.h
Abst_MovieProgressUPP
typedef STACK_UPP_TYPE(MovieProgressProcPtr) MovieProgressUPP;
Movies.h
Abst_MoviesErrorUPP
typedef STACK_UPP_TYPE(MoviesErrorProcPtr) MoviesErrorUPP;
Movies.h
Abst_OSErr
typedef SInt16 OSErr;
IOMacOSTypes.h
Abst_OSStatus
typedef SInt32 OSStatus;
OSTypes.h
Abst_PicHandle
typedef PicPtr * PicHandle;
QuickdrawTypes.h
Abst_PicPtr
typedef Picture * PicPtr;
QuickdrawTypes.h
Abst_PixMapHandle
typedef PixMapPtr * PixMapHandle;
QuickdrawTypes.h
Abst_PixMapPtr
typedef PixMap * PixMapPtr;
QuickdrawTypes.h
Abst_QTAtom
typedef long QTAtom;
Movies.h
Abst_QTAtomContainer
typedef Handle QTAtomContainer;
Movies.h
Abst_QTAtomID
typedef long QTAtomID;
Movies.h
Abst_QTCallBack
typedef CallBackRecord * QTCallBack;
Movies.h
Abst_QTCallBackUPP
typedef STACK_UPP_TYPE(QTCallBackProcPtr) QTCallBackUPP;
Movies.h
Abst_QTEventRecordPtr
typedef QTEventRecord * QTEventRecordPtr;
Movies.h
Abst_QTNextTaskNeededSoonerCallbackUPP
typedef STACK_UPP_TYPE(QTNextTaskNeededSoonerCallbackProcPtr) QTNextTaskNeededSoonerCallbackUPP;
Movies.h
Abst_QTParameterDialog
typedef long QTParameterDialog;
Movies.h
Abst_QTParameterDialogOptions
typedef long QTParameterDialogOptions;
Movies.h
Abst_RgnHandle
typedef RgnPtr * RgnHandle;
QuickdrawTypes.h
Abst_RgnPtr
typedef MacRegion * RgnPtr;
QuickdrawTypes.h
Abst_SampleDescriptionHandle
typedef SampleDescriptionPtr * SampleDescriptionHandle;
Movies.h
Abst_SampleDescriptionPtr
typedef SampleDescription * SampleDescriptionPtr;
Movies.h
Abst_ScriptCode
typedef SInt16 ScriptCode;
MacTypes.h
Abst_Size
typedef long Size;
MacTypes.h
Abst_SoundDescriptionHandle
typedef SoundDescriptionPtr * SoundDescriptionHandle;
Movies.h
Abst_SoundDescriptionPtr
typedef SoundDescription * SoundDescriptionPtr;
Movies.h
Abst_Str255
typedef unsigned char Str255;
MacTypes.h
Abst_StringPtr
typedef unsigned char * StringPtr;
MacTypes.h
Abst_TextMediaUPP
typedef STACK_UPP_TYPE(TextMediaProcPtr) TextMediaUPP;
Movies.h
Abst_TimeBase
typedef TimeBaseRecord * TimeBase;
MacTypes.h
Abst_TimeScale
typedef long TimeScale;
MacTypes.h
Abst_TimeValue
typedef long TimeValue;
MacTypes.h
Abst_TimeValue64
typedef SInt64 TimeValue64;
MacTypes.h
Abst_Track
typedef TrackRecord * Track;
Movies.h
Abst_TrackTransferUPP
typedef STACK_UPP_TYPE(TrackTransferProcPtr) TrackTransferUPP;
Movies.h
Abst_UserData
typedef UserDataRecord * UserData;
Movies.h
Abst_VdigIntUPP
typedef STACK_UPP_TYPE(VdigIntProcPtr) VdigIntUPP;
QuickTimeComponents.h
Abst_WindowPtr
typedef GrafPtr WindowPtr;
QuickdrawTypes.h
Abst_WindowRef
typedef WindowPtr WindowRef;
QuickdrawTypes.h
© 2006 Apple Computer, Inc. All Rights Reserved. (Last updated: 2006-05-23)