DIRECTORY
ImagerFont USING [Escapement, Font],
NodeStyle USING [DataEntry, DataList, RealInit0, overflow, RealCode, RealParam, Ref, TabStop, LeaderTabStop, RuleTabStop, RulesTabStop, TabRealParam],
NodeStyleExtras USING [],
NodeStyleFont USING [FontFromStyleParams],
Real USING [InlineRoundI],
RefTab USING [Create, Ref, Update, UpdateAction],
TJaM USING [Equal];

NodeStyleImpl: CEDAR MONITOR
IMPORTS ImagerFont, NodeStyleFont, Real, RefTab, TJaM
EXPORTS NodeStyle, NodeStyleExtras
~ BEGIN OPEN NodeStyle;
GetScreenSpaceWidth: PUBLIC PROC [style: NodeStyle.Ref] RETURNS [REAL] ~ {
font: ImagerFont.Font _ style.font;
IF font = NIL THEN font _ NodeStyleFont.FontFromStyleParams[prefix: style.name[fontPrefix], family: style.name[fontFamily], face: style.fontFace, size: GetReal[style, fontSize], alphabets: style.fontAlphabets];
RETURN[ImagerFont.Escapement[font, [set: 0, code: 40B]].x];
};

GetPrintSpaceWidth: PUBLIC PROC [style: NodeStyle.Ref] RETURNS [REAL] ~ {
font: ImagerFont.Font _ style.font;
IF font = NIL THEN font _ NodeStyleFont.FontFromStyleParams[prefix: style.name[fontPrefix], family: style.name[fontFamily], face: style.fontFace, size: GetReal[style, fontSize], alphabets: style.fontAlphabets];
RETURN[ImagerFont.Escapement[font, [set: 0, code: 40B]].x];
};

GetReal: PUBLIC PROC [ref: Ref, param: RealParam] RETURNS [value: REAL _ 0.0] ~ {
code: RealCode;
IF (code _ ref.real[param]) # overflow THEN RETURN [realArray[code]];
RETURN [GetRealOverflow[ref,param]];
};

GetInt: PUBLIC PROC [ref: Ref, param: RealParam] RETURNS [value: INTEGER] ~ {
code: RealCode;
IF (code _ ref.real[param]) # overflow THEN RETURN [intArray[code]];
RETURN [GetIntOverflow[ref,param]];
};

GetRealOverflow: PROC [ref: Ref, param: RealParam] RETURNS [value: REAL _ 0.0] ~ {
code: RealCode _ ref.real[param];
IF code # overflow THEN RETURN [realArray[code]];
FOR x: DataList _ ref.dataList, x.next UNTIL x=NIL DO
WITH x SELECT FROM
xx: REF DataEntry.real => { IF xx.param = param THEN RETURN [xx.value] };
ENDCASE => NULL;
ENDLOOP;
ERROR -- failed to find it on the data list --
};

GetIntOverflow: PROC [ref: Ref, param: RealParam] RETURNS [value: INTEGER] ~ {
code: RealCode _ ref.real[param];
IF code # overflow THEN RETURN [intArray[code]];
FOR x: DataList _ ref.dataList, x.next UNTIL x=NIL DO
WITH x SELECT FROM
xx: REF DataEntry.real => { IF xx.param = param THEN RETURN [xx.valueI] };
ENDCASE => NULL;
ENDLOOP;
ERROR -- failed to find it on the data list --
};

realArray: PUBLIC REF ARRAY RealCode OF RealInit0 _ NEW[ARRAY RealCode OF RealInit0];
intArray: PUBLIC REF ARRAY RealCode OF INTEGER _ NEW[ARRAY RealCode OF INTEGER];
nextFreeRealCode: RealCode _ 1;
overflowCount: INT _ 0;
realTableOverflow: PUBLIC ERROR ~ CODE;

IntegerValue: PUBLIC PROC [value: REAL _ 0.0] RETURNS [INTEGER] ~ {
RETURN [SELECT value FROM
> lastIntegerAsReal => LAST[INTEGER],
< firstIntegerAsReal => FIRST[INTEGER],
ENDCASE => Real.InlineRoundI[value]];
};
lastIntegerAsReal: REAL _ LAST[INTEGER];
firstIntegerAsReal: REAL _ FIRST[INTEGER];
EnterReal: PUBLIC ENTRY PROC [value: REAL _ 0.0] RETURNS [code: RealCode] ~ {
ENABLE UNWIND => NULL;
code _ nextFreeRealCode;
FOR c: RealCode IN [FIRST[RealCode]..nextFreeRealCode) DO
IF realArray[c]=value THEN { code _ c; EXIT };
ENDLOOP;
SELECT code FROM
< nextFreeRealCode => NULL; -- already was in realArray
= overflow => { -- realArray is full
overflowCount _ overflowCount+1;
ERROR realTableOverflow;
};
= nextFreeRealCode => { -- enter in realArray
nextFreeRealCode _ nextFreeRealCode+1;
realArray[code] _ value;
intArray[code] _ IntegerValue[value];
};
ENDCASE => ERROR;
};

SetReal: PUBLIC PROC [ref: Ref, param: RealParam, value: REAL _ 0.0] ~ {
ref.real[param] _ EnterReal[value !
realTableOverflow => {
ref.real[param] _ overflow;
ref.dataList _ ConsDataListReal[param, value, ref.dataList];
CONTINUE }
];
};
GetTabLoc: PUBLIC PROC [stop: TabStop, s:Ref] RETURNS [REAL _ 0.0] ~ {
code: RealCode;
IF (code _ stop.loc) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,loc]];
};

GetTabLocI: PUBLIC PROC [stop: TabStop, s:Ref] RETURNS [INTEGER] ~ {
code: RealCode;
IF (code _ stop.loc) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,loc]];
};

GetTabLeaderSpacing: PUBLIC PROC [stop: LeaderTabStop, s:Ref] RETURNS [REAL _ 0.0] ~ {
code: RealCode;
IF (code _ stop.spacing) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,spacing]];
};
GetTabLeaderSpacingI: PUBLIC PROC [stop: LeaderTabStop, s:Ref] RETURNS [INTEGER] ~ {
code: RealCode;
IF (code _ stop.spacing) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,spacing]];
};
GetTabRuleWeight: PUBLIC PROC [stop: RuleTabStop, s:Ref] RETURNS [REAL _ 0.0] ~ {
code: RealCode;
IF (code _ stop.weight) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,weight]];
};
GetTabRuleWeightI: PUBLIC PROC [stop: RuleTabStop, s:Ref] RETURNS [INTEGER] ~ {
code: RealCode;
IF (code _ stop.weight) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,weight]];
};
GetTabRuleVShift: PUBLIC PROC [stop: RuleTabStop, s:Ref] RETURNS [REAL _ 0.0] ~ {
code: RealCode;
IF (code _ stop.vshift) # overflow THEN RETURN [realArray[code]];
RETURN [GetTabOverflow[s,stop,vshift]];
};
GetTabRuleVShiftI: PUBLIC PROC [stop: RuleTabStop, s:Ref] RETURNS [INTEGER] ~ {
code: RealCode;
IF (code _ stop.vshift) # overflow THEN RETURN [intArray[code]];
RETURN [GetTabIntOverflow[s,stop,vshift]];
};
GetTabRealCode: PUBLIC PROC [ref: Ref, stop: TabStop, which: TabRealParam,
value: REAL _ 0.0]
RETURNS [code: RealCode] ~ {
code _ EnterReal[value ! realTableOverflow => {
code _ overflow;
ref.dataList _ ConsDataListTab[stop, which, value, ref.dataList];
CONTINUE }];
};

GetRulesTabCount: PUBLIC PROC [stop: RulesTabStop] RETURNS [count: INTEGER] ~ {
RETURN [stop.rules.length];
};

GetRulesTabInfo: PUBLIC PROC [stop: RulesTabStop, num: INTEGER]
RETURNS [weight, vshift: REAL] ~ {
weight _ stop.rules.array[num].weight;
vshift _ stop.rules.array[num].vshift };

GetRulesTabInfoI: PUBLIC PROC [stop: RulesTabStop, num: INTEGER]
RETURNS [weight, vshift: INTEGER] ~ {
weight _ IntegerValue[stop.rules.array[num].weight];
vshift _ IntegerValue[stop.rules.array[num].vshift] };

GetTabOverflow: PROC [ref: Ref, stop: TabStop, which: TabRealParam]
RETURNS [value: REAL _ 0.0] ~ {
FOR x: DataList _ ref.dataList, x.next UNTIL x=NIL DO
WITH x SELECT FROM
xx: REF DataEntry.tab => { IF xx.tabStop=stop AND xx.which=which THEN RETURN [xx.value] };
ENDCASE => NULL;
ENDLOOP;
ERROR -- failed to find it on the data list --
};

GetTabIntOverflow: PROC [ref: Ref, stop: TabStop, which: TabRealParam]
RETURNS [value: INTEGER] ~ {
FOR x: DataList _ ref.dataList, x.next UNTIL x=NIL DO
WITH x SELECT FROM
xx: REF DataEntry.tab => { IF xx.tabStop=stop AND xx.which=which THEN RETURN [xx.valueI] };
ENDCASE => NULL;
ENDLOOP;
ERROR -- failed to find it on the data list --
};

PointsPerPica: PUBLIC REAL _ 12.0;
PointsPerInch: PUBLIC REAL _ 1.0/0.0138370; -- 72.27
PointsPerCentimeter: PUBLIC REAL _ PointsPerInch/2.540;
PointsPerMillimeter: PUBLIC REAL _ PointsPerCentimeter/10;
PointsPerDidot: PUBLIC REAL _ PointsPerCentimeter/26.60;
PointsPerFil: PUBLIC REAL _ 10000.0;
PointsPerFill: PUBLIC REAL _ PointsPerFil*PointsPerFil;
PointsPerFilll: PUBLIC REAL _ PointsPerFill*PointsPerFil;

canonicalizeDataLists: BOOL _ TRUE;
dataListTable: RefTab.Ref _ RefTab.Create[];

consStats: RECORD [calls, finds, allocs, real, tab: INT _ 0];

ConsDataListObject: PUBLIC PROC [name: ATOM, object: REF, dataList: DataList] RETURNS [newDataList: DataList _ NIL] ~ {
IF canonicalizeDataLists THEN {
Update: RefTab.UpdateAction = {
tops: LIST OF DataList _ NARROW[val];
FOR each: LIST OF DataList _ tops, each.rest UNTIL each = NIL DO
WITH each.first SELECT FROM
xx: REF DataEntry.object => {
IF xx.name = name AND TJaM.Equal[xx.object, object] THEN {
newDataList _ each.first;
consStats.finds _ consStats.finds + 1;
RETURN [op: none]
};
};
ENDCASE => NULL;
ENDLOOP;
newDataList _ NEW[DataEntry.object _ [dataList, object[name, object]]];
tops _ CONS[newDataList, tops];
consStats.allocs _ consStats.allocs + 1;
RETURN [op: store, new: tops]
};
consStats.calls _ consStats.calls + 1;
FOR x: DataList _ dataList, x.next UNTIL x = NIL DO
WITH x SELECT FROM
xx: REF DataEntry.object => {
IF xx.name = name THEN {
IF TJaM.Equal[xx.object, object] THEN RETURN [dataList] ELSE EXIT;
};
};
ENDCASE => NULL;
ENDLOOP;
RefTab.Update[x: dataListTable, key: dataList, action: Update]
};
IF newDataList = NIL THEN {
newDataList _ NEW[DataEntry.object _ [dataList, object[name, object]]];
};
};

ConsDataListReal: PROC [param: RealParam, value: REAL, dataList: DataList] RETURNS [DataList] ~ {
consStats.real _ consStats.real + 1;
RETURN [NEW[DataEntry.real _ [dataList, real[param, value, IntegerValue[value]]]]];
};

ConsDataListTab: PROC [tabStop: TabStop, which: TabRealParam, value: REAL, dataList: DataList] RETURNS [DataList] ~ {
consStats.tab _ consStats.tab + 1;
RETURN [NEW[DataEntry.tab _ [dataList, tab[tabStop, which, value, IntegerValue[value]]]]];
};



END.
žNodeStyleImpl.mesa
Copyright ำ 1985, 1987 by Xerox Corporation.  All rights reserved.
Written by Bill Paxton, January 1981
Bill Paxton, December 1, 1982 7:38 am
Maxwell, January 6, 1983 8:46 am
Russ Atkinson, March 7, 1985 3:34:46 am PST
Plass, March 14, 1985 5:00:54 pm PST
Rick Beach, March 21, 1985 2:32:26 pm PST
Doug Wyatt, January 20, 1987 1:58:47 am PST
Michael Plass, November 17, 1987 2:21:05 pm PST
Implements JaM commands for style rules and commands to load styles.

Space width attributes
Real Parameters
array of real-valued distances
parallel array of integer-valued distances

next free entry in realArray
reserve entry 0 for 0.0

Tabs






For num in [0..RulesTabCount), returns the weight and vshift values for that rule.
Dimensions
DataList maintainence
It is desireable to canonicalize the dataList, so that the style cache hit rate is large, even in the presence of many StyleParams
[found: BOOL, val: RefTab.Val] RETURNS [op: RefTab.UpdateOperation _ none, new: RefTab.Val _ NIL]
This is for overflow reals; if this happens often, should canonicalize here as well
This is for overflow tab stops; if this happens often, should canonicalize here as well
สœ˜
codeš
œ™Kš
œB™BKš
œ$™$Kš
œ%™%K™ K™+K™$J™)K™+K™/—K˜Kš
œD™DK™š
ฯk	˜	Kšœœ˜$Kšœ
œ‡
˜–
Kšœœ˜Kšœœ˜*Kšœœ˜Kšœœ%˜1Kšœœ	˜—K˜Kšะbl
œœ
˜Kšœ.˜5Kšœ˜"Kšœœ
œ˜
head™š
ฯnœœ
œœœ˜JKš
œ#˜#Kšœœ
œภ
˜า
Kšœ5˜;Kš
œ˜K˜—š
Ÿœœ
œœœ˜IKš
œ#˜#Kšœœ
œภ
˜า
Kšœ5˜;Kš
œ˜K˜——š
œ™š
Ÿœœ
œœ	œ˜QK˜Kšœ%œ
œ˜EKšœ˜$Kš
œ˜K˜—š
Ÿœœ
œœ	œ˜MK˜Kšœ%œ
œ˜DKšœ˜#Kš
œ˜K˜—šŸœœœ	œ˜RK˜!Kšœœ
œ˜1šœ$œœ
˜5šœœ
˜Kš	œœœœ
œ˜IKšœœ
˜—Kšœ
˜—Kšœ
ฯc(˜.Kš
œ˜K˜—šŸœœœ	œ˜NK˜!Kšœœ
œ˜0šœ$œœ
˜5šœœ
˜Kš	œœœœ
œ˜JKšœœ
˜—Kšœ
˜—Kšœ
 (˜.Kš
œ˜—K˜šœœ
œ
œ
œ
œ
œ
œ˜UKš
 ™—šœ
œ
œ
œ
œ
œœ
œ
œ
œ˜PKš
œ*™*K™—š
œ˜Kš
œ™Kš
œ™—Kšœœ˜Kšœœ
œœ
˜'K˜šŸœœ
œ	œœœ˜Cšœœ˜Kšœœ
œ˜%Kšœœ
œ˜'Kšœ˜%—Kš
œ˜—Kšœœœ
œ˜(šœœœ
œ˜*K™—šŸ	œœ
œ
œ	œœ˜MKšœ
œœ
˜K˜šœ
œœ˜9Kšœœ
œ˜.Kšœ
˜—šœ˜Kšœœ ˜7šœ ˜$Kš
œ ˜ Kšœ˜Kš
œ˜—šœ ˜-K˜&K˜K˜%K˜—Kšœœ
˜—Kš
œ˜K˜—šŸœœ
œ%œ˜Hš
œ#˜#š
œ˜Kš
œ˜Kš
œ<˜<Kšœ˜
—Kš
œ˜—Kš
œ˜——™š
Ÿ	œœ
œœœ˜FK˜Kšœœ
œ˜>Kšœ˜$Kš
œ˜K˜—š
Ÿ
œœ
œœœ˜DK˜Kšœœ
œ˜=Kšœ!˜'Kš
œ˜K˜—š
Ÿœœ
œœœ˜VK˜Kšœ"œ
œ˜BKšœ"˜(Kš
œ˜K™—š
Ÿœœ
œœœ˜TK˜Kšœ"œ
œ˜AKšœ%˜+Kš
œ˜K™—š
Ÿœœ
œœœ˜QK˜Kšœ!œ
œ˜AKšœ!˜'Kš
œ˜K™—š
Ÿœœ
œœœ˜OK˜Kšœ!œ
œ˜@Kšœ$˜*Kš
œ˜K™—š
Ÿœœ
œœœ˜QK˜Kšœ!œ
œ˜AKšœ!˜'Kš
œ˜K™—š
Ÿœœ
œœœ˜OK˜Kšœ!œ
œ˜@Kšœ$˜*Kš
œ˜K™—š
Ÿœœ
œ7œœ˜zš
œ/˜/Kš
œ˜Kš
œA˜AKšœ˜Kš
œ˜—K˜—š
Ÿœœ
œœ	œ˜OKšœ˜Kš
œ˜K˜—šŸœœ
œœ
œœ˜bK™RKš
œ&˜&Kš
œ(˜(K˜—šŸœœ
œœ
œœ˜fKš
œ4˜4Kš
œ6˜6K˜—šŸœœ/œ	œ˜cšœ$œœ
˜5šœœ
˜Kšœœœœœ
œ˜ZKšœœ
˜—Kšœ
˜—Kšœ
 (˜.Kš
œ˜K˜—šŸœœ/œ	œ˜cšœ$œœ
˜5šœœ
˜Kšœœœœœ
œ˜[Kšœœ
˜—Kšœ
˜—Kšœ
 (˜.Kš
œ˜K˜——š
œ
™
Kšœœ
œ˜"Kšœœ
œ ˜4Kšœœ
œ˜7Kšœœ
œ˜:Kšœœ
œ˜8Kšœœ
œ˜$Kšœœ
œ˜7Kšœœ
œ˜9—™™‚
K˜—Kšœœœ
˜#˜,K˜—Kšœœ#œ˜=J˜šŸœœ
œœ
œœœ˜wšœœ˜•StartOfExpansione -- [found: BOOL, val: RefTab.Val] RETURNS [op: RefTab.UpdateOperation _ none, new: RefTab.Val _ NIL]šŸœ˜Kš
ะcka™aKšœœ
œœ˜%šœœ
œœœ
˜@šœœ
˜šœœ˜šœœœ˜:Kš
œ˜Kš
œ&˜&Kšœ˜Kš
œ˜—K˜—Kšœœ
˜—Kšœ
˜—Kšœœ6˜GKšœœ˜Kš
œ(˜(Kšœ˜K˜—Kš
œ&˜&šœ œœ
˜3šœœ
˜šœœ˜šœœ˜Kš
œœ
œœ
œ
˜BKš
œ˜—K˜—Kšœœ
˜—Kšœ
˜—Kš
œ>˜>Kš
œ˜—šœœ
œ˜Kšœœ6˜GKš
œ˜—Kš
œ˜K˜—šŸœœœœ˜aK™SKš
œ$˜$KšœœH˜SKš
œ˜K˜—šŸœœ0œœ˜uK™WKš
œ"˜"KšœœO˜ZKš
œ˜—K˜—K˜K˜Kšœ
˜—…—#ž4ุ