DIRECTORY
ImagerFont USING [Font],
TextLooks USING [Looks];

NodeStyle: CEDAR DEFINITIONS
~ BEGIN
Ref: TYPE ~ REF StyleBody;
StyleBody: TYPE ~ RECORD [
fontFace: FontFace _ Regular, -- 2 bits
fontAlphabets: FontAlphabets _ CapsAndLower, -- 2 bits
strikeout: FontUnderlining _ None, -- 2 bits
underlining: FontUnderlining _ None, -- 2 bits
lineFormatting: LineFormatting _ FlushLeft, -- 2 bits
lastLineFormatting: LineFormatting _ FlushLeft, -- 2 bits
pathType: PathType _ Filled, -- 2 bits
print: BOOL _ FALSE, -- true if using the hardcopy style rules
isComment: BOOL _ FALSE, -- set to node.comment; readonly for style rules
fixedTabs: BOOL _ FALSE, -- true if stops at fixed locations. else relative to left margin
nestingLevel: [0..MaxNestingLevel] _ 0, -- node level in tree; readonly for style rules
numTabStops: [0..MaxTabStops) _ 0, -- length of the tabStops list
name: ARRAY NameParam OF ATOM,
real: PACKED ARRAY RealParam OF RealCode,
defaultTabStops: TabStop, -- if NIL, use 0.5 in flushLeft blank defaultTabStops
tabStops: LIST OF TabStop, -- kept sorted by decreasing location, i.e., from right to left on page
font: ImagerFont.Font, -- function of fontPrefix, fontFamily, fontFace, and fontSize
dataList: DataList -- for special parameters
];

MaxNestingLevel: INTEGER ~ 31; -- 5 bits
MaxTabStops: INTEGER ~ 64; -- 6 bits

NameParam: TYPE ~ {
style, -- name of the style, such as "TechicalNote"
fontPrefix, -- prefix of interpress hierarchical name for font, e.g. Xerox/xc1-1-1/
fontFamily -- name of the font family, such as "Helvetica"
};

RealParam: TYPE ~ {
freeVar,
fontSize, -- in points
letterspacing, -- distance added between each character
letterspacingStretch,
letterspacingShrink,
hshift, -- distance to offset text, positive to the right
vshift, -- distance to raise text above baseline (can be negative)
tabStops, -- tab spacing in points (for typewriter-style tab stops)
textRotation,
textHue, -- color for text
textSaturation,
textBrightness,
leftIndent, -- all lines indent this much on left
rightIndent, -- all lines indent this much on right
firstIndent, -- first line indent this much more on left
firstIndentRight, -- first line indent this much more on the right
restIndent, -- other lines indent this much more on left
runaroundLeft,  -- depth of first indent on the left
runaroundRight,  -- depth of first indent on the right
topIndent, -- top line at least this much down from top of viewer/page
bottomIndent, -- bottom baseline at least this up from bottom of page
minLineGap, -- min distance between line top and previous bottom (can be negative)
leading, -- distance between baselines
leadingStretch,
leadingShrink,
topLeading, -- min distance from first baseline to previous
topLeadingStretch,
topLeadingShrink,
bottomLeading, -- min distance from last baseline to next
bottomLeadingStretch,
bottomLeadingShrink,
areaHue, -- color for filled areas
areaSaturation,
areaBrightness,
outlineHue, -- color for outlines
outlineSaturation,
outlineBrightness,
lineWeight, -- width of graphics lines
pageWidth, 
pageLength,
leftMargin,
rightMargin,
topMargin,
bottomMargin,
headerMargin,
footerMargin,
bindingMargin,
lineLength,
columns, -- number of columns
pagebreak,  -- glue added between pages (well sort of)
pagebreakStretch,
pagebreakShrink,
pageBreakPenalty, -- penalty for breaking inside node
pageBreakAfterFirstLinePenalty, -- penalty for breaking node after its first line
pageBreakBeforeLastLinePenalty, -- penalty for breaking node before its last line
pageBreakBeforeFirstLinePenalty, -- penalty for breaking before first line of node
pageBreakAfterLastLinePenalty, -- penalty for breaking after last line of node
underlineThickness, -- width of the rule drawn under characters
underlineDescent, -- positive offset to position bottom of underline below the baseline
underlineHue, -- color for underlines
underlineSaturation,
underlineBrightness,
strikeoutThickness, -- width of the rule drawn through characters
strikeoutAscent, -- positive offset to position bottom of strikeout above the baseline
strikeoutHue, -- color for strikeouts
strikeoutSaturation,
strikeoutBrightness,
outlineboxThickness, -- width of the rule drawn around text
outlineboxBearoff, -- positive distance between the font box for text and the outline
outlineboxHue, -- color for outlinebox
outlineboxSaturation,
outlineboxBrightness,
backgroundAscent, -- positive offset to position top of background above the baseline
backgroundDescent, -- positive offset to position bottom of background below the baseline
backgroundHue, -- color for backgrounds
backgroundSaturation,
backgroundBrightness
};

RealCode: TYPE ~ [0..255] _ 0;
zero: RealCode ~ 0;

DataList: TYPE ~ REF DataEntry;
OfEntry: TYPE ~ { object, real, tab };
DataEntry: TYPE ~ RECORD [
next: DataList, 
data: SELECT kind:OfEntry FROM
object => [
name: ATOM, -- name of the parameter
object: REF -- value of the parameter
],
real => [ -- for real values which overflow the table of common values
param: RealParam, -- which one it is
value: REAL _ 0.0, -- the value
valueI: INTEGER -- the value rounded to an integer
],
tab => [ -- for real values from tabspecs which overflow the table of common values
tabStop: TabStop, -- which tab stop it is
which: TabRealParam, -- which value for the tab stop it is
value: REAL _ 0.0, -- the value
valueI: INTEGER -- the value rounded to an integer
]
ENDCASE
];

TabRealParam: TYPE ~ { loc, spacing, weight, vshift };

TabStop: TYPE ~ REF TabStopRec;
LeaderTabStop: TYPE ~ REF leaders TabStopRec;
RuleTabStop: TYPE ~ REF rule TabStopRec;
RulesTabStop: TYPE ~ REF rules TabStopRec;

TabStopRec: TYPE ~ RECORD [
looks: TextLooks.Looks, -- the default looks for the stop
loc: RealCode, -- the location of the stop
alignment: TabAlign _ FlushLeft, -- how the tab is aligned
alignmentChar: CHAR _ 0C, -- only of interest if alignment = Character
breakIfPast: BOOL _ FALSE, -- what to do if you are already beyond the tab stop
fill: SELECT fillKind:OfTabFill FROM
blank => [],
leaders => [
congruent: BOOL _ TRUE, -- otherwise, centered
char: CHAR _ 0C, -- the character to be repeated
spacing: RealCode -- the distance between repetitions
],
rule => [
weight: RealCode, -- the thickness of the rule
vshift: RealCode -- the distance up from the baseline to the bottom of the rule
],
rules => [
rules: TabArray -- array of records with weight and vshift for each rule
],
ENDCASE
];

TabAlign: TYPE ~ { FlushLeft, FlushRight, Centered, Character };
OfTabFill: TYPE ~ { blank, leaders, rule, rules };
TabArray: TYPE ~ REF TabArrayRec;
TabArrayRec: TYPE ~ RECORD[
array: SEQUENCE length: CARDINAL OF RECORD[weight, vshift: RealCode]
];

FontFace: TYPE ~ { Regular, Bold, Italic, BoldItalic };
FontAlphabets: TYPE ~ { CapsAndLower, CapsAndSmallCaps, LowerOnly, CapsOnly };
FontUnderlining: TYPE ~ { None, LettersAndDigits, Visible, All };
LineFormatting: TYPE ~ { FlushLeft, FlushRight, Justified, Centered };
PathType: TYPE ~ { Filled, Outlined, FilledAndOutlined };

PointsPerPica: REAL;
PointsPerInch: REAL;
PointsPerCentimeter: REAL;
PointsPerMillimeter: REAL;
PointsPerDidot: REAL;
PointsPerFil: REAL;
PointsPerFill: REAL;
PointsPerFilll: REAL;
GetStyleName: PROC [s:Ref] RETURNS [ATOM] ~ INLINE {
RETURN [s.name[style]] };

GetFontFamily: PROC [s:Ref] RETURNS [ATOM] ~ INLINE {
RETURN [s.name[fontFamily]] };

GetFontFace: PROC [s:Ref] RETURNS [FontFace] ~ INLINE {
RETURN [s.fontFace] };

GetFontAlphabets: PROC [s:Ref] RETURNS [FontAlphabets] ~ INLINE {
RETURN [s.fontAlphabets] };

GetUnderlining: PROC [s:Ref] RETURNS [FontUnderlining] ~ INLINE {
RETURN [s.underlining] };

GetStrikeout: PROC [s:Ref] RETURNS [FontUnderlining] ~ INLINE {
RETURN [s.strikeout] };

GetLineFormatting: PROC [s:Ref] RETURNS [LineFormatting] ~ INLINE {
RETURN [s.lineFormatting] };

GetLastLineFormatting: PROC [s:Ref] RETURNS [LineFormatting] ~ INLINE {
RETURN [s.lastLineFormatting] };

GetFontSize: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,fontSize]] };

GetFontSizeI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,fontSize]] };

GetHShift: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,hshift]] };

GetHShiftI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,hshift]] };

GetVShift: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,vshift]] };

GetVShiftI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,vshift]] };

GetTabStops: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,tabStops]] };

GetTabStopsI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,tabStops]] };
GetLeftIndent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,leftIndent]] };

GetLeftIndentI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,leftIndent]] };

GetRightIndent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,rightIndent]] };

GetRightIndentI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,rightIndent]] };

GetFirstIndent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,firstIndent]] };

GetFirstIndentI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,firstIndent]] };

GetRestIndent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,restIndent]] };

GetRestIndentI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,restIndent]] };

GetTopIndent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,topIndent]] };

GetTopIndentI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,topIndent]] };

GetBottomIndent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,bottomIndent]] };

GetBottomIndentI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,bottomIndent]] };
GetMinLineGap: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,minLineGap]] };

GetMinLineGapI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,minLineGap]] };

GetLeading: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,leading]] };

GetLeadingI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,leading]] };

GetLeadingStretch: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,leadingStretch]] };

GetLeadingShrink: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,leadingShrink]] };

GetTopLeading: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,topLeading]] };

GetTopLeadingI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,topLeading]] };

GetTopLeadingStretch: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,topLeadingStretch]] };

GetTopLeadingShrink: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,topLeadingShrink]] };

GetBottomLeading: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,bottomLeading]] };

GetBottomLeadingI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,bottomLeading]] };

GetBottomLeadingStretch: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,bottomLeadingStretch]] };

GetBottomLeadingShrink: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,bottomLeadingShrink]] };

GetPageWidth: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,pageWidth]] };

GetPageLength: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,pageLength]] };

GetLeftMargin: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,leftMargin]] };

GetRightMargin: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,rightMargin]] };

GetTopMargin: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,topMargin]] };

GetBottomMargin: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,bottomMargin]] };

GetHeaderMargin: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,headerMargin]] };

GetFooterMargin: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,footerMargin]] };

GetBindingMargin: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,bindingMargin]] };

GetLineLength: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,lineLength]] };

GetColumns: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,columns]] };

GetTabLoc: PROC [stop: TabStop, s:Ref] RETURNS [REAL];
GetTabLocI: PROC [stop: TabStop, s:Ref] RETURNS [INTEGER];

GetTabLeaderSpacing: PROC [stop: LeaderTabStop, s:Ref] RETURNS [REAL];
GetTabLeaderSpacingI: PROC [stop: LeaderTabStop, s:Ref] RETURNS [INTEGER];
GetTabRuleWeight: PROC [stop: RuleTabStop, s:Ref] RETURNS [REAL];
GetTabRuleWeightI: PROC [stop: RuleTabStop, s:Ref] RETURNS [INTEGER];
GetTabRuleVShift: PROC [stop: RuleTabStop, s:Ref] RETURNS [REAL];
GetTabRuleVShiftI: PROC [stop: RuleTabStop, s:Ref] RETURNS [INTEGER];
GetTabRealCode: PROC [ref: Ref, stop: TabStop, which: TabRealParam,
value: REAL _ 0.0]
RETURNS [code: RealCode];

GetRulesTabCount: PROC [stop: RulesTabStop] RETURNS [count: INTEGER]; -- number of rules

GetRulesTabInfo: PROC [stop: RulesTabStop, num: INTEGER]
RETURNS [weight, vshift: REAL];

GetRulesTabInfoI: PROC [stop: RulesTabStop, num: INTEGER]
RETURNS [weight, vshift: INTEGER];

GetScreenSpaceWidth: PROC[style: Ref] RETURNS[REAL];

GetPrintSpaceWidth: PROC[style: Ref] RETURNS[REAL];

GetReal: PROC [ref: Ref, param: RealParam] RETURNS [REAL];

GetInt: PROC [ref: Ref, param: RealParam] RETURNS [INTEGER];

RealInit0: TYPE ~ REAL _ 0.0;
realArray: REF ARRAY RealCode OF RealInit0; -- array of distances
intArray: REF ARRAY RealCode OF INTEGER;
overflow: RealCode ~ LAST[RealCode];
realTableOverflow: ERROR;

IntegerValue: PROC [value: REAL _ 0.0] RETURNS [INTEGER];

EnterReal: PROC [value: REAL _ 0.0] RETURNS [code: RealCode];
SetReal: PROC [ref: Ref, param: RealParam, value: REAL _ 0.0];


END.
0NodeStyle.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Written by Bill Paxton, January 1981
Last changed by Bill Paxton, December 1, 1982 8:37 am
Plass, March 14, 1985 4:47:24 pm PST
Doug Wyatt, March 2, 1985 5:35:13 pm PST
Beach, March 23, 1985 5:16:53 pm PST
Michael Plass, May 20, 1985 8:01:47 pm PDT

Style Record Definitions
this order substantially reduces allocations during the creation of the list since styles tend to define tab stops in increasing order, so can add to start of list and list additions must be non-destructive of the previous list.  since length of list is given, can easily find the nth stop.
special variable used for extensions 
miscellaneous font and positioning 
indent parameters
leading parameters
graphics
page layout parameters
penalty parameters for page layout
underline
strikeout
outlinebox
background
Non-numeric style parameters
Many of the following style parameter procs are comments because the interface is too large.

GetPathType: PROC [s:Ref] RETURNS [PathType] ~ INLINE {
RETURN [s.pathType] };

Numeric Style Parameters
GetLetterspacing: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,letterspacing]] };

GetLetterspacingI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,letterspacing]] };

GetLetterspacingStretch: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,letterspacingStretch]] };

GetLetterspacingShrink: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,letterspacingShrink]] };


GetTextRotation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,textRotation]] };

GetTextHue: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,textHue]] };

GetTextSaturation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,textSaturation]] };

GetTextBrightness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,textBrightness]] };

Indents
GetRunaroundLeft: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,runaroundLeft]] };

GetRunaroundLeftI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,runaroundLeft]] };

GetRunaroundRight: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,runaroundRight]] };

GetRunaroundRightI: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,runaroundRight]] };


Leadings
Graphics
GetAreaHue: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,areaHue]] };

GetAreaSaturation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,areaSaturation]] };

GetAreaBrightness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,areaBrightness]] };

GetOutlineHue: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineHue]] };

GetOutlineSaturation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineSaturation]] };

GetOutlineBrightness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineBrightness]] };

GetLineWeight: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,lineWeight]] };

Page Layout
GetPageBreak: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,pagebreak]] };

GetPageBreakStretch: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,pagebreakStretch]] };

GetPageBreakShrink: PROC [s:Ref] RETURNS [INTEGER] ~ INLINE {
RETURN [GetInt[s,pagebreakShrink]] };

Penalties
GetPageBreakPenalty: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,pageBreakPenalty]] };

GetPageBreakAfterFirstLinePenalty: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,pageBreakAfterFirstLinePenalty]] };

GetPageBreakBeforeLastLinePenalty: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,pageBreakBeforeLastLinePenalty]] };

GetPageBreakBeforeFirstLinePenalty: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,pageBreakBeforeFirstLinePenalty]] };

GetPageBreakAfterLastLinePenalty: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,pageBreakAfterLastLinePenalty]] };

Underline, Strikeout, Outlines, and Backgrounds
GetUnderlineThickness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,underlineThickness]] };

GetUnderlineDescent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,underlineDescent]] };

GetUnderlineHue: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,underlineHue]] };

GetUnderlineSaturation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,underlineSaturation]] };

GetUnderlineBrightness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,underlineBrightness]] };

GetStrikeoutThickness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,strikeoutThickness]] };

GetStrikeoutAscent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,strikeoutAscent]] };

GetStrikeoutHue: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,strikeoutHue]] };

GetStrikeoutSaturation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,strikeoutSaturation]] };

GetStrikeoutBrightness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,strikeoutBrightness]] };

GetOutlineboxThickness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineboxThickness]] };

GetOutlineboxBearoff: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineboxBearoff]] };

GetOutlineboxHue: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineboxHue]] };

GetOutlineboxSaturation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineboxSaturation]] };

GetOutlineboxBrightness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,outlineboxBrightness]] };

GetBackgroundAscent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,backgroundAscent]] };

GetBackgroundDescent: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,backgroundDescent]] };

GetBackgroundHue: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,backgroundHue]] };

GetBackgroundSaturation: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,backgroundSaturation]] };

GetBackgroundBrightness: PROC [s:Ref] RETURNS [REAL] ~ INLINE {
RETURN [GetReal[s,backgroundBrightness]] };

Tab stop info



For num in [0..RulesTabCount), returns the weight and vshift values for that rule.
Spaces
Implemented in NodeStyleSpacesImpl

Returns the width of a space in the screen font for the given style.
Returns the width of a space in the printing font for the given style.
Generic Numeric Style Parameter routines
safely rounds the real value to an integer
determine the code for this real value

set the parameter to have this real value
ΚΚ–
"Mesa" style˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ$™$Kš
œ5™5K™$K™(J™$K™*—K™š
Οk	˜	Kšœžœ˜Kšœ
žœ	˜—K˜KšΠbl	œžœ
ž˜Kšœž˜
head™Kšœžœžœ˜šœžœžœ˜KšœΟc	˜'Kšœ- 	˜6Kšœ# 	˜,Kšœ% 	˜.Kšœ, 	˜5Kšœ0 	˜9Kšœ 	˜&Kšœžœžœ )˜>Kšœžœžœ 0˜IKšœžœžœ A˜ZKšœ( /˜WKšœ# ˜AKšœžœžœ
žœ
˜Kšœžœ
žœžœ
˜)Kšœ 5˜Ošœ
žœ
žœ
 G˜bKš
œ’™’—Kšœ =˜TKšœ ˜,K˜K˜—Kšœžœ 	˜(Kšœ
žœ 	˜$K˜šœžœ˜Kšœ ,˜3Kšœ G˜SKšœ /˜:K˜K˜—šœžœ˜š
œ%™%Kš
œ˜—š
œ#™#Kšœ
 ˜Kšœ (˜7Kš
œ˜Kš
œ˜Kšœ 1˜9Kšœ :˜BKšœ
 9˜CK˜
Kšœ	 ˜K˜K˜—š
œ™Kšœ %˜1Kšœ
 &˜3Kšœ
 +˜8Kšœ 0˜BKšœ ,˜8Kšœ $˜4Kšœ %˜6Kšœ ;˜FKšœ 7˜E—š
œ™Kšœ F˜RKšœ	 ˜&K˜K˜Kšœ /˜;K˜K˜Kšœ *˜9K˜K˜—š
œ™Kšœ	 ˜"K˜K˜Kšœ ˜!K˜K˜Kšœ ˜&—š
œ™K˜K˜K˜K˜K˜
K˜
K˜
K˜
K˜K˜Kšœ	 ˜Kšœ *˜6K˜K˜—š
œ"™"Kšœ #˜5Kšœ  1˜QKšœ  1˜QKšœ! 1˜RKšœ /˜N—™	Kšœ +˜?Kšœ E˜WKšœ ˜%Kš
œ˜Kš
œ˜—™	Kšœ -˜AKšœ E˜VKšœ ˜%Kš
œ˜Kš
œ˜—™
Kšœ &˜;Kšœ B˜UKšœ ˜&Kš
œ˜Kš
œ˜—™
Kšœ C˜UKšœ F˜YKšœ ˜'Kš
œ˜Kš
œ˜—K˜K˜—Kšœ
žœ˜K˜K˜Kšœ
žœžœ˜Kšœ	žœ˜&šœžœžœ˜K˜šœžœž˜˜Kšœžœ ˜$Kšœžœ
 ˜%Kš
œ˜—šœ
 <˜FKšœ ˜$Kšœžœ ˜Kšœžœ
 "˜2Kš
œ˜—šœ	 J˜SKšœ ˜)Kšœ %˜:Kšœžœ ˜Kšœžœ
 "˜2Kš
œ
˜
—Kš
ž˜—š
œ˜K˜——Kšœžœ$˜6K˜Kšœ	žœžœ˜Kšœžœžœ˜-Kšœ
žœžœ˜(Kšœžœžœ˜*K˜šœžœžœ˜Kšœ !˜9Kšœ ˜*Kšœ! ˜:Kšœžœ ,˜FKšœ
žœžœ 4˜Ošœžœž˜$K˜˜Kšœžœžœ ˜.Kšœžœ ˜0Kšœ #˜5K˜—˜	Kšœ ˜.Kšœ >˜OK˜—˜
Kšœ 8˜HK˜—Kš
ž˜—K˜K˜—Kšœ
žœ2˜@Kšœžœ#˜2Kšœ
žœžœ
˜!šœ
žœžœ
˜Kš	œžœ	žœ
žœ
žœ˜DK˜—K˜Kšœ
žœ)˜7Kšœžœ;˜NKšœžœ,˜AKšœžœ2˜FKšœ
žœ+˜9K˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜—š
œ™K™\K™š
Οnœžœ	žœžœžœ˜4Kšžœ˜K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜K˜—š‘œžœ	žœžœ˜7Kšžœ˜K˜—š‘œžœ	žœžœ˜AKšžœ˜K˜—š‘œžœ	žœžœ˜AKšžœ˜K˜—š‘œžœ	žœžœ˜?Kšžœ˜K˜—š‘œžœ	žœžœ˜CKšžœ˜K˜—š‘œžœ	žœžœ˜GKšžœ˜ K˜—š‘œžœ	žœžœ™7Kšžœ™K™——š
œ™š
‘œžœ	žœžœžœ˜3Kšžœ˜K˜—š
‘œžœ	žœžœžœ˜7Kšžœ˜K˜—š
‘œžœ	žœžœžœ™8Kšžœ™$K™—š
‘œžœ	žœžœžœ™<Kšžœ™#K™—š
‘œžœ	žœžœžœ™?Kšžœ%™+K™—š
‘œžœ	žœžœžœ™>Kšžœ$™*K™—š
‘	œžœ	žœžœžœ˜1Kšžœ˜K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜K˜—š
‘	œžœ	žœžœžœ˜1Kšžœ˜K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜K˜—š
‘œžœ	žœžœžœ˜3Kšžœ˜K˜—š
‘œžœ	žœžœžœ˜7Kšžœ˜K™—š
‘œžœ	žœžœžœ™7Kšžœ™#K™—š
‘
œžœ	žœžœžœ™2Kšžœ™K™—š
‘œžœ	žœžœžœ™9Kšžœ™%K™—š
‘œžœ	žœžœžœ™9Kšžœ™%K™——š
œ™š
‘
œžœ	žœžœžœ˜5Kšžœ˜!K˜—š
‘œžœ	žœžœžœ˜9Kšžœ˜ K˜—š
‘œžœ	žœžœžœ˜6Kšžœ˜"K˜—š
‘œžœ	žœžœžœ˜:Kšžœ˜!K˜—š
‘œžœ	žœžœžœ˜6Kšžœ˜"K˜—š
‘œžœ	žœžœžœ˜:Kšžœ˜!K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜!K˜—š
‘œžœ	žœžœžœ˜9Kšžœ˜ K˜—š
‘œžœ	žœžœžœ™8Kšžœ™$K™—š
‘œžœ	žœžœžœ™<Kšžœ™#K™—š
‘œžœ	žœžœžœ™9Kšžœ™%K™—š
‘œžœ	žœžœžœ™=Kšžœ™$K™—š
‘œžœ	žœžœžœ˜4Kšžœ˜ K˜—š
‘
œžœ	žœžœžœ˜8Kšžœ˜K˜—š
‘œžœ	žœžœžœ˜7Kšžœ˜#K˜—š
‘œžœ	žœžœžœ˜;Kšžœ˜"K™——š
œ™š
‘
œžœ	žœžœžœ˜5Kšžœ˜!K˜—š
‘œžœ	žœžœžœ˜9Kšžœ˜ K˜—š
‘
œžœ	žœžœžœ˜2Kšžœ˜K˜—š
‘œžœ	žœžœžœ˜6Kšžœ˜K˜—š
‘œžœ	žœžœžœ˜9Kšžœ˜%K˜—š
‘œžœ	žœžœžœ˜8Kšžœ˜$K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜!K˜—š
‘œžœ	žœžœžœ˜9Kšžœ˜ K˜—š
‘œžœ	žœžœžœ˜<Kšžœ"˜(K˜—š
‘œžœ	žœžœžœ˜;Kšžœ!˜'K˜—š
‘œžœ	žœžœžœ˜8Kšžœ˜$K˜—š
‘œžœ	žœžœžœ˜<Kšžœ˜#K˜—š
‘œžœ	žœžœžœ˜?Kšžœ%˜+K˜—š
‘œžœ	žœžœžœ˜>Kšžœ$˜*K˜——™š
‘
œžœ	žœžœžœ™2Kšžœ™K™—š
‘œžœ	žœžœžœ™9Kšžœ™%K™—š
‘œžœ	žœžœžœ™9Kšžœ™%K™—š
‘
œžœ	žœžœžœ™5Kšžœ™!K™—š
‘œžœ	žœžœžœ™<Kšžœ"™(K™—š
‘œžœ	žœžœžœ™<Kšžœ"™(K™—š
‘
œžœ	žœžœžœ™5Kšžœ™!K™——š
œ™š
‘œžœ	žœžœžœ˜4Kšžœ˜ K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜!K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜!K˜—š
‘œžœ	žœžœžœ˜6Kšžœ˜"K˜—š
‘œžœ	žœžœžœ˜4Kšžœ˜ K˜—š
‘œžœ	žœžœžœ˜7Kšžœ˜#K˜—š
‘œžœ	žœžœžœ˜7Kšžœ˜#K˜—š
‘œžœ	žœžœžœ˜7Kšžœ˜#K˜—š
‘œžœ	žœžœžœ˜8Kšžœ˜$K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜!K˜—š
‘
œžœ	žœžœžœ˜5Kšžœ˜K˜—š
‘œžœ	žœžœžœ™7Kšžœ™K™—š
‘œžœ	žœžœžœ™>Kšžœ ™&K™—š
‘œžœ	žœžœžœ™=Kšžœ™%K™——š
œ	™	š
‘œžœ	žœžœžœ™;Kšžœ!™'K™—š
‘!œžœ	žœžœžœ™IKšžœ/™5K™—š
‘!œžœ	žœžœžœ™IKšžœ/™5K™—š
‘"œžœ	žœžœžœ™JKšžœ0™6K™—š
‘ œžœ	žœžœžœ™HKšžœ.™4K™——™/š
‘œžœ	žœžœžœ™=Kšžœ#™)K™—š
‘œžœ	žœžœžœ™;Kšžœ!™'K™—š
‘œžœ	žœžœžœ™7Kšžœ™#K™—š
‘œžœ	žœžœžœ™>Kšžœ$™*K™—š
‘œžœ	žœžœžœ™>Kšžœ$™*K™—š
‘œžœ	žœžœžœ™=Kšžœ#™)K™—š
‘œžœ	žœžœžœ™:Kšžœ ™&K™—š
‘œžœ	žœžœžœ™7Kšžœ™#K™—š
‘œžœ	žœžœžœ™>Kšžœ$™*K™—š
‘œžœ	žœžœžœ™>Kšžœ$™*K™—š
‘œžœ	žœžœžœ™>Kšžœ$™*K™—š
‘œžœ	žœžœžœ™<Kšžœ"™(K™—š
‘œžœ	žœžœžœ™8Kšžœ™$K™—š
‘œžœ	žœžœžœ™?Kšžœ%™+K™—š
‘œžœ	žœžœžœ™?Kšžœ%™+K™—š
‘œžœ	žœžœžœ™;Kšžœ!™'K™—š
‘œžœ	žœžœžœ™<Kšžœ"™(K™—š
‘œžœ	žœžœžœ™8Kšžœ™$K™—š
‘œžœ	žœžœžœ™?Kšžœ%™+K™—š
‘œžœ	žœžœžœ™?Kšžœ%™+K™——š
œ
™
Kš‘	œžœžœžœ˜6š‘
œžœžœžœ˜:K˜—Kš‘œžœžœžœ˜Fš‘œžœžœžœ˜JK™—Kš‘œžœžœžœ˜Aš‘œžœžœžœ˜EK™—Kš‘œžœžœžœ˜Aš‘œžœžœžœ˜EK™—š‘œžœ7žœžœ˜pK˜—Kš	‘œžœžœ	žœ ˜XK˜š
‘œžœžœžœžœ˜XK™R—K˜š
‘œžœžœžœžœ˜\K˜——š
œ™™"K™—š‘œžœ
žœ
žœ˜4K™D—K˜š‘œžœ
žœ
žœ˜3K™FK˜——š
œ(™(š‘œžœžœžœ˜:K˜—Kš‘œžœžœžœ˜<K˜Kšœžœžœ˜Kšœžœ
žœ
žœ ˜AKš	œ
žœ
žœ
žœ
žœ
˜(Kšœžœ˜$Kšœžœ
˜K˜š
‘œžœ	žœžœžœ˜9Kš
œ*™*K˜—š‘	œžœ	žœžœ˜=Kš
œ&™&K™—š‘œžœ%žœ˜>Kš
œ)™)—K˜—K˜Kšžœ
˜—…—4ΪfΤ