Last edit by Michael Plass, January 31, 1983 2:51 pm

Last Edited by: Teitelman, April 12, 1983 5:01 pm

Last Edited by: Doug Wyatt, April 22, 1983 4:37 pm

OPEN MessageWindow;  -- for Append and Blink
IF (handle.mark1.x = 0) AND (handle.mark1.y = 0) AND
 (handle.mark2.x = 0) AND (handle.mark2.y = 0) THEN {
 SELECT representation FROM
  rect=>Append["Hold down yellow mouse button and mark a rectangular area first...",TRUE];
  line=>Append["Hold down yellow mouse button and control key and mark a line first...",
     TRUE];
  ENDCASE => ERROR;
 Blink[];
 RETURN[FALSE] }
ELSE RETURN[TRUE];
};

handle.savedBitMap ← handle.icons[LOOPHOLE[handle.currentIC]].bits;
};

iconsOnDisplay: CARDINAL ← MIN[handle.numberOfIcons, maxIconsOnDisplay];
handle.numIconsPerRow ← Real.FixC[bounds.xmax/(iconW+distX)];
handle.numIconsPerCol ← Real.FixC[bounds.ymax/(iconH+distY)];
IF handle.numIconsPerRow*handle.numIconsPerCol < iconsOnDisplay THEN {
 MessageWindow.Append["Icon Editor viewer is too small to display current Icon menu.", TRUE];
 SIGNAL ViewerNoGood};
handle.possibleX ← Real.FixC[bounds.xmax - ((iconsOnDisplay + handle.numIconsPerCol - 1) /
 handle.numIconsPerCol) * (iconW + distX)];
handle.possibleY ← Real.FixC[bounds.ymax - ((iconsOnDisplay + handle.numIconsPerRow-1) /
 handle.numIconsPerRow) * (iconH+distY)];
IF handle.possibleX < minimumUnit * iconW AND handle.possibleY < minimumUnit * iconH THEN {
 MessageWindow.Append["Icon Editor viewer is too small for a decent drawing board.", TRUE];
 SIGNAL ViewerNoGood};
IF handle.possibleX <= handle.possibleY THEN { -- use a vertical layout, preferred if square
 handle.boardSize ← MIN[Real.FixC[bounds.xmax], handle.possibleY];
 handle.numIconsPerCol ← (iconsOnDisplay + handle.numIconsPerRow - 1) /
  handle.numIconsPerRow;
 handle.icX ← 0;
 handle.icY ← Real.FixC[handle.boardSize] + 1}
ELSE { -- use a horizontal layout
 handle.boardSize ← MIN[Real.FixC[bounds.ymax], handle.possibleX];
 handle.numIconsPerRow ← (iconsOnDisplay + handle.numIconsPerCol - 1) /
  handle.numIconsPerCol;
 handle.icX ← Real.FixC[handle.boardSize] + 1;
 handle.icY ← 0};
handle.unit ← Real.FixI[handle.boardSize / (intHBound + 1)];
handle.boardSize ← handle.unit * (intHBound + 1);
};

newFlavor ← handle.nextFlavor;
handle.nextFlavor ← SUCC[newFlavor];
IF LOOPHOLE[handle.nextFlavor, CARDINAL] >= maxStorage THEN {
 MessageWindow.Append[message: "Sorry but you have exceeded the current limit on icons.",
  clearFirst: TRUE];
 MessageWindow.Blink[];
 ERROR};
END;

iconFile ← FileIO.Open[fileName: filename, accessOptions: overwrite];
FOR j: CARDINAL IN [0..numberOfIcons) DO
 iconName: Rope.ROPE;
 IO.UnsafePutBlock[iconFile, [LOOPHOLE[handle.icons[LOOPHOLE[j]]], 0,
  SIZE[iconFileFormat]*2]];
 TRUSTED {IF Runtime.IsBound[IconRegistry.IsRegistered] AND (iconName ← IconRegistry.IsRegistered[fileName: filename, index: j].name) # NIL THEN IconRegistry.InvalidateCache[iconName]}; -- w.t.
 ENDLOOP;
IO.Flush[iconFile];  -- make sure we got everything
IO.Close[iconFile];  -- now close things up
};

takes two diagonal points and computes the bottom left corner of the rectangle and its width and height

rect.x ← MIN[corner1.x, corner2.x];
rect.y ← MIN[corner1.y, corner2.y];
rect.w ← ABS[corner2.x-corner1.x] + 1;
rect.h ← ABS[corner2.y-corner1.y] + 1;
};

line.x1 ← endpoint1.x; line.y1 ← endpoint1.y;
line.x2 ← endpoint2.x; line.y2 ← endpoint2.y;
};

center: INTEGER;
center ← Real.FixI[handle.unit/2];  -- used to center endpoints of line in grid square
newLine.x1 ← oldLine.x1*handle.unit; newLine.y1 ← (intHBound- oldLine.y1)*handle.unit;
newLine.x2 ← oldLine.x2*handle.unit; newLine.y2 ← (intHBound- oldLine.y2)*handle.unit;

Now add one unit to the rightmost x and to the upper y so that an accurate representation of the line is drawn.

IF newLine.x1 > newLine.x2 THEN {
 newLine.x1 ← newLine.x1 + handle.unit - center;
 newLine.x2 ← newLine.x2 + center};
IF newLine.x2 > newLine.x1 THEN {
 newLine.x2 ← newLine.x2 + handle.unit - center;
 newLine.x1 ← newLine.x1 + center};
IF newLine.x1 = newLine.x2 THEN {
 newLine.x1 ← newLine.x2 ← newLine.x2 + center};
IF newLine.y1 > newLine.y2 THEN {
 newLine.y1 ← newLine.y1 + handle.unit - center;
 newLine.y2 ← newLine.y2 + center};
IF newLine.y2 > newLine.y1 THEN {
 newLine.y2 ← newLine.y2 + handle.unit - center;
 newLine.y1 ← newLine.y1 + center};
IF newLine.y1 = newLine.y2 THEN {
 newLine.y1 ← newLine.y2 ← newLine.y2 + center};
};

i,j: CARDINAL;
iconToClear: iconRef ← handle.icons[LOOPHOLE[flavor]];
FOR i IN intW DO
 FOR j IN intH DO
  iconToClear.bits[j].b[i] ← FALSE;
  ENDLOOP;
 ENDLOOP;
};

Reflects icon accross imaginary x-axis. Achieves the effect of holding the icon in a mirror

i,j: INTEGER;
temp: BOOLEAN;
farRight: CARDINAL ← rect.x+rect.w-1;
FOR j IN [rect.y..rect.y+rect.h-1] DO
 FOR i IN [0..rect.w/2) DO
  temp ← handle.icons[LOOPHOLE[flavor]].bits[j].b[rect.x + i];
  handle.icons[LOOPHOLE[flavor]].bits[j].b[rect.x + i] ←
   handle.icons[LOOPHOLE[flavor]].bits[j].b[farRight - i];
  handle.icons[LOOPHOLE[flavor]].bits[j].b[farRight - i] ← temp;
 ENDLOOP;
ENDLOOP;
};

deltaX, deltaY, i, e, x, y, factor: INTEGER;
deltaX ← ABS[line.x2 - line.x1];
deltaY ← ABS[line.y2 - line.y1];

IF ((line.x1<line.x2) AND (line.y2<line.y1)) OR ((line.x2<line.x1) AND (line.y1<line.y2)) THEN {

ELSE {

x ← MIN[line.x1, line.x2];

IF deltaX >= deltaY THEN {

ELSE {

FreshMarks[handle];
};

handle.mark1.x ← handle.mark1.y ← handle.mark2.x ← handle.mark2.y ← 0;
handle.functionNotApplied ← FALSE;
};

handle.icons[LOOPHOLE[flavor]].invertLabel ← TRUE;
};

handle.icons[LOOPHOLE[flavor]].invertLabel ← FALSE;
};

sets the proper parameters in the file representation

OPEN i: handle.icons[LOOPHOLE[flavor]];
i.label ← TRUE;
handle.labelRect.x ← i.lx ← rect.x;
i.ly ← iconH - 1 - (rect.y + rect.h);
handle.labelRect.y ← rect.y;
handle.labelRect.w ← i.lw ← rect.w;
handle.labelRect.h ← i.lh ← rect.h;
FreshMarks[handle];
};

undoes the proper parameters in the file representation

OPEN i: handle.icons[LOOPHOLE[flavor]];
i.label ← FALSE;
i.lx ← 0; i.ly ← 0;
i.lw ← 0; i.lh ← 0;
};

i, j: INTEGER;
iconToClear: iconRef ← handle.icons[LOOPHOLE[flavor]];
FOR i IN [rect.x..rect.x+rect.w-1] DO
 FOR j IN [rect.y..rect.y+rect.h-1] DO
  iconToClear.bits[j].b[i] ← FALSE;
  ENDLOOP;
 ENDLOOP;
FreshMarks[handle];
};

set gray pattern in specified icon

i, j, k: INTEGER;
indent: INTEGER ← 0;
FOR j ← 0, j+2 WHILE j < LOOPHOLE[IconEditorDefs.intHBound] DO
 -- each gray line is two lines high
 FOR k IN [0..1] DO
  -- paint gray
  FOR i ← indent, i+4 WHILE i <= LOOPHOLE[IconEditorDefs.intWBound] DO
   IF j IN [rect.y .. rect.y+rect.h) AND i IN [rect.x ..rect.x+rect.w) THEN
    handle.icons[LOOPHOLE[flavor]].bits[j+k].b[i] ← TRUE;
  ENDLOOP;
 ENDLOOP;
 -- next time do a differnt indentation
 indent ← IF indent=0 THEN 2 ELSE 0;
ENDLOOP;
FreshMarks[handle];
};

set dark gray pattern in specified icon

i, j: INTEGER;
indent: INTEGER ← 0;
FOR j IN [rect.y..rect.y+rect.h-1) DO
 -- paint gray
 FOR i ← (rect.x+indent), i+2 WHILE i < (rect.x+rect.w-1) DO
   handle.icons[LOOPHOLE[flavor]].bits[j].b[i] ← TRUE;
 ENDLOOP;
 -- next time do a differnt indentation
 indent ← IF indent=0 THEN 1 ELSE 0;
ENDLOOP;
FreshMarks[handle];
};

fills in a rectangle with black

i, j: INTEGER;
FOR i IN [rect.x..rect.x+rect.w-1] DO
 FOR j IN [rect.y..rect.y+rect.h-1] DO
  handle.icons[LOOPHOLE[flavor]].bits[j].b[i] ← TRUE;
  ENDLOOP;
 ENDLOOP;
FreshMarks[handle];
};

i,j: INTEGER;
FOR i IN [rect.x..rect.x+rect.w-1] DO
 FOR j IN [rect.y..rect.y+rect.h-1] DO
  handle.icons[LOOPHOLE[flavor]].bits[j].b[i] ←
   IF handle.icons[LOOPHOLE[flavor]].bits[j].b[i] THEN FALSE ELSE TRUE;
  ENDLOOP;
 ENDLOOP;
FreshMarks[handle];
};

x1, y1, x2, y2: NAT;

x1 ← handle.mark1.x; y1 ← handle.mark1.y;

x2 ← handle.mark2.x; y2 ← handle.mark2.y;

IF x1=0 AND y1=0 AND x2=0 AND y2=0 THEN { x2 ← intWBound; y2 ← intHBound };

RETURN[[xmin: MIN[x1, x2], ymin: MIN[y1, y2], xmax: MAX[x1, x2], ymax: MAX[y1, y2]]];

};

numberToMove: CARDINAL ← IF slowShift THEN 1 ELSE 4;

r: Rectangle = GetRectangle[handle];

FOR k: CARDINAL IN [1..numberToMove] DO

};

numberToMove: CARDINAL ← IF slowShift THEN 1 ELSE 4;

r: Rectangle = GetRectangle[handle];

FOR k: CARDINAL IN [1..numberToMove] DO

};

numberToMove: CARDINAL ← IF slowShift THEN 1 ELSE 4;

r: Rectangle = GetRectangle[handle];

FOR k: CARDINAL IN [1..numberToMove] DO

};

numberToMove: CARDINAL ← IF slowShift THEN 1 ELSE 4;

r: Rectangle = GetRectangle[handle];

FOR k: CARDINAL IN [1..numberToMove] DO

};

fixed SaveIcons to invalidate cache of IconRegistry for any icons in the file that is being saved.

changes to: SaveIcons, DIRECTORY, IMPORTS

changes to: SaveIcons, DIRECTORY, IMPORTS

Added GetRectangle; the shifting operations now use GetRectangle, so they are insensitive to which corners were used to select the rectangle.