mirror of
https://github.com/elliotnunn/supermario.git
synced 2024-11-26 01:49:19 +00:00
1521 lines
48 KiB
R
1521 lines
48 KiB
R
/*
|
||
Pict.r -- Type Declaration for Rez and DeRez
|
||
|
||
Copyright Apple Computer, Inc. 1986-1989
|
||
All rights reserved.
|
||
|
||
This PICT resource definition should probably used
|
||
for DeRez’ing purposes only.
|
||
|
||
*/
|
||
|
||
#ifndef __PICT.R__
|
||
#define __PICT.R__
|
||
|
||
type 'PICT' {
|
||
startOfPict:
|
||
unsigned integer = (endOfPict - startOfPict) >> 3;
|
||
Rect; /* Bounds of picture */
|
||
switch {
|
||
case VersionOne:
|
||
key integer = $1101;
|
||
array OpCodes {
|
||
switch {
|
||
case NOP:
|
||
key byte = $00;
|
||
|
||
case clipRgn:
|
||
key byte = $01;
|
||
clipRgnStart: integer = (clipRgnEnd[$$ArrayIndex(OpCodes)] - clipRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(clipRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
clipRgnEnd:
|
||
case bkPat:
|
||
key byte = $02;
|
||
hex string [8];
|
||
|
||
case txFont:
|
||
key byte = $03;
|
||
integer; /* font */
|
||
|
||
case txFace:
|
||
key byte = $04;
|
||
unsigned hex byte; /* text face */
|
||
|
||
case txMode:
|
||
key byte = $05;
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic;
|
||
|
||
case spExtra:
|
||
key byte = $06;
|
||
unsigned hex longint;
|
||
|
||
case pnSize:
|
||
key byte = $07;
|
||
Point;
|
||
|
||
case pnMode:
|
||
key byte = $08;
|
||
unsigned hex integer;
|
||
|
||
case pnPat:
|
||
key byte = $09;
|
||
hex string [8];
|
||
|
||
case thePat:
|
||
key byte = $0A;
|
||
hex string [8];
|
||
|
||
case ovSize:
|
||
key byte = $0B;
|
||
Point;
|
||
|
||
case origin:
|
||
key byte = $0C;
|
||
integer; /* dh */
|
||
integer; /* dv */
|
||
|
||
case txSize:
|
||
key byte = $0D;
|
||
integer;
|
||
|
||
case fgColor:
|
||
key byte = $0E;
|
||
longint;
|
||
|
||
case bkColor:
|
||
key byte = $0F;
|
||
longint;
|
||
|
||
case txRatio:
|
||
key byte = $10;
|
||
Point; /* numer */
|
||
Point; /* denom */
|
||
|
||
case picVersion:
|
||
key byte = $11;
|
||
byte;
|
||
|
||
case line:
|
||
key byte = $20;
|
||
Point; /* pnLoc */
|
||
Point; /* newPt */
|
||
|
||
case lineFrom:
|
||
key byte = $21;
|
||
Point; /* newPt */
|
||
|
||
case shortLine:
|
||
key byte = $22;
|
||
Point; /* pnLoc */
|
||
byte; /* dh */
|
||
byte; /* dv */
|
||
|
||
case shortLineFrom:
|
||
key byte = $23;
|
||
byte; /* dh */
|
||
byte; /* dv */
|
||
|
||
case longText:
|
||
key byte = $28;
|
||
Point; /* txLoc */
|
||
pstring;
|
||
|
||
case dhText:
|
||
key byte = $29;
|
||
byte; /* dh */
|
||
pstring;
|
||
|
||
case dvText:
|
||
key byte = $2A;
|
||
byte; /* dvh */
|
||
pstring;
|
||
|
||
case dhdvText:
|
||
key byte = $2B;
|
||
byte; /* dh */
|
||
byte; /* dv */
|
||
pstring;
|
||
|
||
case frameRect:
|
||
key byte = $30;
|
||
Rect;
|
||
|
||
case paintRect:
|
||
key byte = $31;
|
||
Rect;
|
||
|
||
case eraseRect:
|
||
key byte = $32;
|
||
Rect;
|
||
|
||
case invertRect:
|
||
key byte = $33;
|
||
Rect;
|
||
|
||
case fillRect:
|
||
key byte = $34;
|
||
Rect;
|
||
|
||
case frameSameRect:
|
||
key byte = $38;
|
||
|
||
case paintSameRect:
|
||
key byte = $39;
|
||
|
||
case eraseSameRect:
|
||
key byte = $3A;
|
||
|
||
case invertSameRect:
|
||
key byte = $3B;
|
||
|
||
case fillSameRect:
|
||
key byte = $3C;
|
||
|
||
case frameRRect:
|
||
key byte = $40;
|
||
Rect;
|
||
|
||
case paintRRect:
|
||
key byte = $41;
|
||
Rect;
|
||
|
||
case eraseRRect:
|
||
key byte = $42;
|
||
Rect;
|
||
|
||
case invertRRect:
|
||
key byte = $43;
|
||
Rect;
|
||
|
||
case fillRRect:
|
||
key byte = $44;
|
||
Rect;
|
||
|
||
case frameSameRRect:
|
||
key byte = $48;
|
||
|
||
case paintSameRRect:
|
||
key byte = $49;
|
||
|
||
case eraseSameRRect:
|
||
key byte = $4A;
|
||
|
||
case invertSameRRect:
|
||
key byte = $4B;
|
||
|
||
case fillSameRRect:
|
||
key byte = $4C;
|
||
|
||
case frameOval:
|
||
key byte = $50;
|
||
Rect;
|
||
|
||
case paintOval:
|
||
key byte = $51;
|
||
Rect;
|
||
|
||
case eraseOval:
|
||
key byte = $52;
|
||
Rect;
|
||
|
||
case invertOval:
|
||
key byte = $53;
|
||
Rect;
|
||
|
||
case fillOval:
|
||
key byte = $54;
|
||
Rect;
|
||
|
||
case frameSameOval:
|
||
key byte = $58;
|
||
|
||
case paintSameOval:
|
||
key byte = $59;
|
||
|
||
case eraseSameOval:
|
||
key byte = $5A;
|
||
|
||
case invertSameOval:
|
||
key byte = $5B;
|
||
|
||
case fillSameOval:
|
||
key byte = $5C;
|
||
|
||
case frameArc:
|
||
key byte = $60;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case paintArc:
|
||
key byte = $61;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case eraseArc:
|
||
key byte = $62;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case invertArc:
|
||
key byte = $63;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case fillArc:
|
||
key byte = $64;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case frameSameArc:
|
||
key byte = $68;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case paintSameArc:
|
||
key byte = $69;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case eraseSameArc:
|
||
key byte = $6A;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case invertSameArc:
|
||
key byte = $6B;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case fillSameArc:
|
||
key byte = $6C;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case framePoly:
|
||
key byte = $70;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case paintPoly:
|
||
key byte = $71;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case erasePoly:
|
||
key byte = $72;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case invertPoly:
|
||
key byte = $73;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case fillPoly:
|
||
key byte = $74;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case frameSamePoly:
|
||
key byte = $78;
|
||
|
||
case paintSamePoly:
|
||
key byte = $79;
|
||
|
||
case eraseSamePoly:
|
||
key byte = $7A;
|
||
|
||
case invertSamePoly:
|
||
key byte = $7B;
|
||
|
||
case fillSamePoly:
|
||
key byte = $7C;
|
||
|
||
case frameRgn:
|
||
key byte = $80;
|
||
frameRgnStart: integer = (frameRgnEnd[$$ArrayIndex(OpCodes)] - frameRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(frameRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
frameRgnEnd:
|
||
case paintRgn:
|
||
key byte = $81;
|
||
paintRgnStart: integer = (paintRgnEnd[$$ArrayIndex(OpCodes)] - paintRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(paintRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
paintRgnEnd:
|
||
case eraseRgn:
|
||
key byte = $82;
|
||
eraseRgnStart: integer = (eraseRgnEnd[$$ArrayIndex(OpCodes)] - eraseRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(eraseRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
eraseRgnEnd:
|
||
case invertRgn:
|
||
key byte = $83;
|
||
invertRgnStart: integer = (invertRgnEnd[$$ArrayIndex(OpCodes)] - invertRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(invertRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
invertRgnEnd:
|
||
case fillRgn:
|
||
key byte = $84;
|
||
fillRgnStart: integer = (fillRgnEnd[$$ArrayIndex(OpCodes)] - fillRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(fillRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
fillRgnEnd:
|
||
case frameSameRgn:
|
||
key byte = $88;
|
||
|
||
case paintSameRgn:
|
||
key byte = $89;
|
||
|
||
case eraseSameRgn:
|
||
key byte = $8A;
|
||
|
||
case invertSameRgn:
|
||
key byte = $8B;
|
||
|
||
case fillSameRgn:
|
||
key byte = $8C;
|
||
|
||
case bitsRect:
|
||
key byte = $90;
|
||
BitsRectRowBytes: integer; /* row bytes */
|
||
BitsRectBounds: Rect; /* bounds */
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic;
|
||
hex string [($$BitField(BitsRectBounds[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(BitsRectBounds[$$ArrayIndex(OpCodes)],0,16))
|
||
* $$Word(BitsRectRowBytes[$$ArrayIndex(OpCodes)])];
|
||
|
||
case bitsRgn:
|
||
key byte = $91;
|
||
BitsRgnRowBytes: integer; /* row bytes */
|
||
BitsRgnBounds: Rect; /* bounds */
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic;
|
||
bitsRgnStart: integer = (bitsRgnEnd[$$ArrayIndex(OpCodes)] - bitsRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(bitsRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
bitsRgnEnd:
|
||
hex string [($$BitField(BitsRgnBounds[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(BitsRgnBounds[$$ArrayIndex(OpCodes)],0,16))
|
||
* $$Word(BitsRgnRowBytes[$$ArrayIndex(OpCodes)])];
|
||
|
||
case packBitsRect:
|
||
key byte = $98;
|
||
PackBitsRectRowBytes: integer; /* row bytes */
|
||
PackBitsRectBounds: Rect; /* bounds */
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic;
|
||
PackBitsBits: hex string [$$PackedSize(PackBitsBits[$$ArrayIndex(OpCodes)],
|
||
$$Word(PackBitsRectRowBytes[$$ArrayIndex(OpCodes)]),
|
||
($$BitField(PackBitsRectBounds[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(PackBitsRectBounds[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case packBitsRgn:
|
||
key byte = $99;
|
||
packBitsRgnRowBytes: integer; /* row bytes */
|
||
packBitsRgnBounds: Rect; /* bounds */
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic;
|
||
packBitsRgnStart: integer = (packBitsRgnEnd[$$ArrayIndex(OpCodes)] - packBitsRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(packBitsRgnStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
packBitsRgnEnd: hex string [$$PackedSize(packBitsRgnEnd[$$ArrayIndex(OpCodes)],
|
||
$$Word(packBitsRgnRowBytes[$$ArrayIndex(OpCodes)]),
|
||
($$BitField(packBitsRgnBounds[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(packBitsRgnBounds[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case shortComment:
|
||
key byte = $A0;
|
||
integer; /* kind */
|
||
|
||
case longComment:
|
||
key byte = $A1;
|
||
integer; /* kind */
|
||
longCommentStart: integer = (longCommentEnd[$$ArrayIndex(OpCodes)] - longCommentStart[$$ArrayIndex(OpCodes)] - 16) >> 3;
|
||
hex string [$$Word(longCommentStart[$$ArrayIndex(OpCodes)])];
|
||
longCommentEnd:
|
||
};
|
||
};
|
||
byte = $FF; /* End of picture */
|
||
|
||
case VersionTwo:
|
||
key longint = $001102ff; /* Version op + version */
|
||
array OpCodes {
|
||
switch {
|
||
case Clip:
|
||
key integer = $0001;
|
||
ClipStart: integer = (ClipEnd[$$ArrayIndex(OpCodes)] - ClipStart[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(ClipStart[$$ArrayIndex(OpCodes)]) - 10];
|
||
ClipEnd:
|
||
case BkPat:
|
||
key integer = $0002;
|
||
hex string [8];
|
||
|
||
case TxFont:
|
||
key integer = $0003;
|
||
integer; /* font */
|
||
|
||
case TxFace:
|
||
key integer = $0004;
|
||
unsigned hex byte; /* text face */
|
||
|
||
case TxMode:
|
||
key integer = $0005;
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic;
|
||
|
||
case SpExtra:
|
||
key integer = $0006;
|
||
unsigned hex longint;
|
||
|
||
case PnSize:
|
||
key integer = $0007;
|
||
Point;
|
||
|
||
case PnMode:
|
||
key integer = $0008;
|
||
unsigned hex integer;
|
||
|
||
case PnPat:
|
||
key integer = $0009;
|
||
hex string [8];
|
||
|
||
case FillPat:
|
||
key integer = $000A;
|
||
hex string [8];
|
||
|
||
case OvSize:
|
||
key integer = $000B;
|
||
Point;
|
||
|
||
case Origin:
|
||
key integer = $000C;
|
||
integer; /* dh */
|
||
integer; /* dv */
|
||
|
||
case TxSize:
|
||
key integer = $000D;
|
||
integer;
|
||
|
||
case FgColor:
|
||
key integer = $000E;
|
||
longint;
|
||
|
||
case BkColor:
|
||
key integer = $000F;
|
||
longint;
|
||
|
||
case TxRatio:
|
||
key integer = $0010;
|
||
Point; /* numer */
|
||
Point; /* denom */
|
||
|
||
case Version:
|
||
key integer = $0011;
|
||
byte;
|
||
|
||
case BkPixPat:
|
||
key integer = $0012;
|
||
switch {
|
||
case newPattern:
|
||
key integer = 1;
|
||
hex string [8]; /* old-style pattern */
|
||
unsigned bitstring[1] = 1; /* New pixMap flag */
|
||
unsigned bitstring[2] = 0; /* Must be 0 */
|
||
BkPixPatpMapRowBytes: unsigned bitstring[13]; /* Offset to next row */
|
||
BkPixPatBounds: rect; /* Bitmap bounds */
|
||
integer; /* pixMap vers number */
|
||
integer unpacked; /* Packing format */
|
||
unsigned longint; /* Size of pixel data */
|
||
unsigned hex longint; /* h. resolution (ppi) (fixed) */
|
||
unsigned hex longint; /* v. resolution (ppi) (fixed) */
|
||
integer chunky, chunkyPlanar, planar; /* Pixel storage format */
|
||
integer; /* # bits in pixel */
|
||
integer; /* # components in pixel*/
|
||
integer; /* # bits per field */
|
||
unsigned longint; /* Offset to next plane */
|
||
unsigned longint; /* Offset to color table*/
|
||
fill long; /* Reserved */
|
||
/* Color Table */
|
||
unsigned hex longint; /* ctSeed */
|
||
integer; /* ctFlags */
|
||
integer = $$Countof(ColorSpec) - 1; /* ctSize */
|
||
wide array ColorSpec {
|
||
integer; /* value */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
/* If rowBytes < 8 then data is unpacked,
|
||
if >= 8, then data is packed */
|
||
BkPixPatBits: hex string [($$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
|
||
$$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
|
||
($$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
|
||
$$PackedSize(BkPixPatBits[$$ArrayIndex(OpCodes)],
|
||
$$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
|
||
($$BitField(BkPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(BkPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case ditherPattern:
|
||
key integer = 2;
|
||
hex string [8]; /* old-style pattern */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
|
||
case PnPixPat:
|
||
key integer = $0013;
|
||
switch {
|
||
case newPattern:
|
||
key integer = 1;
|
||
hex string [8]; /* old-style pattern */
|
||
unsigned bitstring[1] = 1; /* New pixMap flag */
|
||
unsigned bitstring[2] = 0; /* Must be 0 */
|
||
PnPixPatpMapRowBytes: unsigned bitstring[13]; /* Offset to next row */
|
||
PnPixPatBounds: rect; /* Bitmap bounds */
|
||
integer; /* pixMap vers number */
|
||
integer unpacked; /* Packing format */
|
||
unsigned longint; /* Size of pixel data */
|
||
unsigned hex longint; /* h. resolution (ppi) (fixed) */
|
||
unsigned hex longint; /* v. resolution (ppi) (fixed) */
|
||
integer chunky, chunkyPlanar, planar; /* Pixel storage format */
|
||
integer; /* # bits in pixel */
|
||
integer; /* # components in pixel*/
|
||
integer; /* # bits per field */
|
||
unsigned longint; /* Offset to next plane */
|
||
unsigned longint; /* Offset to color table*/
|
||
fill long; /* Reserved */
|
||
/* Color Table */
|
||
unsigned hex longint; /* ctSeed */
|
||
integer; /* ctFlags */
|
||
integer = $$Countof(ColorSpec) - 1; /* ctSize */
|
||
wide array ColorSpec {
|
||
integer; /* value */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
/* If rowBytes < 8 then data is unpacked,
|
||
if >= 8, then data is packed */
|
||
PnPixPatBits: hex string [($$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
|
||
$$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
|
||
($$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
|
||
$$PackedSize(PnPixPatBits[$$ArrayIndex(OpCodes)],
|
||
$$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
|
||
($$BitField(PnPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(PnPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case ditherPattern:
|
||
key integer = 2;
|
||
hex string [8]; /* old-style pattern */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
|
||
case FillPixPat:
|
||
key integer = $0014;
|
||
switch {
|
||
case newPattern:
|
||
key integer = 1;
|
||
hex string [8]; /* old-style pattern */
|
||
unsigned bitstring[1] = 1; /* New pixMap flag */
|
||
unsigned bitstring[2] = 0; /* Must be 0 */
|
||
FillPixPatpMapRowBytes: unsigned bitstring[13]; /* Offset to next row */
|
||
FillPixPatBounds: rect; /* Bitmap bounds */
|
||
integer; /* pixMap vers number */
|
||
integer unpacked; /* Packing format */
|
||
unsigned longint; /* Size of pixel data */
|
||
unsigned hex longint; /* h. resolution (ppi) (fixed) */
|
||
unsigned hex longint; /* v. resolution (ppi) (fixed) */
|
||
integer chunky, chunkyPlanar, planar; /* Pixel storage format */
|
||
integer; /* # bits in pixel */
|
||
integer; /* # components in pixel*/
|
||
integer; /* # bits per field */
|
||
unsigned longint; /* Offset to next plane */
|
||
unsigned longint; /* Offset to color table*/
|
||
fill long; /* Reserved */
|
||
/* Color Table */
|
||
unsigned hex longint; /* ctSeed */
|
||
integer; /* ctFlags */
|
||
integer = $$Countof(ColorSpec) - 1; /* ctSize */
|
||
wide array ColorSpec {
|
||
integer; /* value */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
/* If rowBytes < 8 then data is unpacked,
|
||
if >= 8, then data is packed */
|
||
FillPixPatBits: hex string [($$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
|
||
$$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
|
||
($$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
|
||
$$PackedSize(FillPixPatBits[$$ArrayIndex(OpCodes)],
|
||
$$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
|
||
($$BitField(FillPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(FillPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case ditherPattern:
|
||
key integer = 2;
|
||
hex string [8]; /* old-style pattern */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
|
||
case PnLocHFrac:
|
||
key integer = $0015;
|
||
unsigned hex integer;
|
||
|
||
case ChExtra:
|
||
key integer = $0016;
|
||
integer; /* extra for each character */
|
||
|
||
case AppleReserved0017:
|
||
key integer = $0017;
|
||
|
||
case AppleReserved0018:
|
||
key integer = $0018;
|
||
|
||
case AppleReserved0019:
|
||
key integer = $0019;
|
||
|
||
case RGBFgCol:
|
||
key integer = $001A;
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
|
||
case RGBBkCol:
|
||
key integer = $001B;
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
|
||
case HiliteMode:
|
||
key integer = $001C;
|
||
|
||
case HiliteColor:
|
||
key integer = $001D;
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
|
||
case DefHilite:
|
||
key integer = $001E;
|
||
|
||
case OpColor:
|
||
key integer = $001F;
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
|
||
case Line:
|
||
key integer = $0020;
|
||
Point; /* pnLoc */
|
||
Point; /* newPt */
|
||
|
||
case LineFrom:
|
||
key integer = $0021;
|
||
Point; /* newPt */
|
||
|
||
case ShortLine:
|
||
key integer = $0022;
|
||
Point; /* pnLoc */
|
||
byte; /* dh */
|
||
byte; /* dv */
|
||
|
||
case ShortLineFrom:
|
||
key integer = $0023;
|
||
byte; /* dh */
|
||
byte; /* dv */
|
||
|
||
case AppleReserved0024:
|
||
key integer = $0024;
|
||
AR24: unsigned integer = (AR24End - AR24) / 8 - 2;
|
||
hex string [$$Word(AR24)];
|
||
AR24End:
|
||
|
||
case AppleReserved0025:
|
||
key integer = $0025;
|
||
AR25: unsigned integer = (AR25End - AR25) / 8 - 2;
|
||
hex string [$$Word(AR25)];
|
||
AR25End:
|
||
|
||
case AppleReserved0026:
|
||
key integer = $0026;
|
||
AR26: unsigned integer = (AR26End - AR26) / 8 - 2;
|
||
hex string [$$Word(AR26)];
|
||
AR26End:
|
||
|
||
case AppleReserved0027:
|
||
key integer = $0027;
|
||
AR27: unsigned integer = (AR27End - AR27) / 8 - 2;
|
||
hex string [$$Word(AR27)];
|
||
AR27End:
|
||
|
||
case LongText:
|
||
key integer = $0028;
|
||
Point; /* txLoc */
|
||
pstring; /* text */
|
||
|
||
case DHText:
|
||
key integer = $0029;
|
||
byte; /* dh */
|
||
pstring; /* text */
|
||
|
||
case DVText:
|
||
key integer = $002A;
|
||
byte; /* dv */
|
||
pstring; /* text */
|
||
|
||
case DHDVText:
|
||
key integer = $002A;
|
||
byte; /* dh */
|
||
byte; /* dv */
|
||
pstring; /* text */
|
||
|
||
case AppleReserved002C:
|
||
key integer = $002C;
|
||
AR2C: unsigned integer = (AR2CEnd - AR2C) / 8 - 2;
|
||
hex string [$$Word(AR2C)];
|
||
AR2CEnd:
|
||
|
||
case AppleReserved002D:
|
||
key integer = $002D;
|
||
AR2D: unsigned integer = (AR2DEnd - AR2D) / 8 - 2;
|
||
hex string [$$Word(AR2D)];
|
||
AR2DEnd:
|
||
|
||
case AppleReserved002E:
|
||
key integer = $002E;
|
||
AR2E: unsigned integer = (AR2EEnd - AR2E) / 8 - 2;
|
||
hex string [$$Word(AR2E)];
|
||
AR2EEnd:
|
||
|
||
case AppleReserved002F:
|
||
key integer = $002F;
|
||
AR2F: unsigned integer = (AR2FEnd - AR2F) / 8 - 2;
|
||
hex string [$$Word(AR2F)];
|
||
AR2FEnd:
|
||
|
||
case FrameRect:
|
||
key integer = $0030;
|
||
Rect;
|
||
|
||
case PaintRect:
|
||
key integer = $0031;
|
||
Rect;
|
||
|
||
case EraseRect:
|
||
key integer = $0032;
|
||
Rect;
|
||
|
||
case InvertRect:
|
||
key integer = $0033;
|
||
Rect;
|
||
|
||
case FillRect:
|
||
key integer = $0034;
|
||
Rect;
|
||
|
||
case AppleReserved0035:
|
||
key integer = $0035;
|
||
Rect;
|
||
|
||
case AppleReserved0036:
|
||
key integer = $0036;
|
||
Rect;
|
||
|
||
case AppleReserved0037:
|
||
key integer = $0037;
|
||
Rect;
|
||
|
||
case FrameSameRect:
|
||
key integer = $0038;
|
||
|
||
case PaintSameRect:
|
||
key integer = $0039;
|
||
|
||
case EraseSameRect:
|
||
key integer = $003A;
|
||
|
||
case InvertSameRect:
|
||
key integer = $003B;
|
||
|
||
case FillSameRect:
|
||
key integer = $003C;
|
||
|
||
case AppleReserved003D:
|
||
key integer = $003D;
|
||
|
||
case AppleReserved003E:
|
||
key integer = $003E;
|
||
|
||
case AppleReserved003F:
|
||
key integer = $003F;
|
||
|
||
case FrameRRect:
|
||
key integer = $0040;
|
||
Rect;
|
||
|
||
case PaintRRect:
|
||
key integer = $0041;
|
||
Rect;
|
||
|
||
case EraseRRect:
|
||
key integer = $0042;
|
||
Rect;
|
||
|
||
case InvertRRect:
|
||
key integer = $0043;
|
||
Rect;
|
||
|
||
case FillRRect:
|
||
key integer = $0044;
|
||
Rect;
|
||
|
||
case AppleReserved0045:
|
||
key integer = $0045;
|
||
Rect;
|
||
|
||
case AppleReserved0046:
|
||
key integer = $0046;
|
||
Rect;
|
||
|
||
case AppleReserved0047:
|
||
key integer = $0047;
|
||
Rect;
|
||
|
||
case FrameSameRRect:
|
||
key integer = $0048;
|
||
|
||
case PaintSameRRect:
|
||
key integer = $0049;
|
||
|
||
case EraseSameRRect:
|
||
key integer = $004A;
|
||
|
||
case InvertSameRRect:
|
||
key integer = $004B;
|
||
|
||
case FillSameRRect:
|
||
key integer = $004C;
|
||
|
||
case AppleReserved004D:
|
||
key integer = $004D;
|
||
|
||
case AppleReserved004E:
|
||
key integer = $004E;
|
||
|
||
case AppleReserved004F:
|
||
key integer = $004F;
|
||
|
||
case FrameOval:
|
||
key integer = $0050;
|
||
Rect;
|
||
|
||
case PaintOval:
|
||
key integer = $0051;
|
||
Rect;
|
||
|
||
case EraseOval:
|
||
key integer = $0052;
|
||
Rect;
|
||
|
||
case InvertOval:
|
||
key integer = $0053;
|
||
Rect;
|
||
|
||
case FillOval:
|
||
key integer = $0054;
|
||
Rect;
|
||
|
||
case AppleReserved0055:
|
||
key integer = $0055;
|
||
Rect;
|
||
|
||
case AppleReserved0056:
|
||
key integer = $0056;
|
||
Rect;
|
||
|
||
case AppleReserved0057:
|
||
key integer = $0057;
|
||
Rect;
|
||
|
||
case FrameSameOval:
|
||
key integer = $0058;
|
||
|
||
case PaintSameOval:
|
||
key integer = $0059;
|
||
|
||
case EraseSameOval:
|
||
key integer = $005A;
|
||
|
||
case InvertSameOval:
|
||
key integer = $005B;
|
||
|
||
case FillSameOval:
|
||
key integer = $005C;
|
||
|
||
case AppleReserved005D:
|
||
key integer = $005D;
|
||
|
||
case AppleReserved005E:
|
||
key integer = $005E;
|
||
|
||
case frameArc:
|
||
key integer = $0060;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case paintArc:
|
||
key integer = $0061;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case eraseArc:
|
||
key integer = $0062;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case invertArc:
|
||
key integer = $0063;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case fillArc:
|
||
key integer = $0064;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case AppleReserved0065:
|
||
key integer = $0065;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case AppleReserved0066:
|
||
key integer = $0066;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case AppleReserved0067:
|
||
key integer = $0067;
|
||
Rect;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case frameSameArc:
|
||
key integer = $0068;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case paintSameArc:
|
||
key integer = $0069;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case eraseSameArc:
|
||
key integer = $006A;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case invertSameArc:
|
||
key integer = $006B;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case fillSameArc:
|
||
key integer = $006C;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case AppleReserved006D:
|
||
key integer = $006D;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case AppleReserved006E:
|
||
key integer = $006E;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case AppleReserved006F:
|
||
key integer = $006F;
|
||
integer; /* startAngle */
|
||
integer; /* arcAngle */
|
||
|
||
case framePoly:
|
||
key integer = $0070;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case paintPoly:
|
||
key integer = $0071;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case erasePoly:
|
||
key integer = $0072;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case invertPoly:
|
||
key integer = $0073;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case fillPoly:
|
||
key integer = $0074;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case AppleReserved0075:
|
||
key integer = $0075;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case AppleReserved0076:
|
||
key integer = $0076;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case AppleReserved0077:
|
||
key integer = $0077;
|
||
integer = $$CountOf(framePoly) * 4 + 10;
|
||
Rect; /* enclosing rectangle */
|
||
array framePoly {
|
||
Point;
|
||
};
|
||
|
||
case frameSamePoly:
|
||
key integer = $0078;
|
||
|
||
case paintSamePoly:
|
||
key integer = $0079;
|
||
|
||
case eraseSamePoly:
|
||
key integer = $007A;
|
||
|
||
case invertSamePoly:
|
||
key integer = $007B;
|
||
|
||
case fillSamePoly:
|
||
key integer = $007C;
|
||
|
||
case AppleReserved007D:
|
||
key integer = $007D;
|
||
|
||
case AppleReserved007E:
|
||
key integer = $007E;
|
||
|
||
case AppleReserved007F:
|
||
key integer = $007F;
|
||
|
||
case frameRgn:
|
||
key integer = $0080;
|
||
frameRgnStart2: integer = (frameRgnEnd2[$$ArrayIndex(OpCodes)] - frameRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(frameRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
|
||
frameRgnEnd2:
|
||
case paintRgn:
|
||
key integer = $0081;
|
||
paintRgnStart2: integer = (paintRgnEnd2[$$ArrayIndex(OpCodes)] - paintRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(paintRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
|
||
paintRgnEnd2:
|
||
case eraseRgn:
|
||
key integer = $0082;
|
||
eraseRgnStart2: integer = (eraseRgnEnd2[$$ArrayIndex(OpCodes)] - eraseRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(eraseRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
|
||
eraseRgnEnd2:
|
||
case invertRgn:
|
||
key integer = $0083;
|
||
invertRgnStart2: integer = (invertRgnEnd2[$$ArrayIndex(OpCodes)] - invertRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(invertRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
|
||
invertRgnEnd2:
|
||
case fillRgn:
|
||
key integer = $0084;
|
||
fillRgnStart2: integer = (fillRgnEnd2[$$ArrayIndex(OpCodes)] - fillRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(fillRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
|
||
fillRgnEnd2:
|
||
case AppleReserved0085:
|
||
key integer = $0085;
|
||
AppleReserved0085Start:integer = (AppleReserved0085End[$$ArrayIndex(OpCodes)] - AppleReserved0085Start[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(AppleReserved0085Start[$$ArrayIndex(OpCodes)]) - 10];
|
||
AppleReserved0085End:
|
||
case AppleReserved0086:
|
||
key integer = $0086;
|
||
AppleReserved0086Start: integer = (AppleReserved0086End[$$ArrayIndex(OpCodes)] - AppleReserved0086Start[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(AppleReserved0086Start[$$ArrayIndex(OpCodes)]) - 10];
|
||
AppleReserved0086End:
|
||
case AppleReserved0087:
|
||
key integer = $0087;
|
||
AppleReserved0087Start: integer = (AppleReserved0087End[$$ArrayIndex(OpCodes)] - AppleReserved0087Start[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(AppleReserved0087Start[$$ArrayIndex(OpCodes)]) - 10];
|
||
AppleReserved0087End:
|
||
case frameSameRgn:
|
||
key integer = $0088;
|
||
|
||
case paintSameRgn:
|
||
key integer = $0089;
|
||
|
||
case eraseSameRgn:
|
||
key integer = $008A;
|
||
|
||
case invertSameRgn:
|
||
key integer = $008B;
|
||
|
||
case fillSameRgn:
|
||
key integer = $008C;
|
||
|
||
case AppleReserved008D:
|
||
key integer = $008D;
|
||
|
||
case AppleReserved008E:
|
||
key integer = $008E;
|
||
|
||
case AppleReserved008F:
|
||
key integer = $008F;
|
||
|
||
case BitsRect:
|
||
key integer = $0090;
|
||
unsigned bitstring[1] = 1; /* New pixMap flag */
|
||
unsigned bitstring[2] = 0; /* Must be 0 */
|
||
BitsRectpMapRowBytes: unsigned bitstring[13]; /* Offset to next row */
|
||
BitsRectBounds2: rect; /* Bitmap bounds */
|
||
integer; /* pixMap vers number */
|
||
integer unpacked; /* Packing format */
|
||
unsigned longint; /* Size of pixel data */
|
||
unsigned hex longint; /* h. resolution (ppi) (fixed) */
|
||
unsigned hex longint; /* v. resolution (ppi) (fixed) */
|
||
integer chunky, chunkyPlanar, planar; /* Pixel storage format */
|
||
integer; /* # bits in pixel */
|
||
integer; /* # components in pixel*/
|
||
integer; /* # bits per field */
|
||
unsigned longint; /* Offset to next plane */
|
||
unsigned longint; /* Offset to color table*/
|
||
fill long; /* Reserved */
|
||
/* Color Table */
|
||
unsigned hex longint; /* ctSeed */
|
||
integer; /* ctFlags */
|
||
integer = $$Countof(ColorSpec) - 1; /* ctSize */
|
||
wide array ColorSpec {
|
||
integer; /* value */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic,
|
||
blend = 32, addPin, addOver, subPin,
|
||
adMax = 37, subOver, adMin;
|
||
BitsRectBits: hex string [$$BitField(BitsRectpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) *
|
||
($$BitField(BitsRectBounds2[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(BitsRectBounds2[$$ArrayIndex(OpCodes)],0,16))];
|
||
|
||
|
||
case BitsRgn:
|
||
key integer = $0091;
|
||
unsigned bitstring[1] = 1; /* New pixMap flag */
|
||
unsigned bitstring[2] = 0; /* Must be 0 */
|
||
BitsRgnpMapRowBytes: unsigned bitstring[13]; /* Offset to next row */
|
||
BitsRgnBounds2: rect; /* Bitmap bounds */
|
||
integer; /* pixMap vers number */
|
||
integer unpacked; /* Packing format */
|
||
unsigned longint; /* Size of pixel data */
|
||
unsigned hex longint; /* h. resolution (ppi) (fixed) */
|
||
unsigned hex longint; /* v. resolution (ppi) (fixed) */
|
||
integer chunky, chunkyPlanar, planar; /* Pixel storage format */
|
||
integer; /* # bits in pixel */
|
||
integer; /* # components in pixel*/
|
||
integer; /* # bits per field */
|
||
unsigned longint; /* Offset to next plane */
|
||
unsigned longint; /* Offset to color table*/
|
||
fill long; /* Reserved */
|
||
/* Color Table */
|
||
unsigned hex longint; /* ctSeed */
|
||
integer; /* ctFlags */
|
||
integer = $$Countof(ColorSpec) - 1; /* ctSize */
|
||
wide array ColorSpec {
|
||
integer; /* value */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic,
|
||
blend = 32, addPin, addOver, subPin,
|
||
adMax = 37, subOver, adMin;
|
||
BitsRgnStart2: integer = (BitsRgnEnd2[$$ArrayIndex(OpCodes)] - BitsRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(BitsRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
|
||
BitsRgnEnd2: hex string [$$PackedSize(BitsRgnEnd2[$$ArrayIndex(OpCodes)],
|
||
$$BitField(BitsRgnpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
|
||
($$BitField(BitsRgnBounds2[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(BitsRgnBounds2[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case AppleReserved0092:
|
||
key integer = $0092;
|
||
AppleReserved0092Start: unsigned integer = (AppleReserved0092End[$$ArrayIndex(OpCodes)] - AppleReserved0092Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved0092Start[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved0092End:
|
||
case AppleReserved0093:
|
||
key integer = $0093;
|
||
AppleReserved0093Start: unsigned integer = (AppleReserved0093End[$$ArrayIndex(OpCodes)] - AppleReserved0093Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved0093Start[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved0093End:
|
||
case AppleReserved0094:
|
||
key integer = $0094;
|
||
AppleReserved0094Start: unsigned integer = (AppleReserved0094End[$$ArrayIndex(OpCodes)] - AppleReserved0094Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved0094Start[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved0094End:
|
||
case AppleReserved0095:
|
||
key integer = $0095;
|
||
AppleReserved0095Start: unsigned integer = (AppleReserved0095End[$$ArrayIndex(OpCodes)] - AppleReserved0095Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved0095Start[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved0095End:
|
||
case AppleReserved0096:
|
||
key integer = $0096;
|
||
AppleReserved0096Start: unsigned integer = (AppleReserved0096End[$$ArrayIndex(OpCodes)] - AppleReserved0096Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved0096Start[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved0096End:
|
||
case AppleReserved0097:
|
||
key integer = $0097;
|
||
AppleReserved0097Start: unsigned integer = (AppleReserved0097End[$$ArrayIndex(OpCodes)] - AppleReserved0097Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved0097Start[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved0097End:
|
||
case PackBitsRect:
|
||
key integer = $0098;
|
||
unsigned bitstring[1] = 1; /* New pixMap flag */
|
||
unsigned bitstring[2] = 0; /* Must be 0 */
|
||
PackBitsRectpMapRowBytes:unsigned bitstring[13]; /* Offset to next row */
|
||
PackBitsRectBounds2: rect; /* Bitmap bounds */
|
||
integer; /* pixMap vers number */
|
||
integer unpacked; /* Packing format */
|
||
unsigned longint; /* Size of pixel data */
|
||
unsigned hex longint; /* h. resolution (ppi) (fixed) */
|
||
unsigned hex longint; /* v. resolution (ppi) (fixed) */
|
||
integer chunky, chunkyPlanar, planar; /* Pixel storage format */
|
||
integer; /* # bits in pixel */
|
||
integer; /* # components in pixel*/
|
||
integer; /* # bits per field */
|
||
unsigned longint; /* Offset to next plane */
|
||
unsigned longint; /* Offset to color table*/
|
||
fill long; /* Reserved */
|
||
/* Color Table */
|
||
unsigned hex longint; /* ctSeed */
|
||
integer; /* ctFlags */
|
||
integer = $$Countof(ColorSpec) - 1; /* ctSize */
|
||
wide array ColorSpec {
|
||
integer; /* value */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic,
|
||
blend = 32, addPin, addOver, subPin,
|
||
adMax = 37, subOver, adMin;
|
||
PackBitsRectBits: hex string [$$PackedSize(PackBitsRectBits[$$ArrayIndex(OpCodes)],
|
||
$$BitField(PackBitsRectpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
|
||
($$BitField(PackBitsRectBounds2[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(PackBitsRectBounds2[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case PackBitsRgn:
|
||
key integer = $0099;
|
||
unsigned bitstring[1] = 1; /* New pixMap flag */
|
||
unsigned bitstring[2] = 0; /* Must be 0 */
|
||
PackBitsRgnpMapRowBytes:unsigned bitstring[13]; /* Offset to next row */
|
||
PackBitsRgnBounds2: rect; /* Bitmap bounds */
|
||
integer; /* pixMap vers number */
|
||
integer unpacked; /* Packing format */
|
||
unsigned longint; /* Size of pixel data */
|
||
unsigned hex longint; /* h. resolution (ppi) (fixed) */
|
||
unsigned hex longint; /* v. resolution (ppi) (fixed) */
|
||
integer chunky, chunkyPlanar, planar; /* Pixel storage format */
|
||
integer; /* # bits in pixel */
|
||
integer; /* # components in pixel*/
|
||
integer; /* # bits per field */
|
||
unsigned longint; /* Offset to next plane */
|
||
unsigned longint; /* Offset to color table*/
|
||
fill long; /* Reserved */
|
||
/* Color Table */
|
||
unsigned hex longint; /* ctSeed */
|
||
integer; /* ctFlags */
|
||
integer = $$Countof(ColorSpec) - 1; /* ctSize */
|
||
wide array ColorSpec {
|
||
integer; /* value */
|
||
unsigned integer; /* RGB: red */
|
||
unsigned integer; /* green */
|
||
unsigned integer; /* blue */
|
||
};
|
||
Rect; /* srcRect */
|
||
Rect; /* destRect */
|
||
integer srcCopy, srcOr, srcXor, srcBic, /* mode */
|
||
notSrcCopy, notSrcOr, notSrcXor,
|
||
notSrcBic, patCopy, patOr, patXor,
|
||
patBic, notPatCopy, notPatOr, notPatBic,
|
||
blend = 32, addPin, addOver, subPin,
|
||
adMax = 37, subOver, adMin;
|
||
packBitsRgnStart2: integer = (packBitsRgnEnd2[$$ArrayIndex(OpCodes)] - packBitsRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
|
||
Rect; /* region's enclosing rect */
|
||
hex string [$$Word(packBitsRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
|
||
packBitsRgnEnd2: hex string [$$PackedSize(packBitsRgnEnd2[$$ArrayIndex(OpCodes)],
|
||
$$BitField(PackBitsRgnpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
|
||
($$BitField(PackBitsRgnBounds2[$$ArrayIndex(OpCodes)],32,16)
|
||
- $$BitField(PackBitsRgnBounds2[$$ArrayIndex(OpCodes)],0,16)))];
|
||
|
||
case AppleReserved009A:
|
||
key integer = $009A;
|
||
AppleReserved009AStart: unsigned integer = (AppleReserved009AEnd[$$ArrayIndex(OpCodes)] - AppleReserved009AStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved009AStart[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved009AEnd:
|
||
case AppleReserved009B:
|
||
key integer = $009B;
|
||
AppleReserved009BStart: unsigned integer = (AppleReserved009BEnd[$$ArrayIndex(OpCodes)] - AppleReserved009BStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved009BStart[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved009BEnd:
|
||
case AppleReserved009C:
|
||
key integer = $009C;
|
||
AppleReserved009CStart: unsigned integer = (AppleReserved009CEnd[$$ArrayIndex(OpCodes)] - AppleReserved009CStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved009CStart[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved009CEnd:
|
||
case AppleReserved009D:
|
||
key integer = $009D;
|
||
AppleReserved009DStart: unsigned integer = (AppleReserved009DEnd[$$ArrayIndex(OpCodes)] - AppleReserved009DStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved009DStart[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved009DEnd:
|
||
case AppleReserved009E:
|
||
key integer = $009E;
|
||
AppleReserved009EStart: unsigned integer = (AppleReserved009EEnd[$$ArrayIndex(OpCodes)] - AppleReserved009EStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved009EStart[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved009EEnd:
|
||
case AppleReserved009F:
|
||
key integer = $009F;
|
||
AppleReserved009FStart: unsigned integer = (AppleReserved009FEnd[$$ArrayIndex(OpCodes)] - AppleReserved009FStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
|
||
hex string [$$Word(AppleReserved009FStart[$$ArrayIndex(OpCodes)])];
|
||
AppleReserved009FEnd:
|
||
case ShortComment:
|
||
key integer = $00A0;
|
||
integer; /* comment kind */
|
||
|
||
case LongComment:
|
||
key integer = $00A1;
|
||
integer; /* comment kind */
|
||
longCommentStart2: integer = (longCommentEnd2[$$ArrayIndex(OpCodes)] - longCommentStart2[$$ArrayIndex(OpCodes)] - 16) >> 3;
|
||
hex string [$$Word(longCommentStart2[$$ArrayIndex(OpCodes)])];
|
||
longCommentEnd2:
|
||
case OpEndPic:
|
||
key integer = $00FF;
|
||
|
||
case HeaderOp:
|
||
key integer = $0C00;
|
||
longint Version2 = -1;
|
||
/* Fixed point bounding box */
|
||
unsigned hex longint;
|
||
unsigned hex longint;
|
||
unsigned hex longint;
|
||
unsigned hex longint;
|
||
longint Version2 = -1; /* Reserved */
|
||
|
||
};
|
||
align word;
|
||
};
|
||
};
|
||
endOfPict:
|
||
};
|
||
|
||
#endif __PICT.R__
|