DIRECTORY
Basics USING [DIVMOD, LongDivMod, LongMult],
CGArea USING [Empty, Ref, Remove],
CGBitmapDevice USING [], -- exports only
CGBitmapDeviceExtras USING [], -- exports only
CGColor USING [GetStipple],
CGDevice USING [Ref, Rep],
CGMatrix USING [Inv, InvRel, IsTrivial, Make, Ref],
CGSample USING [Flags, Sample0, Sample8, Table],
CGScreen USING [Bits],
CGSource USING [Mode, Ref, Type],
CGStorage USING [pZone, qZone],
GraphicsBasic USING [black, Box, Color, Trap, white],
GraphicsColor USING [ColorToIntensity],
PrincOps USING [BBTableSpace, BitBltTable, BitBltTablePtr],
PrincOpsUtils USING [AlignedBBTable, BITBLT],
Real USING [Fix, FixC, RoundC];

CGBitmapDeviceImpl: CEDAR PROGRAM
IMPORTS Basics, CGArea, CGColor, CGMatrix, CGSample, CGScreen, CGStorage,
GraphicsColor, PrincOpsUtils, Real
EXPORTS CGBitmapDevice, CGBitmapDeviceExtras = {
OPEN CGDevice, GraphicsBasic;

dataZone: ZONE = CGStorage.qZone;
repZone: ZONE = CGStorage.qZone;
brickZone: ZONE = CGStorage.pZone;

Error: SIGNAL = CODE;

Data: TYPE = REF DataRep;
DataRep: TYPE = RECORD [
baseref: REF, -- ref for bitmap (or NIL if screen)
base: LONG POINTER, -- base address of bitmap
rast: CARDINAL, -- bitmap words per line
lines: CARDINAL, -- bitmap lines
matrix: CGMatrix.Ref -- base transformation matrix
];

New: PUBLIC PROC[base: REF, raster, height: CARDINAL] RETURNS[Ref] = {
data: Data _ dataZone.NEW[DataRep _ [baseref: NIL, base: NIL, rast: 0, lines: 0, matrix: NIL]];
IF base=NIL THEN [base: data.base, raster: raster, height: height] _ CGScreen.Bits[]
ELSE { data.baseref _ base; data.base _ LOOPHOLE[base] };
data.rast _ raster; data.lines _ height;
data.matrix _ CGMatrix.Make[[1,0,0,-1,0,height]];
RETURN[repZone.NEW[Rep _ [
GetMatrix: GetMatrix, GetBounds: GetBounds, Show: Show,
GetRaster: GetRaster, MoveBlock: MoveBlock, data: data]]];
};

UnsafeNew: PUBLIC UNSAFE PROC[base: LONG POINTER, raster, height: CARDINAL] RETURNS[Ref] = {
data: Data _ dataZone.NEW[DataRep _ [baseref: NIL,
base: base, rast: raster, lines: height, matrix: NIL]];
data.matrix _ CGMatrix.Make[[1,0,0,-1,0,height]];
RETURN[repZone.NEW[Rep _ [
GetMatrix: GetMatrix, GetBounds: GetBounds, Show: Show,
GetRaster: GetRaster, MoveBlock: MoveBlock, data: data]]];
};

GetMatrix: PROC[self: Ref] RETURNS[CGMatrix.Ref] = {
data: Data _ NARROW[self.data];
RETURN[data.matrix];
};

GetBounds: PROC[self: Ref] RETURNS[Box] = {
data: Data _ NARROW[self.data];
w: CARDINAL _ 16*data.rast;
h: CARDINAL _ data.lines;
e: REAL = 0.1; -- small fudge factor
RETURN[[xmin: e, ymin: e, xmax: w-e, ymax: h-e]];
};

GetRaster: PROC[self: Ref] RETURNS[LONG POINTER,CARDINAL] = {
data: Data _ NARROW[self.data];
RETURN[data.base,data.rast];
};

Show: PROC[self: Ref, area: CGArea.Ref, src: CGSource.Ref, map: CGMatrix.Ref] = {
data: Data _ NARROW[self.data];
fat: BOOLEAN _ (src.fat AND src.type#array);
UNTIL CGArea.Empty[area] DO
trap: Trap _ CGArea.Remove[area];
IF trap.xbotL=trap.xtopL AND trap.xbotR=trap.xtopR THEN {
rect: Box _ [xmin: trap.xbotL, ymin: trap.ybot, xmax: trap.xbotR, ymax: trap.ytop];
ShowRect[data,rect,src,map] }
ELSE ShowTrap[data,trap,src,map];
ENDLOOP;
};

Bot: PROC[r: REAL] RETURNS[CARDINAL] = INLINE { RETURN[Real.FixC[r]] };
Top: PROC[r: REAL] RETURNS[CARDINAL] = INLINE { RETURN[Real.FixC[r]+1] };
Fix: PROC[r: REAL] RETURNS[CARDINAL] = INLINE { RETURN[Real.FixC[r]] };
Rnd: PROC[r: REAL] RETURNS[CARDINAL] = INLINE { RETURN[Real.FixC[r+.5]] };
RndI: PROC[r: REAL] RETURNS[INTEGER] = INLINE {
RETURN[Real.FixC[r+(LAST[INTEGER]+.5)]-LAST[INTEGER]] };
FixF: PROC[r: REAL] RETURNS[LONG INTEGER] = INLINE {
RETURN[Real.Fix[r*200000B]] };


Brick: TYPE = REF BrickRep;
BrickRep: TYPE = RECORD[w, h, d: CARDINAL, array: SEQUENCE size: CARDINAL OF CARDINAL];

brick3, brick4: Brick _ NIL;
currentBrick, defaultBrick: Brick _ NIL;

InitBricks: PROC = {
index3: ARRAY[0..9) OF NAT = [8,3,6,5,1,9,2,7,4];
index4: ARRAY[0..16) OF NAT = [09,13,08,04,14,07,03,10,06,02,11,15,01,12,16,05];
brick3 _ brickZone.NEW[BrickRep[9] _ [w: 3, h: 3, d: 0, array: ]];
FOR i: NAT IN[0..9) DO brick3[i] _ (255*index3[i]+5)/10 ENDLOOP;
brick4 _ brickZone.NEW[BrickRep[16] _ [w: 4, h: 4, d: 0, array: ]];
FOR i: NAT IN[0..16) DO brick4[i] _ (255*index4[i]+8)/17 ENDLOOP;
currentBrick _ defaultBrick _ brick3;
};

BadArgs: ERROR = CODE;

SetBrick: PUBLIC PROC[w, h, d: CARDINAL,
proc: PROC[i: CARDINAL] RETURNS[CARDINAL]] = {
IF w>0 AND h>0 AND d<w AND Basics.LongMult[w,h]<=LAST[CARDINAL] THEN {
size: CARDINAL _ w*h;
brick: Brick _ brickZone.NEW[BrickRep[size] _ [w: w, h: h, d: d, array: ]];
FOR i: NAT IN[0..size) DO brick[i] _ proc[i] ENDLOOP;
currentBrick _ brick }
ELSE ERROR BadArgs;
};

ResetBrick: PUBLIC PROC = { currentBrick _ defaultBrick };

Byte: TYPE = [0..256);

SetMap: PUBLIC PROC[proc: PROC[Byte] RETURNS[Byte]] = {
FOR i: Byte IN Byte DO defaultMap[i] _ proc[i] ENDLOOP;
};

black: CARDINAL = LAST[CARDINAL];

grayTable: ARRAY[0..16) OF CARDINAL _ [
000000B, 010421B, 021042B, 031463B, 042104B, 052525B, 063146B, 073567B,
104210B, 114631B, 125252B, 135673B, 146314B, 156735B, 167356B, 177777B];

GrayArray: TYPE = ARRAY [0..4) OF CARDINAL;

MakeGray: PROC[color: CARDINAL] RETURNS[GrayArray] = INLINE {
IF color=black THEN RETURN[ALL[black]] ELSE RETURN[MakeGrayProc[color]] };

MakeGrayProc: PROC[t: CARDINAL] RETURNS[GrayArray] = {
gray: GrayArray _ ALL[0];
IF t#0 THEN { temp: CARDINAL _ t;
FOR i: CARDINAL DECREASING IN[0..4) DO
gray[i] _ grayTable[temp MOD 16]; temp _ temp/16;
ENDLOOP; };
RETURN[gray];
};

ColorToStipple: PROC[color: GraphicsBasic.Color] RETURNS[CARDINAL] = INLINE {
IF color=GraphicsBasic.black THEN RETURN[177777B]
ELSE IF color=GraphicsBasic.white THEN RETURN[0]
ELSE IF color.tag=stipple THEN RETURN[CGColor.GetStipple[color]]
ELSE RETURN[ComputeStipple[color]] };

ComputeStipple: PROC[color: GraphicsBasic.Color] RETURNS[CARDINAL] = {
table: ARRAY [0..15] OF CARDINAL = [
177777B, 32767, 32735, 24543, 24415, 23391, 23390, 23134,
23130, 6746, 6730, 2634, 2570, 2058, 2050, 0];
IF color.tag=stipple THEN RETURN[CGColor.GetStipple[color]]
ELSE { intensity: REAL _ GraphicsColor.ColorToIntensity[color];
i: [0..15] _ Real.RoundC[intensity*15]; RETURN[table[i]] };
};

nullBitBltTable: PrincOps.BitBltTable = [dst: [word: NIL, bit: 0], dstBpl: 0,
src: [word: NIL, bit: 0], srcDesc: [srcBpl[0]], width: 0, height: 0,
flags: [disjoint: TRUE, gray: TRUE, srcFunc: null, dstFunc: null]];

nullSampleFlags: CGSample.Flags = [function: 0,
mConst: FALSE, bConst: FALSE, sConst: FALSE, useMap: FALSE, size: 0];
nullSampleTable: CGSample.Table = [flags: nullSampleFlags,
count: 0, bValue: 0, sValue: 0, dLine: NIL, mLine: NIL, di: 0, mi: 0, map: NIL,
bLine: NIL, bi: 0, bw: 0, sBase: NIL, sRast: 0, sw: 0, sh: 0, sox: 0, soy: 0,
sx: 0, sy: 0, sdx: 0, sdy: 0];

MapArray: TYPE = ARRAY[0..256) OF CARDINAL;
defaultMap: REF MapArray _ InitDefaultMap[];
InitDefaultMap: PROC RETURNS[REF MapArray] = {
map: REF MapArray _ repZone.NEW[MapArray];
FOR i: NAT IN[0..256) DO map[i] _ i ENDLOOP;
RETURN[map] };

ShowRect: PROC[data: Data, rect: Box, src: CGSource.Ref, map: CGMatrix.Ref] = {
type: CGSource.Type _ src.type;
mode: CGSource.Mode _ src.mode;
easy: BOOLEAN _ (SELECT type FROM
const, tile => TRUE, -- always easy
array => (CGMatrix.IsTrivial[map] AND src.bps<2), -- bitmap is easy
proc => FALSE, -- never easy
ENDCASE => ERROR);
fat: BOOLEAN _ (src.fat AND type#array);
xmin, xmax, ymin, ymax: CARDINAL _ 0;
dbase: LONG POINTER _ data.base;
drast: CARDINAL _ data.rast;
IF fat THEN {
xmin _ Bot[rect.xmin]; xmax _ Top[rect.xmax];
ymin _ Bot[rect.ymin]; ymax _ Top[rect.ymax];
}
ELSE {
xmin _ Rnd[rect.xmin]; xmax _ Rnd[rect.xmax];
ymin _ Rnd[rect.ymin]; ymax _ Rnd[rect.ymax];
};
IF NOT(xmin<xmax AND ymin<ymax) THEN RETURN; -- nothing to do
IF easy THEN TRUSTED {
bbspace: PrincOps.BBTableSpace;
bb: PrincOps.BitBltTablePtr _ PrincOpsUtils.AlignedBBTable[@bbspace];
gray: ARRAY [0..4) OF CARDINAL;
color: CARDINAL _ ColorToStipple[src.color];
bb^ _ nullBitBltTable;
bb.flags.dstFunc _ (SELECT mode FROM transparent => or, invert => xor, ENDCASE => null);
bb.dst.word _ dbase + Basics.LongMult[ymin, drast] + xmin/16;
bb.dst.bit _ xmin MOD 16; bb.dstBpl _ drast*16;
SELECT type FROM
const => { yOffset: [0..4) _ ymin MOD 4;
bb.srcDesc.gray _ [yOffset: 0, widthMinusOne: 0, heightMinusOne: 3];
bb.srcDesc.gray.yOffset _ yOffset;
bb.src.word _ @gray + yOffset; bb.src.bit _ xmin MOD 16;
gray _ MakeGray[color];
};
tile => { yOffset: [0..16) _ ymin MOD 16;
bb.srcDesc.gray _ [yOffset: 0, widthMinusOne: 0, heightMinusOne: 15];
bb.srcDesc.gray.yOffset _ yOffset;
bb.src.word _ src.xbase + yOffset; bb.src.bit _ xmin MOD 16;
IF mode=transparent AND color=0 THEN {
bb.flags.srcFunc _ complement; bb.flags.dstFunc _ and };
};
array => {
sxmin: CARDINAL _ Real.FixC[xmin+0.5-map.m.e];
symin: CARDINAL _ Real.FixC[ymin+0.5-map.m.f];
sbase: LONG POINTER _ src.xbase;
srast: CARDINAL _ src.xrast;
bb.flags.gray _ FALSE;
IF (src.bps>0)=(color>0) THEN bb.flags.srcFunc _ complement;
bb.src.word _ sbase + Basics.LongMult[symin,srast] + sxmin/16;
bb.src.bit _ sxmin MOD 16;
bb.srcDesc.srcBpl _ srast*16;
};
ENDCASE => ERROR;
bb.width _ xmax - xmin; bb.height _ ymax - ymin;
PrincOpsUtils.BITBLT[bb];
}
ELSE TRUSTED {
table: CGSample.Table _ nullSampleTable;
rsx, rsy, rsdx, rsdy: REAL;
y: CARDINAL _ ymin;
[[rsdx,rsdy]] _ CGMatrix.InvRel[map,[1,0]];
table.sdx _ FixF[rsdx]; table.sdy _ FixF[rsdy];
table.sBase _ src.xbase; table.sRast _ src.xrast;
table.dLine _ dbase+Basics.LongMult[drast, ymin];
table.di _ xmin; table.count _ xmax-xmin;
IF src.bps=8 THEN {
brick: Brick _ currentBrick;
bbase: LONG POINTER _ @brick[0];
bw, bh, bd, be, br, bx, by: CARDINAL;
bw _ brick.w; bh _ brick.h; bd _ brick.d;
be _ (IF bd=0 THEN 0 ELSE bw-bd);
[quotient: br, remainder: by] _ Basics.DIVMOD[y, bh];
bx _ Basics.LongDivMod[Basics.LongMult[br, be], bw].remainder;
table.bLine _ bbase + by*bw; table.bw _ bw;
table.bi _ (xmin+bx) MOD bw;
table.map _ LOOPHOLE[defaultMap];
DO
[[rsx,rsy]] _ CGMatrix.Inv[map,[xmin+0.5,y+0.5]];
table.sx _ FixF[rsx]; table.sy _ FixF[rsy];
CGSample.Sample8[@table, mode];
IF (y _ y+1)=ymax THEN EXIT;
table.dLine _ table.dLine+drast;
IF (by _ by+1)=bh THEN { by _ 0; table.bLine _ bbase;
IF bx<bd THEN bx _ bx+be ELSE bx _ bx-bd;
table.bi _ (xmin+bx) MOD bw }
ELSE table.bLine _ table.bLine+bw;
ENDLOOP;
}
ELSE IF src.bps=0 THEN {
IF src.color=GraphicsBasic.white THEN table.flags.function _ 1;
DO
[[rsx,rsy]] _ CGMatrix.Inv[map,[xmin+0.5,y+0.5]];
table.sx _ FixF[rsx]; table.sy _ FixF[rsy];
CGSample.Sample0[@table, mode];
IF (y _ y+1)=ymax THEN EXIT;
table.dLine _ table.dLine+drast;
ENDLOOP;
}
ELSE NULL;
};
};

ShowTrap: PROC[data: Data, trap: Trap, src: CGSource.Ref, map: CGMatrix.Ref] = TRUSTED {
type: CGSource.Type _ src.type;
mode: CGSource.Mode _ src.mode;
color: CARDINAL _ ColorToStipple[src.color];
ymin, ymax, xmin, xmax, y: CARDINAL;
xL, xR, dxL, dxR, dy, fy: REAL;
dline: LONG POINTER; -- destination line for current y
drast: CARDINAL; -- destination raster width (in words)

IF src.fat AND type#array THEN { ShowFatTrap[data, trap, src]; RETURN };
ymin _ Rnd[trap.ybot]; ymax _ Rnd[trap.ytop];
IF NOT ymax>ymin THEN { IF ymin>ymax THEN SIGNAL Error; RETURN }; -- nothing to do
dy _ trap.ytop-trap.ybot; -- delta y
dxL _ (trap.xtopL-trap.xbotL)/dy; -- dx/dy, left
dxR _ (trap.xtopR-trap.xbotR)/dy; -- dx/dy, right
fy _ (ymin+0.5)-trap.ybot; -- distance to middle of first line
xL _ trap.xbotL+fy*dxL; xR _ trap.xbotR+fy*dxR; -- left and right x at middle of current line
y _ ymin; drast _ data.rast; dline _ data.base + Basics.LongMult[y, drast];
SELECT type FROM
const, tile => {
bbspace: PrincOps.BBTableSpace;
bb: PrincOps.BitBltTablePtr _ PrincOpsUtils.AlignedBBTable[@bbspace];
gray: ARRAY [0..4) OF CARDINAL; -- gray pattern, if type=const
pbase: LONG POINTER; -- pattern base address
ph, py: CARDINAL; -- pattern height and current line
bb^ _ nullBitBltTable;
bb.dstBpl _ drast*16; bb.height _ 1; bb.flags.gray _ TRUE;
bb.flags.dstFunc _ (SELECT mode FROM transparent => or, invert => xor, ENDCASE => null);
IF type=const THEN { pbase _ @gray; ph _ 4; gray _ MakeGray[color] }
ELSE { pbase _ src.xbase; ph _ 16;
IF mode=transparent AND color=0 THEN {
bb.flags.srcFunc _ complement; bb.flags.dstFunc _ and };
};
py _ y MOD ph; bb.src.word _ pbase + py;
bb.srcDesc.gray _ [yOffset: py, widthMinusOne: 0, heightMinusOne: ph-1];
DO xmin _ Rnd[xL]; xmax _ Rnd[xR];
IF xmin<xmax THEN {
bb.dst.word _ dline + xmin/16; bb.dst.bit _ xmin MOD 16;
bb.src.bit _ bb.dst.bit; bb.width _ xmax-xmin;
PrincOpsUtils.BITBLT[bb] };
IF (y _ y+1)=ymax THEN EXIT;
xL _ xL+dxL; xR _ xR+dxR; -- update left and right x
dline _ dline + drast; -- bump destination line
IF (py _ py+1)=ph THEN { bb.src.word _ pbase; py _ 0 }
ELSE bb.src.word _ bb.src.word + 1; -- bump pattern line
ENDLOOP;
};
array => IF CGMatrix.IsTrivial[map] AND src.bps=0 THEN { -- easy array
bbspace: PrincOps.BBTableSpace;
bb: PrincOps.BitBltTablePtr _ PrincOpsUtils.AlignedBBTable[@bbspace];
tx, ty: INTEGER;
sline: LONG POINTER;
srast: CARDINAL;
bb^ _ nullBitBltTable;
bb.dstBpl _ drast*16; bb.height _ 1; bb.flags.gray _ FALSE;
bb.flags.dstFunc _ (SELECT mode FROM transparent => or, invert => xor, ENDCASE => null);
IF color=0 THEN { bb.flags.srcFunc _ complement;
IF mode=transparent THEN bb.flags.dstFunc _ and };
tx _ RndI[map.m.e]; ty _ RndI[map.m.f];
srast _ src.xrast; sline _ src.xbase + Basics.LongMult[(ymin-ty), srast];
bb.srcDesc.srcBpl _ srast*16;
DO xmin _ Rnd[xL]; xmax _ Rnd[xR];
IF xmin<xmax THEN { sxmin: CARDINAL _ xmin-tx;
bb.dst.word _ dline + xmin/16; bb.dst.bit _ xmin MOD 16;
bb.src.word _ sline + sxmin/16; bb.src.bit _ sxmin MOD 16;
bb.width _ xmax-xmin;
PrincOpsUtils.BITBLT[bb] };
IF (y _ y+1)=ymax THEN EXIT;
xL _ xL+dxL; xR _ xR+dxR; -- update left and right x
dline _ dline+drast; -- bump destination line
sline _ sline+srast; -- bump source line
ENDLOOP;
}
ELSE { -- hard array
table: CGSample.Table _ nullSampleTable;
sx, sy, sdx, sdy: REAL;
[[sdx, sdy]] _ CGMatrix.InvRel[map, [1,0]];
table.sdx _ FixF[sdx]; table.sdy _ FixF[sdy];
table.sBase _ src.xbase; table.sRast _ src.xrast;
IF src.bps=8 THEN {
brick: Brick _ currentBrick;
bbase: LONG POINTER _ @brick[0];
bw, bh, bd, be, br, bx, by: CARDINAL;
bw _ brick.w; bh _ brick.h; bd _ brick.d;
be _ (IF bd=0 THEN 0 ELSE bw-bd);
[quotient: br, remainder: by] _ Basics.DIVMOD[y, bh];
bx _ Basics.LongDivMod[Basics.LongMult[br, be], bw].remainder;
table.bLine _ bbase + by*bw; table.bw _ bw;
table.map _ LOOPHOLE[defaultMap];
DO xmin _ Rnd[xL]; xmax _ Rnd[xR];
IF xmin<xmax THEN {
[[sx, sy]] _ CGMatrix.Inv[map, [xmin+0.5, y+0.5]];
table.sx _ FixF[sx]; table.sy _ FixF[sy];
table.bi _ (xmin+bx) MOD bw;
table.dLine _ dline; table.di _ xmin;
table.count _ xmax-xmin;
CGSample.Sample8[@table, mode];
};
IF (y _ y+1)=ymax THEN EXIT;
xL _ xL+dxL; xR _ xR+dxR; -- update left and right x
dline _ dline+drast; -- bump destination line
IF (by _ by+1)=bh THEN { by _ 0; table.bLine _ bbase;
IF bx<bd THEN bx _ bx+be ELSE bx _ bx-bd }
ELSE table.bLine _ table.bLine+bw; -- bump brick line
ENDLOOP;
}
ELSE IF src.bps=0 THEN {
IF src.color=GraphicsBasic.white THEN table.flags.function _ 1;
DO xmin _ Rnd[xL]; xmax _ Rnd[xR];
IF xmin<xmax THEN {
[[sx, sy]] _ CGMatrix.Inv[map, [xmin+0.5, y+0.5]];
table.sx _ FixF[sx]; table.sy _ FixF[sy];
table.dLine _ dline; table.di _ xmin;
table.count _ xmax-xmin;
CGSample.Sample0[@table, mode];
};
IF (y _ y+1)=ymax THEN EXIT;
xL _ xL+dxL; xR _ xR+dxR; -- update left and right x
dline _ dline+drast; -- bump destination line
ENDLOOP;
}
ELSE NULL;
};
ENDCASE => ERROR; -- bad src.type
};

ShowFatTrap: PROC[data: Data, trap: Trap, src: CGSource.Ref] = TRUSTED {
type: CGSource.Type _ src.type;
mode: CGSource.Mode _ src.mode;
color: CARDINAL _ ColorToStipple[src.color];
ymin, ymax, ylast, xl, xr, y: CARDINAL;
dxL, dxR, xbL, xbR, xtL, xtR, dy, fy: REAL;
topL, topR: BOOLEAN;
dline: LONG POINTER; -- destination line for current y
drast: CARDINAL; -- destination raster width (in words)
bbspace: PrincOps.BBTableSpace;
bb: PrincOps.BitBltTablePtr _ PrincOpsUtils.AlignedBBTable[@bbspace];
gray: ARRAY [0..4) OF CARDINAL; -- gray pattern, if type=const
pbase: LONG POINTER; -- pattern base address
ph, py: CARDINAL; -- pattern height and current line

ymin _ Bot[trap.ybot]; ymax _ Top[trap.ytop];
IF NOT ymax>ymin THEN { SIGNAL Error; RETURN };
ylast _ ymax-1; -- ylast is last line
y _ ymin; drast _ data.rast; dline _ data.base + Basics.LongMult[y, drast];
bb^ _ nullBitBltTable;
bb.dstBpl _ drast*16; bb.height _ 1; bb.flags.gray _ TRUE;
bb.flags.dstFunc _ (SELECT mode FROM transparent => or, invert => xor, ENDCASE => null);
IF type=const THEN { pbase _ @gray; ph _ 4; gray _ MakeGray[color] }
ELSE { pbase _ src.xbase; ph _ 16 };
py _ y MOD ph; bb.src.word _ pbase + py;
bb.srcDesc.gray _ [yOffset: py, widthMinusOne: 0, heightMinusOne: ph-1];

xbL _ trap.xbotL; xbR _ trap.xbotR; -- bottom x
IF ylast>ymin THEN { -- more than one line
dy _ trap.ytop-trap.ybot; -- height of trapezoid
dxL _ (trap.xtopL-trap.xbotL)/dy; -- left dx/dy
dxR _ (trap.xtopR-trap.xbotR)/dy; -- right dx/dy
fy _ (ymin+1)-trap.ybot; -- distance to top of first line
xtL _ xbL+fy*dxL; xtR _ xbR+fy*dxR; -- top x
topL _ (dxL<0); -- TRUE means leftmost x is at top of line
topR _ (dxR>0); -- TRUE means rightmost x is at top of line
}
ELSE { -- exactly one line
xtL _ trap.xtopL; xtR _ trap.xtopR; -- top x
topL _ (xtL<xbL); -- TRUE means leftmost x is at top of line
topR _ (xtR>xbR); -- TRUE means rightmost x is at top of line
};

DO -- for each scan line
xl _ Bot[IF topL THEN xtL ELSE xbL];
xr _ Top[IF topR THEN xtR ELSE xbR];
IF xl<xr THEN {
bb.dst.word _ dline + xl/16; bb.dst.bit _ xl MOD 16;
bb.src.bit _ bb.dst.bit; bb.width _ xr-xl;
PrincOpsUtils.BITBLT[bb] };
IF (y _ y+1)=ymax THEN EXIT;
xbL _ xtL; xbR _ xtR; -- new bottom is previous top
IF y=ylast THEN { xtL _ trap.xtopL; xtR _ trap.xtopR } -- last line
ELSE { xtL _ xbL+dxL; xtR _ xbR+dxR }; -- middle lines
dline _ dline + drast; -- bump destination line
IF (py _ py+1)=ph THEN { bb.src.word _ pbase; py _ 0 }
ELSE bb.src.word _ bb.src.word + 1; -- bump pattern line
ENDLOOP;
};

MoveBlock: PROC[self: Ref, width, height, fromX, fromY, toX, toY: NAT] = {
data: Data _ NARROW[self.data];
wmax: CARDINAL _ 16*data.rast;
hmax: CARDINAL _ data.lines;
IF width>0 AND height>0 AND
fromX<wmax AND fromY<hmax AND toX<wmax AND toY<hmax THEN TRUSTED {
dbase: LONG POINTER _ data.base;
drast: CARDINAL _ data.rast;
sx: CARDINAL _ fromX;
sy: CARDINAL _ fromY;
dx: CARDINAL _ toX;
dy: CARDINAL _ toY;
w: CARDINAL _ MIN[width, wmax-sx, wmax-dx];
h: CARDINAL _ MIN[height, hmax-sy, hmax-dy];
bpl: INTEGER _ 16*drast;
bbspace: PrincOps.BBTableSpace;
bb: PrincOps.BitBltTablePtr _ PrincOpsUtils.AlignedBBTable[@bbspace];
bb^ _ nullBitBltTable;
bb.flags _ [direction: forward, disjoint: TRUE, disjointItems: TRUE,
gray: FALSE, srcFunc: null, dstFunc: null];
IF (sx+w)>dx AND (dx+w)>sx AND (sy+h)>dy AND (dy+h)>sy THEN {
bb.flags.disjoint _ FALSE; -- the rectangles overlap
IF dy=sy THEN bb.flags.disjointItems _ FALSE; -- so do the items
IF dy>sy OR (dy=sy AND dx>sx) THEN { -- reverse direction
bb.flags.direction _ backward; bpl _ -bpl;
sy _ sy + (h-1); dy _ dy + (h-1);
};
};
bb.dst.word _ dbase + Basics.LongMult[dy, drast] + dx/16; bb.dst.bit _ dx MOD 16;
bb.src.word _ dbase + Basics.LongMult[sy, drast] + sx/16; bb.src.bit _ sx MOD 16;
bb.dstBpl _ bb.srcDesc.srcBpl _ bpl;
bb.width _ w; bb.height _ h;
PrincOpsUtils.BITBLT[bb];
};
};


InitBricks[];

}.


zCGBitmapDeviceImpl.mesa
Last changed by Paul Rovner, August 10, 1983 11:29 am
Last changed by Doug Wyatt, January 13, 1984 4:54 pm
weird "transparent white" semantics for McGregor's grey text hack:
map transforms source coordinates to device coordinates
Since this is an easy case, we know map is a simple translation;
so subtracting map's translation elements will take us from device to source
function#0 means "white" (by private agreement with Sample0)
weird "transparent white" semantics for McGregor's grey text hack:
The matrix 'map' transforms source coordinates to device coordinates.
Here we know map is a simple translation, so subtracting its translation
elements will take us from device to source coordinates.
function#0 means "white" (by private agreement with Sample0)
compute ymin (bottom of first scanline) and ymax (top of last scanline)
---- Initialization ------
�ÊC˜š
œ™Jš
œ5™5Jš
œ4™4—J˜š
Ïk	˜	Jšœ�œ�œ˜,Jšœ�œ˜"Jšœ�œÏc˜(Jšœ�œž˜.Jšœ�œ˜Jšœ	�œ˜Jšœ	�œ%˜3Jšœ	�œ"˜0Jšœ	�œ˜Jšœ	�œ˜!Jšœ
�œ˜Jšœ�œ"˜5Jšœ�œ˜'Jšœ	�œ-˜;Jšœ�œ�œ˜-Jšœ�œ˜J˜—Jšœ�œ
�˜!š�œB˜IJ˜"—Jš�œ)˜0Jš�œ˜J˜Jšœ
�œ˜!Jšœ	�œ˜ Jšœ�œ˜"J˜Jšœ�œ�œ
˜J˜Jšœ�œ�œ	˜šœ	�œ�œ˜Jšœ	�œž$˜2Jšœ�œ
�œž˜-Jšœ�œž˜(Jšœ�œž˜ Jšœž˜2J˜J˜—šÏnœ�œ
�œ�œ�œ�œ	˜FJš	œ�œ�œ�œ�œ˜_Jš�œ�œ
�œD˜TJš�œ$�œ	˜9J˜(J˜1š�œ	�œ˜J˜7J˜:—J˜J˜—šŸ	œ�œ
�œ
�œ�œ
�œ�œ�œ	˜\šœ�œ�œ
˜2Jšœ1�œ˜7—J˜1š�œ	�œ˜J˜7J˜:—J˜J˜—šŸ	œ�œ�œ˜4Jšœ
�œ˜Jš�œ˜J˜J˜—šŸ	œ�œ�œ	˜+Jšœ
�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œž˜$Jš�œ+˜1J˜J˜—šŸ	œ�œ�œ
�œ
�œ
�œ˜=Jšœ
�œ˜Jš�œ˜J˜J˜—šŸœ�œG˜QJšœ
�œ˜Jšœ�œ�œ˜,š�œ�˜J˜!š�œ�œ�œ˜9J˜SJ˜—Jš�œ˜!Jš�œ
˜—J˜J˜—JšŸœ�œ�œ�œ
�œ�œ�œ˜GJšŸœ�œ�œ�œ
�œ�œ�œ˜IJšŸœ�œ�œ�œ
�œ�œ�œ˜GJšŸœ�œ�œ�œ
�œ�œ�œ˜JšŸœ�œ�œ�œ
�œ�œ˜/Jš
�œ�œ
�œ�œ
�œ˜8—šŸœ�œ�œ�œ
�œ
�œ�œ˜4Jš�œ˜J˜J˜—Jšœ�œ�œ
˜Jšœ
�œ�œ
�œ	�œ�œ
�œ
�œ˜WJ˜Jšœ�œ
˜Jšœ$�œ
˜(J˜šŸ
œ�œ˜Jšœ�œ�œ
�œ˜1Jšœ�œ�œ
�œ5˜PJšœ�œ,˜BJš
�œ�œ
�œ�œ"�œ
˜@Jšœ�œ-˜CJš
�œ�œ
�œ�œ"�œ
˜AJ˜%J˜J˜—Jšœ	�œ�œ
˜J˜šŸœ�œ
�œ
�œ
˜(Jš	œ�œ�œ�œ
�œ˜.š�œ�œ�œ�œ�œ
�œ�œ˜FJšœ�œ˜Jšœ�œ/˜KJš
�œ�œ
�œ
�œ�œ
˜5J˜—Jš�œ
�œ	˜J˜J˜—JšŸ
œ�œ
�œ#˜:J˜Jšœ�œ˜J˜š
Ÿœ�œ
�œ�œ�œ˜7Jš�œ	�œ�œ�œ
˜7J˜J˜—Jšœ�œ�œ
�œ˜!J˜šœ�œ�œ
�œ˜'J˜GJ˜HJ˜—Jš	œ�œ�œ�œ
�œ
˜+J˜š
Ÿœ�œ�œ�œ�œ˜=Jš�œ
�œ
�œ
�œ	�œ
�œ˜JJ˜—šŸœ�œ�œ�œ˜6Jšœ�œ˜š�œ�œ	�œ˜!š	�œ�œ
�
œ
�œ�˜&Jšœ�œ˜1Jš�œ˜——Jš�œ˜
J˜J˜—š
Ÿœ�œ�œ
�œ�œ˜MJš�œ�œ
�œ	˜1Jš�œ
�œ�œ
�œ˜0Jš�œ
�œ�œ
�œ˜@Jš�œ
�œ˜%J˜—šŸœ�œ�œ
�œ˜Fšœ�œ	�œ
�œ˜$J˜9J˜.—Jš�œ�œ
�œ˜;š�œ�œ)˜?Jšœ(�œ
˜;—J˜J˜—šœ5�œ˜MJšœ�œ5˜DJšœ�œ�œ!˜CJ˜—˜/Jš	œ�œ
�œ
�œ
�œ˜E—˜:Jšœ'�œ	�œ�œ
˜OJšœ�œ�œ)˜MJ˜J˜—Jš	œ
�œ�œ	�œ
�œ
˜+Jšœ�œ˜,šŸœ�œ
�œ
�œ˜.Jšœ�œ�œ˜*Jš
�œ�œ
�œ	�œ�œ
˜,Jš�œ˜J˜—šŸœ�œA˜OJ˜J˜šœ�œ�œ�˜!Jšœ�œž˜#Jšœ"�œ
ž˜CJšœ�œž
˜Jš�œ�œ˜—Jšœ�œ�œ
˜(Jšœ�œ˜%Jšœ�œ
�œ
˜ Jšœ�œ
˜š�œ�œ˜
J˜-J˜-J˜
—š�œ˜J˜-J˜-J˜—Jš�œ
�œ�œ�œ
�œž˜=š�œ�œ
�œ˜J˜J˜EJšœ�œ�œ
�œ
˜Jšœ�œ˜,J˜Jšœ�œ�œ#�œ
˜XJ˜=Jšœ�œ˜/š�œ�˜šœ"�œ˜(J˜DJ˜"Jšœ1�œ˜8J˜J˜—šœ"�œ˜)J˜EJ˜"Jšœ5�œ˜<Jš
œB™Bš�œ�œ	�œ˜&J˜8—J˜—˜
Jš
œ7™7Jš
œ@™@Jš
œL™LJšœ�œ˜.Jšœ�œ˜.Jšœ�œ
�œ
˜ Jšœ�œ
˜Jšœ�œ
˜Jš�œ�œ˜<J˜>Jšœ�œ˜J˜J˜—Jš�œ�œ
˜—J˜0Jšœ�œ˜J˜
—š�œ
�œ˜J˜(Jšœ�œ
˜Jšœ�œ˜J˜+J˜/J˜1J˜1J˜)š�œ�œ˜J˜Jšœ�œ
�œ
˜ Jšœ�œ
˜%J˜)Jšœ�œ�œ�œ˜!Jšœ'�œ˜5J˜>J˜+Jšœ�œ˜Jšœ�œ
˜!š
�˜J˜1J˜+J˜Jš�œ�œ
�œ
˜J˜ š�œ�œ˜5Jš�œ�œ�œ˜)Jšœ�œ˜—Jš�œ˜"Jš�œ
˜—J˜
—š�œ
�œ�œ˜š�œ�œ˜?Jš
œ<™<—š
�˜J˜1J˜+J˜Jš�œ�œ
�œ
˜J˜ Jš�œ
˜—J˜
—Jš�œ
�œ
˜
J˜—J˜J˜—šŸœ�œA�œ˜XJ˜J˜Jšœ�œ˜,Jšœ�œ
˜$Jšœ�œ
˜Jšœ�œ
�œž!˜6Jšœ�œž&˜7J˜Jš�œ	�œ�œ!�œ˜HJ˜-Jš�œ
�œ�œ�œ�œ
�œ�œž˜RJšœž
˜$Jšœ"ž˜0Jšœ"ž˜1Jšœž#˜>Jšœ0ž-˜]J˜Kš�œ�˜˜J˜J˜EJšœ�œ�œ
�œž˜>Jšœ�œ
�œž˜,Jšœ�œž"˜4J˜Jšœ5�œ
˜:Jšœ�œ�œ#�œ
˜XJš�œ�œ2˜Dš�œ˜"Jš
œB™Bš�œ�œ	�œ˜&J˜8—J˜—Jšœ�œ˜(J˜Hš�œ ˜"š�œ�œ˜Jšœ1�œ˜8J˜.Jšœ�œ˜—Jš�œ�œ
�œ
˜Jšœž˜4Jšœž˜/Jš�œ�œ ˜6Jš�œ ž˜8Jš�œ
˜—J˜—šœ	�œ�œ�œž
˜FJ˜J˜EJšœ�œ
˜Jšœ�œ
�œ
˜Jšœ�œ
˜J˜Jšœ5�œ
˜;Jšœ�œ�œ#�œ
˜Xš�œ	�œ!˜0Jš�œ�œ˜2—Jš
œE™EJš
œH™HJš
œ8™8J˜'J˜IJ˜š�œ ˜"š�œ�œ
�œ˜.Jšœ1�œ˜8Jšœ3�œ˜:J˜Jšœ�œ˜—Jš�œ�œ
�œ
˜Jšœž˜4Jšœž˜-Jšœž˜(Jš�œ
˜—J˜
—š�œž
˜J˜(Jšœ�œ
˜J˜+J˜-J˜1š�œ�œ˜J˜Jšœ�œ
�œ
˜ Jšœ�œ
˜%J˜)Jšœ�œ�œ�œ˜!Jšœ'�œ˜5J˜>J˜+Jšœ�œ
˜!š�œ ˜"š�œ�œ˜J˜2J˜)Jšœ�œ˜J˜%J˜J˜J˜—Jš�œ�œ
�œ
˜Jšœž˜4Jšœž˜-š�œ�œ˜5Jš�œ�œ�œ
˜*—Jš�œž˜5Jš�œ
˜—J˜
—š�œ
�œ�œ˜š�œ�œ˜?Jš
œ<™<—š�œ ˜"š�œ�œ˜J˜2J˜)J˜%J˜J˜J˜—Jš�œ�œ
�œ
˜Jšœž˜4Jšœž˜-Jš�œ
˜—J˜
—Jš�œ
�œ
˜
J˜—Jš�œ�œž˜!—J˜J˜—šŸœ�œ.�œ˜HJ˜J˜Jšœ�œ˜,Jšœ�œ
˜'Jšœ&�œ
˜+Jšœ�œ
˜Jšœ�œ
�œž!˜6Jšœ�œž&˜7J˜J˜EJšœ�œ�œ
�œž˜>Jšœ�œ
�œž˜,Jšœ�œž"˜4J˜Jš
œG™GJ˜-Jš
�œ
�œ�œ�œ�œ˜/Jšœž˜%J˜KJ˜Jšœ5�œ
˜:Jšœ�œ�œ#�œ
˜XJš�œ�œ2˜DJš�œ ˜$Jšœ�œ˜(J˜HJ˜Jšœ$ž˜/š�œ�œž˜*Jšœž˜0Jšœ"ž
˜/Jšœ"ž˜0Jšœž ˜9Jšœ$ž˜,Jšœž*˜:Jšœž+˜;J˜
—š�œž˜Jšœ$ž˜,Jšœž*˜<Jšœž+˜=J˜J˜—š�œ
ž˜Jšœ	�œ�œ�œ˜$Jšœ	�œ�œ�œ˜$š�œ�œ˜Jšœ-�œ˜4J˜*Jšœ�œ˜—Jš�œ�œ
�œ
˜Jšœž˜3Jš�œ	�œ(ž˜CJš�œ#ž˜6Jšœž˜/Jš�œ�œ ˜6Jš�œ ž˜8Jš�œ
˜—J˜J˜—šŸ	œ�œ3�œ˜JJšœ
�œ˜Jšœ�œ˜Jšœ�œ˜š�œ	�œ
�˜šœ�œ�œ
�œ
�œ
�œ˜BJšœ�œ
�œ
˜ Jšœ�œ
˜Jšœ�œ	˜Jšœ�œ	˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ�œ˜+Jšœ�œ�œ˜,Jšœ�œ˜J˜J˜EJ˜šœ*�œ�œ
˜DJšœ�œ ˜+—š
�œ�œ�œ�œ�œ˜=Jšœ�œž˜4Jš�œ�œ�œž˜@š	�œ�œ�œ�œž˜9J˜*J˜!J˜—J˜—JšœJ�œ˜QJšœJ�œ˜QJ˜$J˜Jšœ�œ˜J˜——J˜J˜—Jš
œ™J˜J˜
J˜J˜J˜J˜—…—LdÁ