-- CGBitmapDeviceImpl.mesa
-- Last changed by Doug Wyatt, November 2, 1982 10:26 am

DIRECTORY
  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],
  BitBlt USING [AlignedBBTable, BBTableSpace, BITBLT, BitBltTable, BitBltTablePtr],
  Inline USING [DIVMOD, LongDivMod, LongMult],
  Real USING [Fix, FixC, RoundC];

CGBitmapDeviceImpl: CEDAR PROGRAM
IMPORTS CGArea, CGColor, CGMatrix, CGSample, CGScreen, CGStorage,
  GraphicsColor, BitBlt, Inline, 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]]];
  };

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 Inline.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: BitBlt.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: BitBlt.BBTableSpace;
    bb: BitBlt.BitBltTablePtr _ BitBlt.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 + Inline.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;
        -- weird "transparent white" semantics for McGregor's grey text hack:
        IF mode=transparent AND color=0 THEN {
          bb.flags.srcFunc _ complement; bb.flags.dstFunc _ and };
        };
      array => {
        -- 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
        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 + Inline.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;
    BitBlt.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+Inline.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] _ Inline.DIVMOD[y, bh];
      bx _ Inline.LongDivMod[Inline.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 {
      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 + Inline.LongMult[y, drast];
  SELECT type FROM
    const, tile => {
      bbspace: BitBlt.BBTableSpace;
      bb: BitBlt.BitBltTablePtr _ BitBlt.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;
        -- weird "transparent white" semantics for McGregor's grey text hack:
        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;
          BitBlt.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: BitBlt.BBTableSpace;
      bb: BitBlt.BitBltTablePtr _ BitBlt.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 };
      -- 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.
      tx _ RndI[map.m.e]; ty _ RndI[map.m.f];
      srast _ src.xrast; sline _ src.xbase + Inline.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;
          BitBlt.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] _ Inline.DIVMOD[y, bh];
        bx _ Inline.LongDivMod[Inline.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 {
        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: BitBlt.BBTableSpace;
  bb: BitBlt.BitBltTablePtr _ BitBlt.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

  -- compute ymin (bottom of first scanline) and ymax (top of last scanline)
  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 + Inline.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;
      BitBlt.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: BitBlt.BBTableSpace;
    bb: BitBlt.BitBltTablePtr _ BitBlt.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 + Inline.LongMult[dy, drast] + dx/16; bb.dst.bit _ dx MOD 16;
    bb.src.word _ dbase + Inline.LongMult[sy, drast] + sx/16; bb.src.bit _ sx MOD 16;
    bb.dstBpl _ bb.srcDesc.srcBpl _ bpl;
    bb.width _ w; bb.height _ h;
    BitBlt.BITBLT[bb];
    };
  };

------ Initialization ------

InitBricks[];

}.