DIRECTORY
 ChoiceButtons USING [GetSelectedButton, SetButtonState, UpdateChoiceButtons],
Containers USING [Container, Create],
EditSpanSupport USING [Apply],
Icons USING [NewIconFromFile],
IO USING [char, PutFR], 
Labels USING [Set],
Menus USING [CreateEntry, CreateMenu, MenuProc, InsertMenuEntry],
MessageWindow USING [Append, Blink, Clear],
NameSymbolTable USING [Name, nullName, RopeFromName], 
NodeStyle USING [ApplyAll, ApplyLooks, Create, GetBindingMargin, GetBottomMargin,
	-- GetColumns, GetFooterMargin,GetHeaderMargin,GetLineLength,
	GetFontSize,  GetLeftIndent, GetRightIndent, GetFirstIndent, GetRestIndent, GetTopIndent,
	GetBottomIndent, GetLeading, GetLeadingStretch, GetLeadingShrink, GetTopLeading,
	GetTopLeadingStretch, GetTopLeadingShrink, GetBottomLeading, GetBottomLeadingStretch,
	GetBottomLeadingShrink, GetVShift, GetLeftMargin, GetMinLineGap, GetTabStops,
	GetPageBreakPenalty, GetPageBreakAfterFirstLinePenalty,
	GetPageBreakBeforeLastLinePenalty, GetPageBreakBeforeFirstLinePenalty,
	GetPageBreakAfterLastLinePenalty, GetPageLength, GetPageWidth, GetRightMargin,
   GetTopMargin, GetAreaHue, GetAreaSaturation, GetAreaBrightness, GetOutlineHue,
	GetOutlineSaturation, GetOutlineBrightness, GetTextHue, GetTextSaturation,
	GetTextBrightness, GetTextRotation, GetLineWeight, OfStyle, Ref, StyleNameForNode],
Rope USING [Cat, Equal, ROPE],
StyleToolDefs,
StyleToolBuilders,
StyleToolConvert USING [GetFontFamily, -- GetFontFace, 
	GetFontAlphabetsChoice, GetFontUnderliningChoice, GetLineFormattingChoice,
	GetPathTypeChoice],
StyleToolSample USING [ApplyFormat, ApplyToSelection],
StyleToolToJaM USING [WriteDisplayInfo],
TEditDocument USING [Selection],
TEditOps USING [GetSelData], 
TextEdit USING [FetchLooks, Size],
TextLooks USING [Looks, Look],
TextNode USING [Offset, Ref, RefTextNode, Span, StepForward],
Commander USING [CommandProc, Register],
ViewerClasses USING [Viewer],
ViewerOps USING [CreateViewer, PaintViewer, SetOpenHeight],
ViewerTools USING [SetContents];
StyleToolImpl: CEDAR PROGRAM

IMPORTS  ChoiceButtons, Commander, Containers, EditSpanSupport, Icons, IO, Labels, Menus, MessageWindow, NameSymbolTable, NodeStyle, Rope, StyleToolBuilders, StyleToolConvert, StyleToolSample, StyleToolToJaM, TEditOps, TextEdit, TextNode, ViewerOps, ViewerTools
EXPORTS StyleToolDefs =

BEGIN OPEN StyleToolDefs;

fontFamilyList: PUBLIC LIST OF Rope.ROPE _ LIST["Arrows", "Classic", "Cream", "Cyrillic", "Gacha", "Helvetica", "Hippo", "Logo", "Math", "OldEnglish", "TimesRoman", "Tioga", "None", "Other"];
fontFaceList: PUBLIC LIST OF Rope.ROPE _ LIST["Regular", "Bold", "Italic", "BoldItalic"];
fontAlphabetsList: PUBLIC LIST OF Rope.ROPE _ LIST["CapsAndLower", "CapsAndSmallCaps", "LowerOnly", "CapsOnly"];
fontUnderliningList: PUBLIC LIST OF Rope.ROPE _ LIST["None", "LettersAndDigits", "Visible", "All"];
lineFormattingList: PUBLIC LIST OF Rope.ROPE _ LIST["FlushLeft", "FlushRight", "Justified", "Centered"];
pathTypeList: PUBLIC LIST OF Rope.ROPE _ LIST["Filled", "Outlined", "FilledAndOutlined"];
ruleList: PUBLIC LIST OF Rope.ROPE _ LIST["ScreenRule", "PrintRule", "StyleRule"];
unitsList: PUBLIC LIST OF Rope.ROPE _ LIST["points", "picas", "inches", "centimeters", "millimeters", "didot points", "ems", "ens", "spaces"];

realNumberFormat: PUBLIC Rope.ROPE _ "%-5.2f";
integerFormat: PUBLIC Rope.ROPE _ "%g";

NotUniform: SIGNAL = CODE;

---- ---- ---- ---- ---- ---- ---- ----
BuildStyleTool: Commander.CommandProc = TRUSTED
BEGIN
tool: StyleToolHandle _ NEW[StyleToolHandleRec];
defaultNodeStyle: NodeStyle.Ref;

-- construct the outer container
tool.outer _ Containers.Create[[
	name: "Style Tool",		-- name displayed in the caption
	iconic: TRUE,			-- so tool will be open and on the screen when first created
	menu: Menus.CreateMenu[lines: 3],
	column: right,			-- initially in the left column
	icon: Icons.NewIconFromFile["StyleTool.icons", 2],
	scrollable: TRUE			-- inhibit user from scrolling contents
	]];

Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name:
	"SetChangesMode", proc: SetChangesModeProc, fork: TRUE, clientData: tool], line: 2];	
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name:
	"SetCreateMode", proc: SetCreateModeProc, clientData: tool], line: 2];
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name: "SetToDefault",
	proc: SetToDefaultProc, clientData: tool], line: 2];
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name:
	"ApplyToSelection", proc: ApplySelectionProc, fork: TRUE, clientData: tool], line: 0];	
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name:
	"ApplyToSample", proc: ApplyFormatProc, clientData: tool], line: 0];
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name: "WriteLook",
	proc: WriteLookProc, clientData: tool], line: 1];
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name:
	"WriteFormatOnly", proc: WriteFormatProc, clientData: tool], line: 1];
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name: "ShowLooks",
	proc: ShowLooksProc, clientData: tool], line: 1];
Menus.InsertMenuEntry[menu: tool.outer.menu, entry: Menus.CreateEntry[name:
	"ShowFormatOnly", proc: ShowFormatProc, clientData: tool], line: 1];

StyleToolBuilders.BuildStyleNameField[tool];		-- build each section in turn
StyleToolBuilders.BuildFormatNameField[tool];
StyleToolBuilders.BuildLooksField[tool];
StyleToolBuilders.BuildRuleField[tool];
StyleToolBuilders.BuildDisplayViewer[tool];
StyleToolBuilders.BuildSwapArea[tool];	-- builds print information field and JaMCodeViewer
defaultNodeStyle _ NodeStyle.Create[];
tool.default _ defaultNodeStyle;
tool.nodeInfo _ defaultNodeStyle;
tool.looksInfo _ defaultNodeStyle;
UpdateDisplayViewer[tool, defaultNodeStyle];
ViewerOps.SetOpenHeight[tool.outer, tool.height];		-- hint our desired height
ViewerOps.PaintViewer[tool.outer, all];					-- reflect above change
END;

---- ---- ---- ---- ---- ---- ---- ----

SetChangesModeProc: Menus.MenuProc = BEGIN
 handle: StyleToolHandle _ NARROW[clientData];
handle.changesMode _ TRUE;
END;
SetCreateModeProc: Menus.MenuProc = BEGIN
 handle: StyleToolHandle _ NARROW[clientData];
handle.changesMode _ FALSE;
END;
SetToDefaultProc: Menus.MenuProc = BEGIN
 handle: StyleToolHandle _ NARROW[clientData];
handle.nodeInfo _ handle.default;
handle.looksInfo _ handle.default;
UpdateDisplayViewer[handle, handle.default];
END;
WriteFormatProc: Menus.MenuProc = BEGIN

 handle: StyleToolHandle _ NARROW[clientData];
StyleToolToJaM.WriteDisplayInfo[handle, handle.default, TRUE];
END;

WriteLookProc: Menus.MenuProc = BEGIN
 handle: StyleToolHandle _ NARROW[clientData];
StyleToolToJaM.WriteDisplayInfo[handle, handle.looksInfo, FALSE];
END;

ShowFormatProc: Menus.MenuProc = BEGIN
 handle: StyleToolHandle _ NARROW[clientData];
-- First make sure the style name gets displayed
GetName[handle: handle, style: TRUE];
GetName[handle: handle, style: FALSE];
-- make sure there are no looks names showing (have nothing to do with the format)
ViewerTools.SetContents[handle.looksData.textViewer, NIL];
GetFormat[handle: handle];
END;

ShowLooksProc: Menus.MenuProc = BEGIN
handle: StyleToolHandle _ NARROW[clientData];
-- First make sure the style name gets displayed
GetName[handle: handle, style: TRUE];
-- Make sure the format name isn't showing (has nothing to do with a look)
ViewerTools.SetContents[handle.formatNameData.textViewer, NIL];
GetLooks[handle: handle];
END;

ApplyFormatProc: Menus.MenuProc = BEGIN
 handle: StyleToolHandle _ NARROW[clientData];
MessageWindow.Append["Applying to sample....", TRUE];
StyleToolSample.ApplyFormat[handle];
MessageWindow.Clear[];
END;

ApplySelectionProc: Menus.MenuProc = BEGIN
 handle: StyleToolHandle _ NARROW[clientData];
IF ~handle.userAware THEN {
 MessageWindow.Append["Please make sure you are using a COPY of the actual document.", TRUE];
MessageWindow.Blink[];
handle.userAware _ TRUE;
};
 MessageWindow.Append["Applying to selection....", TRUE];
StyleToolSample.ApplyToSelection[handle];
MessageWindow.Clear[];
END;
---- ---- ---- ---- ---- ---- ---- ----

GetName: PROCEDURE [handle: StyleToolHandle, style: BOOLEAN] = {
 pSel: TEditDocument.Selection = TEditOps.GetSelData[];
name: NameSymbolTable.Name _ NameSymbolTable.nullName;
viewer: ViewerClasses.Viewer _ IF style THEN handle.styleNameData.textViewer ELSE handle.formatNameData.textViewer;
	
Get: PROCEDURE [node: TextNode.Ref] = {

firstName: NameSymbolTable.Name _ IF style THEN NodeStyle.StyleNameForNode[node]
		ELSE node.typename;
IF name = NameSymbolTable.nullName THEN name _ firstName	-- initialize
ELSE IF name # firstName THEN {
	MessageWindow.Append[IF style THEN "Nodes don't have uniform style.  Using first."
		ELSE "Nodes don't have uniform display.  Using first.", TRUE];
	MessageWindow.Blink[];
	SIGNAL NotUniform};
	};

 IF ~CheckPSel[pSel] THEN RETURN;	-- Checks that a selection has been made
FOR node: TextNode.Ref _ pSel.start.pos.node, TextNode.StepForward[node] DO
	Get[node ! NotUniform => CONTINUE];
	IF node = pSel.end.pos.node THEN EXIT;
	ENDLOOP;
ViewerTools.SetContents[viewer, NameSymbolTable.RopeFromName[name]];
};
CheckPSel: PROC [pSel: TEditDocument.Selection, typescriptOK: BOOL _ FALSE]
	RETURNS [ok: BOOLEAN] = { OPEN MessageWindow;
IF pSel#NIL AND pSel.viewer#NIL AND
	(pSel.viewer.class.flavor=$Text OR (typescriptOK AND pSel.viewer.class.flavor=$Typescript))
	THEN RETURN [TRUE];
Append["Please make a text selection.",TRUE];
Blink[]; RETURN [FALSE] };
GetLooks: PROCEDURE [handle: StyleToolHandle] = {
 pSel: TEditDocument.Selection = TEditOps.GetSelData[];
looks: TextLooks.Looks;
looksRope: Rope.ROPE;
first: BOOLEAN _ TRUE;
span: TextNode.Span;
nodeStyle: NodeStyle.Ref _ NodeStyle.Create[];
looksStyle: NodeStyle.Ref _ NodeStyle.Create[];
ruleStyle: NodeStyle.OfStyle _ GetRuleStyle[handle];

GetSelLooks: PROCEDURE [node: TextNode.RefTextNode, start, len: TextNode.Offset]
	RETURNS [stop: BOOLEAN] = {
 end: TextNode.Offset _ MIN[TextEdit.Size[node], start+len];
FOR i: TextNode.Offset IN [start..end) DO
	lks: TextLooks.Looks _ TextEdit.FetchLooks[node,i];
	IF first THEN { first _ FALSE; looks _ lks }
	ELSE IF lks # looks THEN {
		MessageWindow.Append["Selection does not have uniform looks.", TRUE];
		MessageWindow.Append["  Using looks from first char."];
		MessageWindow.Blink[]; 
		RETURN[TRUE];
		};
	ENDLOOP;
RETURN[FALSE]
};

IF pSel = NIL OR pSel.viewer = NIL OR pSel.viewer.class.flavor # $Text THEN {
	MessageWindow.Append["Make selection.", TRUE];
	MessageWindow.Blink[];
	RETURN;
	};
looksRope _ "";
span.start _ [pSel.start.pos.node, pSel.start.pos.where];
span.end _ [pSel.end.pos.node, pSel.end.pos.where];
EditSpanSupport.Apply[span, GetSelLooks];
IF first THEN looks _ pSel.looks; -- null selection, use caret
FOR c: CHAR IN TextLooks.Look DO
	IF looks[c] THEN looksRope _ Rope.Cat[looksRope, " ", IO.PutFR["%g", IO.char[c]]];
	ENDLOOP;
-- now display the looks.  
ViewerTools.SetContents[handle.looksData.textViewer, looksRope];
-- now apply them to a display record. First apply the style
NodeStyle.ApplyAll[nodeStyle, pSel.start.pos.node, ruleStyle]; -- using the first node in case > 1
handle.nodeInfo _ nodeStyle;
looksStyle^ _ nodeStyle^;
NodeStyle.ApplyLooks[looksStyle, looks, ruleStyle];
handle.looksInfo _ looksStyle;
-- Now display the info we got from Apply Looks
UpdateDisplayViewer[handle, looksStyle];
};

GetFormat: PROCEDURE [handle: StyleToolHandle] = {
nodeStyle: NodeStyle.Ref _ NodeStyle.Create[];
pSel: TEditDocument.Selection = TEditOps.GetSelData[];
ruleStyle: NodeStyle.OfStyle _ GetRuleStyle[handle];

IF ~CheckPSel[pSel] THEN RETURN;
NodeStyle.ApplyAll[nodeStyle, pSel.start.pos.node, ruleStyle];  

handle.nodeInfo _ nodeStyle;

UpdateDisplayViewer[handle, nodeStyle];
};
GetRuleStyle: PROCEDURE [handle: StyleToolHandle] RETURNS [NodeStyle.OfStyle] = BEGIN
ruleRope: Rope.ROPE _ ChoiceButtons.GetSelectedButton[handle.ruleType];
SELECT TRUE FROM
	Rope.Equal[ruleRope, "ScreenRule", FALSE]	=> RETURN[screen];
	Rope.Equal[ruleRope, "PrintRule", FALSE] 	=> RETURN[print];
	Rope.Equal[ruleRope, "StyleRule", FALSE] 	=> RETURN[screen];
	ENDCASE => ERROR;
END;
UpdateDisplayViewer: PROCEDURE [handle: StyleToolHandle, styleInfo: NodeStyle.Ref] = BEGIN
ruleStyle: NodeStyle.OfStyle _ GetRuleStyle[handle];

UpdateValueAndUnits: PROCEDURE [container: Containers.Container, item: ValueAndUnitsRef, value: REAL, units: Rope.ROPE _ "points"] = BEGIN
 StyleToolBuilders.DisplayRealInViewer[value, item.valueData.textViewer];
item.originalValue _ value;
ChoiceButtons.UpdateChoiceButtons[container, item.units, units];  
item.originalUnits _ units
END;
UpdateFontFace: PROCEDURE = BEGIN
SELECT styleInfo.fontFace FROM
	Regular	=> {	ChoiceButtons.SetButtonState[handle.display.boldFontFace.button, off];
						handle.display.boldFontFace.state _ off;
						ChoiceButtons.SetButtonState[handle.display.italicFontFace.button, off];
						handle.display.italicFontFace.state _ off;
						};
	Bold		=> {	ChoiceButtons.SetButtonState[handle.display.boldFontFace.button, on];
						handle.display.boldFontFace.state _ on;
						ChoiceButtons.SetButtonState[handle.display.italicFontFace.button, off];
						handle.display.italicFontFace.state _ off;
						};
	Italic		=> {	ChoiceButtons.SetButtonState[handle.display.boldFontFace.button, off];
						handle.display.boldFontFace.state _ off;
						ChoiceButtons.SetButtonState[handle.display.italicFontFace.button, on];
						handle.display.italicFontFace.state _ on;
						};
	BoldItalic	=> {	ChoiceButtons.SetButtonState[handle.display.boldFontFace.button, on];
						handle.display.boldFontFace.state _ on;
						ChoiceButtons.SetButtonState[handle.display.italicFontFace.button, on];
						handle.display.italicFontFace.state _ on;
						};
	ENDCASE	=> ERROR;
END;
UpdateFontInfo: PROCEDURE = BEGIN
 fontFamilyInfo: FontFamilyRec_StyleToolConvert.GetFontFamily[styleInfo.name[fontFamily]];
ChoiceButtons.UpdateChoiceButtons[handle.outer, handle.display.fontFamilyChoice,
	fontFamilyInfo.name];
IF Rope.Equal[fontFamilyInfo.name, "other", FALSE] THEN {
	Labels.Set[handle.display.fontFamilyOtherLabel, "Font Name:"];
	ViewerTools.SetContents[handle.display.fontFamilyOtherViewer, fontFamilyInfo.text];
	};
UpdateFontFace;

UpdateValueAndUnits[handle.outer, handle.display.fontSizeInfo,
NodeStyle.GetFontSize[styleInfo]];
ChoiceButtons.UpdateChoiceButtons[handle.outer, handle.display.fontAlphabetsChoice,
StyleToolConvert.GetFontAlphabetsChoice[styleInfo.fontAlphabets]];
ChoiceButtons.UpdateChoiceButtons[handle.outer, handle.display.fontUnderliningChoice,
StyleToolConvert.GetFontUnderliningChoice[styleInfo.underlining]];
END;
UpdateIndentInfo: PROCEDURE = BEGIN
UpdateValueAndUnits[handle.outer, handle.display.leftIndentInfo,
	NodeStyle.GetLeftIndent[styleInfo]];
UpdateValueAndUnits[handle.outer, handle.display.rightIndentInfo,
	NodeStyle.GetRightIndent[styleInfo]];
UpdateValueAndUnits[handle.outer, handle.display.firstIndentInfo,
	NodeStyle.GetFirstIndent[styleInfo]];
UpdateValueAndUnits[handle.outer, handle.display.restIndentInfo,
	NodeStyle.GetRestIndent[styleInfo]];
UpdateValueAndUnits[handle.outer, handle.display.topIndentInfo,
	NodeStyle.GetTopIndent[styleInfo]];
UpdateValueAndUnits[handle.outer, handle.display.bottomIndentInfo,
	NodeStyle.GetBottomIndent[styleInfo]];
END;
UpdateLeadingInfo: PROCEDURE = BEGIN
UpdateValueAndUnits[handle.outer, handle.display.leadingInfo.leading,
	NodeStyle.GetLeading[styleInfo]];
handle.display.leadingInfo.originalStretch _ NodeStyle.GetLeadingStretch[styleInfo];
StyleToolBuilders.DisplayRealInViewer[handle.display.leadingInfo.originalStretch,
	handle.display.leadingInfo.stretch.textViewer];
handle.display.leadingInfo.originalShrink _ NodeStyle.GetLeadingShrink[styleInfo];
StyleToolBuilders.DisplayRealInViewer[handle.display.leadingInfo.originalShrink,
	handle.display.leadingInfo.shrink.textViewer];
			
UpdateValueAndUnits[handle.outer, handle.display.topLeadingInfo.leading,
	NodeStyle.GetTopLeading[styleInfo]];
handle.display.topLeadingInfo.originalStretch _ NodeStyle.GetTopLeadingStretch[styleInfo];
StyleToolBuilders.DisplayRealInViewer[handle.display.topLeadingInfo.originalStretch,
	handle.display.topLeadingInfo.stretch.textViewer];
handle.display.topLeadingInfo.originalShrink _ NodeStyle.GetTopLeadingShrink[styleInfo];
StyleToolBuilders.DisplayRealInViewer[handle.display.topLeadingInfo.originalShrink,
	handle.display.topLeadingInfo.shrink.textViewer];
			
UpdateValueAndUnits[handle.outer, handle.display.bottomLeadingInfo.leading,
	NodeStyle.GetBottomLeading[styleInfo]];
handle.display.bottomLeadingInfo.originalStretch _
	NodeStyle.GetBottomLeadingStretch[styleInfo];
StyleToolBuilders.DisplayRealInViewer[handle.display.bottomLeadingInfo.originalStretch,
	handle.display.bottomLeadingInfo.stretch.textViewer];
handle.display.bottomLeadingInfo.originalShrink _
	NodeStyle.GetBottomLeadingShrink[styleInfo];
StyleToolBuilders.DisplayRealInViewer[handle.display.bottomLeadingInfo.originalShrink,
	handle.display.bottomLeadingInfo.shrink.textViewer];
END;
UpdateMiscInfo: PROCEDURE = BEGIN
 UpdateValueAndUnits[handle.outer, handle.display.vshiftInfo,
	NodeStyle.GetVShift[styleInfo]];
UpdateValueAndUnits[handle.outer, handle.display.minLineGapInfo,
	NodeStyle.GetMinLineGap[styleInfo]];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetTabStops[styleInfo],
	handle.display.tabStopsViewer];
ChoiceButtons.UpdateChoiceButtons[handle.outer, handle.display.lineFormattingChoice,
	StyleToolConvert.GetLineFormattingChoice[styleInfo.lineFormatting]];
END;
UpdatePenaltyInfo: PROCEDURE = BEGIN
 StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetPageBreakPenalty[styleInfo],
	handle.swap.penalty.pageBreakPenalty];
StyleToolBuilders.DisplayRealInViewer[
	NodeStyle.GetPageBreakAfterFirstLinePenalty[styleInfo],
	handle.swap.penalty.afterFirstLinePenalty];
StyleToolBuilders.DisplayRealInViewer[
	NodeStyle.GetPageBreakBeforeLastLinePenalty[styleInfo],
	handle.swap.penalty.beforeLastLinePenalty];
StyleToolBuilders.DisplayRealInViewer[
	NodeStyle.GetPageBreakBeforeFirstLinePenalty[styleInfo],
	handle.swap.penalty.beforeFirstLinePenalty];
StyleToolBuilders.DisplayRealInViewer[
	NodeStyle.GetPageBreakAfterLastLinePenalty[styleInfo],
	handle.swap.penalty.afterLastLinePenalty];
END;
UpdatePageLayoutInfo: PROCEDURE = BEGIN
UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.pageWidth,
	NodeStyle.GetPageWidth[styleInfo]];
UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.pageLength,
	NodeStyle.GetPageLength[styleInfo]];
UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.leftMargin,
	NodeStyle.GetLeftMargin[styleInfo]];
UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.rightMargin,
	NodeStyle.GetRightMargin[styleInfo]];
UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.topMargin,
	NodeStyle.GetTopMargin[styleInfo]];
UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.bottomMargin,
	NodeStyle.GetBottomMargin[styleInfo]];

 UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.bindingMargin,
	NodeStyle.GetBindingMargin[styleInfo]];

END;
UpdateArtworkInfo: PROCEDURE = BEGIN
ChoiceButtons.UpdateChoiceButtons[handle.outer, handle.display.pathTypeChoice,
	StyleToolConvert.GetPathTypeChoice[styleInfo.pathType]];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetAreaHue[styleInfo],
	handle.display.areaHueViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetAreaSaturation[styleInfo],
	handle.display.areaSaturationViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetAreaBrightness[styleInfo],
	handle.display.areaBrightnessViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetOutlineHue[styleInfo],
	handle.display.outlineHueViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetOutlineSaturation[styleInfo],
	handle.display.outlineSaturationViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetOutlineBrightness[styleInfo],
	handle.display.outlineBrightnessViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetTextHue[styleInfo],
	handle.display.textHueViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetTextSaturation[styleInfo],
	handle.display.textSaturationViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetTextBrightness[styleInfo],
	handle.display.textBrightnessViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetTextRotation[styleInfo],
	handle.display.textRotationViewer];
StyleToolBuilders.DisplayRealInViewer[NodeStyle.GetLineWeight[styleInfo],
	handle.display.lineWeightViewer];
END;
UpdateFontInfo;
UpdateIndentInfo;
UpdateLeadingInfo;
UpdateMiscInfo;
IF ~Rope.Equal["ScreenRule", ChoiceButtons.GetSelectedButton[handle.ruleType], FALSE] THEN {
	-- dont update these fields if they're not visible
	UpdatePenaltyInfo;
	UpdatePageLayoutInfo;
	};

END;

---- ---- ---- ---- ---- ---- ---- ----

Commander.Register[
	key: "StyleTool",
	proc: BuildStyleTool,
	doc: "Create a Tioga style modifying tool"
	];

END.
	° StyleToolImpl.mesa
Written by Linda Gass on July 13, 1982 1:43 pm
Last Edit by Linda Gass on November 4, 1982 5:15 pm
Last Edited by: Plass, March 28, 1983 3:12 pm
Last Edited by: Beach, February 22, 1984 3:34:35 pm PST
DestroyProc: Menus.MenuProc = BEGIN
 Destroys all the viewers associated with the Style Tool (no longer used)
 handle: StyleToolHandle _ NARROW[clientData];
IF ~MessageWindow.Confirm["Style Tool about to be destroyed . . ."] THEN RETURN;
ViewerOps.DestroyViewer[handle.outer];
IF handle.sample.viewer # NIL THEN ViewerOps.DestroyViewer[handle.sample.viewer];
IF handle.layoutGraphics.container # NIL THEN ViewerOps.DestroyViewer[handle.layoutGraphics.container];
END;
 originally I wanted to use MessageWindow.Confirm here but that cancels the selection.  Until there is a better way to accomplish this (ie - guarded menu items) I will use just Append and Blink
"gets" a display record for the selected node(s)
now we can apply the style of the node
we use the 1st node in case the nodes in the selection weren't consistent.  We dont need to test for consistency here because we guarantee this has been done before calling this procedure.

Now display the info we got from ApplyAll

finds out which rule style (ScreenRule, PrintRule or StyleRule) has been selected and returns the corresponsding enumerated type.

NOTE:  StyleRule really corresponds to base but calling NodeStyle.ApplyAll with base as
the kind causes things to blow up.  Since screen is the default, I chose that.
makes incremental changes to the display viewer.  Depending upon which rule style is on, certain parts of the display viewer are not displayed (eg - if the rule style is ScreenRule, then it's not necessary to deal with any of the page break penalties)
ChoiceButtons.UpdateChoiceButtons[handle.outer, handle.display.fontFaceChoice,
StyleToolConvert.GetFontFace[styleInfo.fontFace]];

 UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.headerMargin,
	NodeStyle.GetHeaderMargin[styleInfo]];
UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.footerMargin,
	NodeStyle.GetFooterMargin[styleInfo]];

 UpdateValueAndUnits[handle.swap.layout.outer, handle.swap.layout.lineLength,
	NodeStyle.GetLineLength[styleInfo]];
StyleToolBuilders.DisplayIntInViewer[NodeStyle.GetColumns[styleInfo],
	handle.swap.layout.column];

UpdateArtworkInfo;

Below is the actual start code.
Register a command with the UserExec that will create an instance of our tool.

�Ê�–
"Mesa" style˜Iprocš
Ïcv™vJ™-J™7š
Ïk	˜	Kš7œžœFžœ&žœžœžœ
žœžœžœEžœ)žœ,žœD�>œœžœžœ6žœ�œqžœ1žœ#žœžœžœžœžœ:žœ(žœžœ9žœ˜É—Kškœžœ
žœžœ@žœ½
žœžœ
žœ!žœ
žœ
žœžœžœŸ
žœ
žœ
žœžœžœ@žœ
žœ
žœžœžœTžœ
žœ
žœžœžœDžœ
žœ
žœžœžœDžœ
žœ
žœžœžœ7žœ
žœ
žœžœžœ5žœ
žœ
žœžœžœxžœžœžœžœžœžœ˜à
Kš�œ
�œ
�œ
�œ
�œ
�œ
�œ
�˜'šÏnœž˜/Kš%žœžœ8�!œ7�!œ	žœ�=œ5� œAžœ�(œ…
žœÇžœ½�
œ“
�
œž�
œ.�œÓ
�3œî
�œ,�žœ˜Í—Kš�œ
�œ
�œ
�œ
�œ
�œ
�œ
�œ
˜(šŸœž˜*Kšœžœ#žœžœ
˜N—šŸœž˜)Kšœžœ#žœžœ
˜O—šŸœž˜(Kšœžœ€
žœ
˜¥
—šŸœž™#Kš
œI™IKšœžœžœBžœ
žœ)žœžœ
žœ0žœ#žœ
žœ;žœ
™å—šŸœžœ
˜(KšœžœFžœžœ˜s—šŸ
œž˜%KšœžœHžœžœ˜v—šŸœž˜&Kšœžœ�1œžœ"žœ�Sœ5žœžœ˜Û—šŸ
œž˜%Kš
œžœ�1œžœ�Kœ:žœžœ˜¯—šŸœž˜'Kšœžœ=žœ?žœ˜¦
—šŸœž˜*šœžœžœžœ˜JKš
�Á
™Á
KšœWžœ-žœ˜�
—Kšœ3žœDžœ
˜—Kš�œ
�œ
�œ
�œ
�œ
�œ
�œ
�œ
˜(šŸœž	œ"žœ˜@šœŽ
žœžœ!žœ%Ÿœž	œ˜�Kšœ"žœžœ$žœžœ!žœ�žœ
žœžœžœžœ3žœ4žœžœ˜”—Kšžœžœ
žœ�)žœFžœžœžœžœ
žœžœI˜µ—šŸ	œžœ/žœžœžœžœžœ˜zKšžœžœ
žœ
žœ
žœ"žœžœ)žœ
žœžœ*žœžœžœ˜Þ
—šŸœž	œ˜1Kšœ`žœ	žœžœ«
˜¦šŸœž	œ<žœžœ˜mKš!œžœ"žœžœžœ7žœžœžœžœ
žœ
žœDžœYžœ
žœ	žœžœ
žœ˜²—Kš/žœžœ
žœžœ
žœ"žœ,žœžœ®
žœžœ�žœžœ
žœžœžœ
žœ&žœ
žœ
žœ�œA�=œ?�$œŠ
�0œ,˜ì—šŸ	œž	œ˜2Kš
�0™0Kšœœ
žœžœ
žœ
˜¼
Kš
�&™&Kš
œA˜AKš
�½
™½
Kš
œ˜Kš
�*™*Kš
œ*˜*—šŸœž	œžœž˜UKš
œ‚
™‚
šœžœ5žœ
žœ
žœ%žœžœ-žœžœ,žœžœ	˜‘Kšžœ•
ž
œ™¦
—Kšžœžœžœ
˜—šŸœž	œ7ž˜ZKš
�û
™û
Kš
œ5˜5š	Ÿœž	œBžœžœž˜Š
Kšœ§
�œžœ
˜È
—šŸœž	œž˜!Kš
žœžœ¯žœžœžœ
˜ã—šŸœž	œž˜!KšœÃ
žœ*žœžœ¬
˜¦Kš
�‚
™‚
Kšœ’žœ
˜–—šŸœž	œž˜#Kšœðžœ
˜ô—šŸœž	œž˜$Kšœ£
žœ
˜§
—šŸœž	œž˜!KšœËžœ
˜Ï—šŸœž	œž˜$Kšœ­žœ
˜±—šŸœž	œž˜'Kš
œ´˜´Kš
ϕ
™ï
Kš
œz˜zKš
œ×
™×
Kšžœ
˜—šŸœž	œž˜$Kšœì
žœ
˜ð
—Kš	œEžœMžœžœ�3œ/˜…Kš
�™Kšžœ˜—Kš�œ
�œ
�œ
�œ
�œ
�œ
�œ
�œ
˜(Kš
�o™oKšœožœ
˜s—…—RFd…