DIRECTORY
NodeStyle USING [FontUnderlining, NameParam, RealParam],
NodeStyleOps USING [defaultStyleName, InitializeDefaultStyle, LoadStyle],
NodeStyleWorks USING [AddRealError, attachmentsDict, bindingDict, colorOps, defaultFrame, DoStyleOp, get, GetCommand, glueOps, InitDict, load, LoadProc, NameError, nameOps, OpsRec, Param, ParamRec, PercentError, realOps, RegisterStyleCommand, RegisterStyleLiteral, RegisterWorks1, RegisterWorks2, RegisterWorks3, run, SetNameProc, StoreError, styledict, StyleError, stylesDicts, sysdict, TypeCheckDict, userdict],
Rope USING [ROPE],
TJaM USING [Any, AtomFromRope, AttachDict, Begin, CommandProc, CvX, DictTop, End, Execute, Frame, NewFrame, Pop, PopBool, Push, PushRope, TryToLoad];

NodeStyleWorks4Impl: CEDAR PROGRAM
IMPORTS NodeStyleOps, NodeStyleWorks, TJaM
EXPORTS NodeStyleWorks
~ BEGIN OPEN NodeStyleWorks;

Frame: TYPE ~ TJaM.Frame;
ROPE: TYPE ~ Rope.ROPE;
opsList: LIST OF RECORD[name: ATOM, op: TJaM.CommandProc] ¬ NIL;

Preregister: PROC [param: Param, op: TJaM.CommandProc] RETURNS [Param] ~ {
opsList ¬ CONS[[param.opName, op], opsList];
RETURN [param];
};
PreregisterName: PROC [opName: ATOM, op: TJaM.CommandProc, 
param: NodeStyle.NameParam] RETURNS [Param] ~ {
RETURN Preregister[NEW[ParamRec.name ¬ [nameOps, opName, name[param]]], op];
};
PreregisterReal: PROC [opName: ATOM, op: TJaM.CommandProc, 
param: NodeStyle.RealParam] RETURNS [Param] ~ {
RETURN Preregister[NEW[ParamRec.real ¬ [realOps, opName, real[param]]], op];
};

PreregisterGlue: PROC [opName: ATOM, op: TJaM.CommandProc, 
size, stretch, shrink: NodeStyle.RealParam] RETURNS [Param] ~ {
RETURN Preregister[NEW[ParamRec.glue ¬ [glueOps, opName, 
glue[size: size, stretch: stretch, shrink: shrink]]], op];
};

PreregisterColor: PROC [opName: ATOM, op: TJaM.CommandProc, 
hue, saturation, brightness: NodeStyle.RealParam] RETURNS [Param] ~ {
RETURN Preregister[NEW[ParamRec.color ¬ [colorOps, opName, 
color[hue: hue, saturation: saturation, brightness: brightness]]], op];
};

RegisterWorks4: PUBLIC PROC [frame: Frame] ~ {
WHILE opsList # NIL DO
RegisterStyleCommand[frame, opsList.first.name, opsList.first.op];
opsList ¬ opsList.rest;
ENDLOOP;
TJaM.Execute[frame, TJaM.CvX[prolog]];
};

prolog: ROPE ¬ "
(firstFolio) 1 StyleParam
(firstVisibleFolio) 1 StyleParam
(lastDropFolio) 1 StyleParam
(firstHeaders) 0 StyleParam
(sided) 1 StyleParam
(keep) 0 pt StyleParam
(keepStretch) 1 fil StyleParam
(columnGap) 0.5 in StyleParam
(topIndentStretch) 0 StyleParam
(bottomIndentStretch) 0 StyleParam
(pageRotation) 0 StyleParam
(pageRotationVerso) 0 StyleParam
(mediumColor) {mediumBrightness mediumSaturation mediumHue} .cvx .def
(mediumHue) 0 StyleParam
(mediumSaturation) 0 StyleParam
(mediumBrightness) 1 StyleParam
";
UnderliningOp: TJaM.CommandProc ~ { DoStyleOp[frame, underliningParam] };
underliningParam: Param ¬ Preregister[NEW [misc ParamRec ¬ [NEW [OpsRec ¬
[UnderliningLoad, StoreError, AddRealError, PercentError, UnderliningSetName]],
$underlining, misc[]]], UnderliningOp];

UnderliningLoad: LoadProc ~ {
TJaM.Push[frame, SELECT style.underlining FROM
None => $none,
LettersAndDigits => lettersAndDigits,
Visible => $visible,
All => $all,
ENDCASE => ERROR]
};
lettersAndDigits: ATOM ~ TJaM.AtomFromRope["letters+digits"];


UnderliningSetName: SetNameProc ~ {
Error: PROC RETURNS [NodeStyle.FontUnderlining] ~ INLINE --gfi saver-- { NameError[frame, name, p]; RETURN [None] };
style.underlining ¬ SELECT name FROM
$none => None,
lettersAndDigits => LettersAndDigits,
$visible => Visible,
$all => All,
ENDCASE => Error[];
};
StrikeoutOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutParam] };
strikeoutParam: Param ¬ Preregister[NEW [misc ParamRec ¬ [NEW [OpsRec ¬
[StrikeoutLoad, StoreError, AddRealError, PercentError, StrikeoutSetName]],
$strikeout, misc[]]], StrikeoutOp];

StrikeoutLoad: LoadProc ~ {
TJaM.Push[frame, SELECT style.strikeout FROM
None => $none,
LettersAndDigits => lettersAndDigits,
Visible => $visible,
All => $all,
ENDCASE => ERROR]
};

StrikeoutSetName: SetNameProc ~ {
Error: PROC RETURNS [NodeStyle.FontUnderlining] ~ INLINE --gfi saver-- { NameError[frame, name, p]; RETURN [None] };
style.strikeout ¬ SELECT name FROM
$none => None,
lettersAndDigits => LettersAndDigits,
$visible => Visible,
$all => All,
ENDCASE => Error[];
};
LetterspacingOp: TJaM.CommandProc ~ { DoStyleOp[frame, letterspacingParam] };
letterspacingParam: Param ~ PreregisterReal[$letterspacing, LetterspacingOp, letterspacing];

LetterspacingStretchOp: TJaM.CommandProc ~ { DoStyleOp[frame, letterspacingStretchParam] };
letterspacingStretchParam: Param ~ PreregisterReal[$letterspacingStretch, LetterspacingStretchOp, letterspacingStretch];

LetterspacingShrinkOp: TJaM.CommandProc ~ { DoStyleOp[frame, letterspacingShrinkParam] };
letterspacingShrinkParam: Param ~ PreregisterReal[$letterspacingShrink, LetterspacingShrinkOp, letterspacingShrink];

LetterspacingGlueOp: TJaM.CommandProc ~ { DoStyleOp[frame, letterspacingGlueParam] };
letterspacingGlueParam: Param ~ PreregisterGlue[$letterspacingGlue, LetterspacingGlueOp, letterspacing, letterspacingStretch, letterspacingShrink];
PagebreakOp: TJaM.CommandProc ~ { DoStyleOp[frame, pagebreakParam] };
pagebreakParam: Param ~ PreregisterReal[$pagebreak, PagebreakOp, pagebreak];

PagebreakStretchOp: TJaM.CommandProc ~ { DoStyleOp[frame, pagebreakStretchParam] };
pagebreakStretchParam: Param ~ PreregisterReal[$pagebreakStretch, PagebreakStretchOp, pagebreakStretch];

PagebreakShrinkOp: TJaM.CommandProc ~ { DoStyleOp[frame, pagebreakShrinkParam] };
pagebreakShrinkParam: Param ~ PreregisterReal[$pagebreakShrink, PagebreakShrinkOp, pagebreakShrink];

PagebreakGlueOp: TJaM.CommandProc ~ { DoStyleOp[frame, pagebreakGlueParam] };
pagebreakGlueParam: Param ~ PreregisterGlue[$pagebreakGlue, PagebreakGlueOp, pagebreak, pagebreakStretch, pagebreakShrink];
UnderlineThicknessOp: TJaM.CommandProc ~ { DoStyleOp[frame, underlineThicknessParam] };
underlineThicknessParam: Param ~ PreregisterReal[$underlineThickness, UnderlineThicknessOp, underlineThickness];

UnderlineDescentOp: TJaM.CommandProc ~ { DoStyleOp[frame, underlineDescentParam] };
underlineDescentParam: Param ~ PreregisterReal[$underlineDescent, UnderlineDescentOp, underlineDescent];

UnderlineHueOp: TJaM.CommandProc ~ { DoStyleOp[frame, underlineHueParam] };
underlineHueParam: Param ~ PreregisterReal[$underlineHue, UnderlineHueOp, underlineHue];

UnderlineSaturationOp: TJaM.CommandProc ~ { DoStyleOp[frame, underlineSaturationParam] };
underlineSaturationParam: Param ~ PreregisterReal[$underlineSaturation, UnderlineSaturationOp, underlineSaturation];

UnderlineBrightnessOp: TJaM.CommandProc ~ { DoStyleOp[frame, underlineBrightnessParam] };
underlineBrightnessParam: Param ~ PreregisterReal[$underlineBrightness, UnderlineBrightnessOp, underlineBrightness];

UnderlineColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, underlineColorParam] };
underlineColorParam: Param ~ PreregisterColor[$underlineColor, UnderlineColorOp, underlineHue, underlineSaturation, underlineBrightness];

UnderlineNamedColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, underlineNamedColorParam] };
underlineNamedColorParam: Param ~ PreregisterName[$underlineNamedColor, UnderlineNamedColorOp, underlineNamedColor];
StrikeoutThicknessOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutThicknessParam] };
strikeoutThicknessParam: Param ~ PreregisterReal[$strikeoutThickness, StrikeoutThicknessOp, strikeoutThickness];

StrikeoutAscentOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutAscentParam] };
strikeoutAscentParam: Param ~ PreregisterReal[$strikeoutAscent, StrikeoutAscentOp, strikeoutAscent];

StrikeoutHueOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutHueParam] };
strikeoutHueParam: Param ~ PreregisterReal[$strikeoutHue, StrikeoutHueOp, strikeoutHue];

StrikeoutSaturationOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutSaturationParam] };
strikeoutSaturationParam: Param ~ PreregisterReal[$strikeoutSaturation, StrikeoutSaturationOp, strikeoutSaturation];

StrikeoutBrightnessOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutBrightnessParam] };
strikeoutBrightnessParam: Param ~ PreregisterReal[$strikeoutBrightness, StrikeoutBrightnessOp, strikeoutBrightness];

StrikeoutColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutColorParam] };
strikeoutColorParam: Param ~ PreregisterColor[$strikeoutColor, StrikeoutColorOp, strikeoutHue, strikeoutSaturation, strikeoutBrightness];

StrikeoutNamedColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, strikeoutNamedColorParam] };
strikeoutNamedColorParam: Param ~ PreregisterName[$strikeoutNamedColor, StrikeoutNamedColorOp, strikeoutNamedColor];
OutlineBoxThicknessOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBoxThicknessParam] };
outlineBoxThicknessParam: Param ~ PreregisterReal[$outlineBoxThickness, OutlineBoxThicknessOp, outlineBoxThickness];

OutlineBoxBearoffOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBoxBearoffParam] };
outlineBoxBearoffParam: Param ~ PreregisterReal[$outlineBoxBearoff, OutlineBoxBearoffOp, outlineBoxBearoff];

OutlineBoxHueOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBoxHueParam] };
outlineBoxHueParam: Param ~ PreregisterReal[$outlineBoxHue, OutlineBoxHueOp, outlineBoxHue];

OutlineBoxSaturationOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBoxSaturationParam] };
outlineBoxSaturationParam: Param ~ PreregisterReal[$outlineBoxSaturation, OutlineBoxSaturationOp, outlineBoxSaturation];

OutlineBoxBrightnessOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBoxBrightnessParam] };
outlineBoxBrightnessParam: Param ~ PreregisterReal[$outlineBoxBrightness, OutlineBoxBrightnessOp, outlineBoxBrightness];

OutlineBoxColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBoxColorParam] };
outlineBoxColorParam: Param ~ PreregisterColor[$outlineBoxColor, OutlineBoxColorOp, outlineBoxHue, outlineBoxSaturation, outlineBoxBrightness];

OutlineBoxNamedColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBoxNamedColorParam] };
outlineBoxNamedColorParam: Param ~ PreregisterName[$outlineBoxNamedColor, OutlineBoxNamedColorOp, outlineBoxNamedColor];
BackgroundAscentOp: TJaM.CommandProc ~ { DoStyleOp[frame, backgroundAscentParam] };
backgroundAscentParam: Param ~ PreregisterReal[$backgroundAscent, BackgroundAscentOp, backgroundAscent];

BackgroundDescentOp: TJaM.CommandProc ~ { DoStyleOp[frame, backgroundDescentParam] };
backgroundDescentParam: Param ~ PreregisterReal[$backgroundDescent, BackgroundDescentOp, backgroundDescent];

BackgroundHueOp: TJaM.CommandProc ~ { DoStyleOp[frame, backgroundHueParam] };
backgroundHueParam: Param ~ PreregisterReal[$backgroundHue, BackgroundHueOp, backgroundHue];

BackgroundSaturationOp: TJaM.CommandProc ~ { DoStyleOp[frame, backgroundSaturationParam] };
backgroundSaturationParam: Param ~ PreregisterReal[$backgroundSaturation, BackgroundSaturationOp, backgroundSaturation];

BackgroundBrightnessOp: TJaM.CommandProc ~ { DoStyleOp[frame, backgroundBrightnessParam] };
backgroundBrightnessParam: Param ~ PreregisterReal[$backgroundBrightness, BackgroundBrightnessOp, backgroundBrightness];

BackgroundColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, backgroundColorParam] };
backgroundColorParam: Param ~ PreregisterColor[$backgroundColor, BackgroundColorOp, backgroundHue, backgroundSaturation, backgroundBrightness];

BackgroundNamedColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, backgroundNamedColorParam] };
backgroundNamedColorParam: Param ~ PreregisterName[$backgroundNamedColor, BackgroundNamedColorOp, backgroundNamedColor];
AreaHueOp: TJaM.CommandProc ~ { DoStyleOp[frame, areaHueParam] };
areaHueParam: Param ~ PreregisterReal[$areaHue, AreaHueOp, areaHue];

AreaSaturationOp: TJaM.CommandProc ~ { DoStyleOp[frame, areaSaturationParam] };
areaSaturationParam: Param ~ PreregisterReal[$areaSaturation, AreaSaturationOp, areaSaturation];

AreaBrightnessOp: TJaM.CommandProc ~ { DoStyleOp[frame, areaBrightnessParam] };
areaBrightnessParam: Param ~ PreregisterReal[$areaBrightness, AreaBrightnessOp, areaBrightness];

AreaColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, areaColorParam] };
areaColorParam: Param ~ PreregisterColor[$areaColor, AreaColorOp, areaHue, areaSaturation, areaBrightness];

AreaNamedColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, areaNamedColorParam] };
areaNamedColorParam: Param ~ PreregisterName[$areaNamedColor, AreaNamedColorOp, areaNamedColor];
OutlineHueOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineHueParam] };
outlineHueParam: Param ~ PreregisterReal[$outlineHue, OutlineHueOp, outlineHue];

OutlineSaturationOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineSaturationParam] };
outlineSaturationParam: Param ~ PreregisterReal[$outlineSaturation, OutlineSaturationOp, outlineSaturation];

OutlineBrightnessOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineBrightnessParam] };
outlineBrightnessParam: Param ~ PreregisterReal[$outlineBrightness, OutlineBrightnessOp, outlineBrightness];

OutlineColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineColorParam] };
outlineColorParam: Param ~ PreregisterColor[$outlineColor, OutlineColorOp, outlineHue, outlineSaturation, outlineBrightness];

OutlineNamedColorOp: TJaM.CommandProc ~ { DoStyleOp[frame, outlineNamedColorParam] };
outlineNamedColorParam: Param ~ PreregisterName[$outlineNamedColor, OutlineNamedColorOp, outlineNamedColor];
HyphenationOp: TJaM.CommandProc ~ { DoStyleOp[frame, hyphenationParam] };
hyphenationParam: Param ~ PreregisterName[$hyphenation, HyphenationOp, hyphenation];

HyphenCodeOp: TJaM.CommandProc ~ { DoStyleOp[frame, hyphenCodeParam] };
hyphenCodeParam: Param ~ PreregisterReal[$hyphenCode, HyphenCodeOp, hyphenCode];

MaxVerticalExpansionOp: TJaM.CommandProc ~ { DoStyleOp[frame, maxVerticalExpansionParam] };
maxVerticalExpansionParam: Param ~ PreregisterReal[$maxVerticalExpansion, MaxVerticalExpansionOp, maxVerticalExpansion];

MaxHorizontalExpansionOp: TJaM.CommandProc ~ { DoStyleOp[frame, maxHorizontalExpansionParam] };
maxHorizontalExpansionParam: Param ~ PreregisterReal[$maxHorizontalExpansion, MaxHorizontalExpansionOp, maxHorizontalExpansion];

FIOp: TJaM.CommandProc ~ {
truePart: TJaM.Any ¬ TJaM.Pop[frame];
falsePart: TJaM.Any ¬ NIL;
body: TJaM.Any ¬ NIL;
elseOrThen: TJaM.Any ¬ TJaM.Pop[frame];
if: TJaM.Any ¬ NIL;
IF elseOrThen = $ELSE THEN {
falsePart ¬ truePart;
truePart ¬ TJaM.Pop[frame];
elseOrThen ¬ TJaM.Pop[frame];
};
IF elseOrThen = $THEN THEN {
condition: BOOL ~ TJaM.PopBool[frame];
body ¬ IF condition THEN truePart ELSE falsePart;
if ¬ TJaM.Pop[frame];
};
IF if # $IF THEN {TJaM.PushRope[frame, "Mismatched IF construct"]; StyleError[frame, 1]};
IF body # NIL THEN TJaM.Execute[frame, TJaM.CvX[body]];
};
RunFile: PROC [frame: Frame, name: ATOM, fileName: ROPE] RETURNS [ran: BOOL] ~ {
known: BOOL;
[known, ] ¬ TJaM.TryToLoad[frame, name];
IF known THEN RETURN [FALSE];
TJaM.Push[frame, fileName];
TJaM.Execute[frame, run];
RETURN [TRUE];
};

StartTheWorks: PUBLIC PROC ~ {
frame: Frame ¬ defaultFrame ¬ TJaM.NewFrame[];
get ¬ GetCommand[frame, TJaM.AtomFromRope[".get"]];
run ¬ GetCommand[frame, TJaM.AtomFromRope[".run"]];
load ¬ GetCommand[frame, TJaM.AtomFromRope[".load"]];

TJaM.Execute[frame, TJaM.AtomFromRope[".sysdict"]];
sysdict ¬ TypeCheckDict[TJaM.Pop[frame]];

IF NOT RunFile[frame, $user ,"start.jam"] THEN
TJaM.Execute[frame, TJaM.AtomFromRope[".start"]];

userdict ¬ TJaM.DictTop[frame];

styledict ¬ InitDict[$TiogaStylesDictionary];
TJaM.AttachDict[styledict, userdict];
TJaM.End[frame];
TJaM.Begin[frame, styledict];

stylesDicts[base] ¬ InitDict[$TiogaBaseStylesDictionary];
stylesDicts[print] ¬ InitDict[$TiogaPrintStylesDictionary];
stylesDicts[screen] ¬ InitDict[$TiogaScreenStylesDictionary];
bindingDict ¬ InitDict[$TiogaBindingDictionary, 200];
attachmentsDict ¬ InitDict[$TiogaAttachedStylesDictionary];

[] ¬ RunFile[frame, $StyleError, "TiogaUtils.jam"];

RegisterWorks1[frame];
RegisterWorks2[frame];
RegisterWorks3[frame];
RegisterWorks4[frame];
RegisterStyleLiteral[frame, $the];
RegisterStyleLiteral[frame, $smaller];
RegisterStyleLiteral[frame, $bigger];
RegisterStyleLiteral[frame, $percent];
RegisterStyleLiteral[frame, $regular];
RegisterStyleLiteral[frame, $bold];
RegisterStyleLiteral[frame, $italic];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["bold+italic"]];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["+bold"]];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["+italic"]];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["-bold"]];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["-italic"]];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["caps+lowercase"]];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["caps+smallcaps"]];
RegisterStyleLiteral[frame, $lowercase];
RegisterStyleLiteral[frame, $caps];
RegisterStyleLiteral[frame, $all];
RegisterStyleLiteral[frame, $visible];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["letters+digits"]];
RegisterStyleLiteral[frame, $none];

RegisterStyleLiteral[frame, $justified];
RegisterStyleLiteral[frame, $flush];
RegisterStyleLiteral[frame, $flushLeft];
RegisterStyleLiteral[frame, $flushRight];
RegisterStyleLiteral[frame, $centered];
RegisterStyleLiteral[frame, $filled];
RegisterStyleLiteral[frame, $outlined];
RegisterStyleLiteral[frame, $filled];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["filled+outlined"]];
RegisterStyleLiteral[frame, $fixed];
RegisterStyleLiteral[frame, $relative];
RegisterStyleLiteral[frame, $looks];
RegisterStyleLiteral[frame, $breakIfPast];
RegisterStyleLiteral[frame, $spaceIfPast];
RegisterStyleLiteral[frame, $blank];
RegisterStyleLiteral[frame, $leaders];
RegisterStyleLiteral[frame, $rule];
RegisterStyleLiteral[frame, $rules];
RegisterStyleLiteral[frame, $aligned];
RegisterStyleLiteral[frame, $congruent];

RegisterStyleLiteral[frame, $IF];
RegisterStyleLiteral[frame, $THEN];
RegisterStyleLiteral[frame, $ELSE];
RegisterStyleCommand[frame, $FI, FIOp];
NodeStyleOps.InitializeDefaultStyle["Cedar"];
[] ¬ NodeStyleOps.LoadStyle[NodeStyleOps.defaultStyleName];
};

StartTheWorks[!];
END.
΄
NodeStyleWorks4Impl.mesa
Copyright Σ 1985, 1987, 1991 by Xerox Corporation.  All rights reserved.
Rick Beach, July 15, 1987 9:49:11 pm PDT
Michael Plass, November 20, 1987 2:56:48 pm PST
Doug Wyatt, March 3, 1992 11:50 am PST
Implements JaM commands for style rules and commands to load styles.

Initialization
This must be first to pick up the Preregister calls in the start code.



New Style Parameters
These are style parameters that have not been given a place NodeStyle.RealParam.  They may be used in a style just like any other real-valued style parameter, and they may be accessed from a client program by means of NodeStyleOps.GetStyleParam.

Number associated with first formatted page
Folios smaller than this will not be printed.  Use a large value to kill page numbers.
Last folio to be placed at the bottom center of the page
Page headers will first appear on the page with this folio.
Should be 1 or 2
Asserts that a new column or page should be started if there is less than this amount of vertical space remaining when the first line of the node is formatted.
Added to the bottomIndentStretch when a new column is started because of a keep.
Minimum gap between columns
Stretchability at the top of the column
Stretchability at the bottom of the column
Degrees of counterclockwise rotation for the whole page
Degrees of counterclockwise rotation for verso pages (only used if 2 sided)
Color of the page background
Underlining
Strikeout
Letter Spacing Glue
Pagebreak Glue
Underline Dimensions and Color
Strikeout Dimensions and Color
Outline Box Dimensions and Color
Background Dimensions and Color
Area Color
Outline Color
Other params
IF-THEN-ELSE-FI
Expects stack to contain either "$IF b $THEN t" or "$IF b $THEN t $ELSE f"
Startup 
The starting process for the Tioga style machinery is somewhat magical.
We orchestrate the start up sequence from here.

if name is unknown in the current frame, then run the named file

Some JaM commands needed to run the style machinery
Remember the system dictionary, since the style machinery manipulates the dictionary stack
Check if we have run the start jam code: (start.jam) .run
This provides a user dictionary into which start.jam loads util.jam and errordefs.jam
Remember the user dictionary pointer
Create the dicitionary of Tioga style names

Replace userdict by styledict for rest of startup
Create and register dictionaries for style rules, name bindings, and attached styles
Check if have run the Tioga utility jam code: (TiogaUtils.jam) .run
Register various style and JaM commands implemented elsewhere
TJaM.Register[frame, $GetFreeVarOp, NodeStyleObsolete.GetFreeVarOp];
TJaM.Register[frame, $GetFreeVarObjOp, NodeStyleObsolete.GetFreeVarObjOp];

Register various literals used by the style machinery as keywords
numeric style attributes

font attributes

font alphabets

underlining and strikeout
line formatting

graphical paths

tab stop positioning

tab stop attributes
Conditional

Initialize the default style
ΚO•NewlineDelimiter

–
(cedarcode) style™
codeš
œ™Kšœ
Οe
œ=™HJ™(K™/K™&—K˜Kš
œD™DK™š
Οk	˜	Kšœ
žœ)˜8Kšœ
žœ7˜IKšœžœ‰˜Kšœžœžœ˜Kšœžœ‹
˜•
—K˜KšΠblœžœ
ž˜"Kšžœ#˜*Kšžœ˜šœžœ
žœ˜K˜Kšœžœ˜Kšžœžœžœ
˜—
headš
œ™K™FK™šœ	žœ
žœ
žœžœžœ
˜@K˜—šΟnœžœ&žœ˜JKšœ
žœ˜,Kšžœ	˜K˜J™—š œžœ
žœ5žœ˜kKšžœ
žœ6˜LJš
œ˜J™—š œžœ
žœ5žœ˜kKšžœ
žœ6˜LJš
œ˜J˜—š œžœ
žœEžœ˜{Kšžœ
žœ^˜tJš
œ˜J˜—š œžœ
žœKžœ˜‚
Kšžœ
žœm˜ƒ
Jš
œ˜J˜—š œžœ
žœ˜.šžœžœ
ž˜Kš
œB˜BK˜Kšžœ
˜—Kš
œ&˜&Kš
œ˜K˜——™š
œυ
™υ
K™—šœžœ˜š
œ˜K™+—š
œ ˜ K™V—š
œ˜K™8—˜K™;—š
œ˜K™—š
œ˜Kš
œŸ
™Ÿ
—š
œ˜Kš
œP™P—š
œ˜K™—š
œ˜K™'—š
œ"˜"K™*—š
œ˜K™7—š
œ ˜ K™K—˜EK™Kš
œ˜Kš
œ˜Kš
œ˜—K˜——š
œ™Kš 
œ<˜IKšœ&žœžœ‚
˜Α
K˜š œ˜šœžœž˜.K˜K˜%K˜K˜Kšžœžœ
˜—K˜—Kšœžœ'˜=˜K˜—š œ˜#Kš œžœ
žœžœ
Οc
œžœ
˜tšœžœž˜$K˜K˜%K˜K˜Kšžœ˜—Kš
œ˜——š
œ	™	Kš œ:˜EKšœ$žœžœz˜·
K˜š 
œ˜šœžœž˜,K˜K˜%K˜K˜Kšžœžœ
˜—˜K˜——š œ˜!Kš œžœ
žœžœ
‘
œžœ
˜tšœžœž˜"K˜K˜%K˜K˜Kšžœ˜—Kš
œ˜——™Kš œ>˜MKš
œ\˜\K˜Kš œE˜[Kš
œx˜xK˜Kš œD˜YKš
œt˜tK˜Kš œB˜UKš
œ“
˜“
—™Kš œ:˜EKš
œL˜LK˜Kš œA˜SKš
œh˜hK˜Kš œ@˜QKš
œd˜dK˜Kš œ>˜MKš
œ{˜{—™Kš œC˜WKš
œp˜pK˜Kš œA˜SKš
œh˜hK˜Kš œ=˜KKš
œX˜XK˜Kš œD˜YKš
œt˜tK˜Kš œD˜YKš
œt˜tK˜Kš œ?˜OKš
œ‰
˜‰
K˜Kš œD˜YKš
œt˜t—™Kš œC˜WKš
œp˜pK˜Kš œ@˜QKš
œd˜dK˜Kš œ=˜KKš
œX˜XK˜Kš œD˜YKš
œt˜tK˜Kš œD˜YKš
œt˜tK˜Kš œ?˜OKš
œ‰
˜‰
K˜Kš œD˜YKš
œt˜t—™ Kš œD˜YKš
œt˜tK˜Kš œB˜UKš
œl˜lK˜Kš œ>˜MKš
œ\˜\K˜Kš œE˜[Kš
œx˜xK˜Kš œE˜[Kš
œx˜xK˜Kš œ@˜QKš
œ
˜
K˜Kš œE˜[Kš
œx˜x—™Kš œA˜SKš
œh˜hK˜Kš œB˜UKš
œl˜lK˜Kš œ>˜MKš
œ\˜\K˜Kš œE˜[Kš
œx˜xK˜Kš œE˜[Kš
œx˜xK˜Kš œ@˜QKš
œ
˜
K˜Kš œE˜[Kš
œx˜x—š
œ
™
Kš 	œ8˜AKš
œD˜DK˜Kš œ?˜OKš
œ`˜`K˜Kš œ?˜OKš
œ`˜`K˜Kš œ:˜EKš
œk˜kK˜Kš œ?˜OKš
œ`˜`—š
œ
™
Kš œ;˜GKš
œP˜PK˜Kš œB˜UKš
œl˜lK˜Kš œB˜UKš
œl˜lK˜Kš œ=˜KKš
œ}˜}K˜Kš œB˜UKš
œl˜l—™Kš 
œ<˜IKš
œT˜TK˜Kš œ;˜GKš
œP˜PK˜Kš œE˜[Kš
œx˜xK˜Kš œG˜_Kš
œ€
˜€
K˜—™š œ˜K™JKš
œ%˜%Kšœžœ
˜Kšœžœ
˜Kš
œ'˜'Kšœžœ
˜šžœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—šžœžœ˜Kšœžœ˜&Kšœžœžœ
žœ˜1Kš
œ˜Kš
œ˜—Kšžœ
žœI˜YKšžœžœ
žœ%˜7Kš
œ˜——™K™GK™/K™š œžœžœžœžœžœ˜PKš
œ@™@Kšœžœ
˜K˜(Kšžœžœ
žœžœ˜Kš
œ˜K˜Kšžœžœ˜Kš
œ˜K˜—š 
œžœ
žœ˜Kš
œ.˜.K™Kš
œ3™3Kš
œ3˜3Kš
œ3˜3Kš
œ5˜5K˜Kš
œZ™ZKš
œ3˜3Kš
œ)˜)K˜Kš
œ9™9K™Ušžœ
žœ$ž˜.Kšœž
œ˜1K˜—Kš
œ$™$K˜K˜Kš
œ+™+K˜-K˜%K™Kš
œ1™1Kš
œ˜K˜K˜K™TK˜9K˜;K˜=K˜5K˜;K˜Kš
œC™CK˜3K˜K™=K˜K˜K˜K˜Kš
œD™DKš
œJ™JK™Kš
œA™AKš
œ™Kš
œ"˜"Kš
œ&˜&Kš
œ%˜%Kš
œ&˜&K™Kš
œ™Kš
œ&˜&Kš
œ#˜#Kš
œ%˜%Kš
œ>˜>Kš
œ8˜8Kš
œ:˜:Kš
œ8˜8Kš
œ:˜:K™Kš
œ™Kš
œA˜AKš
œA˜AKš
œ(˜(Kš
œ#˜#K™Kš
œ™Kš
œ"˜"Kš
œ&˜&Kš
œA˜AKš
œ#˜#K˜Kš
œ™Kš
œ(˜(Kš
œ$˜$Kš
œ(˜(Kš
œ)˜)Kš
œ'˜'K™Kš
œ™Kš
œ%˜%Kš
œ'˜'Kš
œ%˜%Kš
œB˜BK™Kš
œ™Kš
œ$˜$Kš
œ'˜'K™Kš
œ™Kš
œ$˜$Kš
œ*˜*Kš
œ*˜*Kš
œ$˜$Kš
œ&˜&Kš
œ#˜#Kš
œ$˜$Kš
œ&˜&Kš
œ(˜(K˜K™Kš
œ!˜!Kš
œ#˜#Kš
œ#˜#Kš
œ'˜'K™Kš
œ™K˜-K˜;Kš
œ˜K˜—K˜—Kšžœ
˜—…—F^