nexty: INTEGER;
handle.layoutGraphics.container ← Containers.Create[info: [name: "PAGE LAYOUT", scrollable: FALSE, iconic: FALSE, column: left, icon: Icons.NewIconFromFile["StyleTool.icons", 3]]];

nexty ← CreateNumbersContainer[handle];
handle.layoutGraphics.interval ← defaultInterval;
SetUpNumbers[handle];
CreateGraphicsViewer[handle, nexty];
ViewerOps.PaintViewer[handle.layoutGraphics.container, all];
};

handle: StyleToolHandle ← NARROW[clientData];
IF ~MessageWindow.Confirm["Confirm discarding all edits . . ."] THEN RETURN;
ViewerOps.DestroyViewer[handle.layoutGraphics.container];
handle.layoutGraphics.container ← NIL;
handle.layoutGraphics.exists ← FALSE;
};

layoutViewerClass: ViewerClasses.ViewerClass ← NEW[ViewerClasses.ViewerClassRec ← [
 paint: LayoutPainter,
 notify: NotifyEvents,
 coordSys: bottom,
 tipTable: TIPUser.InstantiateNewTIPTable["StyleToolGraphics.TIP"]
 ]];
ViewerOps.RegisterViewerClass[$LayoutViewer, layoutViewerClass];
handle.layoutGraphics.viewer ← ViewerOps.CreateViewer[flavor: $LayoutViewer, info: [
 parent: handle.layoutGraphics.container, wx: 0, wy: starty, scrollable: FALSE, border: FALSE,
 data: handle]];

Since we have created our own viewer class, we can attach anything we want to the data field of the viewer rec. We put the handle there so that in future calls to the paint proc, we can have handle on the StyleTool

Containers.ChildXBound[handle.layoutGraphics.container, handle.layoutGraphics.viewer];
Containers.ChildYBound[handle.layoutGraphics.container, handle.layoutGraphics.viewer];
};

StyleToolBuilders.DisplayRealInViewer[newValue, displayInfo.textViewer];
};

handle: StyleToolHandle ← NARROW[self.data];
MessageWindow.Clear[];
IF whatChanged = NIL THEN {

ELSE {

};

handle: StyleToolHandle ← NARROW[self.data];
iMouse, jMouse: REAL;

InterpretAtom: PROCEDURE [atom: ATOM] = {

FOR items: LIST OF REF ANY ← input, items.rest UNTIL items = NIL DO
 WITH items.first SELECT FROM
  x: TIPUser.TIPScreenCoords => { iMouse ← x.mouseX;
            jMouse ← x.mouseY;
            };
  x: ATOM       => InterpretAtom[x];
  ENDCASE;
 ENDLOOP;

};

xpos, ypos, rem: INTEGER;
path: Graphics.Path;

start on an even interval boundary

xpos ← Real.FixI[bounds.xmin];
rem ← (xpos MOD handle.layoutGraphics.interval);
IF rem # 0 THEN
 xpos ← xpos+ handle.layoutGraphics.interval - rem;
ypos ← Real.FixI[bounds.ymin];
rem ← (ypos MOD handle.layoutGraphics.interval);
IF rem # 0 THEN
 ypos ← ypos + handle.layoutGraphics.interval - rem;

first clear the viewer if necessary

IF ~clear THEN {
 Graphics.SetColor[context, Graphics.white];
 Graphics.DrawBox[context, bounds];
 };

now draw the grid

Graphics.SetColor[context, gray];
path ← Graphics.NewPath[];

WHILE xpos <= bounds.xmax OR ypos <= bounds.ymax DO

};

start the proper amount of units in

OPEN handle.layoutGraphics; -- for screenPage, interval, indent, pageWidth, pageLength
pageVal: REAL;
path: Graphics.Path;
DetermineIndent[handle];
DetermineSkipAndIncrement[handle];
screenPage.xmin ← indent*interval;
pageVal ← StyleToolConvert.GetRealFromViewer[pageWidth.textViewer];
screenPage.xmax ← ((pageVal / (increment/skip)) + indent) * interval;
screenPage.ymin ← indent*interval;
pageVal ← StyleToolConvert.GetRealFromViewer[pageLength.textViewer];
screenPage.ymax ← ((pageVal / (increment/skip)) + indent) * interval;

clear the area which is the page

Graphics.SetColor[context, Graphics.white];
Graphics.DrawBox[context, handle.layoutGraphics.screenPage];

now draw the outline of the page

Graphics.SetColor[context, Graphics.black];
path ← Graphics.NewPath[];
Graphics.MoveTo[path, screenPage.xmin, screenPage.ymin];
Graphics.LineTo[path, screenPage.xmax, screenPage.ymin];
Graphics.LineTo[path, screenPage.xmax, screenPage.ymax];
Graphics.LineTo[path, screenPage.xmin, screenPage.ymax];
Graphics.LineTo[path, screenPage.xmin, screenPage.ymin];
Graphics.DrawStroke[context, path, pageOutlineThickness];
};

units: Rope.ROPE ← ChoiceButtons.GetSelectedButton[handle.layoutGraphics.units.ref];

SELECT TRUE FROM

};

OPEN handle.layoutGraphics; -- for interval
font: Graphics.FontRef ← VFonts.GraphicsFont[VFonts.EstablishFont[
 family: "Helvetica", size: 10, bold: TRUE, italic: FALSE, defaultOnFailure: TRUE]];
xline, yline: REAL ← GetNumberLine[handle] * interval;
xpos, ypos: REAL ← indent*interval;
rxmin, rxmax, rymin, rymax: REAL;
x0, y0, x1, y1: REAL;
i: CARDINAL ← 0;
numberRope: Rope.ROPE;
path: Graphics.Path ← Graphics.NewPath[];

numbers accross x axis

WHILE xpos <= bounds.xmax DO
 numberRope ← IO.PutFR["%g", IO.int[i]];
 [rxmin, rymin, rxmax, rymax] ← Graphics.RopeBox[font, numberRope];
 x0 ← xpos - (rxmax - rxmin)/2 - 2; -- bottom right corner
 y0 ← yline - (rymax - rymin)/2;
 x1 ← xpos + (rxmax - rxmin)/2 + 2; -- top left corner plus some pixels
 y1 ← yline + (rymax - rymin)/2;
 Graphics.SetColor[context, Graphics.white];
 Graphics.MoveTo[path, x0, y0, TRUE];
 Graphics.Rectangle[path, x0, y0, x1, y1];
 Graphics.DrawArea[context, path];
 Graphics.SetColor[context, Graphics.black];
 Graphics.SetCP[context, x0 + 2, y0 + 2];
 Graphics.DrawRope[self: context, rope: numberRope, font: font];
 xpos ← xpos + skip * interval;
 i ← i + increment;
 ENDLOOP;

numbers accross the y axis

i ← 0;
WHILE ypos <= bounds.ymax DO
 numberRope ← IO.PutFR["%g", IO.int[i]];
 [rxmin, rymin, rxmax, rymax] ← Graphics.RopeBox[font, numberRope];
 x0 ← xline - (rxmax - rxmin)/2 - 2; -- bottom right corner
 y0 ← ypos - (rymax - rymin)/2;
 x1 ← xline + (rxmax - rxmin)/2 + 2; -- top left corner plus some pixels
 y1 ← ypos + (rymax - rymin)/2;
 Graphics.SetColor[context, Graphics.white];
 Graphics.MoveTo[path, x0, y0, TRUE];
 Graphics.Rectangle[path, x0, y0, x1, y1];
 Graphics.DrawArea[context, path];
 Graphics.SetColor[context, Graphics.black];
 Graphics.SetCP[context, x0 + 2, y0 + 2];
 Graphics.DrawRope[self: context, rope: numberRope, font: font];
 ypos ← ypos + skip * interval;
 i ← i + increment;
 ENDLOOP;
};

units: Rope.ROPE ← ChoiceButtons.GetSelectedButton[handle.layoutGraphics.units.ref];
SELECT TRUE FROM

};

units: Rope.ROPE ← ChoiceButtons.GetSelectedButton[handle.layoutGraphics.units.ref];
SELECT TRUE FROM

};

unitsRope: Rope.ROPE;
font: Graphics.FontRef ← VFonts.GraphicsFont[VFonts.EstablishFont[
 family: "Helvetica", size: 8, bold: TRUE, italic: FALSE, defaultOnFailure: TRUE]];
xline, yline: REAL ← GetNumberLine[handle] * handle.layoutGraphics.interval;
rxmin, rxmax, rymin, rymax: REAL;
x0, y0, x1, y1: REAL;
path: Graphics.Path ← Graphics.NewPath[];
unitsRope ← ChoiceButtons.GetSelectedButton[handle.layoutGraphics.units.ref];

[rxmin, rymin, rxmax, rymax] ← Graphics.RopeBox[font, unitsRope];
x0 ← xline - (rxmax - rxmin)/2 - 2; -- bottom right corner
y0 ← yline - (rymax - rymin)/2;
x1 ← xline + (rxmax - rxmin)/2 + 2; -- top left corner plus some pixels
y1 ← yline + (rymax - rymin)/2;

Graphics.SetColor[context, Graphics.white];
Graphics.MoveTo[path, x0, y0];
Graphics.Rectangle[path, x0, y0, x1, y1];
Graphics.DrawArea[context, path];
Graphics.SetColor[context, Graphics.black];
Graphics.SetCP[context, x0 + 2, y0 + 2];
Graphics.DrawRope[self: context, rope: unitsRope, font: font];
};

Graphics.SetColor[context, Graphics.black];
DrawLeftMargin[handle, context];
DrawRightMargin[handle, context];
DrawTopMargin[handle, context];
DrawBottomMargin[handle, context];
DrawBindingMargin[handle, context];
};

OPEN handle.layoutGraphics; -- for leftMargin, screenLeftMargin, screenPage and interval
margin: REAL ← StyleToolConvert.GetRealFromViewer[leftMargin.textViewer];
path: Graphics.Path ← Graphics.NewPath[];
screenLeftMargin ← screenPage.xmin + ((margin / (increment/skip)) * interval);
IF screenLeftMargin < screenPage.xmax THEN {
 -- Dont bother drawing a margin which lies outside of the page
 Graphics.MoveTo[path, screenLeftMargin, screenPage.ymin];
 Graphics.LineTo[path, screenLeftMargin, screenPage.ymax];
 Graphics.DrawStroke[context, path, marginThickness];
 };
};

OPEN handle.layoutGraphics; -- for rightMargin, screenRightMargin, screenPage and interval
margin: REAL ← StyleToolConvert.GetRealFromViewer[rightMargin.textViewer];
path: Graphics.Path ← Graphics.NewPath[];
screenRightMargin ← screenPage.xmax - ((margin / (increment/skip)) * interval);
IF screenRightMargin > screenPage.xmin THEN {
 Graphics.MoveTo[path, screenRightMargin, screenPage.ymin];
 Graphics.LineTo[path, screenRightMargin, screenPage.ymax];
 Graphics.DrawStroke[context, path, marginThickness];
 };
};

OPEN handle.layoutGraphics; -- for topMargin, screenTopMargin, screenPage and interval
margin: REAL ← StyleToolConvert.GetRealFromViewer[topMargin.textViewer];
path: Graphics.Path ← Graphics.NewPath[];
screenTopMargin ← screenPage.ymax - ((margin / (increment/skip)) * interval);
IF screenTopMargin > screenPage.ymin THEN {
 Graphics.MoveTo[path, screenPage.xmin, screenTopMargin];
 Graphics.LineTo[path, screenPage.xmax, screenTopMargin];
 Graphics.DrawStroke[context, path, marginThickness];
 };
};

OPEN handle.layoutGraphics; -- for bottomMargin, screenBottomMargin, screenPage and interval
margin: REAL ← StyleToolConvert.GetRealFromViewer[bottomMargin.textViewer];
path: Graphics.Path ← Graphics.NewPath[];
screenBottomMargin ← screenPage.ymin + ((margin / (increment/skip)) * interval);
IF screenBottomMargin < screenPage.ymax THEN {
 Graphics.MoveTo[path, screenPage.xmin, screenBottomMargin];
 Graphics.LineTo[path, screenPage.xmax, screenBottomMargin];
 Graphics.DrawStroke[context, path, marginThickness];
 };
};

OPEN handle.layoutGraphics; -- for bindingMargin, screenBindingMargin, screenPage and interval
offset: REAL ← StyleToolConvert.GetRealFromViewer[bindingMargin.textViewer];
path: Graphics.Path ← Graphics.NewPath[];
screenBindingMargin ← screenLeftMargin + ((offset / (increment/skip)) * interval);
IF screenBindingMargin < screenPage.xmax THEN {
 Graphics.MoveTo[path, screenBindingMargin, screenPage.ymin];
 Graphics.LineTo[path, screenBindingMargin, screenPage.ymax];
 Graphics.DrawStroke[context, path, marginThickness];
 };
};

for each different margin we do the same procedure. First check that the new position will not cause the margin to overlap with its "opposite" margin. This means that if we are changing the right margin, we first want to check that the new right margin will not overlap the left margin, this would not make sense and it would drive the typesetter crazy. If everything is OK, then change the position of the margin

OPEN handle.layoutGraphics; -- for currentMargin, screenRightMargin, screenLeftMargin, rightMargin, leftMargin, etc
neverLand: REAL ← 5.0;
SELECT currentMargin FROM
 left => IF (x + neverLand) < screenRightMargin THEN {
     diff: REAL ← x - screenLeftMargin;
     DrawVerticalMargin[handle, context, screenLeftMargin];
     screenLeftMargin ← x;
     DrawVerticalMargin[handle, context, screenLeftMargin];
     UpdateValue[leftMargin, ScreenToLeftMargin[handle]];
     -- also redraw the binding margin accordingly
     DrawVerticalMargin[handle, context, screenBindingMargin];
     screenBindingMargin ← screenBindingMargin + diff;
     DrawVerticalMargin[handle, context, screenBindingMargin];
     -- no need to update the value of the binding margin since it's an offset and
     -- that hasn't changed
     };
 right  => IF (x - neverLand) > screenLeftMargin THEN {
     DrawVerticalMargin[handle, context, screenRightMargin];
     screenRightMargin ← x;
     DrawVerticalMargin[handle, context, screenRightMargin];
     UpdateValue[rightMargin, ScreenToRightMargin[handle]];
     };
 binding => IF x > screenLeftMargin THEN {
     DrawVerticalMargin[handle, context, screenBindingMargin];
     screenBindingMargin ← x;
     DrawVerticalMargin[handle, context, screenBindingMargin];
     UpdateValue[bindingMargin, ScreenToBindingMargin[handle]];
     };
 top => IF (y - neverLand) > screenBottomMargin THEN {
     DrawHorizontalMargin[handle, context, screenTopMargin];
     screenTopMargin ← y;
     DrawHorizontalMargin[handle, context, screenTopMargin];
     UpdateValue[topMargin, ScreenToTopMargin[handle]];
     };
 bottom => IF (y + neverLand) < screenTopMargin THEN {
     DrawHorizontalMargin[handle, context, screenBottomMargin];
     screenBottomMargin ← y;
     DrawHorizontalMargin[handle, context, screenBottomMargin];
     UpdateValue[bottomMargin, ScreenToBottomMargin[handle]];
     };
 ENDCASE;
};

oldPaintMode: Graphics.PaintMode ← Graphics.SetPaintMode[context, invert];
path: Graphics.Path ← Graphics.NewPath[];
Graphics.MoveTo[path, x, handle.layoutGraphics.screenPage.ymin];
Graphics.LineTo[path, x, handle.layoutGraphics.screenPage.ymax];
Graphics.DrawStroke[context, path, marginThickness];
[] ← Graphics.SetPaintMode[context, oldPaintMode];
};

oldPaintMode: Graphics.PaintMode ← Graphics.SetPaintMode[context, invert];
path: Graphics.Path ← Graphics.NewPath[];
Graphics.MoveTo[path, handle.layoutGraphics.screenPage.xmin, y];
Graphics.LineTo[path, handle.layoutGraphics.screenPage.xmax, y];
Graphics.DrawStroke[context, path, marginThickness];
[] ← Graphics.SetPaintMode[context, oldPaintMode];
};

for the different page boundaries we do the same procedure. First check that the new position will not cause the boundary to overlap with its "opposite" boundary. This means that if we are changing the right boundary, we first want to check that the new right boundary will not overlap the left boundary, this would not make sense and it would drive the typesetter crazy. If everything is OK, then change the position of the page boundary.

neverLand: REAL ← 5.0;
SELECT handle.layoutGraphics.currentPage FROM
 side  => IF (x - neverLand) > handle.layoutGraphics.screenPage.xmin THEN {
     IF x < handle.layoutGraphics.screenPage.xmax THEN
      -- indicates that we are making the page smaller so need to redraw the grid.
      DrawSmallerPageFromRight[handle, context, x]
     ELSE DrawLargerPageFromRight[handle, context, x];
     handle.layoutGraphics.screenPage.xmax ← x;
     UpdateValue[handle.layoutGraphics.pageWidth, ScreenToPageWidth[handle]];
     };
 top => IF (y - neverLand) > handle.layoutGraphics.screenPage.ymin THEN {
     IF y < handle.layoutGraphics.screenPage.ymax THEN
      -- indicates that we are making the page smaller so need to redraw the grid
      DrawSmallerPageFromTop[handle, context, y]
     ELSE DrawLargerPageFromTop[handle, context, y];
     handle.layoutGraphics.screenPage.ymax ← y;
     UpdateValue[handle.layoutGraphics.pageLength, ScreenToPageLength[handle]];
     };
 ENDCASE;
};

OPEN handle.layoutGraphics; -- for screenPage, screenRightMargin
tempBox, gridBox: Graphics.Box;
path: Graphics.Path ← Graphics.NewPath[];
tempBox.xmin ← x;
tempBox.xmax ← screenPage.xmax;
tempBox.ymin ← screenPage.ymin;
tempBox.ymax ← screenPage.ymax;

remove the old outline

Graphics.SetColor[context, Graphics.white];
DrawThreePageSides[context, tempBox];

white out the area to be redrawn and redraw the grid

gridBox ← tempBox;
gridBox.xmax ← tempBox.xmax + 1; -- since the page outline is 2 units wide
gridBox.ymax ← tempBox.ymax + 1;
DrawGrid[handle, context, FALSE, gridBox];

now redraw the right page boundary

Graphics.SetColor[context, Graphics.black];
Graphics.MoveTo[path, tempBox.xmin, tempBox.ymin];
Graphics.LineTo[path, tempBox.xmin, tempBox.ymax];
Graphics.DrawStroke[context, path, pageOutlineThickness];

now redraw the margin

IF (screenRightMargin - (tempBox.xmax - tempBox.xmin)) > screenPage.xmin THEN {
 DrawVerticalMargin[handle, context, screenRightMargin];-- erase old one
 screenRightMargin ← screenRightMargin - (tempBox.xmax - tempBox.xmin);
 DrawVerticalMargin[handle, context, screenRightMargin];
 };
};

OPEN handle.layoutGraphics; -- for screenPage, screenTopMargin
tempBox, gridBox: Graphics.Box;
path: Graphics.Path ← Graphics.NewPath[];
tempBox.xmin ← screenPage.xmin;
tempBox.xmax ← screenPage.xmax;
tempBox.ymin ← y;
tempBox.ymax ← screenPage.ymax;

remove the old outline

Graphics.SetColor[context, Graphics.white];
DrawThreePageSidesFromTop[context, tempBox];

white out the area to be redrawn and redraw the grid

gridBox ← tempBox;
gridBox.xmax ← tempBox.xmax + 1; -- since the page outline is 2 units wide
gridBox.ymax ← tempBox.ymax + 1;
DrawGrid[handle, context, FALSE, gridBox];

now redraw the top page boundary

Graphics.SetColor[context, Graphics.black];
Graphics.MoveTo[path, tempBox.xmin, tempBox.ymin];
Graphics.LineTo[path, tempBox.xmax, tempBox.ymin];
Graphics.DrawStroke[context, path, pageOutlineThickness];

now redraw the margin

IF (screenTopMargin - (tempBox.ymax - tempBox.ymin)) > screenPage.ymin THEN {
 DrawHorizontalMargin[handle, context, screenTopMargin];-- erase old one
 screenTopMargin ← screenTopMargin - (tempBox.ymax - tempBox.ymin);
 DrawHorizontalMargin[handle, context, screenTopMargin];
 };
};

OPEN handle.layoutGraphics; -- for screenPage,screenTopMargin,screenBottomMargin,screenRightMargin
tempBox: Graphics.Box;
path: Graphics.Path ← Graphics.NewPath[];
tempBox.xmin ← screenPage.xmax;
tempBox.xmax ← x;
tempBox.ymin ← screenPage.ymin;
tempBox.ymax ← screenPage.ymax;
-- erase the old grid and old page boundary
Graphics.SetColor[context, Graphics.white];
Graphics.DrawBox[context, tempBox];

extend old top and bottom page boundaries and draw new right boundary

Graphics.SetColor[context, Graphics.black];
DrawThreePageSides[context, tempBox];

now redraw the right margin and extend others.

Graphics.MoveTo[path, tempBox.xmin, screenTopMargin];
Graphics.LineTo[path, tempBox.xmax, screenTopMargin];
Graphics.DrawStroke[context, path, marginThickness];
Graphics.MoveTo[path, tempBox.xmin, screenBottomMargin, TRUE];
Graphics.LineTo[path, tempBox.xmax, screenBottomMargin];
Graphics.DrawStroke[context, path, marginThickness];
DrawVerticalMargin[handle, context, screenRightMargin];-- erase old one
screenRightMargin ← screenRightMargin + (tempBox.xmax - tempBox.xmin);
DrawVerticalMargin[handle, context, handle.layoutGraphics.screenRightMargin];
};

OPEN handle.layoutGraphics; -- for screenPage, screenRightMargin, screenLeftMargin, screenBindingMargin
tempBox: Graphics.Box;
path: Graphics.Path ← Graphics.NewPath[];
tempBox.xmin ← screenPage.xmin;
tempBox.xmax ← screenPage.xmax;
tempBox.ymin ← screenPage.ymax-1;
tempBox.ymax ← y;

erase the old grid and old page boundary

Graphics.SetColor[context, Graphics.white];
Graphics.DrawBox[context, tempBox];

extend old left and right page boundaries and draw new top boundary

Graphics.SetColor[context, Graphics.black];
DrawThreePageSidesFromTop[context, tempBox];

now redraw the top margin and extend others.

Graphics.MoveTo[path, screenRightMargin, tempBox.ymin];
Graphics.LineTo[path, screenRightMargin, tempBox.ymax+1];
Graphics.DrawStroke[context, path, marginThickness];
Graphics.MoveTo[path, screenLeftMargin, tempBox.ymin, TRUE];
Graphics.LineTo[path, screenLeftMargin, tempBox.ymax+1];
Graphics.DrawStroke[context, path, marginThickness];
Graphics.MoveTo[path, screenBindingMargin, tempBox.ymin, TRUE];
Graphics.LineTo[path, screenBindingMargin, tempBox.ymax+1];
Graphics.DrawStroke[context, path, marginThickness];
DrawHorizontalMargin[handle,context, screenTopMargin];-- erase old one
screenTopMargin ← screenTopMargin + (tempBox.ymax - tempBox.ymin - 1);
DrawHorizontalMargin[handle, context, screenTopMargin];
};

path: Graphics.Path ← Graphics.NewPath[];
Graphics.MoveTo[path, box.xmin, box.ymin];
Graphics.LineTo[path, box.xmax, box.ymin];
Graphics.LineTo[path, box.xmax, box.ymax];
Graphics.LineTo[path, box.xmin, box.ymax];
Graphics.DrawStroke[context, path, pageOutlineThickness];
};

path: Graphics.Path ← Graphics.NewPath[];
Graphics.MoveTo[path, box.xmin, box.ymin];
Graphics.LineTo[path, box.xmin, box.ymax];
Graphics.LineTo[path, box.xmax, box.ymax];
Graphics.LineTo[path, box.xmax, box.ymin];
Graphics.DrawStroke[context, path, pageOutlineThickness];
};