DIRECTORY
Char, Convert, Feedback, FeedbackTypes, FileNames, GGBasicTypes, GGBoundBox, GGCoreOps, GGCoreTypes, GGFont, GGFromImager, GGHistoryTypes, GGInterfaceTypes, GGModelTypes, GGParseIn, GGParseOut, GGProps, GGScene, GGSegment, GGSegmentTypes, GGShapes, GGSlice, GGSliceOps, GGTransform, GGUtility, Imager, ImagerBox, ImagerFont, ImagerSys, ImagerTransformation, ImagerTypeface, IO, Lines2d, NodeStyle, PFS, Real, RealFns, Rope, SF, Vector2, Vectors2d;

GGSliceImplB: CEDAR MONITOR -- changed to MONITOR because of scratchEdge --
IMPORTS Convert, Feedback, FileNames, GGBoundBox, GGCoreOps, GGFont, GGFromImager, GGParseIn, GGParseOut, GGProps, GGScene, GGSegment, GGShapes, GGSlice, GGSliceOps, GGTransform, GGUtility, Imager, ImagerBox, ImagerFont, ImagerSys, ImagerTransformation, ImagerTypeface, IO, Lines2d, PFS, Real, RealFns, Rope, Vector2, Vectors2d
EXPORTS GGSlice = BEGIN


BoundBox: TYPE = GGCoreTypes.BoundBox;
BoundBoxObj: TYPE = GGCoreTypes.BoundBoxObj;
Camera: TYPE = GGModelTypes.Camera;
CameraObj: TYPE = GGModelTypes.CameraObj;
Color: TYPE = Imager.Color;
DefaultData: TYPE = GGModelTypes.DefaultData;
DisplayStyle: TYPE = GGModelTypes.DisplayStyle;
EditConstraints: TYPE = GGModelTypes.EditConstraints;
ExtendMode: TYPE = GGModelTypes.ExtendMode;
MsgRouter: TYPE = FeedbackTypes.MsgRouter;
Font: TYPE = ImagerFont.Font;
FontData: TYPE = GGFont.FontData;
HistoryEvent: TYPE = GGHistoryTypes.HistoryEvent;
Point: TYPE = GGBasicTypes.Point;
PointGenerator: TYPE = GGModelTypes.PointGenerator;
PointGeneratorObj: TYPE = GGModelTypes.PointGeneratorObj;
PointPairGenerator: TYPE = GGModelTypes.PointPairGenerator;
PointPairGeneratorObj: TYPE = GGModelTypes.PointPairGeneratorObj;
PointWalkProc: TYPE = GGModelTypes.PointWalkProc;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SegmentGeneratorObj: TYPE = GGModelTypes.SegmentGeneratorObj;
SelectedObjectData: TYPE = GGModelTypes.SelectedObjectData;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
SelectMode: TYPE = GGModelTypes.SelectMode;
Slice: TYPE = GGModelTypes.Slice;
SliceClass: TYPE = GGModelTypes.SliceClass;
SliceClassObj: TYPE = GGModelTypes.SliceClassObj;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorObj: TYPE = GGModelTypes.SliceDescriptorObj;
SliceObj: TYPE = GGModelTypes.SliceObj;
SliceParts: TYPE = GGModelTypes.SliceParts;
Transformation:  TYPE = ImagerTransformation.Transformation;
VEC: TYPE = Vector2.VEC;
Vector: TYPE = GGBasicTypes.Vector;
WalkProc: TYPE = GGModelTypes.WalkProc;

jointSize: REAL = GGModelTypes.jointSize;
halfJointSize: REAL = GGModelTypes.halfJointSize;
hotJointSize: REAL = GGModelTypes.hotJointSize;
halfHotJointSize: REAL = GGModelTypes.halfHotJointSize;


Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = Feedback.Problem;

textMaxPoints: INTEGER = 12;
textMaxEdges: INTEGER = 7;

TextPoints: TYPE = REF TextPointsData;
TextPointsData: TYPE = ARRAY [0..textMaxPoints) OF Point; -- see picture 

TextEdgeArray: TYPE = PACKED ARRAY [0..textMaxEdges) OF BOOL; -- left, top, right, bottom, baseline, centerline.
TextPointArray: TYPE = PACKED ARRAY [0..textMaxPoints) OF BOOL; -- see picture. Used in text parts data. 

textPointRopes: ARRAY [0..textMaxPoints) OF Rope.ROPE = [
"lower left point", "base left point", "center left point", "upper left point",
"lower mid point", "base mid point", "center mid point", "upper mid point",
"lower right point", "base right point", "center right point", "upper right point"
];
textEdgeRopes: ARRAY [0..textMaxEdges) OF Rope.ROPE = [
"left edge", "top edge", "right edge", "bottom edge",
"baseline", "horizontal center line", "vertical center line"
];
LeftRightAnchor: TYPE = {left, middle, right};

defaultLineSpacing: REAL = 1.2;
TextData: TYPE = REF TextDataObj;
TextDataObj: TYPE = RECORD [
box: BoundBox, -- not a bounding box but part of the text representation
points: TextPoints, -- cache for "joints"
leftRightAnchor: LeftRightAnchor, -- which point of the text remains fixed when the text is edited
rope: Rope.ROPE,
color: Imager.Color,
fontData: FontData,
trueFont: ImagerFont.Font,
screenFont: ImagerFont.Font,
displayStyle: DisplayStyle Ź print, -- which of the fonts to use
inverse: ImagerTransformation.Transformation, -- inverse of transform
inverseScale: Vector, -- cached value of ImagerTransformation.Factor[inverse].s
amplifySpace: REAL Ź 1.0, -- because the Imager allows space correction (see Imager.mesa)
dropShadowOn: BOOL Ź FALSE,
dropShadowOffset: Vector,
shadowColor: Imager.Color,
lineSpacing: REAL Ź defaultLineSpacing, -- multiplicative factor on the font scale for line spacing after CR
seg: Segment -- a null segment whose entire purpose is to contain properties in seg.props
];

TextParts: TYPE = REF TextPartsObj;
TextPartsObj: TYPE = RECORD [
points: TextPointArray, -- which corners of text box are selected.
edges: TextEdgeArray, -- which edges of text box are selected.
includeText: BOOL --  FALSE => corners and edges only; no text
];

TextHitData: TYPE = REF TextHitDataObj;
TextHitDataObj: TYPE = RECORD [
point: [-1..textMaxPoints), -- which point of box is hit.
edge: [-1..textMaxEdges), -- which edge of box is hit.
hitPoint: Point
];

FontNameError: PUBLIC SIGNAL = CODE;

BuildTextSliceClass: PUBLIC PROC [] RETURNS [class: SliceClass] = {
OPEN GGSlice;
class Ź NEW[SliceClassObj Ź [
type: $Text,
unlink: GGSlice.UnlinkSlice, -- textData doesn't need unlinking
getBoundBox: TextGetBoundBox,
getTransformedBoundBox: GGSlice.GenericTransformedBoundBox,
getTightBox: TextGetTightBox,
copy: TextCopy,
restore: TextRestore,
buildPath: NoOpBuildPath,
drawBorder: NoOpDrawBorder,
drawParts: TextDrawParts,
drawTransform: TextDrawTransform,
drawSelectionFeedback: TextDrawSelectionFeedback,
drawAttractorFeedback: TextDrawAttractorFeedback,
saveSelections: NoOpSaveSelections,
remakeSelections: NoOpRemakeSelections,
transform: TextTransform,
describe: TextDescribe,
describeHit: TextDescribeHit,
fileout: TextFileout,
filein: TextFilein,
isEmptyParts: TextIsEmptyParts,
isCompleteParts: TextIsCompleteParts,
newParts: TextNewParts,
unionParts: TextUnionParts,
differenceParts: TextDiffParts,
movingParts: TextMovingParts,
augmentParts: TextAugmentParts,
alterParts: NoOpAlterParts,
setSelectedFields: NoOpSetSelectedFields,
pointsInDescriptor: TextPointsInDescriptor,
walkPointsInDescriptor: TextWalkPointsInDescriptor,
pointPairsInDescriptor: TextPointPairsInDescriptor,
segmentsInDescriptor: TextSegmentsInDescriptor,
walkSegments: TextWalkSegments,
nextPoint: TextNextPoint,
nextPointPair: TextNextPointPair,
nextSegment: TextNextSegment,
closestPoint: TextClosestPoint,
closestJointToHitData: TextClosestJointToHitData,
closestPointAndTangent: NoOpClosestPointAndTangent,
closestSegment: TextClosestSegment,
filledPathsUnderPoint: NoOpFilledPathsUnderPoint,
lineIntersection: NoOpLineIntersection,
circleIntersection: NoOpCircleIntersection,
hitDataAsSimpleCurve: NoOpHitDataAsSimpleCurve,
setDefaults: TextSetDefaults,
setStrokeWidth: NoOpSetStrokeWidth,
getStrokeWidth: NoOpGetStrokeWidth,
setStrokeEnd: NoOpSetStrokeEnd,
getStrokeEnd: NoOpGetStrokeEnd,
setStrokeJoint: NoOpSetStrokeJoint,
getStrokeJoint: NoOpGetStrokeJoint,
setStrokeColor: TextSetStrokeColor,
getStrokeColor: TextGetStrokeColor,
setFillColor: TextSetFillColor,
getFillColor: TextGetFillColor,
setArrows: NoOpSetArrows,
getArrows: NoOpGetArrows,
setDashed: NoOpSetDashed,
getDashed: NoOpGetDashed,
setOrientation: NoOpSetOrientation,
getOrientation: NoOpGetOrientation
]];
};

MakeTextSlice: PUBLIC PROC [text: Rope.ROPE, color: Imager.Color, displayStyle: DisplayStyle, amplifySpace: REAL Ź 1.0, dropShadowsOn: BOOL Ź FALSE, dropShadowOffset: Vector Ź [0.0, 0.0], shadowColor: Imager.Color Ź Imager.black] RETURNS [slice: Slice] = {
textData: TextData Ź NEW[TextDataObj Ź [
box: GGBoundBox.NullBoundBox[], -- filled in by call to TextSetBoundBox
leftRightAnchor: left,
inverseScale: [-1.0, -1.0],  -- dummy vector
amplifySpace: amplifySpace,
points: NEW[TextPointsData],
fontData: GGFont.CreateFontData[], -- local storage
displayStyle: displayStyle,
color: color,
rope: text,
dropShadowOn: dropShadowsOn,
dropShadowOffset: dropShadowOffset,
shadowColor: shadowColor,
seg: GGSegment.MakeLine[p0: [-1.0, -1.0], p1: [1.0, 1.0], props: NIL]
]];
textData.seg.strokeWidth Ź -1.0; -- so no legal stroke width matches
slice Ź NEW[SliceObj Ź [
class: GGSlice.FetchSliceClass[$Text],
data: textData,
parent: NIL,
selectedInFull: [FALSE, FALSE, FALSE],
tightBox: GGBoundBox.NullBoundBox[], -- filled in by call to TextGetBoundBox
boundBox: GGBoundBox.NullBoundBox[], -- filled in by call to TextGetBoundBox
boxValid: FALSE
]];
};

IsWhitespace: PUBLIC PROC [slice: Slice] RETURNS [BOOL Ź FALSE] = {
IF GGSliceOps.GetType[slice]#$Text THEN RETURN[FALSE] ELSE {
rope: Rope.ROPE Ź NARROW[slice.data, TextData].rope;
RETURN[Rope.Length[rope]=IO.SkipWhitespace[IO.RIS[rope]] ];
};
};

GetText: PUBLIC PROC [slice: Slice] RETURNS [text: Rope.ROPE] = {
RETURN[IF GGSliceOps.GetType[slice]#$Text THEN NIL ELSE NARROW[slice.data, TextData].rope];
};

SetText: PUBLIC PROC [slice: Slice, text: Rope.ROPE] = {
textData: TextData;
IF GGSliceOps.GetType[slice]#$Text THEN RETURN;
textData Ź NARROW[slice.data];
textData.rope Ź text; -- update text
GGSlice.KillBoundBox[slice];
};

AppendText: PUBLIC PROC [slice: Slice, text: Rope.ROPE] = {
textData: TextData;
IF GGSliceOps.GetType[slice]#$Text THEN RETURN;
textData Ź NARROW[slice.data];
textData.rope Ź Rope.Concat[textData.rope, text]; -- update text
GGSlice.KillBoundBox[slice];
};

BackspaceText: PUBLIC PROC [slice: Slice, word: BOOL Ź FALSE] = {
textData: TextData;
IF GGSliceOps.GetType[slice]#$Text THEN RETURN;
textData Ź NARROW[slice.data];
IF word THEN {
WHILE TRUE DO
length: INT Ź Rope.Length[textData.rope];
lastSpaceAt: INT Ź Rope.FindBackward[textData.rope, " ",]; -- index of last space in string
IF lastSpaceAt=length-1 AND length#0 THEN { -- space at very end of non-empty string
textData.rope Ź Rope.Substr[base: textData.rope, len: lastSpaceAt]; -- slough the final space
}
ELSE {
textData.rope Ź IF lastSpaceAt=-1 THEN "" ELSE Rope.Substr[base: textData.rope, len: lastSpaceAt+1]; -- slough the non-spaces back to the next space
EXIT; -- finished
};
ENDLOOP;

}
ELSE textData.rope Ź Rope.Substr[base: textData.rope, len: Rope.Length[textData.rope]-1]; -- BS
GGSlice.KillBoundBox[slice];
};

DigitBreak: IO.BreakProc = {
RETURN[IF char IN ['0..'9]  THEN break ELSE other];
};

TFontParamsFromFontName:  PROC [fontName: Rope.ROPE] RETURNS [fontFamily: Rope.ROPE, fontFace: Rope.ROPE, fontSize: REAL Ź 0.0] = {
GetNumber: PROC [s: IO.STREAM] RETURNS [x: REAL Ź 0.0] = {
frac, fracCount: REAL Ź 0.0;
c: CHAR;
UNTIL (c Ź IO.GetChar[s ! IO.EndOfStream => {c Ź '\000; CONTINUE;}; ]) NOT IN ['0..'9] DO
x Ź x*10+(c-'0);
ENDLOOP;
IF c#'\000 AND c#'. THEN s.Backup[c]; -- restore the terminating character except for decimal point
IF c='. THEN { -- fractional part
UNTIL (c Ź IO.GetChar[s ! IO.EndOfStream => {c Ź '\000; CONTINUE;}; ]) NOT IN ['0..'9] DO
fracCount Ź fracCount+1;
frac Ź frac*10.0+(c-'0);
ENDLOOP;
x Ź x+frac*RealFns.Power[10.0, -1*fracCount];
IF c#'\000 THEN s.Backup[c]; -- restore the terminating character
};
};

face: Rope.ROPE;
fontStream: IO.STREAM Ź IO.RIS[fontName];
[fontFamily, ----] Ź IO.GetTokenRope[stream: fontStream, breakProc: DigitBreak ! IO.EndOfStream => SIGNAL FontNameError];
fontSize Ź GetNumber[fontStream ! IO.EndOfStream => SIGNAL FontNameError];
[face, ----] Ź IO.GetTokenRope[stream: fontStream, breakProc: IO.TokenProc ! IO.EndOfStream => {face Ź NIL; CONTINUE; };];
IF face#NIL THEN fontFace Ź Rope.Concat["-", face];
};

SetTextFont: PUBLIC PROC [slice: Slice, fontData: FontData, router: MsgRouter, history: HistoryEvent] RETURNS [ success: BOOL Ź TRUE] = {
RETURN[SetTextFontAux[slice, fontData, router, FALSE, history]];
};

SetTextFontAndTransform: PUBLIC PROC [slice: Slice, fontData: FontData, router: MsgRouter, history: HistoryEvent] RETURNS [ success: BOOL Ź TRUE] = {
RETURN[SetTextFontAux[slice, fontData, router, TRUE, history]];
};

SetTextFontAux: PROC [slice: Slice, fontData: FontData, router: MsgRouter, andTransform: BOOL Ź FALSE, history: HistoryEvent, substituteFont, trueFont, screenFont: Imager.Font Ź NIL] RETURNS [success: BOOL Ź TRUE] = {
transform, oldTransform: ImagerTransformation.Transformation;
eCode: ATOM;
eExplanation: Rope.ROPE;
IF GGSliceOps.GetType[slice]#$Text THEN RETURN[FALSE];
BEGIN
textData: TextData Ź NARROW[slice.data];
IF GGSliceOps.GetType[slice]#$Text THEN RETURN;
IF fontData.namelessFont # NIL THEN {
textData.fontData­ Ź fontData­;
textData.trueFont Ź textData.fontData.namelessFont;
textData.screenFont Ź textData.trueFont;
transform Ź ImagerTransformation.Copy[fontData.transform];
textData.fontData.transform Ź transform;
textData.inverse Ź ImagerTransformation.Invert[transform];
textData.inverseScale Ź ImagerTransformation.Factor[textData.inverse].s;
GGSlice.KillBoundBox[slice]; -- this is all we really care about
RETURN;
};
IF fontData.literal=NIL THEN GOTO Abort;
oldTransform Ź textData.fontData.transform;
transform Ź IF andTransform THEN ImagerTransformation.Copy[fontData.transform] ELSE IF fontData.transform=NIL THEN ImagerTransformation.PreScale[m: ImagerTransformation.Translate[ImagerTransformation.Factor[m: oldTransform].t], s: fontData.scale] ELSE ImagerTransformation.TranslateTo[fontData.transform, ImagerTransformation.Factor[oldTransform].t];
IF trueFont # NIL THEN textData.trueFont Ź trueFont -- if we know it don't look for it
ELSE IF fontData.substituted AND substituteFont#NIL THEN {
textData.trueFont Ź substituteFont;
}
ELSE {
textData.trueFont Ź ImagerFont.Find[fontData.literal, substituteWithWarning !
Imager.Error => GOTO Abort;
PFS.Error => GOTO PFSError;
ImagerSys.FileError => {
eCode _ code;
eExplanation _ explanation;
GOTO ImagerSysFileError;
};
Imager.Warning => {
IF fontData.substituteOK THEN {
fontData.substituted Ź TRUE;
RESUME;
}
ELSE GOTO NotFound;
};
];
IF fontData.substituted THEN Feedback.PutFL[router, oneLiner, $Warning, "%g substituted for %g", LIST[[rope[ImagerFont.Name[textData.trueFont]]], [rope[fontData.literal]]] ];
textData.trueFont Ź ImagerFont.Scale[textData.trueFont, IF fontData.substituted THEN 1.0 ELSE 1.0/fontData.storedSize];
};
fontData.transform Ź transform; -- must be done before computing alternate font
textData.screenFont Ź IF screenFont # NIL THEN screenFont ELSE NIL;
textData.fontData­ Ź fontData­; -- don't do this assignment until FindFont succeeds !
textData.inverse Ź ImagerTransformation.Invert[transform];
textData.inverseScale Ź ImagerTransformation.Factor[textData.inverse].s;
GGSlice.KillBoundBox[slice];
EXITS
PFSError => {
Feedback.PutF[router, oneLiner, $Complaint, "Fatal PFS Error during ImagerFont.Find of %g", [rope[fontData.literal]] ];
success Ź FALSE;
};
Abort => {
Feedback.PutF[router, oneLiner, $Complaint, "Fatal Imager Error during ImagerFont.Find of %g", [rope[fontData.literal]] ];
success Ź FALSE;
};
NotFound => {
scratch: IO.STREAM Ź IO.ROS[];
IF transform#NIL THEN GGParseOut.WriteFactoredTransformationVEC[scratch, transform];
Feedback.PutFL[router, oneLiner, $Complaint, "No Such Font: %g %g %g %g", LIST[[rope[fontData.literal]], [rope[IO.RopeFromROS[scratch]]], [real[fontData.storedSize]], [real[fontData.designSize]]] ];
success Ź FALSE;
};
ImagerSysFileError => {
Feedback.PutFL[router, oneLiner, $Complaint, "ImagerSys.FileError [%g, %g] during ImagerFont.Find %g", LIST[[atom[eCode]], [rope[eExplanation]], [rope[fontData.literal]]] ];
success Ź FALSE;
};
END;
};

GetLooksDataRope: PUBLIC PROC [slice: Slice] RETURNS [Rope.ROPE] = {
scratch: IO.STREAM Ź IO.ROS[];
IF GGSliceOps.GetType[slice]#$Text THEN RETURN[NIL]
ELSE {
scale: REAL Ź 10.0; -- convert fractions to offsets needed by SetDropShadow
textData: TextData Ź NARROW[slice.data];
IF textData.color#NIL
THEN
scratch.PutF1["Text color: %g ", [rope[GGUtility.DescribeColor[textData.color]]] ]
ELSE
scratch.PutF1["%g", [rope["No Text Fill Color "]]];
IF textData.dropShadowOn THEN {
IF textData.shadowColor#NIL
THEN
scratch.PutF1["ShadowColor: %g ", [rope[GGUtility.DescribeColor[textData.shadowColor]]] ]
ELSE scratch.PutF1["%g", [rope["No Drop Shadow color "]]];
scratch.PutF[" offset: [%g, %g]", [real[textData.dropShadowOffset.x/scale]], [real[textData.dropShadowOffset.y/scale]] ];
};
};
RETURN[IO.RopeFromROS[scratch]];
};

GetFontData: PUBLIC PROC [slice: Slice] RETURNS [fontData: FontData] = {
textData: TextData;
IF GGSliceOps.GetType[slice]#$Text THEN RETURN[NIL];
textData Ź NARROW[slice.data];
RETURN[textData.fontData];
};

GetFontDataRope: PUBLIC PROC [slice: Slice] RETURNS [Rope.ROPE] = {
textData: TextData;
fontData: FontData;
scratch: IO.STREAM Ź IO.ROS[];
IF GGSliceOps.GetType[slice]#$Text THEN RETURN[NIL];
textData Ź NARROW[slice.data];
fontData Ź textData.fontData;
GGParseOut.WriteFactoredTransformationVEC[scratch, fontData.transform];
IF fontData.comfortable THEN RETURN[IO.PutFLR["%g%g %g %g %g %g", LIST[ [rope[textData.fontData.prefix]], [rope[textData.fontData.userFSF]], [rope[IO.RopeFromROS[scratch]]], [real[fontData.storedSize]], [real[fontData.designSize]], [rope[IF fontData.substituted THEN "SUBSTITUTED" ELSE ""]] ]] ]
ELSE RETURN[IO.PutFLR["%g %g %g %g %g", LIST[[rope[fontData.literal]], [rope[IO.RopeFromROS[scratch]]], [real[fontData.storedSize]], [real[fontData.designSize]], [rope[IF fontData.substituted THEN "SUBSTITUTED" ELSE ""]]] ] ];
};

GetFontLiteralDataRope: PUBLIC PROC [slice: Slice] RETURNS [Rope.ROPE] = {
textData: TextData;
IF GGSliceOps.GetType[slice]#$Text THEN RETURN[NIL];
textData Ź NARROW[slice.data];
RETURN[GGFont.FontAsLiteralRope[textData.fontData]];
};

UnpackComplexFontName: PROC [fontName: Rope.ROPE, fontSize: REAL] RETURNS [new: Rope.ROPE] = {
face: Rope.ROPE;
new Ź FileNames.GetShortName[fontName]; -- throw away "xerox/pressfonts/"
face Ź FileNames.Tail[new, '-]; -- get face component (MIR, BRR, ...)
new Ź Rope.Substr[base: new, start: 0, len: Rope.SkipTo[s: new, pos: 0, skip: "-"]]; -- throw away "-XXX"
new Ź Rope.Cat[new, Convert.RopeFromReal[fontSize], SELECT TRUE FROM
Rope.Equal[face, "MRR", FALSE] => "",
Rope.Equal[face, "BRR", FALSE] => "B",
Rope.Equal[face, "MIR", FALSE] => "I",
Rope.Equal[face, "BIR", FALSE] => "BI",
ENDCASE => ERROR
];
};

SetTextAmplifySpace: PUBLIC PROC [slice: Slice, amplifySpace: REAL, router: MsgRouter, history: HistoryEvent] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
textData.amplifySpace Ź amplifySpace;
GGSlice.KillBoundBox[slice];
};
};

GetTextAmplifySpace: PUBLIC PROC [slice: Slice] RETURNS [amplifySpace: REAL] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
RETURN[textData.amplifySpace];
};
RETURN[1.0];
};

DropShadowOn: PUBLIC PROC [slice: Slice, offset: Vector, history: HistoryEvent] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
textData.dropShadowOn Ź TRUE;
textData.dropShadowOffset Ź offset;
GGSlice.KillBoundBox[slice];
};
};

DropShadowOff: PUBLIC PROC [slice: Slice, history: HistoryEvent] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
textData.dropShadowOn Ź FALSE;
GGSlice.KillBoundBox[slice];
};
};

GetTextDropShadow: PUBLIC PROC [slice: Slice] RETURNS [dropShadowOn: BOOL Ź FALSE, dropShadow: Vector Ź [0.0, 0.0], color: Imager.Color] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
RETURN[textData.dropShadowOn, textData.dropShadowOffset, textData.shadowColor];
};
};

GetTextColors: PUBLIC PROC [slice: Slice] RETURNS [textColor, shadowColor: Imager.Color] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
RETURN[textData.color, textData.shadowColor];
};
};

SetTextColors: PUBLIC PROC [slice: Slice, textColor: Imager.Color, useTextColor: BOOL Ź TRUE, shadowColor: Imager.Color, useShadowColor: BOOL Ź FALSE, history: HistoryEvent] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
IF useTextColor THEN textData.color Ź textColor;
IF useShadowColor THEN textData.shadowColor Ź shadowColor;
};
};

GetTextLineSpacing: PUBLIC PROC [slice: Slice] RETURNS [REAL] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
RETURN[textData.lineSpacing];
}
ELSE RETURN[0.0];
};

SetTextLineSpacing: PUBLIC PROC [slice: Slice, lineSpacing: REAL, history: HistoryEvent] = {
IF GGSliceOps.GetType[slice]=$Text THEN {
textData: TextData Ź NARROW[slice.data];
textData.lineSpacing Ź lineSpacing;
};
};

SetTextDisplayStyle: PUBLIC PROC [slice: Slice, displayStyle: DisplayStyle, history: HistoryEvent] = {
textData: TextData Ź NARROW[slice.data];
IF displayStyle # textData.displayStyle THEN GGSlice.KillBoundBox[slice];
textData.displayStyle Ź displayStyle;
};

OutlinesFromTextString: PUBLIC PROC [slice: Slice] RETURNS [shadowOutlines, outlines: LIST OF Slice] = {
textData: TextData Ź NARROW[slice.data];
fontData: FontData Ź textData.fontData;
font: Font Ź textData.trueFont;
amplifySpace: REAL Ź textData.amplifySpace;
camera: Camera Ź NEW[CameraObj]; -- this data is not really used in Capture in this case
SplinesFromTextString: PROC [dc: Imager.Context] = {
SplinesFromChar: PROC [char: Char.XCHAR] = {
proc: PROC = {
escapement: VEC Ź ImagerFont.Escapement[font, char];
IF amplifySpace#1.0 AND ImagerFont.Amplified[font, char] THEN {
escapement Ź Vector2.Mul[escapement, amplifySpace];
};
Imager.Move[dc];
ImagerTypeface.MaskChar[font, char, dc];
Imager.SetXYRel[dc, escapement];
SELECT ImagerFont.Correction[font, char] FROM
none => NULL;
space => Imager.CorrectSpace[dc, escapement];
mask => Imager.CorrectMask[dc];
ENDCASE => ERROR;
};
Imager.DoSave[dc, proc];
};
IF shadows THEN
GGCoreOps.SetColor[dc, IF textData.shadowColor=NIL THEN Imager.black ELSE textData.shadowColor]
ELSE
GGCoreOps.SetColor[dc, IF textData.color=NIL THEN Imager.black ELSE textData.color];
Imager.ConcatT[dc, fontData.transform];
IF shadows THEN Imager.TranslateT[dc, tVec];
Imager.SetXY[dc, [0.0, 0.0]];
ImagerFont.MapRope[textData.rope, 0, INT.LAST, SplinesFromChar];
};
fakeScene: Scene;
shadows: BOOL Ź TRUE;
tVec: VEC;
IF textData.dropShadowOn THEN {
tVec Ź [
x: textData.dropShadowOffset.x*dropScale,
y: textData.dropShadowOffset.y*dropScale];
fakeScene Ź GGFromImager.Capture[SplinesFromTextString, camera];
shadowOutlines Ź GGScene.ListSlices[fakeScene, first];
};
shadows Ź FALSE;
fakeScene Ź GGFromImager.Capture[SplinesFromTextString, camera];
outlines Ź GGScene.ListSlices[fakeScene, first];
};
StringEscapement: PROC [font: ImagerFont.Font, string: ImagerFont.XStringProc, amplifySpace: REAL] RETURNS [VEC] = {
sum: VEC Ź [0, 0];
charAction: ImagerFont.XCharProc ~ {
width: VEC;
width Ź ImagerFont.Escapement[font, char];
IF ImagerFont.Amplified[font, char] THEN {
width.x Ź width.x*amplifySpace;
width.y Ź width.y*amplifySpace;
};
sum.x Ź sum.x+width.x; sum.y Ź sum.y+width.y;
};
string[charAction];
RETURN[sum];
};

RopeEscapement: PROC [font: ImagerFont.Font, rope: Rope.ROPE, amplifySpace: REAL,
start: INT Ź 0, len: INT Ź INT.LAST] RETURNS [VEC] ~ {
string: ImagerFont.XStringProc ~ { ImagerFont.MapRope[rope, start, len, charAction] };
RETURN[StringEscapement[font, string, amplifySpace]];
};

UpdateTextPoints: PROC [textData: TextData, left, middle, right, bottom, base, center, top: REAL] = {
textData.points[0] Ź [left, bottom];
textData.points[1] Ź [left, base];
textData.points[2] Ź [left, center];
textData.points[3] Ź [left, top];
textData.points[4] Ź [middle, bottom];
textData.points[5] Ź [middle, base];
textData.points[6] Ź [middle, center];
textData.points[7] Ź [middle, top];
textData.points[8] Ź [right, bottom];
textData.points[9] Ź [right, base];
textData.points[10] Ź [right, center];
textData.points[11] Ź [right, top];
};

fontExtentRope: Rope.ROPE = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
tryNewBBox: BOOL _ TRUE;
NewComputeTextBounds: PROC [font, namelessFont: Font, rope: Rope.ROPE, amplifySpace: REAL] RETURNS [boundBox: ImagerBox.Box, feedbackBox: ImagerBox.Box] = {
fontExtents: ImagerFont.Extents;
fbRight, bTop, bBottom, cpBottom, cpTop: REAL Ź 0.0;
fbRight Ź RopeEscapement[font, rope, amplifySpace].x; -- feedbackBox, right boundary
fontExtents Ź ImagerFont.RopeBoundingBox[font, rope];
boundBox Ź ImagerBox.BoxFromExtents[fontExtents]; -- accurate bound box for rope
cpTop Ź fontExtents.ascent; -- feedbackBox, top boundary
cpBottom Ź -fontExtents.descent; -- feedbackBox, bottom boundary
IF namelessFont = NIL THEN { -- adjust boundaries to conform to fontExtentRope
fontExtents Ź ImagerFont.RopeBoundingBox[font, fontExtentRope];
cpTop Ź fontExtents.ascent; -- feedbackBox, top boundary
cpBottom Ź -fontExtents.descent; -- feedbackBox, bottom boundary
};
feedbackBox Ź [0.0, cpBottom, fbRight, cpTop];
};

NewTextGetBoundBoxAux: PROC [slice: Slice, parts: SliceParts Ź NIL] RETURNS [tightBox, boundBox: BoundBox]= {
textData: TextData Ź NARROW[slice.data];
fontData: FontData Ź textData.fontData;
eBox: ImagerBox.Box; -- the actual rope bounding box from the rope extents, nothing to do with the fontExtentRope bounds.
fBox: ImagerBox.Box; -- the feedback box, which has its left edge at relative 0.0 (the rope origin), its right edge at the rope escapement, and its top and bottom calculated from the fontExtentRope bounds.  Used to determine the feedback points.
uBox: ImagerBox.Box; -- the union of fBox and eBox, used to calculate the slice boundBox
screenFont: ImagerFont.Font;
[eBox, fBox] Ź NewComputeTextBounds[textData.trueFont, textData.fontData.namelessFont, textData.rope, textData.amplifySpace];
IF textData.displayStyle = print OR (screenFont _ GetScreenFont[textData]) = NIL
THEN NULL
ELSE eBox Ź NewComputeTextBounds[screenFont, textData.fontData.namelessFont, textData.rope, textData.amplifySpace].boundBox; -- recompute eBox for alternate or screen font.  Leave fBox the same so alignments can be performed by the user while displaying alternate fonts

GGBoundBox.UpdateBoundBox[textData.box, fBox.xmin, fBox.ymin, fBox.xmax, fBox.ymax]; -- the feedback box, which may not be very tight because by definition includes the control points.
GGBoundBox.UpdateBoundBoxOfBoundBox[textData.box, textData.box, fontData.transform]; -- transformed in place
GGBoundBox.UpdateCopyBoundBox[slice.tightBox, textData.box]; -- slice.tightBox updated in place from textData.box.

uBox Ź ImagerBox.BoundingBox[fBox, eBox]; -- box union of feedback and extents boxes
GGBoundBox.UpdateBoundBox[slice.boundBox, uBox.xmin, uBox.ymin, uBox.xmax, uBox.ymax]; -- slice.boundBox updated in place
IF textData.dropShadowOn THEN GGBoundBox.EnlargeByVector[slice.boundBox, [x: textData.dropShadowOffset.x*dropScale, y: textData.dropShadowOffset.y*dropScale]]; -- enlarged for drop shadows
GGBoundBox.UpdateBoundBoxOfBoundBox[slice.boundBox, slice.boundBox, fontData.transform]; -- transformed in place
GGBoundBox.EnlargeByOffset[slice.boundBox, halfHotJointSize+1.0]; -- enlarge in place.  Make the worst case assumption that there are hot selected joints instead of finding out.  It is only a few pixels extra in the boundBox

UpdateTextPoints[textData: textData, left: 0.0, middle: --fBox.xmin+-- fBox.xmax/2.0, right: fBox.xmax, bottom: fBox.ymin, base: 0.0, center: (fBox.ymax+fBox.ymin)/2.0, top: fBox.ymax]; -- fBox.xmin is always = 0.0

GGSlice.KillBoundBox[slice.parent]; -- invalidate ancestor caches
slice.boxValid Ź TRUE; -- remember that the boxes were already updated in place
slice.tightBoxValid Ź TRUE; -- not really necessary since only boxValid is used
tightBox Ź slice.tightBox;
boundBox Ź slice.boundBox;
};


ComputeTextBounds: PROC [font, namelessFont: Font, rope: Rope.ROPE, amplifySpace: REAL] RETURNS [middle, right, bottom, top, cpBottom, cpCenter, cpTop: REAL] = {
fontExtents: ImagerFont.Extents;
left, base: REAL = 0.0;
right Ź RopeEscapement[font, rope, amplifySpace].x;
middle Ź (left + right)/2.0;
fontExtents Ź ImagerFont.RopeBoundingBox[font, rope];
top Ź fontExtents.ascent;
bottom Ź -fontExtents.descent;
IF namelessFont # NIL THEN {
cpTop Ź top;
cpBottom Ź bottom;
}
ELSE {
fontExtents Ź ImagerFont.RopeBoundingBox[font, fontExtentRope];
cpTop Ź fontExtents.ascent;
cpBottom Ź -fontExtents.descent;
};
cpCenter Ź (cpTop + cpBottom)/2.0;
};

TextGetBoundBoxAux: PROC [slice: Slice, parts: SliceParts Ź NIL] RETURNS [tightBox, boundBox: BoundBox]= {
TextFindBoundBox: PROC [slice: Slice, parts: SliceParts] RETURNS [tightBox, boundBox: BoundBox] = {
textData: TextData Ź NARROW[slice.data];
fontData: FontData Ź textData.fontData;
left, base: REAL = 0.0;
middle, right, bottom, top, cpBottom, cpCenter, cpTop: REAL;
altMiddle, altRight, altBottom, altTop: REAL;

[middle, right, bottom, top, cpBottom, cpCenter, cpTop] Ź ComputeTextBounds[textData.trueFont, textData.fontData.namelessFont, textData.rope, textData.amplifySpace];
IF textData.displayStyle = print OR GetScreenFont[textData] = NIL
THEN {
altMiddle Ź middle; altRight Ź right; altBottom Ź bottom; altTop Ź top;
}
ELSE
[altMiddle, altRight, altBottom, altTop, ----, ----, ----] Ź ComputeTextBounds[GetScreenFont[textData], textData.fontData.namelessFont, textData.rope, textData.amplifySpace];

GGBoundBox.UpdateBoundBox[textData.box, left, altBottom, altRight, altTop];
IF textData.dropShadowOn THEN GGBoundBox.EnlargeByVector[textData.box, [x: textData.dropShadowOffset.x*dropScale, y: textData.dropShadowOffset.y*dropScale]];
textData.box Ź GGBoundBox.BoundBoxOfBoundBox[textData.box, fontData.transform];
GGBoundBox.EnlargeByOffset[textData.box, 1.0];
boundBox Ź GGBoundBox.CopyBoundBox[textData.box];

tightBox Ź GGBoundBox.CreateBoundBox[left, MIN[bottom, cpBottom], right, MAX[top, cpTop]];
tightBox Ź GGBoundBox.BoundBoxOfBoundBox[tightBox, fontData.transform];

UpdateTextPoints[textData, left, middle, right, cpBottom, base, cpCenter, cpTop];
};

[tightBox, boundBox] Ź TextFindBoundBox[slice, parts]; -- do the bound box update
IF parts=NIL THEN { -- set up cache for fast case next time around
GGSlice.KillBoundBox[slice.parent]; -- invalidate ancestor caches
slice.boundBox Ź boundBox;
slice.tightBox Ź tightBox;
slice.boxValid Ź TRUE;
slice.tightBoxValid Ź TRUE; -- not really necessary since only boxValid is used
};
};

TextGetBoundBox: PROC [slice: Slice, parts: SliceParts] RETURNS [box: BoundBox] = {
IF slice.boxValid AND parts=NIL THEN RETURN[slice.boundBox]; -- fast case
RETURN[IF tryNewBBox THEN NewTextGetBoundBoxAux[slice].boundBox ELSE TextGetBoundBoxAux[slice, parts].boundBox]; -- cache update if possible
};

useBBoxForTBox: BOOL _ FALSE;
TextGetTightBox: PROC [slice: Slice, parts: SliceParts] RETURNS [box: BoundBox] = {
IF slice.boxValid AND parts=NIL THEN RETURN[IF useBBoxForTBox THEN slice.boundBox ELSE slice.tightBox]; -- fast case
[] _ IF tryNewBBox THEN NewTextGetBoundBoxAux[slice] ELSE TextGetBoundBoxAux[slice, parts];
RETURN[IF useBBoxForTBox THEN slice.boundBox ELSE slice.tightBox]; -- cache update if possible
};

TextCopy: PROC [slice: Slice, parts: SliceParts Ź NIL] RETURNS [copy: LIST OF Slice] = {
copySlice: Slice;
copyData: TextData;
textData: TextData Ź NARROW[slice.data];
success: BOOL Ź TRUE;
router: MsgRouter Ź Feedback.EnsureRouter[$Gargoyle];

copySlice Ź MakeTextSlice[textData.rope, GGCoreOps.CopyColor[textData.color], textData.displayStyle, textData.amplifySpace, textData.dropShadowOn, textData.dropShadowOffset, GGCoreOps.CopyColor[textData.shadowColor]];
copyData Ź NARROW[copySlice.data];

success Ź SetTextFontAux[slice: copySlice,
fontData: GGFont.CopyFontData[textData.fontData, copyData.fontData],
router: router,
andTransform: TRUE,
history: NIL,
substituteFont: textData.trueFont,
trueFont: textData.trueFont,
screenFont: textData.screenFont];
IF NOT success THEN ERROR;

copyData.seg Ź GGSegment.CopySegment[seg: textData.seg];
copyData.lineSpacing Ź GGSlice.GetTextLineSpacing[slice];
GGProps.CopyAll[fromSlice: slice, toSlice: copySlice];
RETURN[LIST[copySlice]];
};

TextRestore: PROC [from: Slice, to: Slice] = {
IF to=NIL OR from=NIL THEN ERROR;
IF to.class#from.class THEN ERROR;
IF to.class.type#$Text THEN ERROR;
BEGIN
fromData: TextData Ź NARROW[from.data];
toData: TextData Ź NARROW[to.data];

IF GGSlice.copyRestore THEN {
toData.box­ Ź fromData.box­;
toData.points­ Ź fromData.points­;
toData.rope Ź fromData.rope;
toData.color Ź fromData.color;
toData.fontData Ź fromData.fontData;
toData.trueFont Ź fromData.trueFont;
toData.screenFont Ź fromData.screenFont;
toData.displayStyle Ź fromData.displayStyle;
toData.inverse Ź fromData.inverse;
toData.inverseScale Ź fromData.inverseScale;
toData.amplifySpace Ź fromData.amplifySpace;
toData.dropShadowOn Ź fromData.dropShadowOn;
toData.dropShadowOffset Ź fromData.dropShadowOffset;
toData.dropShadowOffset Ź fromData.dropShadowOffset;
toData.shadowColor Ź fromData.shadowColor;
toData.lineSpacing Ź fromData.lineSpacing;
toData.seg Ź fromData.seg;
}
ELSE to.data Ź from.data;


to.selectedInFull Ź from.selectedInFull; -- RECORD of BOOL
to.normalSelectedParts Ź NIL; -- caller must reselect
to.hotSelectedParts Ź NIL; -- caller must reselect
to.activeSelectedParts Ź NIL; -- caller must reselect
to.matchSelectedParts Ź NIL; -- caller must reselect
to.tightBox­ Ź from.tightBox­;
to.tightBoxValid Ź from.tightBoxValid;
to.boundBox­ Ź from.boundBox­;
to.boxValid Ź from.boxValid;
to.onOverlay Ź from.onOverlay;
to.extraPoints Ź from.extraPoints;
to.priority Ź from.priority;
to.historyTop Ź from.historyTop;
END;

};
TextDrawParts: PROC [slice: Slice, parts: SliceParts Ź NIL, dc: Imager.Context, camera: GGModelTypes.Camera, quick: BOOL] = {
DoDrawText: PROC = {
IF textData.dropShadowOn THEN DrawDropShadow[dc, textData, camera, quick];
DrawText[dc, textData, camera, quick];
};
textData: TextData Ź NARROW[slice.data];
textParts: TextParts Ź NARROW[parts];
IF textParts = NIL OR textParts.includeText THEN Imager.DoSave[dc, DoDrawText];
};

TextDrawSelectionFeedback: PROC [slice: Slice, selectedParts: SliceParts, hotParts: SliceParts, dc: Imager.Context, camera: Camera, dragInProgress, caretIsMoving, hideHot, quick: BOOL] = {
slowNormal, slowHot, completeNormal, completeHot: BOOL Ź FALSE;
firstJoint: Point;
normalTextParts, hotTextParts: TextParts;
textData: TextData Ź NARROW[slice.data];
transform: Transformation Ź textData.fontData.transform;
IF caretIsMoving OR dragInProgress OR camera.quality=quality THEN RETURN;
IF selectedParts=NIL AND hotParts=NIL THEN RETURN;
normalTextParts Ź NARROW[selectedParts];
hotTextParts Ź NARROW[hotParts];
completeNormal Ź normalTextParts#NIL AND IsComplete[normalTextParts];
completeHot Ź hotTextParts#NIL AND IsComplete[hotTextParts];
slowNormal Ź normalTextParts#NIL AND (NOT quick OR (quick AND NOT completeNormal));
slowHot Ź hotTextParts#NIL AND (NOT quick OR (quick AND NOT completeHot));
IF slowNormal AND slowHot THEN DrawSelectionFeedbackText[slice, textData, normalTextParts, hotTextParts, dc, transform, camera]
ELSE IF slowNormal THEN DrawSelectionFeedbackText[slice, textData, normalTextParts, NIL, dc, transform, camera]
ELSE IF slowHot THEN DrawSelectionFeedbackText[slice, textData, NIL, hotTextParts, dc, transform, camera];
IF (NOT slowNormal AND completeNormal) OR (NOT slowHot AND completeHot) THEN {
fullParts: TextParts Ź IF completeNormal THEN normalTextParts ELSE hotTextParts;
[] Ź GGSliceOps.GetTightBox[slice]; -- force update of internal data
firstJoint Ź ImagerTransformation.Transform[transform, textData.points[0]];
};
IF NOT slowHot AND completeHot THEN
GGShapes.DrawQuickSelectedJoint[dc, firstJoint, hot, camera.cpScale];
IF NOT slowNormal AND completeNormal THEN
GGShapes.DrawQuickSelectedJoint[dc, firstJoint, normal, camera.cpScale];
};

DrawSelectionFeedbackText: PROC [slice: Slice, textData: TextData, normalTextParts: TextParts, hotTextParts: TextParts, dc: Imager.Context, t: ImagerTransformation.Transformation, camera: Camera]  = {
DoDrawFeedback: PROC = {
thisCPisHot, thisCPisSelected: BOOL Ź FALSE;
pts: ARRAY [0..11] OF Point;
[] Ź GGSliceOps.GetTightBox[slice]; -- force update of internal data
FOR i: NAT IN [0..11] DO
pts[i] Ź ImagerTransformation.Transform[t, textData.points[i]];
ENDLOOP;
Imager.SetColor[dc, Imager.black];
FOR point: INTEGER IN [0..textMaxPoints) DO
thisCPisHot Ź hotTextParts#NIL AND hotTextParts.points[point];
thisCPisSelected Ź normalTextParts#NIL AND normalTextParts.points[point];
IF thisCPisHot THEN GGShapes.DrawSelectedJoint[dc, pts[point], hot, camera.cpScale];
IF thisCPisSelected THEN GGShapes.DrawSelectedJoint[dc, pts[point], normal, camera.cpScale];
IF NOT thisCPisHot AND NOT thisCPisSelected THEN GGShapes.DrawCP[dc, pts[point], camera.cpScale];
ENDLOOP;
};
Imager.DoSave[dc, DoDrawFeedback];
};

TextDrawAttractorFeedback:  PROC [slice: Slice, attractorParts: SliceParts, selectedParts: SliceParts, dragInProgress: BOOL, dc: Imager.Context, camera: Camera, editConstraints: EditConstraints] = {
bigReal: REAL Ź 1.0e37;
IF NOT (dragInProgress AND selectedParts#NIL) THEN {
DoDrawFeedback: PROC = {
DrawEdgeAndPoints: PROC [start, end, cp1, cp2: Point Ź [bigReal, bigReal] ] = {
Imager.MaskVector[dc, start, end];
GGShapes.DrawCP[dc, start, camera.cpScale];
GGShapes.DrawCP[dc, end, camera.cpScale];
IF cp1.x#bigReal THEN GGShapes.DrawCP[dc, cp1, camera.cpScale];
IF cp2.x#bigReal THEN GGShapes.DrawCP[dc, cp2, camera.cpScale];
};
pts: ARRAY [0..11] OF Point;
t: ImagerTransformation.Transformation Ź fontData.transform;
[] Ź GGSliceOps.GetTightBox[slice]; -- force update of internal data
FOR i: NAT IN [0..11] DO
pts[i] Ź ImagerTransformation.Transform[t, textData.points[i]];
ENDLOOP;
Imager.SetColor[dc, Imager.black];
Imager.SetStrokeJoint[dc, round];
Imager.SetStrokeWidth[dc, 1.0];
IF hitParts.points#ALL[FALSE] THEN FOR point: INTEGER IN [0..textMaxPoints) DO
GGShapes.DrawCP[dc, pts[point], camera.cpScale];
ENDLOOP;
IF hitParts.edges#ALL[FALSE] THEN FOR edge: INTEGER IN [0..textMaxEdges) DO
IF hitParts.edges[edge] THEN {
SELECT edge FROM
0 =>  DrawEdgeAndPoints[pts[0], pts[3], pts[1], pts[2] ];
1 =>  DrawEdgeAndPoints[pts[3], pts[11], pts[7] ];
2 =>  DrawEdgeAndPoints[pts[11], pts[8], pts[9], pts[10] ];
3 =>  DrawEdgeAndPoints[pts[8], pts[0], pts[4] ];
4 =>  DrawEdgeAndPoints[pts[1], pts[9], pts[5] ];
5 =>  DrawEdgeAndPoints[pts[2], pts[10], pts[6] ];
6 =>  DrawEdgeAndPoints[pts[4], pts[7], pts[5], pts[6] ];
ENDCASE => ERROR;
EXIT;
};
ENDLOOP;
};
textData: TextData Ź NARROW[slice.data];
hitParts: TextParts Ź NARROW[attractorParts];
fontData: FontData Ź textData.fontData;
IF camera.quality#quality AND hitParts#NIL THEN Imager.DoSave[dc, DoDrawFeedback];
};
};

DrawText: PROC [dc: Imager.Context, textData: TextData, camera: GGModelTypes.Camera, quick: BOOL] = {
IF textData.color=NIL THEN RETURN;
Imager.SetFont[dc, IF (camera.quality=quality OR camera.displayStyle=print OR textData.displayStyle=print) THEN textData.trueFont ELSE GetScreenFont[textData]];
GGCoreOps.SetColor[dc, textData.color]; -- must happen before the text transform is applied
Imager.ConcatT[dc, textData.fontData.transform];
Imager.SetXY[dc, [0.0, 0.0]]; -- dc must be transformed completely here
Imager.SetAmplifySpace[dc, textData.amplifySpace]; -- adjust spacing (for right justified text)
Imager.ShowRope[dc, textData.rope];
};

DrawDropShadow: PROC [dc: Imager.Context, textData: TextData, camera: GGModelTypes.Camera, quick: BOOL] = {
DoDrawDropShadow: PROC = {
tVec: VEC Ź [x: textData.dropShadowOffset.x*dropScale, y: textData.dropShadowOffset.y*dropScale];
GGCoreOps.SetColor[dc, textData.shadowColor]; -- must happen before text transform is applied
Imager.ConcatT[dc, textData.fontData.transform];
Imager.TranslateT[dc, tVec];
Imager.SetFont[dc, IF (camera.quality=quality OR camera.displayStyle=print OR textData.displayStyle=print) THEN textData.trueFont ELSE GetScreenFont[textData]];
Imager.SetXY[dc, [0.0, 0.0]]; -- dc must be transformed completely here
Imager.SetAmplifySpace[dc, textData.amplifySpace]; -- adjust spacing (for right justified text)
Imager.ShowRope[dc, textData.rope];
};
IF textData.shadowColor=NIL THEN RETURN;
Imager.DoSave[dc, DoDrawDropShadow];
};

GetScreenFont: PROC [textData: TextData] RETURNS [font: ImagerFont.Font] ~ {
RETURN[IF textData.screenFont#NIL THEN textData.screenFont
ELSE GGFont.AlternateFont[textData.fontData, textData.trueFont, $visible]];
};

TextDrawTransform: PROC [slice: Slice, parts: SliceParts Ź NIL, dc: Imager.Context, camera: Camera, transform: ImagerTransformation.Transformation, editConstraints: EditConstraints] = {
DoTextDrawTransform: PROC = {
Imager.ConcatT[dc, transform];
IF textData.dropShadowOn THEN DrawDropShadow[dc, textData, camera, FALSE];
DrawText[dc, textData, camera, FALSE];
};
textData: TextData Ź NARROW[slice.data];
Imager.DoSave[dc, DoTextDrawTransform];
};

TextTransform: PROC [slice: Slice, parts: SliceParts Ź NIL, transform: ImagerTransformation.Transformation, editConstraints: EditConstraints, history: HistoryEvent] = {
textData: TextData Ź NARROW[slice.data];
fontData: FontData Ź textData.fontData;
fontData.transform Ź ImagerTransformation.Concat[fontData.transform, transform];
textData.inverse Ź ImagerTransformation.Invert[fontData.transform];
textData.inverseScale Ź ImagerTransformation.Factor[textData.inverse].s;
textData.color Ź GGCoreOps.TransformColor[textData.color, transform];
textData.shadowColor Ź GGCoreOps.TransformColor[textData.shadowColor, transform];
IF InvolvesScaling[transform] THEN textData.screenFont Ź NIL;
GGSlice.KillBoundBox[slice];
};

InvolvesScaling: PROC [transform: ImagerTransformation.Transformation] RETURNS [BOOL] = {
epsilon: REAL = 0.01;
sigma: VEC Ź ImagerTransformation.SingularValues[transform];
IF ABS[sigma.x-1.0] > epsilon THEN RETURN[TRUE];
IF ABS[sigma.y-1.0] > epsilon THEN RETURN[TRUE];
RETURN[FALSE];
};

TextDescribe: PROC [sliceD: SliceDescriptor] RETURNS [rope: Rope.ROPE] = {
prefix: Rope.ROPE;
textParts: TextParts;
eCount, pCount: NAT Ź 0;
IF sliceD.parts = NIL THEN RETURN["a Text slice"];
textParts Ź NARROW[sliceD.parts];
FOR i: INTEGER IN [0..textMaxPoints) DO
IF textParts.points[i] THEN {
pCount Ź pCount + 1;
prefix Ź textPointRopes[i];
};
ENDLOOP;
FOR i: INTEGER IN [0..textMaxEdges) DO
IF textParts.edges[i] THEN {
eCount Ź eCount + 1;
prefix Ź textEdgeRopes[i];
};
ENDLOOP;
IF pCount+eCount>1 THEN RETURN["multiple parts of a Text slice"];
IF eCount=0 AND pCount=0 THEN RETURN["NO parts of a Text slice"];
rope Ź Rope.Concat[prefix, " of a Text slice"];
};

TextDescribeHit: PROC [slice: Slice, hitData: REF ANY] RETURNS [rope: Rope.ROPE] = {
textHitData: TextHitData Ź NARROW[hitData];
prefix: Rope.ROPE;
IF textHitData.point#-1 THEN prefix Ź textPointRopes[textHitData.point]
ELSE IF textHitData.edge#-1 THEN prefix Ź textEdgeRopes[textHitData.edge]
ELSE ERROR;
rope Ź Rope.Concat[prefix, " of a Text slice"];
};

TextFileout: PROC [slice: Slice, f: IO.STREAM] = {
textData: TextData Ź NARROW[slice.data];
fontData: FontData Ź textData.fontData;
GGParseOut.WriteBool[f, IF fontData.comfortable THEN TRUE ELSE FALSE];
IF fontData.comfortable THEN f.PutF[" \"%q\" %g%g ", [rope[textData.rope]], [rope[fontData.prefix]], [rope[fontData.userFSF]] ] ELSE f.PutF[" \"%q\" %g ", [rope[textData.rope]], [rope[fontData.literal]] ];
GGParseOut.WriteTransformation[f, fontData.transform];
IF NOT fontData.comfortable THEN f.PutF[" %g %g ", [real[fontData.storedSize]], [real[fontData.designSize]] ];
GGParseOut.WriteColor[f, textData.color];
f.PutChar[IO.SP];
IF textData.dropShadowOn THEN {
GGParseOut.WriteBool[f, TRUE];
f.PutChar[IO.SP];
GGParseOut.WritePoint[f, textData.dropShadowOffset];
f.PutChar[IO.SP];
GGParseOut.WriteColor[f, textData.shadowColor];
}
ELSE GGParseOut.WriteBool[f, FALSE];
f.PutF1[" %g", [real[textData.amplifySpace]]];
f.PutRope[" props: ( "];
GGParseOut.WriteBool[f, textData.seg.props#NIL];
IF textData.seg.props#NIL THEN GGParseOut.WriteProps[f, textData.seg.props] ELSE f.PutChar[IO.SP]; -- list of ROPE
f.PutF1[") ls: %g", [real[GGSlice.GetTextLineSpacing[slice]]]];
};

TextFilein: PROC [f: IO.STREAM, version: REAL, router: MsgRouter, camera: Camera] RETURNS [slice: Slice] = {
tempBBox, tempTBox: BoundBox;
text, fontName: Rope.ROPE;
prefix: Rope.ROPE Ź "xerox/pressfonts/";
tiogaPrefix: Rope.ROPE Ź "xerox/tiogafonts/";
family: Rope.ROPE Ź "Helvetica";
face: Rope.ROPE Ź "";
fontData: GGFont.FontData;
fontDataComfortable: BOOL Ź FALSE;
size: REAL Ź 1.0;
preferredSize: REAL Ź 1.0;
preferredSizeRope: Rope.ROPE Ź "";
defaultSize: REAL _ 10.0;
transform: ImagerTransformation.Transformation;
shadowColor: Imager.Color Ź Imager.black;
textColor: Imager.Color Ź Imager.black;
dropShadowOn, good: BOOL Ź FALSE;
dropShadowOffset: Vector Ź [0.0, 0.0];
amplifySpace: REAL Ź 1.0;
lineSpacing: REAL Ź 1.0;
props: LIST OF Rope.ROPE Ź NIL;
IF version >= 8702.11 THEN {
fontDataComfortable Ź GGParseIn.ReadBool[f];
};
IF version > 8601.22 THEN {
text Ź f.GetRopeLiteral[];
}
ELSE {
GGParseIn.ReadChar[f, '(];
text Ź GGParseIn.ReadWord[f];
GGParseIn.ReadChar[f, ')];
};
IF version < 8702.11 THEN { -- many old style formats
IF version >= 8701.30 THEN {
prefix Ź GGParseIn.ReadWord[f];
}; -- ELSE uses default prefix
IF version <= 8601.06 THEN {-- use default family and face and transformation
size Ź defaultSize;
}
ELSE IF version <= 8601.27 THEN { -- a simple name like "Helvetica" or "Gacha"
family Ź GGParseIn.ReadWord[f];
}
ELSE IF version <= 8605.12 THEN { -- a complex name like "xerox/pressfonts/Helvetica-BIR"
fontName Ź GGParseIn.ReadWord[f];
size Ź GGParseIn.ReadReal[f];
[] Ź GGParseIn.ReadWord[f];
fontName Ź UnpackComplexFontName[fontName, size]; -- like Helvetica12BI
[family, face, ----] Ź TFontParamsFromFontName[fontName];
}
ELSE IF version <= 8605.28 THEN { -- a mixed mode name like Helvetica7BI or TimesRoman12
fontName Ź GGParseIn.ReadWord[f];
size Ź GGParseIn.ReadReal[f];
[] Ź GGParseIn.ReadWord[f]; -- throw away redundant size
[family, face, ----] Ź TFontParamsFromFontName[fontName];
}
ELSE IF version < 8701.30 THEN { -- a mixed mode name like Helvetica7BI or TimesRoman12. No colorName, real text color
fontName Ź GGParseIn.ReadWord[f];
size Ź GGParseIn.ReadReal[f];
[family, face, ----] Ź TFontParamsFromFontName[fontName];
}
ELSE IF version = 8701.30 THEN {-- an interim font format
ps: INT Ź 0;
fail: BOOL Ź FALSE;
[fail, ----, family, face] Ź GGFont.OldParseFontData[f, FALSE, TRUE, TRUE];
IF fail THEN ERROR;
transform Ź GGParseIn.ReadTransformation[f];
preferredSize Ź GGParseIn.ReadReal[f];
ps Ź Real.Round[preferredSize];
IF Rope.Equal[prefix, tiogaPrefix, FALSE] THEN preferredSizeRope Ź IO.PutFR1["%g", [integer[ps]] ];
};
fontData Ź GGFont.CreateFontData[];
fontData.transform Ź transform;
fontData.storedSize Ź preferredSize; -- needed by ParseFontData
fontData Ź GGFont.ParseFontData[data: fontData, inStream: IO.RIS[rope: Rope.Cat[prefix, family, face, preferredSizeRope], oldStream: NIL], prefixP: TRUE, familyP: TRUE, faceP: TRUE ! GGFont.ParseError => CONTINUE;]; -- failures handled downstream
}
ELSE {
name: Rope.ROPE Ź GGParseIn.ReadWord[f];
fontData Ź GGFont.CreateFontData[]; -- assure non-NIL fontData
IF fontDataComfortable THEN { -- User data in file: name, transformation
fontData Ź GGFont.ParseFontData[data: fontData, inStream: IO.RIS[rope: name, oldStream: NIL], prefixP: TRUE, familyP: TRUE, faceP: TRUE ! GGFont.ParseError => CONTINUE;];  -- failures handled downstream
fontData.transform Ź GGParseIn.ReadTransformation[f];
}
ELSE { --  Literal data in file
fontData.transform Ź GGParseIn.ReadTransformation[f];
fontData.storedSize Ź GGParseIn.ReadReal[f];
fontData.designSize Ź GGParseIn.ReadReal[f];
fontData Ź GGFont.ParseFontData[data: fontData, inStream: IO.RIS[name], literalP: TRUE ! GGFont.ParseError => CONTINUE;]; -- failures handled downstream
};
};

IF version > 8605.28 THEN {
textColor Ź GGParseIn.ReadColor[f, version];
IF textColor = NIL AND version < 9106.27 THEN textColor Ź Imager.black;
};
IF version >= 8609.26 THEN {
dropShadowOn Ź GGParseIn.ReadBool[f];
IF dropShadowOn THEN {
dropShadowOffset Ź GGParseIn.ReadPoint[f];
shadowColor Ź GGParseIn.ReadColor[f, version];
IF shadowColor = NIL AND version < 9106.27 THEN shadowColor Ź Imager.black;
};
}
ELSE dropShadowOn Ź FALSE;

IF version <= 8607.22 THEN { -- a point rather than a transform
point: Point Ź GGParseIn.ReadPoint[f];
fontData.transform Ź ImagerTransformation.Translate[point];
fontData.transform Ź ImagerTransformation.PreScale[fontData.transform, size];
size Ź 1.0;
}
ELSE IF version < 8701.30 THEN {
fontData.transform Ź GGParseIn.ReadTransformation[f];
fontData.transform Ź ImagerTransformation.PreScale[fontData.transform, size];
size Ź 1.0;
}; -- transform already read in for later versions

IF version >= 8701.13 THEN {
amplifySpace Ź GGParseIn.ReadReal[f];
}
ELSE amplifySpace Ź 1.0;
IF version>=8706.08 THEN { -- read in segment props
hasProps: BOOL Ź FALSE;
GGParseIn.ReadRope[f, "props: ( "];
hasProps Ź GGParseIn.ReadBool[f];
props Ź IF hasProps THEN GGParseIn.ReadListOfRope[f] ELSE NIL;
GGParseIn.ReadChar[f, ')];
};
IF version>=8803.08 THEN { -- read in line spacing
GGParseIn.ReadRope[f, "ls: "];
lineSpacing Ź GGParseIn.ReadReal[f];
};

slice Ź MakeTextSlice[text, textColor, camera.displayStyle, amplifySpace, dropShadowOn, dropShadowOffset, shadowColor];
fontData.substituteOK Ź TRUE; -- allow font substitution on file reads
IF NOT SetTextFontAndTransform[slice, fontData, router, NIL] THEN SIGNAL FontNameError;
IF props#NIL THEN {
seg: Segment Ź NARROW[slice.data, TextData].seg;
FOR next: LIST OF Rope.ROPE Ź props, next.rest UNTIL next=NIL DO
seg.props Ź CONS[next.first, seg.props];
ENDLOOP;
};

GGSlice.KillBoundBox[slice];
tempBBox _ TextGetBoundBox[slice, NIL];
tempTBox _ TextGetTightBox[slice, NIL];

GGSlice.SetTextLineSpacing[slice, lineSpacing, NIL];

};

MakeComplete: PROC [parts: SliceParts]  = {
textParts: TextParts Ź NARROW[parts];
textParts.points Ź ALL[TRUE];
textParts.edges Ź ALL[TRUE];
textParts.includeText Ź TRUE;
};

IsComplete: PROC [parts: SliceParts] RETURNS [BOOL Ź FALSE] = {
textParts: TextParts Ź NARROW[parts];
RETURN[textParts#NIL AND textParts.points=ALL[TRUE] AND textParts.edges=ALL[TRUE] AND textParts.includeText=TRUE];
};

IsEmpty: PROC [parts: SliceParts] RETURNS [BOOL Ź FALSE] = {
textParts: TextParts Ź NARROW[parts];
RETURN[textParts=NIL OR (textParts.points=ALL[FALSE] AND textParts.edges=ALL[FALSE] AND textParts.includeText = FALSE)];
};

TextIsEmptyParts: PROC [sliceD: SliceDescriptor] RETURNS [BOOL Ź FALSE] = {
RETURN[IsEmpty[sliceD.parts]];
};

TextIsCompleteParts: PROC [sliceD: SliceDescriptor] RETURNS [BOOL Ź FALSE] = {
RETURN[IsComplete[sliceD.parts]];
};

TextNewParts: PROC [slice: Slice, hitData: REF ANY, mode: SelectMode] RETURNS [sliceD: SliceDescriptor] = {
textHitData: TextHitData Ź NARROW[hitData];
textParts: TextParts Ź NEW[TextPartsObj Ź [points: ALL[FALSE], edges: ALL[FALSE], includeText: FALSE ] ];
SELECT mode FROM
literal => {
IF textHitData.point#-1 THEN textParts.points[textHitData.point] Ź TRUE
ELSE IF textHitData.edge#-1 THEN textParts.edges[textHitData.edge] Ź TRUE
ELSE ERROR;
};
joint => {
IF textHitData.point#-1 THEN {
textParts.points[textHitData.point] Ź TRUE;
}
ELSE {
hitData: REF ANY;
pointHitData: TextHitData;
success: BOOL;
wholeD: SliceDescriptor;
wholeD Ź TextNewParts[slice, NIL, topLevel];
[----, ----, ----, hitData, success] Ź GGSliceOps.ClosestPoint[wholeD, textHitData.hitPoint, GGUtility.plusInfinity];
IF NOT success THEN ERROR;
pointHitData Ź NARROW[hitData];
IF pointHitData.point = -1 THEN ERROR;
textParts.points[pointHitData.point] Ź TRUE;
};
textParts.includeText Ź TRUE;
};
segment => IF textHitData.edge#-1 THEN {
textParts.edges[textHitData.edge] Ź TRUE;
textParts.includeText Ź TRUE;
};
controlPoint => {
textParts.points Ź ALL[TRUE];
textParts.edges Ź ALL[TRUE];
};
traj, slice, topLevel => MakeComplete[textParts];
none => { -- leave textParts empty
};
ENDCASE => ERROR;
sliceD Ź GGSlice.DescriptorFromParts[slice, textParts];
};

TextUnionParts: PROC [partsA: SliceDescriptor, partsB: SliceDescriptor] RETURNS [aPlusB: SliceDescriptor] = {
textPartsA: TextParts Ź NARROW[partsA.parts];
textPartsB: TextParts Ź NARROW[partsB.parts];
newParts: TextParts;
IF partsA = NIL OR partsB = NIL THEN ERROR;
IF partsA.parts = NIL THEN RETURN[partsB];
IF partsB.parts = NIL THEN RETURN[partsA];
newParts Ź NEW[TextPartsObj Ź [points: ALL[FALSE], edges: ALL[FALSE], includeText: FALSE]];
FOR i: INTEGER IN [0..textMaxPoints) DO
newParts.points[i] Ź textPartsA.points[i] OR textPartsB.points[i];
ENDLOOP;
FOR i: INTEGER IN [0..textMaxEdges) DO
newParts.edges[i] Ź textPartsA.edges[i] OR textPartsB.edges[i];
ENDLOOP;
newParts.includeText Ź textPartsA.includeText OR textPartsB.includeText;
aPlusB Ź GGSlice.DescriptorFromParts[partsA.slice, newParts];
};

TextDiffParts: PROC [partsA: SliceDescriptor, partsB: SliceDescriptor] RETURNS [aMinusB: SliceDescriptor] = {
textPartsA: TextParts Ź NARROW[partsA.parts];
textPartsB: TextParts Ź NARROW[partsB.parts];
newParts: TextParts;
IF partsA = NIL OR partsB = NIL THEN ERROR;
IF partsA.parts=NIL THEN RETURN[GGSlice.DescriptorFromParts[partsA.slice, NIL]];
IF partsB=NIL THEN RETURN[partsA];
newParts Ź NEW[TextPartsObj Ź [points: ALL[FALSE], edges: ALL[FALSE], includeText: FALSE ] ];
FOR i: INTEGER IN [0..textMaxPoints) DO
newParts.points[i] Ź IF textPartsB.points[i] THEN FALSE ELSE textPartsA.points[i];
ENDLOOP;
FOR i: INTEGER IN [0..textMaxEdges) DO
newParts.edges[i] Ź IF textPartsB.edges[i] THEN FALSE ELSE textPartsA.edges[i];
ENDLOOP;
newParts.includeText Ź IF textPartsB.includeText THEN FALSE ELSE textPartsA.includeText;
aMinusB Ź GGSlice.DescriptorFromParts[partsA.slice, newParts];
};

TextMovingParts: PROC [slice: Slice, selectedParts: SliceParts, editConstraints: EditConstraints, bezierDrag: GGInterfaceTypes.BezierDragRecord] RETURNS [background, overlay, rubber, drag: SliceDescriptor] = {
dragParts: TextParts Ź NEW[TextPartsObj Ź [points: ALL[TRUE], edges: ALL[TRUE], includeText: TRUE ] ];
backgroundParts: TextParts Ź NEW[TextPartsObj Ź [points: ALL[TRUE], edges: ALL[TRUE], includeText: TRUE ] ];
IF IsEmpty[selectedParts] THEN { -- everything on background
dragParts.edges Ź ALL[FALSE];
dragParts.points Ź ALL[FALSE];
dragParts.includeText Ź FALSE;
}
ELSE { -- everything is dragging
backgroundParts.edges Ź ALL[FALSE];
backgroundParts.points Ź ALL[FALSE];
backgroundParts.includeText Ź FALSE;
};
background Ź GGSlice.DescriptorFromParts[slice, backgroundParts];
overlay Ź rubber Ź GGSlice.DescriptorFromParts[slice, NIL];
drag Ź GGSlice.DescriptorFromParts[slice, dragParts];
};

TextAugmentParts: PROC [sliceD: SliceDescriptor, selectClass: SelectionClass] RETURNS [more: SliceDescriptor] = {
textParts: TextParts Ź NARROW[sliceD.parts];
newParts: TextParts Ź NEW[TextPartsObj Ź [points: textParts.points, edges: textParts.edges, includeText: textParts.includeText] ];
FOR i: INTEGER IN [0..textMaxEdges) DO
IF textParts.edges[i] THEN SELECT i FROM
0 => {newParts.points[0] Ź TRUE; newParts.points[1] Ź TRUE; newParts.points[2] Ź TRUE; newParts.points[3] Ź TRUE;};
1 => {newParts.points[3] Ź TRUE; newParts.points[7] Ź TRUE; newParts.points[11] Ź TRUE;};
2 => {newParts.points[8] Ź TRUE; newParts.points[9] Ź TRUE; newParts.points[10] Ź TRUE; newParts.points[11] Ź TRUE;};
3 => {newParts.points[0] Ź TRUE; newParts.points[4] Ź TRUE; newParts.points[8] Ź TRUE;};
4 => {newParts.points[1] Ź TRUE; newParts.points[5] Ź TRUE; newParts.points[9] Ź TRUE;};
5 => {newParts.points[2] Ź TRUE; newParts.points[6] Ź TRUE; newParts.points[10] Ź TRUE;};
6 => {newParts.points[4] Ź TRUE; newParts.points[5] Ź TRUE; newParts.points[6] Ź TRUE; newParts.points[7] Ź TRUE;};
ENDCASE => ERROR;
ENDLOOP;
more Ź GGSlice.DescriptorFromParts[sliceD.slice, newParts];
};

TextPointsInDescriptor: PROC [sliceD: SliceDescriptor] RETURNS [pointGen: PointGenerator] = {
parts: TextParts Ź NARROW[sliceD.parts];
pointGen Ź NEW[PointGeneratorObj Ź [sliceD, 0, 0, NIL] ];
<<IF NOT sliceD.slice.boxValid THEN>> [] Ź TextGetBoundBox[sliceD.slice, NIL]; -- has side effect of updating textData.points, if needed
FOR point: INTEGER IN [0..textMaxPoints) DO
IF parts.points[point] THEN pointGen.toGo Ź pointGen.toGo + 1;
ENDLOOP;
};

TextWalkPointsInDescriptor: PROC [sliceD: SliceDescriptor, walkProc: PointWalkProc] = {
parts: TextParts Ź NARROW[sliceD.parts];
textData: TextData Ź NARROW[sliceD.slice.data];
fontData: FontData Ź textData.fontData;
done: BOOL Ź FALSE;
<<IF NOT sliceD.slice.boxValid THEN>> [] Ź TextGetBoundBox[sliceD.slice, NIL]; -- has side effect of updating textData.points, if needed
FOR index: INTEGER IN [0..textMaxPoints) DO
IF parts.points[index] THEN {
point: Point Ź ImagerTransformation.Transform[fontData.transform, textData.points[index]];
done Ź walkProc[point];
};
ENDLOOP;
};

TextPointPairsInDescriptor: PROC [sliceD: SliceDescriptor] RETURNS [pointPairGen: PointPairGenerator] = {
parts: TextParts Ź NARROW[sliceD.parts];
<<IF NOT sliceD.slice.boxValid THEN>> [] Ź TextGetBoundBox[sliceD.slice, NIL]; -- has side effect of updating textData.points, if needed
pointPairGen Ź NEW[PointPairGeneratorObj Ź [sliceD, 0, 0, NIL] ]; -- toGo and index now used
FOR edge: INTEGER IN [0..textMaxEdges) DO
IF parts.edges[edge] THEN pointPairGen.toGo Ź pointPairGen.toGo + 1;
ENDLOOP;
};

TextSegmentsInDescriptor: PROC [sliceD: SliceDescriptor] RETURNS [segGen: SegmentGenerator] = {
parts: TextParts Ź NARROW[sliceD.parts];
segGen Ź NEW[SegmentGeneratorObj Ź [NIL, 0, 0, 0, NIL, FALSE, sliceD, NIL] ]; -- toGo and index now used
FOR edge: INTEGER IN [0..textMaxEdges) DO
IF parts.edges[edge] THEN segGen.toGo Ź 1;-- any edge sets segGen.toGo = 1
ENDLOOP;
};

TextWalkSegments: PROC [slice: Slice, walkProc: WalkProc] RETURNS [sliceD: SliceDescriptor] = {
textData: TextData Ź NARROW[slice.data];
RETURN[IF walkProc[textData.seg, NIL] THEN TextNewParts[slice, NIL, slice] ELSE TextNewParts[slice, NIL, none]];
};

TextNextSegment: PUBLIC PROC [slice: Slice, segGen: SegmentGenerator] RETURNS [seg: Segment, transform: Transformation] = {
IF segGen=NIL OR segGen.toGo = 0 THEN RETURN[NIL, NIL]
ELSE {
textData: TextData Ź NARROW[segGen.sliceD.slice.data];
seg Ź textData.seg;
segGen.toGo Ź 0;
};
};

TextNextPoint: PROC [slice: Slice, pointGen: PointGenerator] RETURNS [pointAndDone: GGModelTypes.PointAndDone] = {
IF pointGen=NIL OR pointGen.toGo = 0 THEN {
pointAndDone.done Ź TRUE;
RETURN;
}
ELSE {
sliceD: SliceDescriptor Ź pointGen.sliceD;
textData: TextData Ź NARROW[sliceD.slice.data];
fontData: FontData Ź textData.fontData;
textParts: TextParts Ź NARROW[sliceD.parts];
index: INTEGER Ź -1;
pointAndDone.done Ź FALSE;
FOR index Ź pointGen.index, index+1 UNTIL index >=textMaxPoints DO
IF textParts.points[index] THEN EXIT; -- index will point to next available point
ENDLOOP;
pointAndDone.point Ź ImagerTransformation.Transform[fontData.transform, textData.points[index] ];
pointGen.toGo Ź pointGen.toGo-1;
pointGen.index Ź IF pointGen.toGo=0 THEN 99 ELSE index+1; -- bump to the next available point in the generator
};
};

TextNextPointPair: PROC [slice: Slice, pointPairGen: PointPairGenerator] RETURNS [pointPairAndDone: GGModelTypes.PointPairAndDone] = {
IF pointPairGen=NIL OR pointPairGen.toGo = 0 THEN {
pointPairAndDone.done Ź TRUE;
RETURN;
}
ELSE {
sliceD: SliceDescriptor Ź pointPairGen.sliceD;
textData: TextData Ź NARROW[sliceD.slice.data];
textParts: TextParts Ź NARROW[sliceD.parts];
t: ImagerTransformation.Transformation Ź  textData.fontData.transform;
index: INTEGER Ź -1;
pointPairAndDone.done Ź FALSE;
FOR index Ź pointPairGen.index, index+1 UNTIL index >=textMaxEdges DO
IF textParts.edges[index] THEN EXIT; -- index will point to next availabe edge
ENDLOOP;
[] Ź GGSliceOps.GetBoundBox[slice, NIL]; -- update of textData.points required
SELECT index FROM -- index in [0..textMaxEdges) of next available edge
0 => {
pointPairAndDone.lo Ź ImagerTransformation.Transform[t, textData.points[0] ];
pointPairAndDone.hi Ź ImagerTransformation.Transform[t, textData.points[3] ];
};
1 => {
pointPairAndDone.lo Ź ImagerTransformation.Transform[t, textData.points[3] ];
pointPairAndDone.hi Ź ImagerTransformation.Transform[t, textData.points[11] ];
};
2 => {
pointPairAndDone.lo Ź ImagerTransformation.Transform[t, textData.points[11] ];
pointPairAndDone.hi Ź ImagerTransformation.Transform[t, textData.points[8] ];
};
3 => {
pointPairAndDone.lo Ź ImagerTransformation.Transform[t, textData.points[8] ];
pointPairAndDone.hi Ź ImagerTransformation.Transform[t, textData.points[0] ];
};
4 => {
pointPairAndDone.lo Ź ImagerTransformation.Transform[t, textData.points[1] ];
pointPairAndDone.hi Ź ImagerTransformation.Transform[t, textData.points[9] ];
};
5 => {
pointPairAndDone.lo Ź ImagerTransformation.Transform[t, textData.points[2] ];
pointPairAndDone.hi Ź ImagerTransformation.Transform[t, textData.points[10] ];
};
6 => {
pointPairAndDone.lo Ź ImagerTransformation.Transform[t, textData.points[4] ];
pointPairAndDone.hi Ź ImagerTransformation.Transform[t, textData.points[7] ];
};
ENDCASE => SIGNAL Problem[msg: "Broken Invariant"];
pointPairGen.toGo Ź pointPairGen.toGo - 1;
pointPairGen.index Ź IF pointPairGen.toGo=0 THEN 99 ELSE index+1; -- bump to the next available pair in the generator
};
};

PointIsInBox: PROC [test: Point, box: BoundBoxObj] RETURNS [BOOL Ź FALSE] = {
RETURN[ NOT (test.x < box.loX OR test.x > box.hiX OR test.y < box.loY OR test.y > box.hiY) ];
};

TextClosestPoint: PROC [sliceD: SliceDescriptor, testPoint: Point, tolerance: REAL] RETURNS [bestPoint: Point, bestDist: REAL, bestNormal: Vector Ź [0,-1], hitData: REF ANY, success: BOOL Ź FALSE] = {
index: NAT Ź 9999;
textData: TextData Ź NARROW[sliceD.slice.data];
tightBox: BoundBox Ź GGSliceOps.GetTightBox[sliceD.slice]; -- update may be required
bigBox: BoundBoxObj Ź [tightBox.loX-tolerance, tightBox.loY-tolerance, tightBox.hiX+tolerance, tightBox.hiY+tolerance, FALSE, FALSE]; -- box in GG coordinates
IF PointIsInBox[testPoint, bigBox] THEN {
textParts: TextParts Ź NARROW[sliceD.parts];
localTestpoint: Point Ź GGTransform.Transform[textData.inverse, testPoint];
localTolerance: REAL Ź ABS[tolerance*MAX[textData.inverseScale.x, textData.inverseScale.y]]; -- MAX function is not correct when text is skewed.
[bestDist, index, bestPoint, success] Ź TextNearestPoint[textData.points, localTestpoint, localTolerance, textParts.points];
IF success THEN {
bestPoint Ź GGTransform.Transform[textData.fontData.transform, bestPoint];
bestDist Ź Vectors2d.Distance[testPoint, bestPoint];
hitData Ź NEW[TextHitDataObj Ź [point: index, edge: -1, hitPoint: bestPoint] ];
};
};
};

TextClosestJointToHitData: PROC [sliceD: SliceDescriptor, mapPoint, testPoint: Point, hitData: REF ANY] RETURNS [jointD: SliceDescriptor, point: Point, normal: Vector] = {
bestDist: REAL;
newHitData: REF ANY;
textHitData: TextHitData;
textParts: TextParts Ź NEW[TextPartsObj Ź [points: ALL[FALSE], edges: ALL[FALSE], includeText: FALSE ] ];
success: BOOL Ź FALSE;
[point, bestDist, normal, newHitData, success] Ź GGSliceOps.ClosestPoint[sliceD, mapPoint, GGUtility.plusInfinity];
textHitData Ź NARROW[newHitData];
textParts.points[textHitData.point] Ź TRUE;
jointD Ź GGSlice.DescriptorFromParts[slice: sliceD.slice, parts: textParts];
};

TextClosestSegment: PROC [sliceD: SliceDescriptor, testPoint: Point, tolerance: REAL] RETURNS [bestPoint: Point, bestDist: REAL, bestNormal: Vector Ź [0, -1], hitData: REF ANY, success: BOOL Ź FALSE] = {
textData: TextData Ź NARROW[sliceD.slice.data];
tightBox: BoundBox Ź GGSliceOps.GetTightBox[sliceD.slice]; -- update may be required
bigBox: BoundBoxObj Ź [tightBox.loX-tolerance, tightBox.loY-tolerance, tightBox.hiX+tolerance, tightBox.hiY+tolerance, FALSE, FALSE]; -- box in GG coordinates
IF PointIsInBox[testPoint, bigBox] THEN {
seg: NAT Ź 9999;
textHitData: TextHitData;
textParts: TextParts Ź NARROW[sliceD.parts];
localTestpoint: Point Ź GGTransform.Transform[textData.inverse, testPoint];
localTolerance: REAL Ź ABS[tolerance*MAX[textData.inverseScale.x, textData.inverseScale.y]]; -- MAX function is not correct when text is skewed.
[bestDist, seg, bestPoint, success] Ź TextNearestEdge[textData.points, localTestpoint, localTolerance, textParts.edges];
IF success THEN {
bestPoint Ź GGTransform.Transform[textData.fontData.transform, bestPoint];
bestDist Ź Vectors2d.Distance[testPoint, bestPoint];
hitData Ź textHitData Ź NEW[TextHitDataObj Ź [point: -1, edge: seg, hitPoint: bestPoint] ];
bestNormal Ź Vectors2d.Sub[testPoint, bestPoint];
};
};
};

TextNearestPoint: PROC [points: TextPoints, testPoint: Point, tolerance: REAL Ź 1E6, mask: TextPointArray ] RETURNS [bestDist: REAL, bestPoint: NAT, bestXY: Point, success: BOOL Ź FALSE] = {
thisPoint: Point;
thisDist2, bestDist2: REAL;
tolerance2: REAL Ź tolerance*tolerance;
index: NAT Ź 0;
bestXY Ź [-1.0, -1.0];
bestDist2 Ź 1E12; -- better be big enough
bestPoint Ź 9999;
FOR index IN [0..textMaxPoints) DO
IF mask[index] THEN {
thisPoint Ź points[index]; -- use tightBox relative coordinates
thisDist2 Ź Vectors2d.DistanceSquared[thisPoint, testPoint];
IF thisDist2 < bestDist2 THEN {
bestDist2 Ź thisDist2;
bestPoint Ź index;
bestXY Ź thisPoint;
};
};
ENDLOOP;
bestDist Ź RealFns.SqRt[bestDist2];
IF bestDist < tolerance THEN success Ź TRUE;
};

TextNearestEdge: ENTRY PROC [points: TextPoints, testPoint: Point, tolerance: REAL Ź 1E6, mask: TextEdgeArray Ź ALL[TRUE] ] RETURNS [bestDist: REAL, bestSeg: NAT, bestPoint: Point, success: BOOL Ź FALSE] = {
thisPoint: Point;
thisDist2, bestDist2: REAL;
tolerance2: REAL Ź tolerance*tolerance;
index: NAT Ź 0;
bestPoint Ź [-1.0, -1.0];
bestDist2 Ź 1E12; -- better be big enough
bestSeg Ź 9999;
FOR index IN [0..textMaxEdges) DO
IF mask[index] THEN {
SELECT index FROM
0 => Lines2d.FillEdge[points[0], points[3], scratchEdge ];
1 => Lines2d.FillEdge[points[3], points[11], scratchEdge ];
2 => Lines2d.FillEdge[points[11], points[8], scratchEdge ];
3 => Lines2d.FillEdge[points[8], points[0], scratchEdge ];
4 => Lines2d.FillEdge[points[1], points[9], scratchEdge ];
5 => Lines2d.FillEdge[points[2], points[10], scratchEdge ];
6 => Lines2d.FillEdge[points[4], points[7], scratchEdge ];
ENDCASE => ERROR;
thisPoint Ź Lines2d.NearestPointOnEdge[testPoint, scratchEdge];
thisDist2 Ź Vectors2d.DistanceSquared[thisPoint, testPoint];
IF thisDist2 < bestDist2 THEN {
bestDist2 Ź thisDist2;
bestSeg Ź index;
bestPoint Ź thisPoint;
};
};
ENDLOOP;
bestDist Ź RealFns.SqRt[bestDist2];
IF bestDist < tolerance THEN success Ź TRUE;
};

TextSetStrokeColor: PROC [slice: Slice, parts: SliceParts, color: Imager.Color, setHow: ATOM, history: HistoryEvent] = {
textData: TextData Ź NARROW[slice.data];
SELECT setHow FROM
$Set => textData.shadowColor Ź color;
$ChangeHue => {
newColor: Color Ź GGUtility.ChangeHue[textData.shadowColor, color];
textData.shadowColor Ź newColor;
};
ENDCASE => ERROR;
};

TextGetStrokeColor: PROC [slice: Slice, parts: SliceParts] RETURNS [color: Imager.Color, isUnique: BOOL Ź TRUE] = {
textData: TextData Ź NARROW[slice.data];
color Ź textData.shadowColor;
};

TextSetDefaults: PROC [slice: Slice, parts: SliceParts, defaults: DefaultData, history: HistoryEvent] = {
textData: TextData Ź NARROW[slice.data];
textParts: TextParts Ź NARROW[parts];
router: MsgRouter Ź Feedback.EnsureRouter[$Gargoyle];
IF textParts=NIL OR textParts.includeText THEN {
[] Ź SetTextFont[slice, defaults.font, router, NIL];
textData.color Ź defaults.textColor;
IF defaults.dropShadowOn THEN DropShadowOn[slice, defaults.dropShadowOffset, NIL] ELSE DropShadowOff[slice, NIL];
textData.shadowColor Ź defaults.dropShadowColor;
};
};

TextSetFillColor: PROC [slice: Slice, parts: SliceParts, color: Imager.Color, setHow: ATOM, history: HistoryEvent] = {
textData: TextData Ź NARROW[slice.data];
SELECT setHow FROM
$Set => textData.color Ź color;
$ChangeHue => {
newColor: Color Ź GGUtility.ChangeHue[textData.color, color];
textData.color Ź newColor;
};
ENDCASE => ERROR;
};

TextGetFillColor: PROC [slice: Slice, parts: SliceParts] RETURNS [color: Imager.Color, isUnique: BOOL Ź TRUE] = {
textData: TextData Ź NARROW[slice.data];
RETURN[textData.color];
};

dropScale: REAL Ź 0.1; -- ratio of drop shadow displacement to font size
scratchEdge: GGBasicTypes.Edge Ź Lines2d.CreateEmptyEdge[]; -- global storage used in TextNearestEdge

END.
  .  
GGSliceImplB.mesa
Contents:  Implements Text slice class in Gargoyle.
Copyright Ó 1987, 1988, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.
Kurlander, July 17, 1987 11:30:09 am PDT
Eisenman, July 22, 1987 6:32:21 pm PDT
Pier, December 1, 1992 11:14 am PST
Bier, on December 3, 1992 5:28 pm PST
Doug Wyatt, April 16, 1992 4:07 pm PDT

Text Slice Class

 [Artwork node; type 'ArtworkInterpress on' to command tool] 
Text Points as shown
Text Edges: 0 => left, 1=> top, 2=> right, 3=> bottom, 4 => baseline, 5 => horizontal centerline, 6 => vertical centerline
IMPORTANT CONVENTION FOR TEXT SLICES:
The procedure TextSetBoundBox maintains not only the bound and tight boxes but the data array textData.points as well. Any code that uses textData.points must be sure and call TextGetBoundBox or TextGetTightBox before using textData.points to force update of textData.points if needed before use.
Text-Only Data and Procs
The following 7 values are of interest:
left:	<the origin of the first character> = 0.0.
right:	<the right escapement of the last character> = Width[string].
middle:	(left + right) / 2.
top:	<the ascender extent of the string "acbdefghijklmnopqrstuvwxyzACBDEFGHIJKLMNOPQRSTUVWXYZ">
base:	0.0
bottom:	<the descender extent of the string "acbdefghijklmnopqrstuvwxyzACBDEFGHIJKLMNOPQRSTUVWXYZ">
center:	(top + bottom) / 2


TopBottomAnchor: TYPE = {lower, base, center, upper};
Filled in by TextClosestPoint, TextClosestSegment, in same order as TextPointArray and TextEdgeArray. -1 means not hit
Fundamentals
Drawing
Transforming
Textual Description
Parts
Part Generators
Hit Testing
Style
Other font related values must be filled in by client call to SetTextFont
A fontName is a font designation with family, size, and face, like Helvetica23BI or TimesRoman6.95 (real font sizes are OK)
can't user IO.GetInt because a string like Helvetica9BI causes it to fail!
The text slice's font will be set using fontData.  IF andTransform, fontData.transform will be used unmodified ELSE the translation component of the existing slice transform will be used.  If fontData.transform=NIL, the scale component of the new transform is set to fontData.scale and the rotation component to 0.

Avoid finding an already substituted font.  Just use the substitution.
Why we get any error other than Imager.Error is not clear, but we do
IF screenFont # NIL THEN textData.screenFont Ź screenFont
ELSE textData.screenFont Ź GGFont.AlternateFont[fontData, textData.trueFont, $visible];
defer setting screenFont until it is really needed
Takes a complex name like "xerox/pressfonts/Helvetica-MIR" and a font size and returns a simple name like Helvetica10I
The tight box should still be OK.
Modified starting from ImagerRasterShowImpl.BasicShowChar.
Text Class Procs
Fundamental

ASSERT: extents all positivesubtract left and descent, add right and ascent
base is the "origin" point for the text
bounding box calculations always ignored parts and calculated the boxes for the complete rope.  So be it.
updating boxes in place saves lots of allocations, as does trafficking in ImagerBox.Boxes which are RECORDS
The slice tightBox, by definition, contains the control points, which can be far away from the actual extent of the rope. So it goes.
Update textData.box amd find bounding boxes
The slice.boundBox will be bigger, taking into account the fontExtentRope bounds and the possibility of drop shadows and selected and hot joints.  This is necessary for refresh to work correctly.
keep the text points where they always were for backwards compatibility
set up cache for fast case next time around, because we ignore parts and always get the boxes for the full slice
live dangerously and return the actual boundBoxes inside the slice instead of copies since thats what the cache does anyway.
ASSERT: extents all positivesubtract left and descent, add right and ascent
cpBottom, cpCenter, and cpTop are the y coordinates to use for the Text control points
IF textData.displayStyle = print OR textData.screenFont = NIL
Update textData.box amd find boundBox.
GGModelTypes.SliceBoundBoxProc
GGModelTypes.SliceBoundBoxProc
GGModelTypes.SliceCopyProc
Just ignore parts and copy the whole slice.
MakeTextSlice allocates but does not assign fields: box, points, fontData, and seg.
MakeTextSlice puts dummy values into trueFont, screenFont, inverse, inverseScale, and lineSpacing
GGModelTypes.SliceRestoreProc
from and to must be nearly identically structured slices, probably because from was made as a copy of to.  Restore the contents of "to", getting all non-REF values from "from".  Good luck.
to.nullDescriptor is always valid
to.fullDescriptor is unused


Drawing
GGModelTypes.SliceDrawPartsProc
GGModelTypes.SliceDrawSelectionFeedbackProc
If any joint was hit, feedback all the joints
If any edge was hit, feedback that edge and joints that touch that edge
Assume a simple descriptor with only one edge selected
called with the dc transformation already set to object coordinates
N.B.: camera quality and displayStyle take precedence over textData displayStyle
GGCoreOps.SetColor[dc, IF textData.color=NIL THEN Imager.black ELSE textData.color];
called with the dc transformation already set to object coordinates
GGCoreOps.SetColor[dc, IF textData.shadowColor=NIL THEN Imager.black ELSE textData.shadowColor];
N.B.: camera quality and displayStyle take precedence over textData displayStyle
This proc should only be called by callers who really need the screenFont.  Callers that are copying or otherwise using the screenFont REF should do so directly and not call this proc.
GGModelTypes.SliceDrawTransformProc

Transforming
GGModelTypes.SliceTransformProc
IF InvolvesScaling[transform] THEN textData.screenFont Ź GGFont.AlternateFont[fontData, textData.trueFont, $visible];
relys on deferred evaluation if the transformed screenFont is every really needed

Textual Description
GGModelTypes.SliceDescribeProc
GGModelTypes.SliceFileoutProc
Write a description of yourself onto stream f.
GGModelTypes.SliceFileinProc
Read a description of yourself from stream f.
Get the comfortable bit if it is there
Get the text
Get the prefix
Get the family and face and size
now manufacture the stuff needed by SetTextFont. Use the parser!
have: prefix, family, face, transform, size, preferredSize
get color
Handle Drop Shadows

Hit Testing
GGModelTypes.SliceNewPartsProc
GGModelTypes.SliceUnionPartsProc
GGModelTypes.SliceMovingPartsProc
If anything is moving, everything is dragging.  Otherwise, leave it in the background.
GGModelTypes.SliceAugmentPartsProc
For every edge, add its corresponding points
Text slices have only one "segment" whose entire purpose is to contain properties in seg.props
Text slices have only one "segment" whose entire purpose is to contain properties in seg.props
GGModelTypes.SliceClosestPointProc
GGModelTypes.SliceClosestJointToHitDataProc
GGModelTypes.SliceClosestSegmentProc
hitData _ NIL;  -- automatically done by compiler
Finds the point which is in mask and nearest to testPoint (and its distance from testPoint).  Number the points as shown in the picture above
Finds the edge which is in mask and nearest to testPoint (and its distance from testPoint).  
Style
 ĘOŮ  NewlineDelimiter
"cedarcode" style codeKĎn+3K
ĎeITK(K&&K#K%K&Idefault LK Ďk		KöżK Ďc/KK7ÇKK IartworkFigure
InterpressInterpress/Xerox/3.0  f j k jĄĽÄ  WB ¤ ¨  ě	ĄŁ={ ˘ ¨ r jÄç­ ˘ ¨ĄĄ¨ÄWB   ¤ ¨ r jĄĽÄ  WB ¤ ¨ĄĄ¨ r jĄĄ¨˘Ż1Ë1ĄšĄĄ¨˘Ż18ĄšĄĄ¨˘Ż88ËĄšĄĄ¨˘Ż8Ë1ËĄš k é˘ŻĄĄ¨˘ˇ1Ú8˘ŻĄĄ¨˘ˇ8Ä 1˘ŻĄĄ¨˘ˇÄ) Ë r jÄů 
Ä­  ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á0ĄĄ¨ k é r jÄł 0ÄŤ  ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á1ĄĄ¨ k é r jÄ× 0Ä m  n ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á2ĄĄ¨ k é r jÄ1 eÄ áň   ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á3ĄĄ¨ k é r jÄ"§Ě ¤Ä\¤ ŁÄ Ă  p ˘ Ľ ¨ĹXeroxĹ
PressFontsĹHelvetica-mrrŁĄ Ş ¤    ĄĄ¨  Á	qwil jrutĄĄ¨ k é r jˇÄ9  ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á4ĄĄ¨ k é r jÄ
  ůÄĎ  ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á5ĄĄ¨ k é r jÄ^Ř WÄAŻ ˙ ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á6ĄĄ¨ k é r jÄM Äĺ  ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á7ĄĄ¨ k é r jÄE ÄE  ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á8ĄĄ¨ k é r jÄ w  RÄJĹ = ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á9ĄĄ¨ k é r jÄM× 0Ä
mk ý ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á10ĄĄ¨ k é r jÄM­ 0Ä  ˘ ¨ĹXeroxĹ
PressFontsĹHelvetica-brrŁĄ Ž ¤    ĄĄ¨  Á11ĄĄ¨ k é k é k é k gArtwork
InterpressBounds:0.0 mm xmin 0.0 mm ymin 117.1222 mm xmax 37.04167 mm ymax G39.86389 mm topLeading 39.86389 mm topIndent 1.411111 mm bottomLeading ==IartworkCaptionNzK K
&K,K#K)KK-K/K 5K+K*KK
!K1K!K3K"9K#;K&AK1K!K	'K!7K$=K#;K!5K+K!K+K1K 5K#;K
'K+K'<KK#K
'K K)K1K/K!7K K K;K Ďb%%K¨head'K0KDKK_K	KcKK KK K& IK K 2p )iK 9KOKKKRK7K5K<KK K.K 5K KK
!K 9HK )K" @bKKKKKK$ @K. EK 9OK ?YKKKK DlK LYKK K#K *BK (>K ,>KK K'KvvK 9K 6KKK K$K CK	K "?KĄKK ;KKKĄKKKK!K1K1K#''KĄKĄKKKKĄKK%KKKKKK))KĄK+K3K3K/KKK!KĄKK1K33K##K11K'K+/KĄKK#K#KKK#K#K#K#KKKKKKK#K"KKK AS(K  'GKK ,KKKStartOfExpansion[]# 3KKKKK##KKN[p0: Lines2dTypes.Point, p1: Lines2dTypes.Point, props: LIST OF REF ANY]AEKKĄIIK! #DK&KKK&K% 'LK% 'LK
KKK C
!<K4K
;KKK 
AK![KK 8KK!/KK $KKK 
;KK!/KK2 @KKK 
AKK!/KK)K+  [
 (TKD ]KK7 /K KKK KKV _KKK 
K
3KK Kx{	:KK
YKKK	 =c !
YKKKK-K	 $AKKK KK[pName: ROPE]	)K	 :y"JKĄĐbkĄ=JK -zK#3KK NK)@KK NK)?KK EMŮK3:`dşK K==KKK!6K(K!/%KK3K(K:K(K:KHK #@KKK(K+K/cŢK "V
:KFFKĄĄ#KĄĄĄ*MKDKK

KKKKKKKK
KKKp[prefix: ATOM, family: ATOM, face: NodeStyle.FontFace, size: REAL, alphabets: NodeStyle.FontAlphabets]EĄ!ŽKĄĄ
ĄĄwKK  /OK!9KSWCKĄ22K  5UK:KHKKww
K

KzzK
KK[fileName: ROPE, accessOptions: FS.AccessOptions _ read, streamOptions: FS.StreamOptions _ (5)[TRUE, TRUE, TRUE, TRUE, TRUE], keep: CARDINAL _ 1B (1), createByteCount: FS.ByteCount _ 2560, streamBufferParms: FS.StreamBufferParms _ [vmPagesPerBuffer: 8, nBuffers: 2], extendFileProc: FS.ExtendFileProc, wantedCreatedTime: GMT _ nullGMT, remoteCheck: BOOL _ TRUE, wDir: ROPE _ NIL]		˘K?TKJ!UĆK
KKgB­K
KKKK 
DK[oldStream: STREAM _ NIL]		K!3K	 7KK(KKR[format: ROPE _ NIL, v1: IO.Value _ [null[]], v2: IO.Value _ [null[]], v3: IO.Value _ [null[]], v4: IO.Value _ [null[]], v5: IO.Value _ [null[]]]K3KKYK[format: ROPE _ NIL, v1: IO.Value _ [null[]], v2: IO.Value _ [null[]], v3: IO.Value _ [null[]], v4: IO.Value _ [null[]], v5: IO.Value _ [null[]]]6:KyyKKK KK HKK!4KKKK 
CKKK[oldStream: STREAM _ NIL]		K!4KKKGGKMY
§K!YâKK 
JKK!4KK.4KK ^KvvKK( !IK  %EK)[s: ROPE, pos: INT _ 0, skip: ROPE]U i4DK%K	&K	&K
'KKKK /q )K(K%KKKK 
P )K(KKKKK :S )K(KK#KKKK *D )K(KKKKK ;!)K(KIOKKK +\!)K(K'-KKK 7-ą!)K(K0K$:KKK 
A!)K(KKKKK \!)K(K#KKK FfK(K&IK!K%KK hK(K'KK+K 7X4,K::K%4"?K3KKK((K  #-KK--KKKKK	K	_K	TK''K	,KK%@KKK	K
K))K**K@K6KK
K@K0KOK 
GtK
$$KK*"*KKKK-KKKKK $	KVVK/5KK FeK$K"K$K!K&K$K&K#K%K#K&K#KK K:SK
':KFLK'K K)4K6 TKĄ*5K2 PK 8K! @ 1NKĄ4?K 8K! @KK..KK $"mKiKkKK(K'K dyK ŕőK CXKKĄZ}KĄPK	KĄĄ
R K KĄ++KĄĄĄĄĄ c¸KĄ2 lKĄ  5rK KĂKĄĄ *TKĄ> "yKĄh źK6 pKĄ( ŕK KGKĄ( t ÖK K ppK$ AK 8O 3OK|KKKK J '9ĄKFLKVVK  KK3KK5KKKKKK?KK KK"KK $"j##cK(K'KK7<K(-K K:ĄZĽK=KĄAKGKK=ĄĄRŽK KĄ&&KKKKKOK..KĄ	(1K K+ZKĄ	>GK KQQKK KĄ Q .BK$ AKKKK 3OKKK #SKK IK	&- KK K# -- [cluster: GGModelTypes.Cluster]# -- [cluster: GGModelTypes.Cluster]#SKK tK"[K	 ^KK $XKK++KKK(K	K5K K	4ĄĄĄĄSK
%ĄĄ
ĄĄĄaKŮK"K *KDDKKK	K""KK!!K	K K[seg: GGSegmentTypes.Segment]8K9K66KKK .KKźK!K"K"K'K
#K 	ĄK	ĄĎtŁ
ĄŁK	ĄŁŁ
ĄŁ"KŁŁ
ŁKŁŁ
ŁKŁŁ
Ł$KŁŁ
Ł$KŁŁ

Ł(KŁŁ
Ł,KŁŁ
Ł"KŁŁ
Ł,KŁŁ
Ł,KŁŁ
Ł,KŁŁ
Ł4KŁŁ
Ł4KŁŁ
Ł*KŁŁ
Ł*K
ŁŁ
ŁKKK K K) :K 5K 2K 5K 4K!KKK&KKKK"KK K KK KK K$:}K
K-JK&&KK(K%KOKK źK+K2?KK)K(K8K
IK
2K(K K!EK<KSKJK	GK
#oK
	'j	NKPK$  DKF[slice: GGModelTypes.Slice, pointGen: GGModelTypes.PointGenerator]KK	#KEE)KHHKK ŠČK,K	K$  D	K?KK""+K>K#IKATKD\K
1aKKK""KK WKĆK	

48OK""K++K))K*?K*?KK	K<K$  D	K?KK""K>[context: Imager.Context, strokeJoint: Imager.StrokeJoint]!!KK-NK00KKGK6KK"9K2K$;K1K1K2K"9KKKKKK(K-K'K
#RKK NeKCK"KPKĄ K	TK( 3[K00K )GK3 ,_K##KK NkKCKXaK	`K. /]K00KKPKĄ K )GK3 ,_K##KK(K$$KK ĐbnLK¸:KGKKK ¤${šK##¤KK&JK&KK(K''KK K K$n¨KK(K'KPKCKHKEKQKSu=KQKKK K 2YK	K2<K
0K
0KKK KJKKKKK2K!'KKKK&KKKKK#AK

AK/KK TK
+KK+GK)IKK/KK 2KK.K(K'K[f: STREAM, bool: BOOL]FKdIÍK66KNnK)K
KK
K44K
K/KK$K.KIproc+0P. rK?KK 
%lKĄ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KKK 5KĄKK KĄ   1MKK ,NKK 7YK!KKK2 GK &9K 6XK!KK 8K &9K UvK!KK &9K 9KKK	 -KKK,K&KK
!ŁcKKĄ@@K::K)[rope: ROPE, oldStream: STREAM _ NIL]#KŁ	ŁKŁŁĐct?K:ŁŁ	 öKK(K)[rope: ROPE, oldStream: STREAM _ NIL]$ Đbc> *HK)[rope: ROPE, oldStream: STREAM _ NIL]:	 ĘKŁ 5K KŁ 5K,K,K
: KK KĄ		K,KGKK[f: STREAM]ĄK%K*K.KKKKK  "?K&K;KMKK K5KMKK /2K K%KK 3K	K#K!K	
>KK 2KK[f: STREAM]$KK KwKß[slice: GGModelTypes.Slice, prefix: ROPE, family: ROPE, face: ROPE, faceRope: ROPE, scale: REAL _ 1.0, fontScale: REAL _ 1.0, transform: ImagerTransformation.Transformation, feedback: ViewerClasses.Viewer] (FK
2WK0@P(PKK KĄKĄ¤'KĄ¤'K2[slice: GGModelTypes.Slice, lineSpacing: REAL] K/4K KK K K+K%KKKKK 

?K%KrKK 
<K%KxKK 
KKKK 
NK!KK 
kKK
+K
iK'GK%IKK

K&+KK	KK	KK,K  juK	K
K&K',KKK(K$)KKKKKK11
 "KKK7KK 4mK  K-K-KK

+K	*K	*K
['K*BK&K(?KK.HK=KK 4mK-K-KK

+K
+PK	"K
]'K	RK&K	OKK	XK>KK |9ŃK!!KVVK
fK
l <KKKK  K#K$K$KKAK6;K5KK 8qK""K,KiK,&(K	sKYK	uKXKXKYK	sKKK;KK ]K(K$9K	$ 9+K#>KKK 7WK(K/K'KK	$ 9+KZKKKKK 'iK(K	$ 9K( \)K+DKKK _K^K(K	
 h)K  JKKK $_K^K(K		pKK *.{K6K6KKKKK *.r
+KKKK*K/K'K,KK!BK +QKKaK K
 4nKKK 263KKKK.K/K,KFKK%EK )NKK# %N 4FKMKMKKMKNKKNKMKKMKMKKMKMKKMKNKKMKMKK"3K*K
 3uKKK 
!MK
]KK 8(ČK"KK/K; TKw !)K,KKK5 3K|	KJK4K
BOKKKK 
@<ŤK++K
KKK
iK	K YsK!K&+K?[slice: GGModelTypes.Slice, parts: GGModelTypes.SliceParts]LKK 8)ËK$$K
 !1K/K; TKw !)KKK,KKK5 3Kx	KJK4K@[K1KKKK 3žKKKK'KKK )K"K $?K<KKKKKKK#K,KK 3Ď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 K@xK(K%KCK KKKK 
#!sK(KKK TiK(K%K50KĄ4K$K
0qK0KKK @vK(KK=KKKKK 
#!qK(KKK K 1HK< )eK K     
 v 