OPEN handle.layoutGraphics;  -- for numbersContainer, container, etc
height: INTEGER ← 0; -- the height of this container
rule: Rules.Rule;
y1, y2: INTEGER;  -- the y positions of the 1st and 2nd rows of items

numbersContainer ← Containers.Create[[iconic: FALSE, scrollable: FALSE, border: FALSE, parent: container, wx: 0, wy: 0]];
Containers.ChildXBound[container, numbersContainer];

now create all the individual information viewers.

y1 ← 0;
units.ref ← ChoiceButtons.BuildEnumTypeSelection[viewer: numbersContainer, x: 0, y: y1, title: "Units", buttonNames: unitsList, default: defaultUnits, borderOnButtons: FALSE, notifyClientProc: ChangeUnits, clientdata: handle, style: flipThru];

units.prev ← defaultUnits;

y2 ← units.ref.nexty;
setButton ← Buttons.Create[info: [wx: 0, wy: y2, name: "Set", border: TRUE, parent: numbersContainer], proc: SetProc, clientData: handle, fork: TRUE, font: setButtonFont];

pageWidth ← ChoiceButtons.BuildTextPrompt[viewer: numbersContainer, x: units.ref.nextx+6, y: y1, title: "Page Width:", font: numbersContainerFont, textViewerWidth: realWidth];

pageLength ← ChoiceButtons.BuildTextPrompt[viewer: numbersContainer, x: units.ref.nextx+6, y: y2, title: "Page Length:", font: numbersContainerFont, textViewerWidth: realWidth];

leftMargin ← ChoiceButtons.BuildTextPrompt[viewer: numbersContainer, x: pageLength.newx+6, y: y1, title: "Left Margin:", font: numbersContainerFont, textViewerWidth: realWidth];

rightMargin 𡤌hoiceButtons.BuildTextPrompt[viewer: numbersContainer, x: pageLength.newx+6, y: y2, title: "Right Margin:", font: numbersContainerFont, textViewerWidth: realWidth];

topMargin ← ChoiceButtons.BuildTextPrompt[viewer: numbersContainer, x: rightMargin.newx+6, y: y1, title: "Top Margin:", font: numbersContainerFont, textViewerWidth: realWidth];

bottomMargin𡤌hoiceButtons.BuildTextPrompt[viewer: numbersContainer, x:rightMargin.newx+6, y: y2, title: "Bottom Margin:", font: numbersContainerFont, textViewerWidth: realWidth];

bindingMargin ← ChoiceButtons.BuildTextPrompt[viewer: numbersContainer, x: topMargin.newx + 6, y: y1, title: "Binding Margin:", font: numbersContainerFont, textViewerWidth: realWidth];

height ← bottomMargin.newy + 3;
ViewerOps.EstablishViewerPosition[numbersContainer, numbersContainer.wx,
 numbersContainer.wy, numbersContainer.ww, height];

create the divider

rule ← Rules.Create[[wx: 0, wy: height, wh: 2, scrollable: FALSE, iconic: FALSE, parent: container]];
Containers.ChildXBound[container, rule];
RETURN[height + 4];
};

causes the information in the numbers container to be applied to the graphics viewer

handle: StyleToolHandle ← NARROW[clientData];
theButton: Buttons.Button ← NARROW[parent];
units: Rope.ROPE;
Buttons.SetDisplayStyle[theButton, $WhiteOnBlack];

First determine the units

units ← ChoiceButtons.GetSelectedButton[handle.layoutGraphics.units.ref];
DetermineInterval[handle, units];
ViewerOps.PaintViewer[handle.layoutGraphics.container, client];

Also make sure that the proper values get set for the original page layout parameters

SetOriginals[handle, handle.swap.layout.pageWidth, handle.layoutGraphics.pageWidth, units]; SetOriginals[handle, handle.swap.layout.pageLength, handle.layoutGraphics.pageLength, units];
SetOriginals[handle, handle.swap.layout.leftMargin, handle.layoutGraphics.leftMargin, units];
SetOriginals[handle, handle.swap.layout.rightMargin, handle.layoutGraphics.rightMargin, units];
SetOriginals[handle, handle.swap.layout.topMargin, handle.layoutGraphics.topMargin, units];
SetOriginals[handle, handle.swap.layout.bottomMargin, handle.layoutGraphics.bottomMargin,
 units];
SetOriginals[handle, handle.swap.layout.bindingMargin, handle.layoutGraphics.bindingMargin,
 units];
Buttons.SetDisplayStyle[theButton, $BlackOnWhite];
};

ViewerTools.SetContents[origRef.valueData.textViewer,
 ViewerTools.GetContents[curRef.textViewer]];
ChoiceButtons.UpdateChoiceButtons[handle.swap.layout.outer, origRef.units, units];
};

handle: StyleToolHandle ← NARROW[clientdata];

determine what the old units were

oldunits: Rope.ROPE ← handle.layoutGraphics.units.prev;

now update the previous units IFF the new units are not ems, ens or spaces. This is a kludge to get around not having conversions for ems, ens and spaces. (They are font dependent)

IF ~(Rope.Equal[name, "ems", FALSE]) AND ~(Rope.Equal[name, "ens",FALSE]) AND
 ~(Rope.Equal[name, "spaces", FALSE]) THEN {
 handle.layoutGraphics.units.prev ← name;
 ChangeValuesInViewers[handle, oldunits, name];
 };
};

ChangeViewerValue[handle.layoutGraphics.pageWidth, newUnits, oldUnits];
ChangeViewerValue[handle.layoutGraphics.pageLength, newUnits, oldUnits];
ChangeViewerValue[handle.layoutGraphics.rightMargin, newUnits, oldUnits];
ChangeViewerValue[handle.layoutGraphics.leftMargin, newUnits, oldUnits];
ChangeViewerValue[handle.layoutGraphics.topMargin, newUnits, oldUnits];
ChangeViewerValue[handle.layoutGraphics.bottomMargin, newUnits, oldUnits];
ChangeViewerValue[handle.layoutGraphics.bindingMargin, newUnits, oldUnits];
};

value: REAL ← StyleToolConvert.GetRealFromViewer[ref.textViewer];
value ← StyleToolConvert.ConvertUnits[value, oldUnits, newUnits];
StyleToolBuilders.DisplayRealInViewer[value, ref.textViewer];
};

ChangeToDefault: PROCEDURE = {

SELECT TRUE FROM
 Rope.Equal[units, "points", FALSE]   => handle.layoutGraphics.interval ← 20; 
 Rope.Equal[units, "picas", FALSE]    => handle.layoutGraphics.interval ← 20;
 Rope.Equal[units, "inches", FALSE]   => handle.layoutGraphics.interval ← 40;
 Rope.Equal[units, "centimeters", FALSE]  => handle.layoutGraphics.interval ← 16;
 Rope.Equal[units, "millimeters", FALSE]  => handle.layoutGraphics.interval ← 16;
 Rope.Equal[units, "didot points", FALSE]  => handle.layoutGraphics.interval ← 16;
 Rope.Equal[units, "ems", FALSE]    => ChangeToDefault[];
 Rope.Equal[units, "ens", FALSE]    => ChangeToDefault[];
 Rope.Equal[units, "spaces", FALSE]   => ChangeToDefault[];
 ENDCASE;
};

takes the value currently on display in the StyleTool (that is, in the ValueAndUnitsRef provided), converts it to inches and returns converted value in form of rope. If the value currently on display in the StyleTool was zero, the default value provided is used

value: REAL;
value ← StyleToolConvert.GetRealFromViewer[ref.valueData.textViewer];
IF (value = 0.0) THEN
 value ← defaultValue
ELSE
 value ← StyleToolConvert.ConvertUnits[value, ChoiceButtons.GetSelectedButton[ref.units],
  defaultUnits];
StyleToolBuilders.DisplayRealInViewer[value, displayInfo.textViewer];
};

initially we will default to inches. The user can change the units later

ConvertAndDisplay[handle.swap.layout.pageWidth, defaultPageWidth,
 handle.layoutGraphics.pageWidth];
ConvertAndDisplay[handle.swap.layout.pageLength, defaultPageLength,
 handle.layoutGraphics.pageLength];
ConvertAndDisplay[handle.swap.layout.leftMargin, defaultLeftMargin,
 handle.layoutGraphics.leftMargin];
ConvertAndDisplay[handle.swap.layout.rightMargin, defaultRightMargin,
 handle.layoutGraphics.rightMargin];
ConvertAndDisplay[handle.swap.layout.topMargin, defaultTopMargin,
 handle.layoutGraphics.topMargin];
ConvertAndDisplay[handle.swap.layout.bottomMargin, defaultBottomMargin,
 handle.layoutGraphics.bottomMargin];
ConvertAndDisplay[handle.swap.layout.bindingMargin, defaultBindingMargin,
 handle.layoutGraphics.bindingMargin];
};

We check for less than or equal or greater than or equal so that the user can bring the margins right up to the page boundaries if desired.

IF (x <= handle.layoutGraphics.screenPage.xmax) AND
 (x >= handle.layoutGraphics.screenPage.xmin) AND
 (y <= handle.layoutGraphics.screenPage.ymax) AND
 (y >= handle.layoutGraphics.screenPage.ymin) THEN
 RETURN [TRUE]
ELSE RETURN [FALSE];
};

check vertical margins first (left and right). This is so that when there is an equally likely chance of choosing one of two margins (eg - the top margin or the left margin) the vertical margin will be chosen. This would happen if the mouse was on or very near to an intersection point. This situation will not happen with 2 vertical margins

epsilon: REAL ← 1.0;
IF (handle.layoutGraphics.screenLeftMargin <= x + epsilon) AND
 (handle.layoutGraphics.screenLeftMargin >= x - epsilon) THEN RETURN [left]
ELSE IF (handle.layoutGraphics.screenBindingMargin <= x + epsilon) AND
 (handle.layoutGraphics.screenBindingMargin >= x - epsilon) THEN RETURN [binding]
ELSE IF (handle.layoutGraphics.screenRightMargin <= x + epsilon) AND
 (handle.layoutGraphics.screenRightMargin >= x - epsilon) THEN RETURN [right]
ELSE IF (handle.layoutGraphics.screenTopMargin <= y + epsilon) AND
 (handle.layoutGraphics.screenTopMargin >= y - epsilon) THEN RETURN [top]
ELSE IF (handle.layoutGraphics.screenBottomMargin <= y+epsilon) AND
 (handle.layoutGraphics.screenBottomMargin >= y - epsilon) THEN RETURN [bottom]
ELSE RETURN [none];
};

check vertical page boundaries first (left and right). This is so that when there is an equally likely chance of choosing one of two page boundaries (eg - the top page boundary or the right page boundary) the vertical page boundary will be chosen. This would happen if the mouse was on or very near to an intersection point.

epsilon: REAL ← 3.0;
IF (handle.layoutGraphics.screenPage.xmin <= x + epsilon) AND
 (handle.layoutGraphics.screenPage.xmin >= x - epsilon) THEN {
 OPEN MessageWindow; -- for Append and Blink
 Append["You cannot move the left page boundary to change the page width", TRUE];
 Blink[];
 RETURN [none];
 }
ELSE IF (handle.layoutGraphics.screenPage.xmax <= x + epsilon) AND
 (handle.layoutGraphics.screenPage.xmax >= x - epsilon) THEN RETURN [side]
ELSE IF (handle.layoutGraphics.screenPage.ymax <= y + epsilon) AND
 (handle.layoutGraphics.screenPage.ymax >= y - epsilon) THEN RETURN [top]
ELSE IF (handle.layoutGraphics.screenPage.ymin <= y+epsilon) AND
 (handle.layoutGraphics.screenPage.ymin >= y - epsilon) THEN {
 OPEN MessageWindow; -- for Append and Blink
 Append["You cannot move the bottom page boundary to change the page length", TRUE];
 Blink[];
 RETURN [none]
 }
ELSE RETURN [none];
};

OPEN handle.layoutGraphics; -- for screenLeftMargin, screenPage, interval, increment
RETURN[((screenLeftMargin - screenPage.xmin)/ interval) * (increment/skip)];
};

OPEN handle.layoutGraphics; -- for screenRightMargin, screenPage, interval, increment
RETURN[((screenPage.xmax - screenRightMargin)/ interval) * (increment/skip)];
};

OPEN handle.layoutGraphics; -- for screenBindingMargin, screenLeftMargin, interval, increment
RETURN[((screenBindingMargin - screenLeftMargin)/ interval) * (increment/skip)];
};

OPEN handle.layoutGraphics; -- for screenTopMargin, screenPage, interval, increment
RETURN[((screenPage.ymax - screenTopMargin)/ interval) * (increment/skip)];
};

OPEN handle.layoutGraphics; -- for screenBottomMargin, screenPage, interval, increment
RETURN[((screenBottomMargin - screenPage.ymin)/ interval) * (increment/skip)];
};

OPEN handle.layoutGraphics;  -- for screenPage, interval, increment
RETURN[((screenPage.xmax - screenPage.xmin)/ interval) * (increment/skip)];
};

OPEN handle.layoutGraphics;  -- for screenPage, interval, increment
RETURN[((screenPage.ymax - screenPage.ymin)/ interval) * (increment/skip)];
};