--  keyboard interrupt routines for silicon (pretty picture) program
-- modified by McCreight, January 4, 1983  2:58 PM

DIRECTORY
  ppddefs,
  ppdddefs,ppdefs,
  multiGraphicsDefs,
  InlineDefs,
  SystemDefs;
ppccur: MONITOR IMPORTS ppdefs,ppddefs, multiGraphicsDefs,InlineDefs EXPORTS ppdddefs =
  BEGIN OPEN InlineDefs, ppdefs, ppdddefs,ppddefs, multiGraphicsDefs;

  wiring, boxing: PUBLIC BOOLEAN;
  wireCol: level;
  wireWidth: INTEGER;
  oldboxing, oldwiring, wireFlipped: BOOLEAN _ FALSE;
  oldwx, oldwy, oldbx, 	oldby,veryOldSpac,oldSpac: INTEGER;
  wirePnt, boxPnt: Point;
  wireOrn: orientation;
  tempwireOffset: INTEGER;

-- for temp busses:
  bussing: BOOLEAN_FALSE;
  wpOffx, wpOffy, cornSpac, bCnt: INTEGER;

  dx1, dy1, dx2, dy2, cx, cy: INTEGER;
  cSize: INTEGER;

  colCursPnt: POINTER TO Bitmap;
  ccOn, gotARect, ccHidden: BOOLEAN;

  initCcurse: PUBLIC PROCEDURE [size: CARDINAL, cp: POINTER TO Bitmap] =
    BEGIN
    cSize _ size;
    ccOn _ gotARect _ ccHidden _ FALSE;
    colCursPnt _ cp;
    wiring _ boxing _ FALSE;
    END;
  gonnaDoCrect: PUBLIC ENTRY PROCEDURE [x1, y1, x2, y2: INTEGER] =
    BEGIN
    dx1 _ x1;
    dy1 _ y1;
    dx2 _ x2;
    dy2 _ y2;
    gotARect _ TRUE;
    IF NOT ccOn THEN RETURN;
    IF overlap[] THEN
      BEGIN ccHidden _ TRUE; XorColorBitmap[colCursPnt, cx, cy]; END;
    END;

  doneCrect: PUBLIC ENTRY PROCEDURE =
    BEGIN
    gotARect _ FALSE;
    IF NOT ccOn THEN RETURN;
    IF ccHidden THEN XorColorBitmap[colCursPnt, cx, cy];
    ccHidden _ FALSE;
    END;

  drawColorCurs: PUBLIC ENTRY PROCEDURE [x, y: INTEGER] =
    BEGIN
    IF ccOn AND NOT ccHidden THEN XorColorBitmap[colCursPnt, cx, cy];
    cx _ x;
    cy _ y;
    IF gotARect AND overlap[] THEN ccHidden _ TRUE
    ELSE BEGIN ccHidden _ FALSE; XorColorBitmap[colCursPnt, cx, cy]; END;
    ccOn _ TRUE;
    END;

  undrawColorCurs: PUBLIC ENTRY PROCEDURE =
    BEGIN
    IF ccOn AND NOT ccHidden THEN XorColorBitmap[colCursPnt, cx, cy];
    ccOn _ FALSE;
    END;

  overlap: PROCEDURE RETURNS [BOOLEAN] =
    BEGIN
    IF cx > dx2 OR cy > dy2 OR cx + cSize < dx1 OR cy + cSize < dy1 THEN
      RETURN[FALSE];
    RETURN[TRUE];
    END;

  drawTempWire: PROCEDURE [x1, y1, x2, y2: INTEGER] =
    BEGIN
    wdt: INTEGER _ wireWidth-tempwireOffset;
    t: INTEGER;
    a, c: CARDINAL;
    IF x1 = x2 THEN
      BEGIN
      x1 _ x1 - tempwireOffset;
      x2 _ x1 + wireWidth;
      IF y1 < y2 THEN y2 _ y2 + wdt
	ELSE BEGIN t _ y1; y1 _ y2 - tempwireOffset; y2 _ t; END;
      END
    ELSE
      IF y1 = y2 THEN
        BEGIN
        y1 _ y1 - tempwireOffset;
        y2 _ y1 + wireWidth;
        IF x1 < x2 THEN x2 _ x2 + wdt
          ELSE BEGIN t _ x1; x1 _ x2 - tempwireOffset; x2 _ t; END;
        END;
    a_BITAND[orLtab[wireCol],377B];
    c_BITOR[a,BITSHIFT[a,8]];
    a_BITOR[c,4000B];
    [[x1: x1, y1: y1, x2: x2, y2: y2]] _ ClipRect[
      [x1: x1, y1: y1, x2: x2, y2: y2],
      [x1: 0, y1: 0, x2: xColorMax, y2: yColorMax]];
    IF x1<=x2 AND y1<=y2 THEN
      PutColorTemp[x1: x1, y1: y1, x2: x2, y2: y2, gray: [a, 0, c, 0, a, 0, c]];
    END;

  doTemps: PUBLIC PROCEDURE =
    BEGIN
	q,qq:INTEGER;
    IF wiring THEN
      BEGIN
      IF oldwiring AND (oldwx # curx OR oldwy # cury) THEN
        reDrawRect[getERect[], 1, FALSE, TRUE, FALSE];
      IF wireOrn = 0 OR wireOrn = 4 THEN
        BEGIN
        drawTempWire[wirePnt.x, wirePnt.y, wirePnt.x, cury];
        drawTempWire[curx, cury, wirePnt.x, cury];
	IF bussing THEN
	    BEGIN
		q_IF curx>wirePnt.x THEN cornSpac ELSE -cornSpac;
		IF cury>wirePnt.y THEN q_-q;
	        drawTempWire[wirePnt.x+wpOffx, wirePnt.y+wpOffy,
			wirePnt.x+wpOffx, cury+q];
	        drawTempWire[curx, cury+q, wirePnt.x+wpOffx, cury+q];
		q_q*bCnt;
		qq_wpOffx*bCnt;
	        drawTempWire[wirePnt.x+qq, wirePnt.y+wpOffy*bCnt,
			wirePnt.x+qq, cury+q];
	        drawTempWire[curx, cury+q, wirePnt.x+qq, cury+q];
	    END;
        END
      ELSE
        BEGIN
        drawTempWire[wirePnt.x, wirePnt.y, curx, wirePnt.y];
        drawTempWire[curx, cury, curx, wirePnt.y];
	IF bussing THEN
	    BEGIN
		q_IF cury>wirePnt.y THEN cornSpac ELSE -cornSpac;
		IF curx>wirePnt.x THEN q_-q;
	        drawTempWire[wirePnt.x+wpOffx, wirePnt.y+wpOffy,
			curx+q, wirePnt.y+wpOffy];
	        drawTempWire[curx+q, cury, curx+q, wirePnt.y+wpOffy];
		q_q*bCnt;
		qq_wpOffy*bCnt;
	        drawTempWire[wirePnt.x+wpOffx*bCnt, wirePnt.y+qq,
			curx+q, wirePnt.y+qq];
	        drawTempWire[curx+q, cury, curx+q, wirePnt.y+qq];
	    END;
        END;
      oldwx _ curx;
      oldwy _ cury;
	oldSpac_q;
	veryOldSpac_qq;
      oldwiring _ TRUE;
      END;
    IF oldwiring AND NOT wiring THEN
      BEGIN
      reDrawRect[
        cannonRect[[wirePnt.x, wirePnt.y, oldwx, oldwy]], 1, FALSE, TRUE, FALSE];
      oldwiring _ FALSE;
      END;
    IF boxing THEN
      BEGIN
      white: Color = 15;
      r: Rect = cannonRect[[x1: boxPnt.x, y1: boxPnt.y, x2: curx, y2: cury]];
      IF oldboxing AND (oldbx # curx OR oldby # cury) THEN unBox[];
      ReplaceColorArea[x1: r.x1, y1: r.y1, x2: r.x1, y2: r.y2, c: white];
      ReplaceColorArea[x1: r.x1, y1: r.y1, x2: r.x2, y2: r.y1, c: white];
      ReplaceColorArea[x1: r.x2, y1: r.y1, x2: r.x2, y2: r.y2, c: white];
      ReplaceColorArea[x1: r.x1, y1: r.y2, x2: r.x2, y2: r.y2, c: white];
      oldbx _ curx;
      oldby _ cury;
      oldboxing _ TRUE;
      END;
    IF oldboxing AND NOT boxing THEN unBox[];
    END;
  getERect: PROCEDURE RETURNS [r: Rect] =
    BEGIN
    wd: INTEGER _ wireWidth-tempwireOffset;
    two: INTEGER _ tempwireOffset;
    IF bussing THEN
		IF oldSpac<0 THEN two_two-oldSpac ELSE wd_wd+oldSpac;
    IF wireFlipped THEN
      BEGIN
      r _ cannonRect[[wirePnt.x, wirePnt.y, oldwx, oldwy]];
      r.x1 _ r.x1 - two;
      r.y1 _ r.y1 - two;
      r.x2 _ r.x2 + wd;
      r.y2 _ r.y2 + wd;
      wireFlipped _ FALSE;
      END
    ELSE
      IF wireOrn = 0 OR wireOrn = 4 THEN
        BEGIN
        r.x1 _ MIN[(IF bussing AND veryOldSpac<0 THEN wirePnt.x+veryOldSpac ELSE wirePnt.x), oldwx] - tempwireOffset;
        r.x2 _ MAX[(IF bussing AND veryOldSpac>0 THEN wirePnt.x+veryOldSpac ELSE wirePnt.x), oldwx] + wireWidth-tempwireOffset;
        IF wirePnt.y < oldwy THEN
          BEGIN
          r.y1 _ MIN[oldwy, MAX[wirePnt.y, cury]] - two;
          r.y2 _ oldwy + wd;
          END
        ELSE
          BEGIN
          r.y2 _ MAX[oldwy, MIN[wirePnt.y, cury]] + wd;
          r.y1 _ oldwy - two;
          END;
        END
      ELSE
        BEGIN
        r.y1 _ MIN[(IF bussing AND veryOldSpac<0 THEN wirePnt.y+veryOldSpac ELSE wirePnt.y), oldwy] - tempwireOffset;
        r.y2 _ MAX[(IF bussing AND veryOldSpac>0 THEN wirePnt.y+veryOldSpac ELSE wirePnt.y), oldwy] + wireWidth-tempwireOffset;
        IF wirePnt.x < oldwx THEN
          BEGIN
          r.x1 _ MIN[oldwx, MAX[wirePnt.x, curx]] - two;
          r.x2 _ oldwx + wd;
          END
        ELSE
          BEGIN
          r.x2 _ MAX[oldwx, MIN[wirePnt.x, curx]] + wd;
          r.x1 _ oldwx - two;
          END;
        END;
    [r.x1, r.y1] _ deScale[r.x1, r.y1];
    [r.x2, r.y2] _ deScale[r.x2, r.y2];
    END;
  unBox: PROCEDURE =
    BEGIN
    x1, y1, x2, y2: INTEGER;
    r: Rect;
    r _ cannonRect[[oldbx, oldby, boxPnt.x, boxPnt.y]];
    [x1, y1] _ deScale[r.x1, r.y1];
    [x2, y2] _ deScale[r.x2, r.y2];
    reDrawRect[[x1, y1, x1, y2], 1, FALSE, TRUE, FALSE];
    reDrawRect[[x1, y1, x2, y1], 1, FALSE, TRUE, FALSE];
    reDrawRect[[x2, y1, x2, y2], 1, FALSE, TRUE, FALSE];
    reDrawRect[[x1, y2, x2, y2], 1, FALSE, TRUE, FALSE];
    oldboxing _ FALSE;
    END;
  deScale: PROCEDURE [x, y: INTEGER]
    RETURNS [INTEGER, INTEGER] =
    BEGIN
    IF x > colWidth THEN x_colWidth;
    IF y > colHeight THEN y_colHeight;
    IF x < 0 THEN x_0;
    IF y < 0 THEN y_0;
    RETURN[(x*cScaleD)/cScaleN - cxoff, (y*cScaleD)/cScaleN - cyoff];
    END;

  setupTempWires: PUBLIC PROCEDURE [
    p: Point, o: orientation, col:level, wid,cornerOffset:INTEGER,
    bigChange: BOOLEAN] =
    BEGIN
    wirePnt _ p;
    IF wiring AND wireOrn # o THEN wireFlipped _ TRUE;
    IF NOT wiring THEN wireFlipped _ FALSE;
    wireOrn _ o;
    wireCol _ col;
    wireWidth _ wid;
    wiring _ TRUE;
    bussing _ FALSE;
    tempwireOffset _ cornerOffset;
    IF bigChange THEN oldwiring _ FALSE;
    END;
  setupBox: PUBLIC PROCEDURE [p: Point, bigChange: BOOLEAN] =
    BEGIN boxPnt _ p; boxing _ TRUE; IF bigChange THEN oldboxing _ FALSE; END;

  setupTempBus: PUBLIC PROCEDURE [
    p: Point, o: orientation, col:level, wid,cornerOffset:INTEGER,
    bigChange: BOOLEAN, strtOffx,strtOffy,cornerOff,count:INTEGER] =
    BEGIN
    wirePnt _ p;
    IF wiring AND wireOrn # o THEN wireFlipped _ TRUE;
    IF NOT wiring THEN wireFlipped _ FALSE;
    wireOrn _ o;
    wireCol _ col;
    wireWidth _ wid;
    wiring _ TRUE;
    bussing _ TRUE;
    tempwireOffset _ cornerOffset;
    IF bigChange THEN oldwiring _ FALSE;
    wpOffx_strtOffx;
    wpOffy_strtOffy;
    cornSpac_cornerOff;
    bCnt_count-1;
      IF wireOrn = 0 OR wireOrn = 4 THEN BEGIN IF strtOffx<0 THEN
	 cornSpac_-cornSpac;END ELSE BEGIN IF strtOffy<0 THEN
	cornSpac_-cornSpac;END;

    END;

  XorColorBitmap: PROC [source: BitmapPtr, x, y: INTEGER] = INLINE
    {SetColorFromSource[source: source, x: x, y: y, fn: invert]};

  END.