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.
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;
Initialization
This must be first to pick up the Preregister calls in the start code.
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]];
};
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.
prolog:
ROPE ¬ "
(firstFolio) 1 StyleParam
Number associated with first formatted page
(firstVisibleFolio) 1 StyleParam
Folios smaller than this will not be printed. Use a large value to kill page numbers.
(lastDropFolio) 1 StyleParam
Last folio to be placed at the bottom center of the page
(firstHeaders) 0 StyleParam
Page headers will first appear on the page with this folio.
(sided) 1 StyleParam
Should be 1 or 2
(keep) 0 pt StyleParam
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.
(keepStretch) 1 fil StyleParam
Added to the bottomIndentStretch when a new column is started because of a keep.
(columnGap) 0.5 in StyleParam
Minimum gap between columns
(topIndentStretch) 0 StyleParam
Stretchability at the top of the column
(bottomIndentStretch) 0 StyleParam
Stretchability at the bottom of the column
(pageRotation) 0 StyleParam
Degrees of counterclockwise rotation for the whole page
(pageRotationVerso) 0 StyleParam
Degrees of counterclockwise rotation for verso pages (only used if 2 sided)
(mediumColor) {mediumBrightness mediumSaturation mediumHue} .cvx .def
Color of the page background
(mediumHue) 0 StyleParam
(mediumSaturation) 0 StyleParam
(mediumBrightness) 1 StyleParam
";
Underlining
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[];
};
Strikeout
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[];
};
Letter Spacing Glue
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];
Pagebreak Glue
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];
Underline Dimensions and Color
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];
Strikeout Dimensions and Color
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];
Outline Box Dimensions and Color
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];
Background Dimensions and Color
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];
Area Color
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];
Outline Color
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];
Other params
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];
IF-THEN-ELSE-FI
FIOp: TJaM.CommandProc ~ {
Expects stack to contain either "$IF b $THEN t" or "$IF b $THEN t $ELSE f"
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]];
};
Startup
The starting process for the Tioga style machinery is somewhat magical.
We orchestrate the start up sequence from here.
RunFile:
PROC [frame: Frame, name:
ATOM, fileName:
ROPE]
RETURNS [ran:
BOOL] ~ {
if name is unknown in the current frame, then run the named file
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[];
Some JaM commands needed to run the style machinery
get ¬ GetCommand[frame, TJaM.AtomFromRope[".get"]];
run ¬ GetCommand[frame, TJaM.AtomFromRope[".run"]];
load ¬ GetCommand[frame, TJaM.AtomFromRope[".load"]];
Remember the system dictionary, since the style machinery manipulates the dictionary stack
TJaM.Execute[frame, TJaM.AtomFromRope[".sysdict"]];
sysdict ¬ TypeCheckDict[TJaM.Pop[frame]];
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
IF
NOT RunFile[frame, $user ,"start.jam"]
THEN
TJaM.Execute[frame, TJaM.AtomFromRope[".start"]];
Remember the user dictionary pointer
userdict ¬ TJaM.DictTop[frame];
Create the dicitionary of Tioga style names
styledict ¬ InitDict[$TiogaStylesDictionary];
TJaM.AttachDict[styledict, userdict];
Replace userdict by styledict for rest of startup
TJaM.End[frame];
TJaM.Begin[frame, styledict];
Create and register dictionaries for style rules, name bindings, and attached styles
stylesDicts[base] ¬ InitDict[$TiogaBaseStylesDictionary];
stylesDicts[print] ¬ InitDict[$TiogaPrintStylesDictionary];
stylesDicts[screen] ¬ InitDict[$TiogaScreenStylesDictionary];
bindingDict ¬ InitDict[$TiogaBindingDictionary, 200];
attachmentsDict ¬ InitDict[$TiogaAttachedStylesDictionary];
Check if have run the Tioga utility jam code: (TiogaUtils.jam) .run
[] ¬ RunFile[frame, $StyleError, "TiogaUtils.jam"];
Register various style and JaM commands implemented elsewhere
RegisterWorks1[frame];
RegisterWorks2[frame];
RegisterWorks3[frame];
RegisterWorks4[frame];
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
RegisterStyleLiteral[frame, $the];
RegisterStyleLiteral[frame, $smaller];
RegisterStyleLiteral[frame, $bigger];
RegisterStyleLiteral[frame, $percent];
font attributes
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"]];
font alphabets
RegisterStyleLiteral[frame, TJaM.AtomFromRope["caps+lowercase"]];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["caps+smallcaps"]];
RegisterStyleLiteral[frame, $lowercase];
RegisterStyleLiteral[frame, $caps];
underlining and strikeout
RegisterStyleLiteral[frame, $all];
RegisterStyleLiteral[frame, $visible];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["letters+digits"]];
RegisterStyleLiteral[frame, $none];
line formatting
RegisterStyleLiteral[frame, $justified];
RegisterStyleLiteral[frame, $flush];
RegisterStyleLiteral[frame, $flushLeft];
RegisterStyleLiteral[frame, $flushRight];
RegisterStyleLiteral[frame, $centered];
graphical paths
RegisterStyleLiteral[frame, $filled];
RegisterStyleLiteral[frame, $outlined];
RegisterStyleLiteral[frame, $filled];
RegisterStyleLiteral[frame, TJaM.AtomFromRope["filled+outlined"]];
tab stop positioning
RegisterStyleLiteral[frame, $fixed];
RegisterStyleLiteral[frame, $relative];
tab stop attributes
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];
Conditional
RegisterStyleLiteral[frame, $IF];
RegisterStyleLiteral[frame, $THEN];
RegisterStyleLiteral[frame, $ELSE];
RegisterStyleCommand[frame, $FI, FIOp];
Initialize the default style
NodeStyleOps.InitializeDefaultStyle["Cedar"];
[] ¬ NodeStyleOps.LoadStyle[NodeStyleOps.defaultStyleName];
};
StartTheWorks[!];
END.