-- ColorDeviceImpl.mesa
-- Last changed by Ken Pier July 11, 1983 12:05 pm
-- Last changed by Maureen Stone October 18, 1982 1:26 pm
-- Last changed by Doug Wyatt, September 1, 1982 3:50 pm

DIRECTORY
  ColorDisplay,
  GraphicsBasic USING [Box, Color, Trap, Vec],
  GraphicsColor USING [blue, cyan, green, magenta, red, white, yellow], 
  CGArea USING [Empty, Ref, Remove],
  ColorDevice USING [], -- only for EXPORTS
  CGDevice USING [Ref, Rep],
  CGMatrix USING [Inv, InvRel, IsTrivial, Make, Ref],
  CGSource USING [Mode, Ref, Type],
  CGStorage USING [qZone],
  ColorMap USING [GetGrayTable, GrayTable, GetIndex, GrayRec],
  CGColor USING [GetStipple],
  Inline USING [BITAND, BITOR, BITSHIFT, BITXOR,
    HighHalf, LongMult, LongNumber, LowByte, LowHalf],
  BitBlt,
  Real USING [Fix, FixC, RoundC];

ColorDeviceImpl: MONITOR
IMPORTS CGArea, CGColor, CGMatrix, CGStorage, BitBlt, Inline, Real,
  CD: ColorDisplay, ColorMap
EXPORTS ColorDevice, GraphicsBasic = {
OPEN Area: CGArea, Matrix: CGMatrix, Source: CGSource,
  CGDevice, GraphicsBasic;

DeviceObject: PUBLIC TYPE = CGDevice.Rep; -- exported to GraphicsBasic
Byte: TYPE = [0..256);

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

Error: PUBLIC SAFE ERROR = CODE;
bbspace: BitBlt.BBTableSpace;
bb: BitBlt.BitBltTablePtr _ BitBlt.AlignedBBTable[@bbspace];

Data: TYPE = REF DataRep;
DataRep: TYPE = RECORD [
  width,height: CARDINAL _ 0,
  grayTable: ColorMap.GrayTable _ NIL,
  lastColor: Color _ [tag: rgb, r: 0, g: 0, b: 0],
  lastPixel: LONG CARDINAL,
  stipple: CARDINAL _ 0,
--base and words per line all available thru ColorDisplay
  matrix: Matrix.Ref _ NIL -- base transformation matrix
  ];

New: PUBLIC SAFE PROC[raster, height: CARDINAL _ 0] RETURNS[CGDevice.Ref] = CHECKED {
    data: Data _ dataZone.NEW[DataRep];
    IF raster = 0 THEN data.width _ CD.width ELSE data.width _ raster;
    IF height = 0 THEN data.height _ CD.height ELSE data.height _ height;
    data.grayTable _ ColorMap.GetGrayTable[];
    data.matrix _ Matrix.Make[[1,0,0,-1,0,data.height]];  --should be a function of pixelsPerInch
    RETURN[repZone.NEW[CGDevice.Rep _ [
    GetMatrix: GetMatrix, GetBounds: GetBounds, Show: Show,
    GetRaster: GetRaster, MoveBlock: MoveBlock, data: data]]];
  };

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

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

--bitmap speedup hack, not valid for color display
GetRaster: SAFE PROC[self: Ref] RETURNS[LONG POINTER,CARDINAL] = CHECKED {
  RETURN[NIL,0] };

Show: ENTRY SAFE PROC[self: Ref, area: Area.Ref, src: Source.Ref, map: Matrix.Ref] = TRUSTED {
  data: Data _ NARROW[self.data];
  bitmap: BOOLEAN _ (src.type=array AND src.bps=0 AND CGMatrix.IsTrivial[map]);
  invertHack: LONG CARDINAL _ data.lastPixel;
  IF CD.curmode=CD.disconnected THEN RETURN;  --colordisplay is disconnected
  IF src.mode=invert THEN {
          IF CD.curmode.full THEN data.lastPixel _ -1 ELSE data.lastPixel _ 255}
  ELSE SetColor[data,src.color];  --sets up the values for color
  IF NOT CD.curmode.full AND src.bps >0 AND ~src.raw 
      THEN SetGrayTable[data,src.bps];  --sets up a lookup table for source grays
  UNTIL Area.Empty[area] DO
    trap: Trap _ Area.Remove[area];
    IF bitmap AND trap.xbotL=trap.xtopL AND trap.xbotR=trap.xtopR THEN {
      box: GraphicsBasic.Box _ [trap.xbotL, trap.ybot, trap.xbotR, trap.ytop];
      ShowBitmap[data,box,src,map] }
    ELSE ShowTrap[data,trap,src,map];
    ENDLOOP;
  IF src.mode=invert THEN data.lastPixel _ invertHack;
  };

SetColor: PROC [data: Data, color: GraphicsBasic.Color] = {
    IF color = data.lastColor THEN RETURN;
    IF color.tag = stipple THEN data.stipple _ CGColor.GetStipple[color];
    IF CD.curmode.full THEN data.lastPixel _ Pack[color.r,color.g,color.b]
    ELSE data.lastPixel _ ColorMap.GetIndex[color.r,color.g,color.b];
    data.lastColor _ color;
    };

SetGrayTable: PROC [data: Data, srcBps: CARDINAL] = {
    cmapGrays: ColorMap.GrayTable _ ColorMap.GetGrayTable[];
    slen: REAL _ TwoToThe[srcBps];
    scaler: REAL _ 255.0/(slen-1);
    IF data.grayTable=NIL OR data.grayTable.length#slen
        THEN data.grayTable _ NEW[ColorMap.GrayRec[TwoToThe[srcBps]]];
    FOR i: CARDINAL IN [0..data.grayTable.length) DO 
        data.grayTable[i] _ cmapGrays[Real.RoundC[i*scaler]];
        ENDLOOP;
    }; 
 
--v is assumed to be 8 bps or less
TwoToThe: PROC[power: INTEGER] RETURNS[INTEGER] = {
    RETURN[Inline.BITSHIFT[value: 2, count: power-1]];
    };
           
GetBBColor: PROC[color: CARDINAL, bps: CARDINAL] RETURNS [CARDINAL] = {
  grey,temp: CARDINAL _ 0;
  IF color#0 THEN {
    SELECT bps FROM
      1 => temp _ Inline.BITAND[color,mask1];
      2 => temp _ Inline.BITAND[color,mask2];
      4 => temp _ Inline.BITAND[color,mask4];
      8 => temp _ Inline.BITAND[color,mask8];
      ENDCASE => ERROR Error;
    FOR b: CARDINAL IN [0..16/bps) DO
      grey _ Inline.BITOR[temp,grey];
      temp _ Inline.BITSHIFT[temp,bps];
      ENDLOOP;
    };
  RETURN[grey];
  };

Line1: TYPE = RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..1B]];
Line2: TYPE = RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..3B]];
Line4: TYPE = RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..17B]];
Line8: TYPE = RECORD[PACKED SEQUENCE COMPUTED CARDINAL OF [0..377B]];
Line16: TYPE = RECORD[SEQUENCE COMPUTED CARDINAL OF CARDINAL];

--these routines put stuff in the bitmap
--assume that s is already masked

Put: PROC[dbase: LONG POINTER, drast: CARDINAL, x,y: CARDINAL, v: LONG CARDINAL] =   {
  xline: LONG POINTER _ dbase + Inline.LongMult[y,drast];
  IF CD.curmode.full THEN {
      pair: CD.Pair _ Inline.LowHalf[v];
      blue: Byte _ Inline.LowByte[Inline.HighHalf[v]];
      CD.SetPixel[x,y,pair.r,pair.g,blue];
      }
  ELSE {
    short: CARDINAL _ Inline.LowHalf[v];
    SELECT CD.curmode.bitsPerPixelA FROM
       1 => LOOPHOLE[xline,LONG POINTER TO Line1][x] _ Inline.BITAND[short,mask1];
       2 => LOOPHOLE[xline,LONG POINTER TO Line2][x] _ Inline.BITAND[short,mask2];
       4 => LOOPHOLE[xline,LONG POINTER TO Line4][x] _ Inline.BITAND[short,mask4];
       8 => LOOPHOLE[xline,LONG POINTER TO Line8][x] _ Inline.BITAND[short,mask8];
       ENDCASE => ERROR Error;
    };
  };

--"transparent mode"
Transparent: PROC[dbase: LONG POINTER, drast: CARDINAL, x,y: CARDINAL, value: LONG CARDINAL] =   {
  xline: LONG POINTER _ dbase + Inline.LongMult[y,drast];
  IF CD.curmode.full THEN {
      pair: CD.Pair _ Inline.LowHalf[value];
      blue: Byte _ Inline.LowByte[Inline.HighHalf[value]];
      r,g,b: Byte;
      [r,g,b] _ CD.GetPixel[x,y];
      pair.r _ MIN[pair.r+r,255];
      pair.g _ MIN[pair.g+g,255];
      blue _ MIN[blue+b,255];
      CD.SetPixel[x,y,pair.r,pair.g,blue];
      }
  ELSE SELECT CD.curmode.bitsPerPixelA FROM
    1 => IF value=1 THEN LOOPHOLE[xline,LONG POINTER TO Line1][x] _ value;
    2 => {v: CARDINAL _ LOOPHOLE[xline,LONG POINTER TO Line2][x];
          v _ MIN[v+value,3];
          LOOPHOLE[xline,LONG POINTER TO Line2][x] _ v};
    4 => {v: CARDINAL _ LOOPHOLE[xline,LONG POINTER TO Line4][x];
          v _ MIN[v+value,15];
          LOOPHOLE[xline,LONG POINTER TO Line4][x] _ v};
    8 => {v: CARDINAL _ LOOPHOLE[xline,LONG POINTER TO Line8][x];
          v _ MIN[v+value,255];
          LOOPHOLE[xline,LONG POINTER TO Line8][x] _ v};
    ENDCASE => ERROR Error;
  };

--"invert mode"
Invert: PROC[dbase: LONG POINTER, drast: CARDINAL, x,y: CARDINAL] =   {
  xline: LONG POINTER _ dbase + Inline.LongMult[y,drast];
  IF CD.curmode.full THEN {
      r,g,b: Byte;
      temp: Byte _ 377B;
      [r,g,b] _ CD.GetPixel[x,y];
      r _ Inline.BITXOR[temp,r];
      g _ Inline.BITXOR[temp,g];
      b _ Inline.BITXOR[temp,b];
      CD.SetPixel[x,y,r,g,b];
      }
  ELSE {
    temp: CARDINAL _ 177777B;
    SELECT CD.curmode.bitsPerPixelA FROM
      1 => {v: CARDINAL _ LOOPHOLE[xline,LONG POINTER TO Line1][x];
          v _ Inline.BITXOR[v,temp]; v _ Inline.BITAND[v,mask1];
          LOOPHOLE[xline,LONG POINTER TO Line2][x] _ v};
      2 => {v: CARDINAL _ LOOPHOLE[xline,LONG POINTER TO Line2][x];
          v _ Inline.BITXOR[v,temp]; v _ Inline.BITAND[v,mask2];
          LOOPHOLE[xline,LONG POINTER TO Line2][x] _ v};
      4 => {v: CARDINAL _ LOOPHOLE[xline,LONG POINTER TO Line4][x];
          v _ Inline.BITXOR[v,temp];  v _ Inline.BITAND[v,mask4];
          LOOPHOLE[xline,LONG POINTER TO Line4][x] _ v};
      8 => {v: CARDINAL _ LOOPHOLE[xline,LONG POINTER TO Line8][x];
          v _ Inline.BITXOR[v,temp]; v _ Inline.BITAND[v,mask8];
          LOOPHOLE[xline,LONG POINTER TO Line8][x] _ v};
      ENDCASE => ERROR Error;
    };
  };

--this gets a source sample from an array of values
AGet: PROC[src: Source.Ref, x,y: CARDINAL] RETURNS[value: LONG CARDINAL] =   {
  xline: LONG POINTER _ src.xbase + Inline.LongMult[y,src.xrast];
  SELECT src.bps FROM
      0 => value _ LOOPHOLE[xline,LONG POINTER TO Line1][x];
      1 => value _ LOOPHOLE[xline,LONG POINTER TO Line1][x];
      2 => value _ LOOPHOLE[xline,LONG POINTER TO Line2][x];
      4 => value _ LOOPHOLE[xline,LONG POINTER TO Line4][x];
      8 => value _ LOOPHOLE[xline,LONG POINTER TO Line8][x];
    ENDCASE => ERROR Error;
  };

mask1: CARDINAL = 1B;
mask2: CARDINAL = 3B;
mask4: CARDINAL = 17B;
mask8: CARDINAL = 377B;

--this converts from a bps bit array value to a 24 bps color
FullTint: PROC[in: LONG CARDINAL, bps: INTEGER, color: GraphicsBasic.Color] RETURNS[out: LONG CARDINAL] = {OPEN GraphicsColor;
     intensity: REAL _ REAL[in]/(TwoToThe[bps]);
    v: Byte _ Real.RoundC[intensity*255];
    SELECT color FROM
        red => out _ Pack[v,0,0];
        green => out _ Pack[0,v,0];
        blue => out _ Pack[0,0,v];
        magenta => out _ Pack[v,0,v];
        cyan => out _ Pack[0,v,v];
        yellow => out _ Pack[v,v,0];
        white => out _ Pack[v,v,v];
        ENDCASE => {
            ir: Byte _ Real.RoundC[intensity*color.r];
            ig: Byte _ Real.RoundC[intensity*color.g];
            ib: Byte _ Real.RoundC[intensity*color.b];
            out _ Pack[ir,ig,ib];
            };
    RETURN[out];
    };


white: LONG CARDINAL _ Pack[377B,377B,377B];
black: LONG CARDINAL _ 0;
Pack: PROC[r,g,b: Byte] RETURNS [LONG CARDINAL] = {
       rg: CD.Pair;
       out: Inline.LongNumber _ [num[0,0]];
       rg.r _ r; rg.g _ g;
       out.lowbits _ LOOPHOLE[rg,CARDINAL];
       out.highbits _ LOOPHOLE[b,CARDINAL];
       RETURN[out.lc];
    };

Masks: TYPE = ARRAY [0..16) OF WORD;
masksArray: Masks _ [
    100000B, 040000B, 020000B, 010000B, 004000B, 002000B, 001000B, 000400B,
    000200B, 000100B, 000040B, 000020B, 000010B, 000004B, 000002B, 000001B];
masks: POINTER TO Masks _ @masksArray;

ShowBitmap: PROC[data: Data, rect: Box, src: CGSource.Ref, map: CGMatrix.Ref] = {
  type: CGSource.Type _ src.type;
  mode: CGSource.Mode _ src.mode;
  xmin, xmax, ymin, ymax: NAT;
  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 type=array AND src.bps=0 AND CGMatrix.IsTrivial[map] THEN {
    pixel: LONG CARDINAL _ data.lastPixel;
    tx: INTEGER _ RndI[map.m.e];
    ty: INTEGER _ RndI[map.m.f];
        -- map transforms source coordinates to device coordinates
        -- Here, we know map is a simple translation, so subtracting map's
        -- translation elements will take us from device to source
    sxmin: INTEGER _ xmin - tx;
    symin: INTEGER _ ymin - ty;
    sBase: LONG POINTER _ src.xbase;
    sRast: CARDINAL _ src.xrast;
    sLine: LONG POINTER _ sBase + Inline.LongMult[symin, sRast];
    y: CARDINAL _ ymin;
    cxmin: INTEGER _ CD.cursorPosition.x;
    cymin: INTEGER _ CD.cursorPosition.y;
    cxmax: INTEGER _ cxmin+CD.cursorWidth;
    cymax: INTEGER _ cymin+CD.cursorHeight;
    hidden: BOOLEAN _ (cxmax>xmin AND cxmin<xmax AND cymax>ymin AND cymin<ymax);
    CD.SetLock[];
    IF hidden THEN CD.HideCursor[];
    IF CD.curmode.full THEN {
      baseA: LONG POINTER _ CD.baseA;
      wplA: CARDINAL _ CD.wplA;
      baseB: LONG POINTER _ CD.baseB;
      wplB: CARDINAL _ CD.wplB;
      lineA: LONG POINTER TO Line16 _ baseA+Inline.LongMult[y, wplA];
      lineB: LONG POINTER TO Line8 _ baseB+Inline.LongMult[y, wplB];
      pixel1A: CARDINAL _ Inline.LowHalf[data.lastPixel];
      pixel0A: CARDINAL _ Inline.LowHalf[white];
      pixel1B: [0..256) _ Inline.HighHalf[data.lastPixel] MOD 256;
      pixel0B: [0..256) _ Inline.HighHalf[white] MOD 256;
      DO
        sAddr: LONG POINTER TO CARDINAL _ sLine+sxmin/16;
        sWord: CARDINAL _ sAddr^;
        si: CARDINAL _ sxmin MOD 16;
      
        SELECT mode FROM
        opaque => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0
            THEN { lineA[x] _ pixel1A; lineB[x] _ pixel1B }
            ELSE { lineA[x] _ pixel0A; lineB[x] _ pixel0B };
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        transparent => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0
            THEN { lineA[x] _ pixel1A; lineB[x] _ pixel1B };
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        invert => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN {
            lineA[x] _ Inline.BITXOR[lineA[x],177777B];
            lineB[x] _ Inline.BITXOR[lineB[x],377B] };
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        ENDCASE;
  
        IF (y _ y+1)=ymax THEN EXIT;
        sLine _ sLine + sRast; -- next source line
        lineA _ lineA + wplA; lineB _ lineB + wplB; -- next destination lines
        ENDLOOP;
      }
    ELSE IF CD.curmode.bitsPerPixelA=8 THEN {
      baseA: LONG POINTER _ CD.baseA;
      wplA: CARDINAL _ CD.wplA;
      lineA: LONG POINTER TO Line8 _ baseA+Inline.LongMult[y, wplA];
      pixel1: [0..256) _ Inline.LowHalf[data.lastPixel] MOD 256;
      pixel0: [0..256) _ Inline.LowHalf[white] MOD 256;
      DO
        sAddr: LONG POINTER TO CARDINAL _ sLine+sxmin/16;
        sWord: CARDINAL _ sAddr^;
        si: CARDINAL _ sxmin MOD 16;
      
        SELECT mode FROM
        opaque => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN lineA[x] _ pixel1 ELSE lineA[x] _ pixel0;
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        transparent => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN lineA[x] _ pixel1;
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        invert => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN lineA[x] _ Inline.BITXOR[lineA[x],377B];
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        ENDCASE;
  
        IF (y _ y+1)=ymax THEN EXIT;
        sLine _ sLine + sRast; -- move to next source line
        lineA _ lineA + wplA; -- move to next destination line
        ENDLOOP;
      }
    ELSE IF CD.curmode.bitsPerPixelA=4 THEN {
      baseA: LONG POINTER _ CD.baseA;
      wplA: CARDINAL _ CD.wplA;
      lineA: LONG POINTER TO Line4 _ baseA+Inline.LongMult[y, wplA];
      pixel1: [0..16) _ Inline.LowHalf[data.lastPixel] MOD 16;
      pixel0: [0..16) _ Inline.LowHalf[white] MOD 16;
      DO
        sAddr: LONG POINTER TO CARDINAL _ sLine+sxmin/16;
        sWord: CARDINAL _ sAddr^;
        si: CARDINAL _ sxmin MOD 16;
      
        SELECT mode FROM
        opaque => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN lineA[x] _ pixel1 ELSE lineA[x] _ pixel0;
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        transparent => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN lineA[x] _ pixel1;
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        invert => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN lineA[x] _ Inline.BITXOR[lineA[x],17B];
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        ENDCASE;
  
        IF (y _ y+1)=ymax THEN EXIT;
        sLine _ sLine + sRast; -- move to next source line
        lineA _ lineA + wplA; -- move to next destination line
        ENDLOOP;
      }
    ELSE{
      dbase: LONG POINTER _ CD.baseA;
      drast: CARDINAL _ CD.wplA;
      pixel: LONG CARDINAL _ data.lastPixel;
      DO
        sAddr: LONG POINTER TO CARDINAL _ sLine+sxmin/16;
        sWord: CARDINAL _ sAddr^;
        si: CARDINAL _ sxmin MOD 16;
      
        SELECT mode FROM
        opaque => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN Put[dbase, drast, x, y, pixel]
          ELSE Put[dbase, drast, x, y, white];
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        transparent => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN Put[dbase, drast, x, y, pixel];
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        invert => FOR x: CARDINAL IN[xmin..xmax) DO
          IF Inline.BITAND[sWord, masks[si]]#0 THEN Invert[dbase, drast, x, y];
          IF (si _ si+1)=16 THEN { sWord _ (sAddr _ sAddr+1)^; si _ 0 };
          ENDLOOP;
        ENDCASE;
  
        IF (y _ y+1)=ymax THEN EXIT;
        sLine _ sLine + sRast; -- move to next source line
        -- table.dLine _ table.dLine+drast;
        ENDLOOP;
      };
    CD.ClearLock[];
    CD.RestoreCursor[];
    }
  ELSE ERROR;
  };

ShowTrap: PROC[data: Data, trap: Trap, src: Source.Ref, map: Matrix.Ref] = {
  easy: BOOLEAN _ IF src.mode=invert OR (src.type=const AND src.mode=opaque) THEN TRUE ELSE FALSE;
  yb,yt,yl,xl,xr: CARDINAL _ 0;
  rdxl,rdxr: REAL _ 0; -- left and right x increments
  rsdx,rsdy: REAL _ 0; -- increments for source position
  fsdx,fsdy: Frac;
  dbase: LONG POINTER;
  drast: CARDINAL;
  fat: BOOLEAN _ src.fat;
  stipple: BOOLEAN _ (data.lastColor.tag=stipple);
  DoLine: PROC[xmin,xmax,y: CARDINAL] =  {
    cx: INTEGER _ CD.cursorPosition.x;
    cy: INTEGER _ CD.cursorPosition.y;
    CD.SetLock[];
    IF INTEGER[y] IN [cy..cy+CD.cursorHeight] AND
        NOT (cx+CD.cursorWidth<INTEGER[xmin] OR cx>INTEGER[xmax])
    THEN CD.HideCursor[];
    IF stipple OR src.type=tile THEN StippleLine[xmin,xmax,y]  --the altoworld special case
    ELSE {IF easy
        THEN EasyLine[xmin,xmax,y]   --split here for easy and hard lines
        ELSE HardLine[xmin,xmax,y]};
    CD.ClearLock[];
    CD.RestoreCursor[];
    };

  EasyLine: PROC[xmin,xmax,y: CARDINAL] =   { --solid colors only
    gray,bpp,ppw: CARDINAL _ 0;
    bb^ _ [dst: [word: NIL, bit: 0], dstBpl: 0, src: [word: @gray, bit: 0],
      srcDesc: [gray[gray: [yOffset: 0, widthMinusOne: 0, heightMinusOne: 0]]],
      width: 0, height: 1, flags: [disjoint: TRUE, gray: TRUE, srcFunc: null,
      dstFunc: IF src.mode=invert THEN xor ELSE null]];
    IF CD.curmode.full THEN  {
      bpp _ 16;
      ppw _ 1;
      gray _ Inline.LowHalf[data.lastPixel];    --red and green together
      }
    ELSE {
      bpp _ CD.curmode.bitsPerPixelA;
      ppw _ 16/bpp;
      gray _ GetBBColor[data.lastPixel,bpp];  --colormap index
      };
    bb.dst.word _ CD.baseA + Inline.LongMult[y,CD.wplA] + xmin/ppw;
    bb.dst.bit _ (xmin MOD ppw)*bpp;
    bb.dstBpl _ CD.wplA*16;
    bb.width _ (xmax - xmin)*bpp;
    BitBlt.BITBLT[bb];
    IF CD.curmode.full THEN {
      blue: CARDINAL _ Inline.HighHalf[data.lastPixel];
      bpp _ 8;
      ppw _ 2;
      gray _ GetBBColor[Inline.LowByte[blue],bpp];    --get the blue color
      bb.dst.word _ CD.baseB + Inline.LongMult[y,CD.wplB] + xmin/ppw;
      bb.dst.bit _ (xmin MOD ppw)*bpp;
      bb.dstBpl _ CD.wplB*16;
      bb.width _ (xmax - xmin)*bpp;
      BitBlt.BITBLT[bb];
      };
   };    
  
StippleLine: PROC[xmin,xmax,y: CARDINAL] = {
    base: CARDINAL _ IF src.type=tile THEN 16 ELSE 4;
    sx: CARDINAL;
    yoff: CARDINAL _ base*(y MOD base);
    bit: CARDINAL;
    bits: LONG POINTER TO Line1 _
        IF src.type=tile THEN LOOPHOLE[src.xbase] ELSE LOOPHOLE[@data.stipple];
    FOR x: CARDINAL IN[xmin..xmax) DO
        sx _ x MOD base + yoff;
        bit _ bits[sx];
        IF bit=0 THEN {
            IF src.mode=opaque THEN Put[dbase,drast,x,y,white]
            ELSE LOOP;
            }
        ELSE{  --bit=1
            IF src.mode=invert THEN Invert[dbase,drast,x,y]
            ELSE Put[dbase,drast,x,y,data.lastPixel];
            };
        ENDLOOP;
    };

  HardLine: PROC[xmin,xmax,y: CARDINAL] = {
    rsx,rsy: REAL; -- current source position
    fsx,fsy: Frac;
    sx,sy: CARDINAL; -- truncated source position
    value: LONG CARDINAL; 
    
    IF src.type=array AND src.bps=0 THEN  FOR x: CARDINAL IN[xmin..xmax) DO
        xline: LONG POINTER;
        bit: CARDINAL;
        IF x=xmin THEN { 
            [[rsx,rsy]] _ Matrix.Inv[map,[x+0.5,y+0.5]];
            fsx _ FixF[rsx]; fsy _ FixF[rsy];
            }
        ELSE {fsx _ AddF[fsx,fsdx]; fsy _ AddF[fsy,fsdy]};
        xline _ src.xbase + Inline.LongMult[IntF[fsy],src.xrast];
        bit _ LOOPHOLE[xline,LONG POINTER TO Line1][IntF[fsx]];
        IF bit=0 THEN {
            IF src.mode=opaque THEN Put[dbase,drast,x,y,white]
            ELSE LOOP;
            }
        ELSE{  --bit=1
            IF src.mode=invert THEN Invert[dbase,drast,x,y]
            ELSE Put[dbase,drast,x,y,data.lastPixel];
            };
        ENDLOOP


    ELSE FOR x: CARDINAL IN[xmin..xmax) DO
      IF x=xmin THEN { 
        [[rsx,rsy]] _ Matrix.Inv[map,[x+0.5,y+0.5]];
        fsx _ FixF[rsx]; fsy _ FixF[rsy];
        }
      ELSE {fsx _ AddF[fsx,fsdx]; fsy _ AddF[fsy,fsdy]};
      -- Get a sample from the source
      SELECT src.type FROM
        proc =>  value _ src.Get[FltF[fsx],FltF[fsy]];
        array => {
            sv: LONG CARDINAL;
            sx _ IntF[fsx];
            sy _ IntF[fsy];
            sv _ AGet[src,sx,sy];
            IF CD.curmode.full THEN value _ FullTint[sv,src.bps,src.color]
            ELSE value _ (IF src.raw THEN sv ELSE data.grayTable[sv]);
            };
        const => value _ data.lastPixel;
        ENDCASE;
      IF src.mode=transparent THEN Transparent[dbase,drast,x,y,value]
      ELSE Put[dbase,drast,x,y,value];
      ENDLOOP;
    };

  -- main code for PTrap starts here
  -- compute yb (bottom of first scanline) and yt (top of last scanline)
  dbase _ CD.baseA;
  drast _ CD.wplA;
  IF fat THEN { yb_Bot[trap.ybot]; yt_Top[trap.ytop] }
  ELSE { yb_Rnd[trap.ybot]; yt_Rnd[trap.ytop] };
  IF yb<yt THEN yl_yt-1 -- yl is last line
  ELSE { IF yb>yt OR fat THEN ERROR Error; RETURN };
  -- Setup for calls on DoLine
  IF src.type=array THEN {
      [[rsdx,rsdy]] _ Matrix.InvRel[map,[1,0]];
      fsdx _ FixF[rsdx]; fsdy _ FixF[rsdy];
      };
  rdxl_(trap.xtopL-trap.xbotL); -- delta x, left
  rdxr_(trap.xtopR-trap.xbotR); -- delta x, right
  IF NOT(fat AND yb=yl) THEN {
    rdy: REAL_trap.ytop-trap.ybot; -- delta y
    rdxl_rdxl/rdy; rdxr_rdxr/rdy; -- dx/dy, left right
    };
  IF fat THEN {
    rxlb,rxrb,rxlt,rxrt: REAL _ 0; -- x at bottom and top of current line
    ltop: BOOLEAN _ rdxl<0; -- TRUE means leftmost x is at top of line
    rtop: BOOLEAN _ rdxr>0; -- TRUE means rightmost x is at top of line
    FOR y: CARDINAL IN[yb..yl] DO -- for each scan line
      IF y=yb THEN { rxlb_trap.xbotL; rxrb_trap.xbotR } -- first line
      ELSE { rxlb_rxlt; rxrb_rxrt }; -- successive lines
      IF y=yl THEN { rxlt_trap.xtopL; rxrt_trap.xtopR } -- last line
      ELSE IF y=yb THEN { -- first line, if yl>yb
        d: REAL_(yb+1)-trap.ybot; -- distance to top of line
        rxlt_rxlb+d*rdxl; rxrt_rxrb+d*rdxr }
      ELSE { rxlt_rxlb+rdxl; rxrt_rxrb+rdxr }; -- middle lines
      xl_Bot[IF ltop THEN rxlt ELSE rxlb];
      xr_Top[IF rtop THEN rxrt ELSE rxrb];
      IF xl<xr THEN DoLine[xmin: xl, xmax: xr, y: y];
      ENDLOOP;
    }
  ELSE {
    rxl,rxr: REAL _ 0; -- left and right x at middle of current line
    FOR y: CARDINAL IN[yb..yl] DO -- for each scan line
      IF y=yb THEN { -- first line
        d: REAL_(yb+0.5)-trap.ybot; -- distance to middle of line
        rxl_trap.xbotL+d*rdxl; rxr_trap.xbotR+d*rdxr }
      ELSE { rxl_rxl+rdxl; rxr_rxr+rdxr }; -- successive lines
      xl_Rnd[rxl]; xr_Rnd[rxr];
      IF xl<xr THEN DoLine[xl,xr,y];
      ENDLOOP;
    };
  };

allOnes: LONG CARDINAL = LAST[LONG CARDINAL];

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]] };

Frac: TYPE = Inline.LongNumber;
fscl: Frac = [num[lowbits: 0, highbits: 1]];

FixF: PROC[r: REAL] RETURNS[Frac] = INLINE {
  RETURN[[li[Real.Fix[r*fscl.li]]]] };

FltF: PROC[f: Frac] RETURNS[REAL] = INLINE {
  r: REAL _ f.li; RETURN[r/fscl.li] };

AddF: PROC[a,b: Frac] RETURNS[Frac] = INLINE {
  RETURN[[li[a.li+b.li]]] };

IntF: PROC[f: Frac] RETURNS[INTEGER] = INLINE {
  RETURN[LOOPHOLE[f.highbits,INTEGER]] };

MoveBlock: SAFE PROC[self: Ref, width, height, fromX, fromY, toX, toY: NAT] = CHECKED {
  data: Data _ NARROW[self.data];
  wmax: CARDINAL _ data.width;
  hmax: CARDINAL _ data.height;
  IF CD.curmode=CD.disconnected THEN RETURN;  --colordisplay is disconnected
  IF width>0 AND height>0 AND
   fromX<wmax AND fromY<hmax AND toX<wmax AND toY<hmax THEN TRUSTED {
    backwardsFlag: INTEGER _ 1; --will get set to -1 if backward BitBLT
    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];
    bbspace: BitBlt.BBTableSpace;
    bb: BitBlt.BitBltTablePtr _ BitBlt.AlignedBBTable[@bbspace];
    bpp: CARDINAL _ IF CD.curmode.full THEN 16 ELSE CD.curmode.bitsPerPixelA;
    ppw: CARDINAL _ 16/bpp;
    bb^ _ [dst: [word: NIL, bit: 0], dstBpl: 0, src: [word: NIL, bit: 0],
      srcDesc: [srcBpl[0]], width: 0, height: 16,
      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;
        backwardsFlag _ -1; sy _ sy + (h-1); dy _ dy + (h-1);
        };
      };
    bb.dst.word _ CD.baseA + Inline.LongMult[dy, CD.wplA] + dx/ppw;
    bb.dst.bit _ (dx MOD ppw)*bpp;
    bb.src.word _ CD.baseA + Inline.LongMult[sy, CD.wplA] + sx/ppw;
    bb.src.bit _ (sx MOD ppw)*bpp;
    bb.dstBpl _ bb.srcDesc.srcBpl _ CD.wplA*16*backwardsFlag;
    bb.width _ w*bpp; bb.height _ h;
    BitBlt.BITBLT[bb];
    IF CD.curmode.full THEN {
      bpp _ 8; ppw _ 2;
      bb.dst.word _ CD.baseB + Inline.LongMult[dy,CD.wplB] + dx/ppw;
      bb.dst.bit _ (dx MOD ppw)*bpp;
      bb.src.word _ CD.baseB + Inline.LongMult[sy, CD.wplB] + sx/ppw;
      bb.src.bit _ (sx MOD ppw)*bpp;
      bb.dstBpl _ bb.srcDesc.srcBpl _ CD.wplB*16*backwardsFlag;
      bb.width _ w*bpp;
      BitBlt.BITBLT[bb];
      };
    };
  };


}.

<<Edited on July 11, 1983 12:04 pm, by Pier>>
<<fixed bug in MoveBlock, adding backwardsFlag>>
<<changes to: MoveBlock>>
<<>>