-- second procedure exporting module of silicon (pretty picture) program
-- last modified by McCreight, January 10, 1983  12:26 PM
--  to copy text properties properly
-- modified (slightly) by Petit  September 23, 1981  8:32 PM
DIRECTORY
  multiGraphicsDefs,
  InlineDefs,
  SegmentDefs,
  StringDefs,
  ppdddefs,ppddefs,
  ppdefs;
ppprocs2: PROGRAM
  IMPORTS ppdddefs,ppdefs, ppddefs, multiGraphicsDefs, InlineDefs, StringDefs
  EXPORTS ppdefs, ppddefs,ppdddefs =
  BEGIN
  OPEN ppdefs, ppdddefs,ppddefs, multiGraphicsDefs, SegmentDefs, StringDefs, InlineDefs;

  masterList: PUBLIC LONG POINTER TO list;
  cellList: PUBLIC LONG POINTER TO cList;
  cellNameMode: PUBLIC BOOLEAN _ FALSE;
  cnList: PUBLIC LONG POINTER TO list _ NIL;

  xx, yy: PUBLIC INTEGER;
  bb: PUBLIC BOOLEAN;
  ii, jj: CARDINAL;

  lp, lqp: LONG POINTER TO list;
  cp: LONG POINTER TO cList;

  localNameString:STRING_[30];
  localBusString:STRING_[30];

  ke: keyEvent;

  ss: STRING;

  cellStack: PUBLIC LONG POINTER TO cellSE;

  unDelPnt: PUBLIC LONG POINTER TO list;
  unDelGrpCnt, unDelItemCnt: PUBLIC CARDINAL;

  maxZeeLevels: CARDINAL _ 8;
  yWdt: CARDINAL = 13;
  sss: STRING _ [100];

    tiCx: CARDINAL = 100;

  doZee: PUBLIC cmdProc =
    BEGIN
    x, y: INTEGER;
    width: CARDINAL;
    count: PROCEDURE [lev: CARDINAL, p: LONG POINTER TO cell object]
      RETURNS [cnt: CARDINAL] =
      BEGIN
      othCnt: CARDINAL;
      lp, lpp: LONG POINTER TO list;
      lev _ lev + 1;
      cnt _ 0;
      othCnt _ 0;
      lp _ p.ptr;
      WHILE lp # NIL DO lp.mark _ 0; lp _ lp.nxt; ENDLOOP;
      lp _ p.ptr;
      WHILE lp # NIL DO
        IF lp.ob.otyp = cell AND lp.mark = 0 THEN
          BEGIN
          othCnt _ othCnt + count[lev, LOOPHOLE[lp.ob]];
          cnt _ cnt + 1;
          lpp _ lp.nxt;
          WHILE lpp # NIL DO
            IF lp.ob = lpp.ob THEN lpp.mark _ 1; lpp _ lpp.nxt; ENDLOOP;
          END;
        lp _ lp.nxt;
        ENDLOOP;
      lp _ p.ptr;
      WHILE lp # NIL DO lp.mark _ 0; lp _ lp.nxt; ENDLOOP;
      cnt _ MAX[cnt, othCnt];
      cnt _ MAX[cnt, 1];
      END;
    drCll: PROCEDURE [
      lev: CARDINAL, p: LONG POINTER TO cell object, x, y: INTEGER,
      wd, inCnt: CARDINAL] =
      BEGIN
      lp, lpp: LONG POINTER TO list;
      cp: LONG POINTER TO cList;
      nxtx: INTEGER;
      twd, tt: CARDINAL;
      s: STRING;
      lev _ lev + 1;
      [s, cp] _ cellNam[p, inCnt];
      nxtx _ MeasureText[s, fnt];
      lpp _ makeList[
        makeCnText[s, nxtx, yWdt, wd, p, cp], x, y + wd*yWdt/2, 0, 0];
      lpp.nxt _ cnList;
      cnList _ lpp;
      nxtx _ nxtx + x + 5;
      lp _ p.ptr;
      WHILE lp # NIL DO
        IF lp.ob.otyp = cell AND lp.mark = 0 THEN
          BEGIN
          lpp _ lp;
          tt _ 0;
          WHILE lpp # NIL DO
            IF lp.ob = lpp.ob THEN BEGIN tt _ tt + 1; lpp.mark _ 1; END;
            lpp _ lpp.nxt;
            ENDLOOP;
          twd _ count[lev, LOOPHOLE[lp.ob]];
          drCll[lev, LOOPHOLE[lp.ob], nxtx, y, twd, tt];
          y _ y + twd*yWdt;
          END;
        lp _ lp.nxt;
        ENDLOOP;
      END;
    cnList _ NIL;
    cellNameMode _ TRUE;
    y _ 40;
    x _ 20;
    cp _ cellList;
    WHILE cp # NIL DO
      width _ count[0, LOOPHOLE[cp.ob]];
      drCll[0, LOOPHOLE[cp.ob], x, y, width, 1];
      y _ y + width*yWdt + 5;
      cp _ cp.nxt;
      ENDLOOP;
    dChange _ FALSE;
    reDrawRect[[0, 0, 0, 0], 2, TRUE, FALSE, TRUE];
    END;
  cellNam: PROCEDURE [p: LONG POINTER TO cell object, cnt: CARDINAL]
    RETURNS [STRING, LONG POINTER TO cList] =
    BEGIN
    cpp: LONG POINTER TO cList _ cellList;
    lp: LONG POINTER TO list _ p.ptr;
    i: INTEGER _ 0;
    flg: BOOLEAN _ FALSE;
    sss.length _ 0;
    IF cnt > 1 THEN BEGIN AppendDecimal[sss, cnt]; AppendChar[sss, 'x]; END;
    WHILE cpp # NIL DO
      IF p = cpp.ob THEN BEGIN AppendString[sss, cpp.name]; flg _ TRUE; EXIT; END;
      cpp _ cpp.nxt;
      ENDLOOP;
    IF NOT flg THEN AppendString[sss, "--noname--"];
    AppendChar[sss, '{];
    WHILE lp # NIL DO i _ i + 1; lp _ lp.nxt; ENDLOOP;
    AppendDecimal[sss, i];
    AppendChar[sss, '}];
    RETURN[sss, cpp];
    END;
  delCellDef: PUBLIC PROCEDURE [
    cn: LONG POINTER TO cList, ob: LONG POINTER TO cell object] =
    BEGIN
    sp: LONG POINTER TO list;
    lpp: LONG POINTER TO list;
    defobs: LONG POINTER TO list _ ob.ptr;
    scp, tcp: LONG POINTER TO cell object;
    scp _ GetCellSuper[];
    sp _ GetSuperPointer[];
    lp _ sp;
    ob.returnable _ TRUE;
    WHILE lp # NIL DO
      IF lp.ob = ob THEN
        BEGIN
        lpp _ sp;
        IF masterList = lp THEN masterList _ lp.nxt
        ELSE
          WHILE lpp # NIL DO
            IF lpp.nxt = lp THEN BEGIN lpp.nxt _ lp.nxt; EXIT; END;
            lpp _ lpp.super;
            ENDLOOP;
        tcp _ scp;
        WHILE tcp # NIL DO
          IF tcp.ptr = lp THEN BEGIN tcp.ptr _ lp.nxt; EXIT; END;
          tcp _ tcp.super;
          ENDLOOP;
        lp.nxt _ NIL;
        lpp _ lp.super;
        flushDel[lp];
        lp _ lpp;
        END
      ELSE lp _ lp.super;
      ENDLOOP;
    IF cn # NIL THEN
      BEGIN
      IF cellList = cn THEN cellList _ cellList.nxt
      ELSE
        BEGIN
        cp _ cellList;
        WHILE cp # NIL DO
          IF cp.nxt = cn THEN BEGIN cp.nxt _ cn.nxt; EXIT; END;
          cp _ cp.nxt;
          ENDLOOP;
        END;
      cn.ob.p.release[cn.ob];
      END;
    END;

  moveOb: PUBLIC PROCEDURE [p: LONG POINTER TO list, x, y: INTEGER] =
    BEGIN
    reDrawRect[getRect[p], 3, TRUE, TRUE, FALSE];
    p.lx _ p.lx + x;
    p.ly _ p.ly + y;
    reDrawRect[getRect[p], 0, TRUE, TRUE, FALSE];
    END;

  doHard: PUBLIC cmdProc =
    BEGIN
    ss: STRING;
    ke: keyEvent;
    ok: BOOLEAN;
    [ok, ss, ke] _ typeIn[
      "Type File Name", "without extension", "I will add .press"];
    refreshTypeInScreen[];
    IF NOT ok THEN RETURN;
    hardOut[ss, masterList];
    END;

  doExpS: PUBLIC cmdProc =
    BEGIN
    backPnt: LONG POINTER TO LONG POINTER TO list;
    lp _ masterList;
    backPnt _ @masterList;
    WHILE lp # NIL DO
      IF lp.selected AND (lp.ob.otyp = cell OR lp.ob.otyp=bus) THEN
        BEGIN
        backPnt^ _ lp.nxt;
        anyChanges _ sinceIOchanges _ TRUE;
        doTheExp[lp];
        RETURN;
        END;
      backPnt _ @lp.nxt;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  doExpP: PUBLIC cmdProc =
    BEGIN
    backPnt: LONG POINTER TO LONG POINTER TO list;
    lp _ masterList;
    backPnt _ @masterList;
    WHILE lp # NIL DO
      IF (lp.ob.otyp = cell OR lp.ob.otyp=bus) AND lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx]
        THEN
        BEGIN
        anyChanges _ sinceIOchanges _ TRUE;
        backPnt^ _ lp.nxt;
        doTheExp[lp];
        RETURN;
        END;
      backPnt _ @lp.nxt;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  doTheExp: PROCEDURE [lpp: LONG POINTER TO list] =
    BEGIN
    dp: LONG POINTER TO cell object;
    bb: LONG POINTER TO bus object;
    lz: LONG POINTER TO list;
    id: CARDINAL _ lpp.idx;
    xo: CARDINAL _ BITAND[id, 1];
    --	IF xo#0 THEN id_id+8;
    id _ BITAND[id, 12];
    IF lpp # NIL THEN
      BEGIN
	IF lpp.ob.otyp=bus THEN
	    BEGIN
		x,y,len:INTEGER;
		bb_LOOPHOLE[lpp.ob];
		lz_NIL;
		x_lpp.lx;
		y_lpp.ly+bb.offsetFirst;
		len_bb.firstLength;
		THROUGH [0..bb.wCnt) DO
		  lqp_makeList[makeWire[len,bb.wwidth,bb.l],x,y,0,0];
		  lqp.nxt_lz;lz_lqp;
		  x_x+bb.wspace;
		  y_y+bb.topIncr;
		  len_len+bb.lenIncr;
		ENDLOOP;
	    END
	ELSE IF lpp.ob.otyp=cell THEN
	    BEGIN

      dp _ LOOPHOLE[lpp.ob];
      lqp _ dp.ptr;
      lz _ NIL;
      WHILE lqp # NIL DO
        lz _ copyObject[lp: lqp, mp: lz, xoff: lpp.lx, yoff: lpp.ly];
        lqp _ lqp.nxt;
        ENDLOOP;
	    END;
      WHILE id # 0 DO rotReflList[FALSE, lz, TRUE]; id _ id - 4; ENDLOOP;
      IF xo # 0 THEN rotReflList[TRUE, lz, TRUE];
      lqp _ lz;
      WHILE lqp # NIL AND lqp.nxt # NIL DO lqp _ lqp.nxt; ENDLOOP;
      IF lqp # NIL THEN BEGIN lqp.nxt _ masterList; masterList _ lz; END;
      lpp.nxt _ NIL;
--  this is a storage leak, but the screen updaters may
--     be holding a pointer to this list, for drawing a selection box.
--      flushDel[lpp];
      dChange _ TRUE;
      END;
    reCount[];
    END;

  reCount: PUBLIC PROCEDURE =
    BEGIN
    selCount _ 0;
    lp _ masterList;
    WHILE lp # NIL DO
      IF lp.selected THEN selCount _ selCount + 1; lp _ lp.nxt; ENDLOOP;
    END;

  undrawUnsel: PROCEDURE [mp: LONG POINTER TO list] =
    BEGIN
    r: Rect;
    selCount _ 0;
    lp _ mp;
    ii _ 1;
    jj _ 1;
    WHILE lp # NIL DO
      IF lp.selected THEN
        BEGIN
        lp.selected _ FALSE;
        IF jj < ii THEN
          BEGIN
          r _ IF jj = 1 THEN getRect[lp] ELSE mergeRects[r, getRect[lp]];
          jj _ jj + 1;
          END
        ELSE
          BEGIN
          IF jj = 1 THEN reDrawRect[getRect[lp], 1, TRUE, TRUE, FALSE]
          ELSE reDrawRect[mergeRects[r, getRect[lp]], 1, TRUE, TRUE, FALSE];
          jj _ 1;
          ii _ ii + 1;
          END;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    IF jj > 1 THEN reDrawRect[r, 1, TRUE, TRUE, FALSE];
    END;

  selSingle: PUBLIC PROCEDURE [mp: LONG POINTER TO list, xx, yy: INTEGER] =
    BEGIN
    lpp: LONG POINTER TO list _ NIL;
    sflg: BOOLEAN _ FALSE;
    lp _ mp;
    IF lp = NIL THEN RETURN;
    WHILE lp # NIL DO
      IF lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN
        IF lpp = NIL THEN lpp _ lp;
        IF sflg THEN BEGIN lpp _ lp; EXIT; END;
        IF lp.selected THEN sflg _ TRUE;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    undrawUnsel[mp];
    IF lpp = NIL THEN RETURN;
    lpp.selected _ TRUE;
    selCount _ 1;
    setupSelDisplay[lpp];
    drawNewlySel[lpp];
    END;
  selExtend: PUBLIC PROCEDURE [mp: LONG POINTER TO list, xx, yy: INTEGER] =
    BEGIN
    lp _ mp;
    WHILE lp # NIL DO
      IF NOT lp.selected AND lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx]
        THEN
        BEGIN
        lp.selected _ TRUE;
        selCount _ selCount + 1;
        drawNewlySel[lp];
	setupSelDisplay[lp];
        RETURN;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  selNewThing: PUBLIC PROCEDURE [
    mp, lp: LONG POINTER TO list, unOthers: BOOLEAN] =
    BEGIN
    IF unOthers THEN BEGIN undrawUnsel[mp]; selCount _ 0; END;
    IF lp = NIL THEN RETURN;
    lp.selected _ TRUE;
    selCount _ selCount + 1;
	setupSelDisplay[lp];
    END;
  unselSingle: PUBLIC PROCEDURE [mp: LONG POINTER TO list, xx, yy: INTEGER] =
    BEGIN
    lp _ mp;
    WHILE lp # NIL DO
      IF lp.selected AND lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN
	nullifySelDisplay[];
        lp.selected _ FALSE;
        selCount _ selCount - 1;
        reDrawRect[getRect[lp], 1, TRUE, TRUE, FALSE];
        RETURN;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  selAreaSingle: PUBLIC PROCEDURE [mp: LONG POINTER TO list, xx, yy: INTEGER] =
    BEGIN
    x1, x2, y1, y2: INTEGER;
    undrawUnsel[mp];
	nullifySelDisplay[];
    x1 _ MIN[xx, selMarkPnt.x];
    y1 _ MIN[yy, selMarkPnt.y];
    x2 _ MAX[xx, selMarkPnt.x];
    y2 _ MAX[yy, selMarkPnt.y];
    lp _ mp;
    WHILE lp # NIL DO
      IF inRect[lp, x1, y1, x2, y2] THEN
        BEGIN lp.selected _ TRUE; selCount _ selCount + 1; drawNewlySel[lp]; END;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  selAreaExtend: PUBLIC PROCEDURE [mp: LONG POINTER TO list, xx, yy: INTEGER] =
    BEGIN
    x1, x2, y1, y2: INTEGER;
	nullifySelDisplay[];
    x1 _ MIN[xx, selMarkPnt.x];
    y1 _ MIN[yy, selMarkPnt.y];
    x2 _ MAX[xx, selMarkPnt.x];
    y2 _ MAX[yy, selMarkPnt.y];
    lp _ mp;
    WHILE lp # NIL DO
      IF inRect[lp, x1, y1, x2, y2] AND NOT lp.selected THEN
        BEGIN lp.selected _ TRUE; selCount _ selCount + 1; drawNewlySel[lp]; END;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  unselAreaSingle: PUBLIC PROCEDURE [mp: LONG POINTER TO list, xx, yy: INTEGER] =
    BEGIN
    x1, x2, y1, y2: INTEGER;
	nullifySelDisplay[];
    x1 _ MIN[xx, selMarkPnt.x];
    y1 _ MIN[yy, selMarkPnt.y];
    x2 _ MAX[xx, selMarkPnt.x];
    y2 _ MAX[yy, selMarkPnt.y];
    lp _ mp;
    WHILE lp # NIL DO
      IF inRect[lp, x1, y1, x2, y2] AND lp.selected THEN
        BEGIN
        lp.selected _ FALSE;
        selCount _ selCount - 1;
        reDrawRect[getRect[lp], 1, TRUE, TRUE, FALSE];
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;
  inRect: PROCEDURE [lp: LONG POINTER TO list, x1, y1, x2, y2: INTEGER]
    RETURNS [BOOLEAN] =
    BEGIN
    x, y, sx, sy: INTEGER;
    x _ lp.lx;
    y _ lp.ly;
    IF BITAND[lp.idx, 4] = 0 THEN
      BEGIN sx _ lp.ob.size[0]; sy _ lp.ob.size[1]; END
    ELSE BEGIN sx _ lp.ob.size[1]; sy _ lp.ob.size[0]; END;
    IF x >= x2 OR y >= y2 OR x + sx <= x1 OR y + sy <= y1 THEN RETURN[FALSE];
    IF x < x1 OR y < y1 OR x + sx > x2 OR y + sy > y2 THEN RETURN[FALSE];
    RETURN[TRUE];
    END;
setupSelDisplay:PROCEDURE[lp:LONG POINTER TO list] =
    BEGIN
	len:CARDINAL;
	tp:LONG POINTER TO text prop_getTextProp[lp];
	makeNNam:PROCEDURE =
	    BEGIN
		localNameString.length_len+2;
		FOR i:CARDINAL DECREASING IN [0..len) DO
			localNameString[i+2]_localNameString[i];ENDLOOP;
		localNameString[0]_'*;
		localNameString[1]_' ;
	    END;
	IF tp=NIL THEN len_0
	 ELSE BEGIN len_MIN[25,tp.s.length];
		FOR i:CARDINAL IN [0..len) DO localNameString[i]_tp.s[i];
				ENDLOOP;END;
	locIName_IF len=0 THEN "" ELSE localNameString;
	localNameString.length_len;
	SELECT lp.ob.otyp FROM
	  wire => BEGIN locCell_"(wire)";IF len>0 THEN makeNNam[];END;
	  rect => BEGIN locCell_"(rectangle)";END;
	  xstr => BEGIN locCell_"(xstr)";END;
	  cont => BEGIN locCell_"(cont)";IF len>0 THEN makeNNam[];END;
	  bus => BEGIN
		bp:LONG POINTER TO bus object_LOOPHOLE[lp.ob];
		localBusString.length_0;
		AppendString[localBusString,"("];
		AppendDecimal[localBusString,bp.wCnt];
		AppendString[localBusString," wire bus)"];
		locCell_localBusString;
	    END;
	  text => BEGIN locCell_"(text)";END;
	  cnText => BEGIN locCell_"(cnText)";END;
	  cell => BEGIN
		cpp: LONG POINTER TO cList _ cellList;
		flg: BOOLEAN _ FALSE;
		WHILE cpp # NIL DO
		  IF lp.ob = cpp.ob THEN BEGIN locCell_cpp.name;
			flg _ TRUE; EXIT; END;
		  cpp _ cpp.nxt;
		ENDLOOP;
		IF NOT flg THEN locCell_"--noname--";
	    END;
	ENDCASE;
    END;
nullifySelDisplay:PROCEDURE =
    BEGIN
	locIName_"";
	locCell_"()";
    END;

  rotReflSel: PUBLIC PROCEDURE [refl: BOOLEAN] =
    BEGIN rotReflList[refl, masterList, FALSE]; END;
  rotReflList: PROCEDURE [
    refl: BOOLEAN, mlp: LONG POINTER TO list, force: BOOLEAN] =
    BEGIN
    mix, miy, may, max, xx, yy, mdif: INTEGER;
    flg: BOOLEAN _ FALSE;
    ii: CARDINAL;
    lp _ mlp;
    WHILE lp # NIL DO
      IF lp.selected OR force THEN
        BEGIN
        ii _ IF BITAND[lp.idx, 4] = 0 THEN 0 ELSE 1;
        IF NOT flg THEN
          BEGIN
          mix _ lp.lx;
          miy _ lp.ly;
          may _ lp.ly + lp.ob.size[ii + 1];
          max _ lp.lx + lp.ob.size[ii];
          flg _ TRUE;
          END
        ELSE
          BEGIN
          mix _ MIN[mix, lp.lx];
          miy _ MIN[miy, lp.ly];
          may _ MAX[may, lp.ly + lp.ob.size[ii + 1]];
          max _ MAX[max, lp.lx + lp.ob.size[ii]];
          END;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    mdif _ MAX[max - mix, may - miy];
    lp _ mlp;
    WHILE lp # NIL DO
      IF lp.selected OR force THEN
        BEGIN
        ii _ IF BITAND[lp.idx, 4] = 0 THEN 0 ELSE 1;
        anyChanges _ sinceIOchanges _ TRUE;
        IF refl THEN
          BEGIN
          lp.idx _ BITXOR[lp.idx, 1];
          lp.lx _ max - lp.lx + mix - lp.ob.size[ii];
          END
        ELSE
          BEGIN
          lp.idx _ BITAND[lp.idx + 4, 15];
          IF BITAND[lp.idx, 1] # 0 THEN lp.idx _ BITXOR[lp.idx, 8];
          xx _ lp.lx - mix;
          yy _ lp.ly - miy;
          lp.lx _ mix - yy - lp.ob.size[ii + 1] + may - miy;
          lp.ly _ miy + xx;
          END;
        lp.ridx _ BITXOR[lp.idx, 1];
        END;
      lp _ lp.nxt;
      ENDLOOP;
    IF force THEN RETURN;
    IF refl THEN reDrawRect[[mix, miy, max, may], 1, TRUE, TRUE, FALSE]
    ELSE reDrawRect[[mix, miy, mix + mdif, miy + mdif], 1, TRUE, TRUE, FALSE];
    END;
  rotReflPnt: PUBLIC PROCEDURE [refl: BOOLEAN, xx, yy: INTEGER] =
    BEGIN
    mdif: INTEGER;
    lp _ masterList;
    WHILE lp # NIL DO
      IF lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN
        lp.idx _ IF refl THEN BITXOR[lp.idx, 1] ELSE BITAND[lp.idx + 4, 15];
        lp.ridx _ BITXOR[lp.idx, 1];
        mdif _ MAX[lp.ob.size[0], lp.ob.size[1]];
        reDrawRect[
          [lp.lx, lp.ly, lp.lx + mdif, lp.ly + mdif], 1, TRUE, TRUE, FALSE];
        anyChanges _ sinceIOchanges _ TRUE;
        RETURN;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;

  mergeRects: PUBLIC PROCEDURE [a, b: Rect] RETURNS [Rect] =
    BEGIN
    RETURN[[MIN[a.x1, b.x1], MIN[a.y1, b.y1], MAX[a.x2, b.x2], MAX[a.y2, b.y2]]];
    END;
  getRect: PUBLIC PROCEDURE [l: LONG POINTER TO list] RETURNS [r: Rect] =
    BEGIN
    ii: CARDINAL _ IF BITAND[l.idx, 4] = 0 THEN 0 ELSE 1;
    oi:INTEGER_l.ob.surround;
    r.x1 _ l.lx-oi;
    r.y1 _ l.ly-oi;
    r.x2 _ l.lx + l.ob.size[ii]+oi;
    r.y2 _ l.ly + l.ob.size[ii + 1]+oi;
    END;

  cannonRect: PUBLIC PROCEDURE [r: Rect] RETURNS [Rect] =
    BEGIN
    t: INTEGER;
    IF r.x1 > r.x2 THEN BEGIN t _ r.x1; r.x1 _ r.x2; r.x2 _ t; END;
    IF r.y1 > r.y2 THEN BEGIN t _ r.y1; r.y1 _ r.y2; r.y2 _ t; END;
    RETURN[r];
    END;

  makeList: PUBLIC PROCEDURE [
    p: LONG POINTER TO object, x, y: INTEGER, o: orientation, refl: reflection]
    RETURNS [lp: LONG POINTER TO list] =
    BEGIN
    lp _ alocList[];
    lp^.lx _ x;
    lp^.ly _ y;
    lp^.ob _ p;
    lp^.idx _ o*2 + refl;
    lp^.ridx _ BITXOR[1, lp.idx];
    END;

  inrect: PUBLIC PROCEDURE [x, y: INTEGER, lp: LONG POINTER TO list]
    RETURNS [BOOLEAN] =
    BEGIN
    xs, ys: INTEGER;
    IF BITAND[lp.idx, 4] = 0 THEN
      BEGIN xs _ lp.ob.size[0]; ys _ lp.ob.size[1]; END
    ELSE BEGIN xs _ lp.ob.size[1]; ys _ lp.ob.size[0]; END;
    IF x IN [lp.lx..lp.lx + xs] AND y IN [lp.ly..lp.ly + ys] THEN RETURN[TRUE]
    ELSE RETURN[FALSE];
    END;

  flushDel: PUBLIC PROCEDURE [lp: LONG POINTER TO list] =
    BEGIN
    lpp: LONG POINTER TO list;
    WHILE lp # NIL DO
      lp.ob.p.release[lp.ob];
      lpp _ lp.nxt;
      lp.deleted _ TRUE;
      freeList[lp];
      lp _ lpp;
      ENDLOOP;
    END;

  --copy stuff:

  copyObject: PUBLIC PROCEDURE [lp, mp: LONG POINTER TO list, xoff, yoff: INTEGER]
    RETURNS [np: LONG POINTER TO list] =
    BEGIN
    np _ makeList[lp.ob.p.anotherme[lp.ob], lp.lx + xoff, lp.ly + yoff, 0, 0];
    np.idx _ lp.idx;
    np.ridx _ lp.ridx;
    np.selected _ FALSE;
    np.gotText _ lp.gotText;
    copyProps[np, lp];
    np _ insertList[mp, np];
    END;

  copyProps: PUBLIC PROCEDURE [n, o: listPtr] =
    BEGIN
    n.props _ NIL;
    FOR pop: propPtr _ o.props, pop.nxt WHILE pop # NIL DO
      WITH dpop: pop SELECT FROM
        text =>
          BEGIN
          p: LONG POINTER TO text prop _ alocTextProp[];
          p.s _ newString[dpop.s];
          putProp[n, p];
          END;
        ENDCASE => NULL;
      ENDLOOP;
    END;

  minmax: PUBLIC PROCEDURE [lp: LONG POINTER TO list]
    RETURNS [mix, miy, max, may: INTEGER] =
    BEGIN
    flg: BOOLEAN _ TRUE;
    ii: CARDINAL;
    mix _ max _ miy _ may _ 0;
    WHILE lp # NIL DO
      ii _ IF BITAND[lp.idx, 4] = 0 THEN 0 ELSE 1;
      IF flg THEN
        BEGIN
        mix _ lp.lx;
        max _ lp.lx + lp.ob.size[ii];
        miy _ lp.ly;
        may _ lp.ly + lp.ob.size[ii + 1];
        flg _ FALSE;
        END
      ELSE
        BEGIN
        mix _ MIN[mix, lp.lx];
        max _ MAX[max, lp.lx + lp.ob.size[ii]];
        miy _ MIN[miy, lp.ly];
        may _ MAX[may, lp.ly + lp.ob.size[ii + 1]];
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;

  typeInNum: PUBLIC PROCEDURE [os1, os2, os3: STRING]
    RETURNS [bb: BOOLEAN, ii: INTEGER, ke: keyEvent] =
    BEGIN
	s:STRING;
	i:CARDINAL;
	[bb,s,ke]_typeIn[os1,os2,os3];
	ii_0;
	IF NOT bb THEN RETURN;
	FOR i IN[0..s.length) DO
	  IF s[i] IN ['0..'9] THEN ii_ii*10+(s[i]-'0);
	ENDLOOP;
	IF s[0]='- THEN ii_-ii;
	FreeString[s];
    END;

  typeIn: PUBLIC PROCEDURE [os1, os2, os3: STRING]
    RETURNS [bb: BOOLEAN, is: STRING, ke: keyEvent] =
    BEGIN
    pos: CARDINAL;
    invertColors[];
    EraseArea[tiCx - 3, bwBottom+4, 700, bwMsgBottom-6];
    pos _ ReplaceText[os1, tiCx, bwBottom + 20, fnt, normal];
    pos _ ReplaceText[os2, tiCx, bwBottom + 30, fnt, normal];
    pos _ ReplaceText[os3, tiCx, bwBottom + 40, fnt, normal];
    [bb, is, ke] _ getstr[tiCx, bwBottom + 50];
    IF bb THEN is _ newString[is] ELSE refreshTypeInScreen[];
    restoreColors[];
    END;
  typeInC: PUBLIC PROCEDURE [os1, os2, os3: STRING] RETURNS [kk: keyEvent] =
    BEGIN
    pos: CARDINAL;
    invertColors[];
    EraseArea[tiCx - 3, bwBottom+4, 700, bwMsgBottom-6];
    pos _ ReplaceText[os1, tiCx, bwBottom + 20, fnt, normal];
    pos _ ReplaceText[os2, tiCx, bwBottom + 30, fnt, normal];
    pos _ ReplaceText[os3, tiCx, bwBottom + 40, fnt, normal];
    kk _ getchr[];
    restoreColors[];
    END;
  typeOut: PUBLIC PROCEDURE [os1, os2, os3: STRING] =
    BEGIN
    pos: CARDINAL;
    EraseArea[tiCx - 3, bwBottom+4, 700, bwMsgBottom-6];
    pos _ ReplaceText[os1, tiCx, bwBottom + 20, fnt, normal];
    pos _ ReplaceText[os2, tiCx, bwBottom + 30, fnt, normal];
    pos _ ReplaceText[os3, tiCx, bwBottom + 40, fnt, normal];
    END;
  refreshTypeInScreen: PUBLIC PROCEDURE =
    BEGIN
    EraseArea[tiCx - 3, bwBottom+4, 700, bwMsgBottom-6];
    END;

  getErfil: PUBLIC cmdProc =
    BEGIN
    ok: BOOLEAN;
    [ok, ss, ke] _ typeIn["", "Type Error File Name:", "(in full)"];
    IF NOT ok THEN RETURN;
    dChange _ TRUE;
    IF NOT openErfile[ss] THEN RETURN;
    END;
  enterText: PUBLIC cmdProc =
    BEGIN
    ok: BOOLEAN;
    pop: LONG POINTER TO text prop;
    IF NOT bb THEN RETURN;
    lqp _ NIL;
    lp _ masterList;
    WHILE lp # NIL DO
      IF (lp.ob.otyp = wire OR lp.ob.otyp = cont)
        AND lp.ob.p.inMe[lp.ob, xx - lp.lx, yy - lp.ly, lp.idx] THEN
        BEGIN
        lqp _ lp;
        EXIT;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    IF lqp = NIL THEN RETURN;
    [ok, ss, ke] _ typeIn["", "Type Text", "<CR> to QUIT"];
    refreshTypeInScreen[];
    IF ss.length = 0 OR NOT ok THEN RETURN;
    pop _ alocTextProp[];
    pop.s _ ss;
    putProp[lqp, pop];
    lqp.gotText _ TRUE;
        anyChanges _ sinceIOchanges _ TRUE;
    END;
  enterName: PUBLIC cmdProc =
    BEGIN
    ok: BOOLEAN;
    pop: LONG POINTER TO text prop;
    pr: LONG POINTER TO prop;
    lp _ masterList;
    WHILE lp # NIL DO
      IF lp.selected THEN
        BEGIN
	pr_lp.props;
	WHILE pr#NIL DO IF pr.ptyp=text THEN EXIT;pr_pr.nxt;ENDLOOP;
	[ok, ss, ke] _ typeIn["", "Type Text", "<CR> to QUIT"];
	refreshTypeInScreen[];
	IF ss.length = 0 OR NOT ok THEN RETURN;
	IF pr=NIL THEN
	    BEGIN
		pop _ alocTextProp[];
		pop.s _ ss;
		putProp[lp, pop];
	    END
	 ELSE
	    BEGIN
		pop_LOOPHOLE[pr];
		IF pop.s#NIL AND pop.s.length>0 THEN FreeString[pop.s];
		pop.s _ ss;
	    END;
	lp.gotText _ TRUE;
        anyChanges _ sinceIOchanges _ TRUE;
        RETURN;
        END;
      lp _ lp.nxt;
      ENDLOOP;
    END;


  END.