DIRECTORY
Ascii, Atom, AtomButtons, BasicTime, --CombinePoly,-- CubicSplines, FS, GGAlign, GGBasicTypes, GGBoundBox, GGCaret, GGError, GGEvent, GGFont, GGFromImager, GGGravity, GGInterface, GGInterfaceTypes, GGModelTypes, GGMultiGravity, GGObjects, GGOutline, GGParseOut, GGRefresh, GGSegment, GGSegmentTypes, GGSelect, GGSequence, GGShapes, GGSlice, GGStatistics, --GGTouch,-- GGTraj, GGUtility, GGVector, GGWindow, Imager, ImagerInterpress, ImagerTransformation, Interpress, IO, IPMaster, MessageWindow, --PrincOpsUtils,-- RealFns, Random, Rope, Rosary, ViewerTools;

GGEventImplA: CEDAR PROGRAM
IMPORTS Atom, AtomButtons, BasicTime, --CombinePoly,-- FS, GGAlign, GGBoundBox, GGCaret, GGError, GGEvent, GGFont, GGFromImager, GGGravity, GGInterface, GGMultiGravity, GGObjects, GGOutline, GGParseOut, GGRefresh, GGSegment, GGSelect, GGSequence, GGShapes, GGSlice, GGStatistics, --GGTouch,-- GGTraj, GGUtility, GGVector, GGWindow, Imager, ImagerInterpress, ImagerTransformation, Interpress, IO, MessageWindow, --PrincOpsUtils,-- Random, RealFns, Rope, ViewerTools
EXPORTS GGEvent = BEGIN

BoundBox: TYPE = GGBoundBox.BoundBox;
Slice: TYPE = GGModelTypes.Slice;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
EntityGenerator: TYPE = GGModelTypes.EntityGenerator;
FeatureData: TYPE = GGInterfaceTypes.FeatureData;
GargoyleData: TYPE = GGInterfaceTypes.GargoyleData;
Joint: TYPE = GGModelTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
ObjectBag: TYPE = GGGravity.ObjectBag;
OutlineDescriptor: TYPE = GGModelTypes.OutlineDescriptor;
TriggerBag: TYPE = GGGravity.TriggerBag;
Outline: TYPE = GGModelTypes.Outline;
Point: TYPE = GGBasicTypes.Point;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegAndIndex: TYPE = GGSequence.SegAndIndex;
Sequence: TYPE = GGModelTypes.Sequence;
SliceParts: TYPE = GGModelTypes.SliceParts;
Traj: TYPE = GGModelTypes.Traj;
TrajGenerator: TYPE = GGModelTypes.TrajGenerator;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SequenceGenerator: TYPE = GGModelTypes.SequenceGenerator;
Vector: TYPE = GGBasicTypes.Vector;
FontData: TYPE = GGFont.FontData;

NotYetImplemented: PUBLIC SIGNAL = CODE;

EnterEditingMode: PROC [gargoyleData: GargoyleData, refChar: REF CHAR] = {
IF refChar^=Ascii.BS THEN { -- try to enter editing of a single selected text slice
sliceDescGen: SliceDescriptorGenerator _  GGSelect.SelectedSlices[gargoyleData.scene, normal];
sliceDesc: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen];
IF sliceDesc=NIL OR sliceDesc.slice.class.type#$Text OR GGSelect.NextSliceDescriptor[sliceDescGen]#NIL THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select a single text slice for editing", oneLiner];
GGError.Blink[gargoyleData.feedback];
RETURN;
};
GGSelect.DeselectSlice[slice: sliceDesc.slice, parts: sliceDesc.parts, scene: gargoyleData.scene, selectClass: normal];
gargoyleData.refresh.textInProgress _ sliceDesc.slice; -- successfully enter editing mode
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, gargoyleData: gargoyleData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
}
ELSE {
slice: Slice _ gargoyleData.refresh.textInProgress _ NewTextSlice[text: Rope.FromChar[refChar^], gargoyleData: gargoyleData]; -- start a new text slice
IF slice=NIL THEN RETURN; -- can't start a string with whitespace
gargoyleData.refresh.startBoundBox^ _ slice.boundBox^;
gargoyleData.refresh.addedObject _ slice;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectAdded, gargoyleData: gargoyleData, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};
}; -- end EnterEditingMode

AddChar: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
slice: Slice;
obBox: BoundBox;
refChar: REF CHAR;
IF NARROW[event.first, ATOM]#$AddChar THEN ERROR;
refChar _ NARROW[event.rest.first];
IF gargoyleData.refresh.textInProgress=NIL THEN {
GGCaret.NoAttractor[gargoyleData.caret]; -- so the feedback goes away.
EnterEditingMode[gargoyleData, refChar];
RETURN;
}
ELSE { -- add to textInProgress
GGStatistics.StartInterval[$AddChar, GGStatistics.GlobalTable[]];
slice _ gargoyleData.refresh.textInProgress;
obBox _ GGBoundBox.CopyBoundBox[slice.boundBox]; -- remember old bound box for now
IF refChar^=Ascii.BS THEN {
GGSlice.BackspaceText[slice: slice];
gargoyleData.refresh.startBoundBox^ _ slice.boundBox^; -- bBox was updated by GGSlice
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: obBox];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
}
ELSE {
GGSlice.AppendText[slice: slice, text: Rope.FromChar[refChar^] ];
gargoyleData.refresh.startBoundBox^ _ slice.boundBox^; -- boundBox was updated by GGSlice
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: obBox];
gargoyleData.refresh.addedObject _ slice;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectAdded, gargoyleData: gargoyleData, remake: none, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};
GGStatistics.StopInterval[$AddChar, GGStatistics.GlobalTable[]];
};
}; -- end AddChar

NewTextSlice: PRIVATE PROC [text: Rope.ROPE, gargoyleData: GargoyleData] RETURNS [slice: Slice] = {
caretPos: Point _ GGCaret.GetPoint[gargoyleData.caret];
success: BOOL _ FALSE;
fontData: FontData _ GGFont.CopyFontData[defaultFontData];
slice _ GGSlice.MakeTextSlice[text];
fontData.transform _ ImagerTransformation.TranslateTo[defaultFontData.transform, caretPos];
success _ GGSlice.SetTextFontAndTransform[slice, fontData, gargoyleData.feedback];
IF NOT success THEN ERROR;
GGObjects.AddSlice[gargoyleData.scene, slice, -1];
gargoyleData.refresh.startBoundBox^ _ slice.boundBox^;
GGSelect.DeselectAll[gargoyleData.scene, normal]; -- speeds up text entry
gargoyleData.refresh.addedObject _ slice;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectAdded, gargoyleData: gargoyleData, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};

AddText: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
text: Rope.ROPE _ IF event.rest = NIL THEN ViewerTools.GetSelectionContents[] ELSE NARROW[event.rest.first];
[] _ NewTextSlice[text, gargoyleData];
};

AmplifySpaceFromSelection: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
amplifySpace: REAL _ NARROW[event.rest.first, REF REAL]^;
slices: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
gargoyleData.refresh.startBoundBox^ _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal]^; -- remember original bound box
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[slices], GGSelect.NextSliceDescriptor[slices] UNTIL sliceD=NIL DO
GGSlice.SetTextAmplifySpace[sliceD.slice, amplifySpace, gargoyleData.feedback];
ENDLOOP;
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: FALSE]; -- GGSlice.SetTextAmplifySpace can post error messages
}; -- end AmplifySpaceFromSelection

PrintAmplifySpace: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
sliceDesc: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen];
IF sliceDesc=NIL OR sliceDesc.slice.class.type#$Text OR GGSelect.NextSliceDescriptor[sliceDescGen]#NIL THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select the single text slice whose amplify space need", oneLiner];
GGError.Blink[gargoyleData.feedback];
}
ELSE GGError.PutF[gargoyleData.feedback, oneLiner, "Amplify space: %g", [real[GGSlice.GetTextAmplifySpace[sliceDesc.slice]]]];

};

DropShadowOn: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
offsetX: REAL _ NARROW[event.rest.first, REF REAL]^;
offsetY: REAL _ NARROW[event.rest.rest.first, REF REAL]^;
slices: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
gargoyleData.refresh.startBoundBox^ _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal]^; -- remember original bound box
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[slices], GGSelect.NextSliceDescriptor[slices] UNTIL sliceD=NIL DO
GGSlice.DropShadowOn[sliceD.slice, [offsetX, offsetY]];
ENDLOOP;
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};

DropShadowOff: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
slices: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
gargoyleData.refresh.startBoundBox^ _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal]^; -- remember original bound box
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[slices], GGSelect.NextSliceDescriptor[slices] UNTIL sliceD=NIL DO
GGSlice.DropShadowOff[sliceD.slice];
ENDLOOP;
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};

SetFontAux: PROC [clientData: REF ANY, fontData: FontData, andTransform: BOOL _ FALSE] = {
gargoyleData: GargoyleData _ NARROW[clientData];
slices: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
gargoyleData.refresh.startBoundBox^ _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal]^; -- remember original bound box
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[slices], GGSelect.NextSliceDescriptor[slices] UNTIL sliceD=NIL DO
[] _ IF andTransform THEN GGSlice.SetTextFontAndTransform[sliceD.slice, fontData, gargoyleData.feedback] ELSE GGSlice.SetTextFont[sliceD.slice, fontData, gargoyleData.feedback];
ENDLOOP;
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: FALSE];
};

SetPressFont: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
inStream: IO.STREAM _ IO.RIS[NARROW[event.rest.first]]; -- "Cream-BI 12"
fontData: FontData _ GGFont.CreateFontData[];
fontData.prefix _ "xerox/pressfonts/"; -- default prefix for SetPressFont
fontData _ GGFont.ParseFontData[data: fontData, inStream: inStream, familyP: TRUE, faceP: TRUE, scaleP: TRUE]; -- family, face, scale
SetFontAux[clientData, fontData];
};

SetPrintFont: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
inStream: IO.STREAM _ IO.RIS[NARROW[event.rest.first]]; -- "Modern-BI 12"
fontData: FontData _ GGFont.CreateFontData[];
fontData.prefix _ "xerox/xc1-2-2/"; -- default prefix for SetPrintFont
fontData _ GGFont.ParseFontData[data: fontData, inStream: inStream, familyP: TRUE, faceP: TRUE, scaleP: TRUE]; -- family, face, scale
SetFontAux[clientData, fontData];
};

SetScreenFont: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
inStream: IO.STREAM _ IO.RIS[NARROW[event.rest.first]]; -- "Cream-BI 12"
fontData: FontData _ GGFont.CreateFontData[];
fontData.prefix _ "xerox/tiogafonts/"; -- default prefix for SetScreenFont
fontData _ GGFont.ParseFontData[data: fontData, inStream: inStream, familyP: TRUE, faceP: TRUE, scaleP: TRUE]; -- family, face, scale
SetFontAux[clientData, fontData];
};

SetFontDetailed: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
inStream: IO.STREAM _ IO.RIS[NARROW[event.rest.first]];
fontData: FontData _ GGFont.CreateFontData[];
fontData _ GGFont.ParseFontData[data: fontData, inStream: inStream, prefixP: TRUE, familyP: TRUE, faceP: TRUE, transformP: TRUE]; -- prefix, family, face, transform
SetFontAux[clientData, fontData];
};

SetFontLiteral: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
inStream: IO.STREAM _ IO.RIS[NARROW[event.rest.first]];
fontData: FontData _ GGFont.CreateFontData[];
fontData _ GGFont.ParseFontData[data: fontData, inStream: inStream, literalP: TRUE, transformP: TRUE, storedSizeP: TRUE, designSizeP: TRUE]; -- literal name, transform, storedSize, designSize
SetFontAux[clientData, fontData];
};

ShowFontValues: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
sliceDesc: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen];
IF sliceDesc=NIL OR sliceDesc.slice.class.type#$Text OR GGSelect.NextSliceDescriptor[sliceDescGen]#NIL THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select a single text slice for font printing", oneLiner];
GGError.Blink[gargoyleData.feedback];
}
ELSE GGError.PutF[gargoyleData.feedback, oneLiner, "Font Values: %g", [rope[GGSlice.GetFontDataRope[sliceDesc.slice]]] ];
};

ShowFontValuesLiteral: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
sliceDesc: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen];
IF sliceDesc=NIL OR sliceDesc.slice.class.type#$Text OR GGSelect.NextSliceDescriptor[sliceDescGen]#NIL THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select a single text slice for font printing", oneLiner];
GGError.Blink[gargoyleData.feedback];
}
ELSE GGError.PutF[gargoyleData.feedback, oneLiner, "Font Values: %g", [rope[GGSlice.GetFontLiteralDataRope[sliceDesc.slice]]] ];
};

CopyFont: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY]  = {
gargoyleData: GargoyleData _ NARROW[clientData];
lastDesc: SliceDescriptor;
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
lastDesc _ sliceD; -- find the LAST selected slice
ENDLOOP;
BEGIN
IF lastDesc=NIL OR lastDesc.slice.class.type#$Text THEN GOTO BadLastSlice
ELSE {
saveTransform: ImagerTransformation.Transformation;
oldData, copyData: FontData;
alikeRope: Rope.ROPE _ GGSlice.GetFontDataRope[lastDesc.slice];
alikeData: FontData _ GGSlice.GetFontData[lastDesc.slice];
gargoyleData.refresh.startBoundBox^ _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal]^; -- remember original bound box
sliceDescGen _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
IF sliceD.slice.class.type#$Text THEN LOOP;
oldData _ GGSlice.GetFontData[sliceD.slice];
saveTransform _ oldData.transform; -- shouldn't need to copy transformation
copyData _ GGFont.CopyFontData[data: alikeData, oldCopy: oldData]; -- reuse storage existing inside slice. CLOBBERS oldData^ !!
copyData.transform _ saveTransform;
[] _ GGSlice.SetTextFontAndTransform[sliceD.slice, copyData, gargoyleData.feedback];
ENDLOOP;
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
GGError.PutFHerald[gargoyleData.feedback, oneLiner, "Text slices with font %g selected", [rope[alikeRope]] ];
};
EXITS
BadLastSlice => {
GGError.AppendHerald[gargoyleData.feedback, "Select a final text slice for Copy Font", oneLiner];
GGError.Blink[gargoyleData.feedback];
};
END;
};

CopyAll: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY]  = {
gargoyleData: GargoyleData _ NARROW[clientData];
lastDesc: SliceDescriptor;
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
lastDesc _ sliceD; -- find the LAST selected slice
ENDLOOP;
BEGIN
IF lastDesc=NIL OR lastDesc.slice.class.type#$Text THEN GOTO BadLastSlice
ELSE {
oldTVec: ImagerTransformation.VEC;
oldData, copyData: FontData;
alikeRope: Rope.ROPE _ GGSlice.GetFontDataRope[lastDesc.slice];
alikeData: FontData _ GGSlice.GetFontData[lastDesc.slice];
gargoyleData.refresh.startBoundBox^ _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal]^; -- remember original bound box
sliceDescGen _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD=NIL DO
IF sliceD.slice.class.type#$Text THEN LOOP;
oldData _ GGSlice.GetFontData[sliceD.slice];
oldTVec _ ImagerTransformation.Factor[oldData.transform].t;
copyData _ GGFont.CopyFontData[data: alikeData, oldCopy: oldData]; -- reuse storage existing inside slice. CLOBBERS oldData^ !!
copyData.transform _ ImagerTransformation.TranslateTo[copyData.transform, oldTVec];
[] _ GGSlice.SetTextFontAndTransform[sliceD.slice, copyData, gargoyleData.feedback];
ENDLOOP;
GGBoundBox.EnlargeByBox[bBox: gargoyleData.refresh.startBoundBox, by: GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
GGError.PutFHerald[gargoyleData.feedback, oneLiner, "Text slices with font %g selected", [rope[alikeRope]] ];
};
EXITS
BadLastSlice => {
GGError.AppendHerald[gargoyleData.feedback, "Select a final text slice for Copy Literal", oneLiner];
GGError.Blink[gargoyleData.feedback];
};
END;
};

MatchAll: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
sliceDesc: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen];
IF sliceDesc=NIL OR sliceDesc.slice.class.type#$Text OR GGSelect.NextSliceDescriptor[sliceDescGen]#NIL THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select a single text slice for matching", oneLiner];
GGError.Blink[gargoyleData.feedback];
}
ELSE { -- select all the text slices with matching fontData
fontData: FontData _ GGSlice.GetFontData[sliceDesc.slice];
SelectMatchingData[fontData, gargoyleData];
};
};

MatchSelectedName: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
matchRope: Rope.ROPE _ NARROW[event.rest.first];
IF Rope.Equal[matchRope, ""] THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select substring for font matching", oneLiner];
GGError.Blink[gargoyleData.feedback];
}
ELSE SelectMatching[matchRope, gargoyleData, $userFSF];
};

MatchSelectedNameLiteral: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
matchRope: Rope.ROPE _ NARROW[event.rest.first];
IF Rope.Equal[matchRope, ""] THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select substring for literal matching", oneLiner];
GGError.Blink[gargoyleData.feedback];
}
ELSE SelectMatching[matchRope, gargoyleData, $literal];
};

SetDefaultFontValues: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: SliceDescriptorGenerator _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
sliceDesc: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen];
IF sliceDesc=NIL OR sliceDesc.slice.class.type#$Text OR GGSelect.NextSliceDescriptor[sliceDescGen]#NIL THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select a single text slice for default font setting", oneLiner];
GGError.Blink[gargoyleData.feedback];
}
ELSE {
defaultFontData _ GGFont.CopyFontData[GGSlice.GetFontData[sliceDesc.slice]];
GGError.PutF[gargoyleData.feedback, oneLiner, "New Default Font: %g", [rope[GGSlice.GetFontDataRope[sliceDesc.slice]]] ];
};
};

ShowDefaultFontValues: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
scratch: IO.STREAM _ IO.ROS[];
GGParseOut.WriteFactoredTransformationVEC[scratch, defaultFontData.transform];
GGError.PutF[gargoyleData.feedback, oneLiner, "Default Font Values: %g %g %g %g", [rope[defaultFontData.literal]], [rope[IO.RopeFromROS[scratch]]], [real[defaultFontData.storedSize]], [real[defaultFontData.designSize]] ];
};

SelectMatching: PROC [matchRope: Rope.ROPE, gargoyleData: GargoyleData, op: ATOM] = {
sliceGen: SliceGenerator _ GGObjects.SlicesInScene[gargoyleData.scene];
GGSelect.DeselectAll[gargoyleData.scene, normal];
FOR slice: Slice _ GGObjects.NextSlice[sliceGen], GGObjects.NextSlice[sliceGen] UNTIL slice=NIL DO
nextData: FontData _ GGSlice.GetFontData[slice];
IF Rope.Find[s1: IF op=$userFSF THEN nextData.userFSF ELSE nextData.literal, s2: matchRope, pos1: 0, case: FALSE]#-1 THEN GGSelect.SelectSlice[slice: slice, parts: slice.class.newParts[slice, NIL, topLevel], scene: gargoyleData.scene, selectClass: normal];
ENDLOOP;
GGError.PutFHerald[gargoyleData.feedback, oneLiner, "Text slices with fonts matching %g selected", [rope[matchRope]] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, gargoyleData: gargoyleData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
};

SelectMatchingData: PROC [fontData: FontData, gargoyleData: GargoyleData] = {
maxPixels: REAL _ 10000.0;
sliceGen: SliceGenerator _ GGObjects.SlicesInScene[gargoyleData.scene];
GGSelect.DeselectAll[gargoyleData.scene, normal];
FOR slice: Slice _ GGObjects.NextSlice[sliceGen], GGObjects.NextSlice[sliceGen] UNTIL slice=NIL DO
nextData: FontData _ GGSlice.GetFontData[slice];
IF Rope.Equal[fontData.literal, nextData.literal, FALSE] AND  RealFns.AlmostEqual[fontData.storedSize, nextData.storedSize, -9] AND --ImagerTransformation.--CloseToTranslation[fontData.transform, nextData.transform, maxPixels]  THEN GGSelect.SelectSlice[slice: slice, parts: slice.class.newParts[slice, NIL, topLevel], scene: gargoyleData.scene, selectClass: normal];
ENDLOOP;
GGError.PutFHerald[gargoyleData.feedback, oneLiner, "Text slices with font %g selected", [rope[fontData.literal]] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, gargoyleData: gargoyleData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
};

ReadIP: PROC [ipName: Rope.ROPE, clientData: REF ANY, opName: Rope.ROPE] RETURNS [scene: Scene _ NIL] = {
ReadMaster: PROC [context: Imager.Context] = {
Imager.ScaleT[context, 2834.646]; -- pointsPerMeter=2834.646
Interpress.DoPage[master: ipmaster, page: 1, context: context, log: NIL];
};
gargoyleData: GargoyleData _ NARROW[clientData];
ipmaster: Interpress.Master _ NIL;
fullName: Rope.ROPE;
startTime, endTime: BasicTime.GMT;
totalTime: INT;
success: BOOL _ FALSE;

[fullName, success] _ GGUtility.GetInterpressFileName[ipName, gargoyleData.currentWDir, gargoyleData.feedback];
IF NOT success THEN RETURN;
[ipmaster, success] _ GGUtility.OpenInterpressOrComplain[gargoyleData.feedback, fullName];
IF NOT success THEN RETURN;

GGError.PutF[gargoyleData.feedback, begin, "%g %g . . . ", [rope[opName]], [rope[fullName]]];
startTime _ BasicTime.Now[];
scene _ GGFromImager.Capture[action: ReadMaster ! GGFromImager.Warning => {
GGError.Append[gargoyleData.feedback, message, oneLiner];
RESUME;
};];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
GGError.PutF[gargoyleData.feedback, end, " Done in time (%r)", [integer[totalTime]]];
};

MergeIPEditable: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
ipName: Rope.ROPE _ NARROW[event.rest.first];
scene: Scene _ ReadIP[ipName, clientData, "MergeIPEditable"];
IF scene = NIL THEN RETURN;
GGSelect.DeselectAll[gargoyleData.scene, normal];
GGSelect.SelectAll[scene, normal];
gargoyleData.scene _ GGObjects.MergeScenes[back: gargoyleData.scene, front: scene];
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: FALSE];
};

MergeIPSlice: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
slice: Slice;
gargoyleData: GargoyleData _ NARROW[clientData];
shortName, fullName: Rope.ROPE;
startTime, endTime: BasicTime.GMT;
totalTime: INT;
ipMaster: Interpress.Master;
success: BOOL;

shortName _ NARROW[event.rest.first];
[fullName, success] _ GGUtility.GetInterpressFileName[shortName, gargoyleData.currentWDir, gargoyleData.feedback];
IF NOT success THEN RETURN;
[ipMaster, success] _ GGUtility.OpenInterpressOrComplain[gargoyleData.feedback, fullName];
IF NOT success THEN RETURN;
GGSelect.DeselectAll[gargoyleData.scene, normal];

GGError.PutF[gargoyleData.feedback, begin, "MergeIPSlice %g . . . ", [rope[fullName]]];
startTime _ BasicTime.Now[];

slice _ GGSlice.MakeIPSliceFromMaster[ipMaster, 2834.646, fullName, gargoyleData.feedback, NIL, NIL, FALSE];
IF slice = NIL THEN RETURN;
GGObjects.AddSlice[gargoyleData.scene, slice, -1];

endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
GGError.PutF[gargoyleData.feedback, end, " Done in time (%r)", [integer[totalTime]]];

GGSelect.SelectEntireSlice[slice, gargoyleData.scene, normal];
gargoyleData.refresh.startBoundBox^ _ slice.boundBox^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: sceneBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: FALSE];

}; -- end MergeIPSlice

IncludeIPByReference: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: GGSelect.SliceDescriptorGenerator;
sliceDescGen _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: GGSelect.SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
IF sliceD.slice.class.type = $IP THEN GGSlice.SetIncludeByValue[sliceD.slice, FALSE];
ENDLOOP;
};

IncludeIPByValue: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: GGSelect.SliceDescriptorGenerator;
sliceDescGen _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: GGSelect.SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
IF sliceD.slice.class.type = $IP THEN GGSlice.SetIncludeByValue[sliceD.slice, TRUE];
ENDLOOP;
};

ShowIPIncludeMode: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
sliceDescGen: GGSelect.SliceDescriptorGenerator;
includeByValue: BOOL;
sliceDescGen _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: GGSelect.SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
IF sliceD.slice.class.type = $IP THEN {
includeByValue _ GGSlice.GetIncludeByValue[sliceD.slice];
IF includeByValue THEN GGError.Append[gargoyleData.feedback, "include by value", oneLiner]
ELSE GGError.Append[gargoyleData.feedback, "include by reference", oneLiner];
RETURN;
};
ENDLOOP;
GGError.Append[gargoyleData.feedback, "ShowIPIncludeMode: No IP Slices selected", oneLiner];
GGError.Blink[gargoyleData.feedback];
};

ToIPAux: PROC [gargoyleData: GargoyleData, ipName: Rope.ROPE, actionAtom: ATOM, makeInterpress: PROC [dc: Imager.Context]] = {
ipRef: ImagerInterpress.Ref;
fullName: Rope.ROPE;
success: BOOL;
startTime: BasicTime.GMT;
endTime: BasicTime.GMT;
totalTime: INT;
msgRope: Rope.ROPE;

[fullName, success] _ GGUtility.GetInterpressFileName[ipName, gargoyleData.currentWDir, gargoyleData.feedback];
IF NOT success THEN RETURN;
ipRef _ ImagerInterpress.Create[fullName];
[fullName] _ FS.FileInfo[fullName]; -- append the version number
msgRope _ IO.PutFR["%g %g . . . ", [rope[Atom.GetPName[actionAtom]]], [rope[fullName]]];
GGError.Append[gargoyleData.feedback, msgRope, begin];
startTime _ BasicTime.Now[];
ImagerInterpress.DoPage[ipRef, makeInterpress, 1.0];
ImagerInterpress.Close[ipRef];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
msgRope _ IO.PutFR[" Done in time (%r)", [integer[totalTime]]];
GGError.Append[gargoyleData.feedback, msgRope, end];
GGEvent.SawTextFinish[NIL, gargoyleData];
};

ToIP: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
DoMakeInterpress: PROC [dc: Imager.Context] = {
tempQuality: GGInterfaceTypes.QualityMode;
tempStyle: GGInterfaceTypes.DisplayStyle;
pixelsPerMeter: REAL = 0.0254/72.0;
tempQuality _ gargoyleData.camera.quality;
gargoyleData.camera.quality _ quality;
tempStyle _ gargoyleData.camera.displayStyle;
gargoyleData.camera.displayStyle _ print;
Imager.ScaleT[dc, pixelsPerMeter];
GGRefresh.InterpressEntireScene[dc, gargoyleData];
gargoyleData.camera.quality _ tempQuality;
gargoyleData.camera.displayStyle _ tempStyle;
};
gargoyleData: GargoyleData _ NARROW[clientData];
ipName: Rope.ROPE _ NARROW[event.rest.first];
ToIPAux[gargoyleData, ipName, NARROW[event.first], DoMakeInterpress];
};

ToIPTestGravity: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
DoMakeInterpress: PROC [dc: Imager.Context] = {
tempQuality: GGInterfaceTypes.QualityMode;
tempStyle: GGInterfaceTypes.DisplayStyle;
pixelsPerMeter: REAL = 0.0254/72.0;
tempQuality _ gargoyleData.camera.quality;
gargoyleData.camera.quality _ quality;
tempStyle _ gargoyleData.camera.displayStyle;
gargoyleData.camera.displayStyle _ print;
Imager.ScaleT[dc, pixelsPerMeter];
TestGravity2[dc, gargoyleData];
gargoyleData.camera.quality _ tempQuality;
gargoyleData.camera.displayStyle _ tempStyle;
};
gargoyleData: GargoyleData _ NARROW[clientData];
ipName: Rope.ROPE _ NARROW[event.rest.first];
ToIPAux[gargoyleData, ipName, NARROW[event.first], DoMakeInterpress];
};

ToIPScreen: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
DoMakeInterpress: PROC [dc: Imager.Context] = {
tempQuality: GGInterfaceTypes.QualityMode;
tempStyle: GGInterfaceTypes.DisplayStyle;
pixelsPerMeter: REAL = 0.0254/72.0;
tempQuality _ gargoyleData.camera.quality;
gargoyleData.camera.quality _ quality;

tempStyle _ gargoyleData.camera.displayStyle;
gargoyleData.camera.displayStyle _ screen;

Imager.ScaleT[dc, pixelsPerMeter];
GGRefresh.InterpressEntireScene[dc, gargoyleData];

gargoyleData.camera.quality _ tempQuality;
gargoyleData.camera.displayStyle _ tempStyle;
};
gargoyleData: GargoyleData _ NARROW[clientData];
ipName: Rope.ROPE _ NARROW[event.rest.first];
ToIPAux[gargoyleData, ipName, NARROW[event.first], DoMakeInterpress];
};

ToIPLit: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
DoMakeInterpress: PROC [dc: Imager.Context] = {
switched: BOOL _ FALSE;
tempQuality _ gargoyleData.camera.quality;
gargoyleData.camera.quality _ showall;
tempStyle _ gargoyleData.camera.displayStyle;
gargoyleData.camera.displayStyle _ print;
IF AtomButtons.GetButtonState[gargoyleData.refresh.showColors] = off THEN { GGEvent.ToggleShowColors[NIL, gargoyleData];
switched _ TRUE;
};
Imager.ScaleT[dc, pixelsPerMeter];
GGRefresh.PaintEntireScene[dc, gargoyleData];
gargoyleData.camera.quality _ tempQuality;
gargoyleData.camera.displayStyle _ tempStyle;
IF switched THEN GGEvent.ToggleShowColors[NIL, gargoyleData];
};
gargoyleData: GargoyleData _ NARROW[clientData];
ipRef: ImagerInterpress.Ref;
fullName: Rope.ROPE;
success: BOOL;
pixelsPerMeter: REAL = 0.0254/72.0;
startTime: BasicTime.GMT;
endTime: BasicTime.GMT;
totalTime: INT;
msgRope: Rope.ROPE;
tempQuality: GGInterfaceTypes.QualityMode;
tempStyle: GGInterfaceTypes.DisplayStyle;
ipName: Rope.ROPE _ "litshot.ip";

[fullName, success] _ GGUtility.GetInterpressFileName[ipName, gargoyleData.currentWDir, gargoyleData.feedback];
IF NOT success THEN RETURN;
ipRef _ ImagerInterpress.Create[fullName];
msgRope _ IO.PutFR["Writing to IP file: %g . . . ", [rope[fullName]]];
GGError.Append[gargoyleData.feedback, msgRope, begin];
startTime _ BasicTime.Now[];
ImagerInterpress.DoPage[ipRef, DoMakeInterpress, 1.0];
ImagerInterpress.Close[ipRef];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
msgRope _ IO.PutFR[" Done in time (%r)", [integer[totalTime]]];
GGError.Append[gargoyleData.feedback, msgRope, end];
GGEvent.SawTextFinish[NIL, gargoyleData];
};

TestGravity2: PUBLIC PROC [dc: Imager.Context, gargoyleData: GargoyleData] = {
xRandomStream, yRandomStream: Random.RandomStream;
testPoint: Point;
x, y: INT;
totalCount, multiHitCount, uniHitCount, diffCount: NAT _ 0;
uniPoint, multiPoint: Point;
uniFeature, multiFeature: FeatureData;
currentObjects: ObjectBag;
sceneObjects: TriggerBag;
xRandomStream _ Random.Create[gargoyleData.actionArea.cw];
yRandomStream _ Random.Create[gargoyleData.actionArea.ch];
GGAlign.SetBagsForAction[gargoyleData, $CaretPos];
gargoyleData.aborted[gravitytest] _ FALSE;  -- in case there was one left over from prior abort
UNTIL totalCount > 1000 DO
IF gargoyleData.aborted[gravitytest] THEN {
gargoyleData.aborted[gravitytest] _ FALSE;
EXIT;
};
x _ Random.NextInt[xRandomStream];
y _ Random.NextInt[yRandomStream];
testPoint _ [x, y];
testPoint _ GGWindow.ViewerToWorld[viewerPoint: testPoint, gargoyleData: gargoyleData];
gargoyleData.refresh.spotPoint _ testPoint;
currentObjects _ gargoyleData.hitTest.currentObjectBag;
sceneObjects _ gargoyleData.hitTest.sceneTriggerBag;
[uniPoint, uniFeature] _ GGGravity.UniMap[testPoint, gargoyleData.hitTest.tolerance, currentObjects, sceneObjects, gargoyleData, TRUE];
[multiPoint, multiFeature] _ GGMultiGravity.Map[testPoint, gargoyleData.hitTest.tolerance, currentObjects, sceneObjects, gargoyleData, TRUE];
IF uniFeature = NIL AND multiFeature = NIL THEN {
PaintSpot[dc, gargoyleData];
totalCount _ totalCount + 1;
LOOP;
};
IF uniFeature = NIL OR multiFeature = NIL OR uniFeature # multiFeature OR uniFeature.resultType # multiFeature.resultType OR uniPoint # multiPoint THEN {
ReportResultsAndPaint2[dc, testPoint, uniPoint, uniFeature, multiPoint, multiFeature, gargoyleData];
totalCount _ totalCount + 1;
diffCount _ diffCount + 1;
IF multiFeature # NIL THEN multiHitCount _ multiHitCount + 1;
IF uniFeature # NIL THEN uniHitCount _ uniHitCount + 1;
}
ELSE {
multiHitCount _ multiHitCount + 1;
uniHitCount _ uniHitCount + 1;
totalCount _ totalCount + 1;
gargoyleData.refresh.hitPoint _ multiPoint;
PaintHitLine[dc, gargoyleData];
};
ENDLOOP;
GGError.PutF[gargoyleData.feedback, oneLiner, "Tested %g total points.  %g unihits.  %g multihits.  %g differences", [integer[totalCount]], [integer[uniHitCount]], [integer[multiHitCount]], [integer[diffCount]]];
}; -- end TestGravity2

PaintSpot: PROC [screen: Imager.Context, gargoyleData: GargoyleData] = {
Imager.SetColor[screen, Imager.black];
GGShapes.DrawSpot[screen, gargoyleData.refresh.spotPoint];
};

PaintOddHitLine: PROC [screen: Imager.Context, gargoyleData: GargoyleData] = {
Imager.SetColor[screen, Imager.black];
Imager.SetStrokeEnd[screen, round];
Imager.MaskVector[screen, [gargoyleData.refresh.spotPoint.x, gargoyleData.refresh.spotPoint.y], [gargoyleData.refresh.hitPoint.x, gargoyleData.refresh.hitPoint.y]];
GGShapes.DrawCP[screen, gargoyleData.refresh.spotPoint];
};

PaintHitLine: PROC [screen: Imager.Context, gargoyleData: GargoyleData] = {
Imager.SetColor[screen, Imager.black];
Imager.SetStrokeEnd[screen, round];
Imager.MaskVector[screen, [gargoyleData.refresh.spotPoint.x, gargoyleData.refresh.spotPoint.y], [gargoyleData.refresh.hitPoint.x, gargoyleData.refresh.hitPoint.y]];
GGShapes.DrawFilledRect[screen, gargoyleData.refresh.spotPoint, 3.0];
};

ReportResultsAndPaint2: PROC [dc: Imager.Context, testPoint: Point, uniPoint: Point, uniFeature: FeatureData, multiPoint: Point, multiFeature: FeatureData, gargoyleData: GargoyleData] = {
IF uniFeature = NIL THEN {
gargoyleData.refresh.hitPoint _ multiPoint;
}
ELSE IF multiFeature = NIL THEN {
gargoyleData.refresh.hitPoint _ uniPoint;
}
ELSE IF uniFeature # multiFeature THEN {
gargoyleData.refresh.hitPoint _ multiPoint;
}
ELSE IF uniFeature.resultType # multiFeature.resultType THEN {
gargoyleData.refresh.hitPoint _ multiPoint;
}
ELSE IF uniPoint # multiPoint THEN {
gargoyleData.refresh.hitPoint _ uniPoint;
PaintOddHitLine[dc, gargoyleData];
gargoyleData.refresh.hitPoint _ multiPoint;
}
ELSE ERROR;
PaintOddHitLine[dc, gargoyleData];
};


UnionCombine: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
GGError.AppendHerald[gargoyleData.feedback, "UnionCombine not implemented", oneLiner];
GGError.Blink[gargoyleData.feedback];
}; -- end UnionCombine

AddHoles: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
seqGen: SequenceGenerator _ GGSelect.SelectedSequences[gargoyleData.scene, normal];
fenceSeq, firstHoleSeq: Sequence;
fence, hole: Traj;
outline: Outline;
bBox: BoundBox _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal];
fenceSeq _ GGSequence.NextSequence[seqGen];
IF fenceSeq = NIL OR fenceSeq.traj.role#fence THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select a closed trajectory to add holes to.", oneLiner];
GOTO Abort;
};
fence _ fenceSeq.traj;
outline _ GGOutline.OutlineOfTraj[fence];
firstHoleSeq _ GGSequence.NextSequence[seqGen];
IF firstHoleSeq = NIL THEN {
GGError.AppendHerald[gargoyleData.feedback, "Extend your selection to some closed trajectories to make holes.", oneLiner];
GOTO Abort;
};
FOR holeSeq: Sequence _ firstHoleSeq, GGSequence.NextSequence[seqGen] UNTIL holeSeq = NIL DO
hole _ holeSeq.traj;
IF NOT GGObjects.IsTopLevel[hole] THEN LOOP;
IF holeSeq.traj.role#fence THEN {
GGError.AppendHerald[gargoyleData.feedback, "Select only CLOSED trajectories as holes.", oneLiner];
LOOP;
};
outline _ GGInterface.AddHole[outline, hole, gargoyleData.scene];
ENDLOOP;
GGBoundBox.EnlargeByBox[bBox: bBox, by: outline.boundBox]; -- boundBox of old shape and new shape
gargoyleData.refresh.startBoundBox^ _ bBox^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: FALSE];
EXITS
Abort => GGError.Blink[NARROW[clientData, GargoyleData].feedback];
}; -- end AddHoles


DeleteAllSelected: PROC [gargoyleData: GargoyleData] RETURNS [bBox: BoundBox]  = {
DeleteRun: GGSelect.RunProc = {
traj _ NIL;
};
sliceDescGen: SliceDescriptorGenerator;
thisBox: BoundBox;
bBox _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal];
sliceDescGen _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
GGSelect.DeselectEntityAllClasses[sliceD.slice, gargoyleData.scene];
GGSlice.DeleteSlice[gargoyleData.scene, sliceD.slice];
ENDLOOP;
GGCaret.NoAttractor[gargoyleData.caret];
thisBox _ GGSelect.ForEachOutlineRun[gargoyleData.scene, gargoyleData.caret, normal, DeleteRun, FALSE];
GGBoundBox.EnlargeByBox[bBox: bBox, by: thisBox];
};

Delete: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
bBoxOfSelected: BoundBox;
GGStatistics.StartInterval[$Delete, GGStatistics.GlobalTable[]];
bBoxOfSelected _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal];
IF bBoxOfSelected=NIL THEN RETURN; -- nothing selected
GGObjects.PushScene[gargoyleData.scene]; -- save for Undelete
gargoyleData.refresh.startBoundBox^ _ DeleteAllSelected[gargoyleData]^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
GGStatistics.StopInterval[$Delete, GGStatistics.GlobalTable[]];
}; -- end Delete

Undelete: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
IF GGObjects.EmptySceneStack[gargoyleData.scene] OR NOT MessageWindow.Confirm["UNDELETE WILL LOSE MOST EDITS performed since last Delete"] THEN RETURN;
GGSelect.DeselectAllAllClasses[gargoyleData.scene];
GGObjects.PopScene[gargoyleData.scene];
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};

SelectAll: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
GGStatistics.StartInterval[$SelectAll, GGStatistics.GlobalTable[]];
GGSelect.DeselectAll[gargoyleData.scene, normal];
GGSelect.SelectAll[gargoyleData.scene, normal];
GGEvent.SawTextFinish[NIL, gargoyleData];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, gargoyleData: gargoyleData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: TRUE];
GGStatistics.StopInterval[$SelectAll, GGStatistics.GlobalTable[]];
};

gScale: REAL _ 0.33;
gAngle: REAL _ 33;
MakeCurveProc: TYPE = PROC [lo, hi: Point, props: LIST OF REF ANY] RETURNS [seg: Segment];

GetPt: PROC[p0, dir: Point] RETURNS [pt: Point] = {
pt _ GGVector.Add[GGVector.Scale[GGVector.VectorPlusAngle[dir,gAngle], gScale*GGVector.Magnitude[dir] ], p0];
};

SetStraight: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
MakeStraightAux: MakeCurveProc = {
seg _ GGSegment.MakeLine[lo, hi, props];
};
gargoyleData: GargoyleData _ NARROW[clientData];
SetCurveAux[gargoyleData, MakeStraightAux, $Line];
}; -- end SetStraight

SetArc: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
MakeArcAux: MakeCurveProc = {
p1: Point;
p1 _ GGVector.Add[GGVector.Scale[GGVector.Sub[hi,lo], 0.5], lo];
seg _ GGSegment.MakeArc[lo, p1, hi, props];
};
gargoyleData: GargoyleData _ NARROW[clientData];
SetCurveAux[gargoyleData, MakeArcAux, $Arc];
}; -- end SetArc

SetSnowflake: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
OPEN GGVector;
MakeSnowflakeAux: PROC [seg: Segment, traj: Traj] RETURNS [patternTraj: Traj] = {
length: REAL;
p1, p2, p3: Point;
sideVec, dir, x: Vector;
seg1, seg2, seg3, seg4: Segment;
lo: Point _ seg.lo;
hi: Point _ seg.hi;
success: BOOL;
length _ GGVector.Distance[lo,hi];
dir _ Sub[hi,lo];
x _ Scale[dir, 1.0/3.0];
p1 _ Add[lo, x];
p3 _ Add[lo, Scale[dir, 2.0/3.0]];
sideVec _ Scale[VectorPlusAngle[dir, 90], length*RealFns.SqRt[3]/6.0];
p2 _ Add[lo, GGVector.Add[Scale[dir, 0.5], sideVec]];
patternTraj _ traj;
seg1 _ GGSegment.MakeLine[p0: lo, p1: p1, props: seg.props];
seg2 _ GGSegment.MakeLine[p0: p1, p1: p2, props: seg.props];
seg3 _ GGSegment.MakeLine[p0: p2, p1: p3, props: seg.props];
seg4 _ GGSegment.MakeLine[p0: p3, p1: hi, props: seg.props];
success _ GGTraj.AddSegment[patternTraj, hi, seg1, lo];
success _ GGTraj.AddSegment[patternTraj, hi, seg2, lo];
success _ GGTraj.AddSegment[patternTraj, hi, seg3, lo];
success _ GGTraj.AddSegment[patternTraj, hi, seg4, lo];
};
gargoyleData: GargoyleData _ NARROW[clientData];
SetPatternAux[gargoyleData, MakeSnowflakeAux];
};

SetConic: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
MakeConicAux: MakeCurveProc = {
p1: Point;
p1 _ GGVector.Add[GGVector.Scale[GGVector.Sub[hi,lo], 0.5], lo];
seg _ GGSegment.MakeConic[lo, p1, hi, 0.7, props];
};
gargoyleData: GargoyleData _ NARROW[clientData];
SetCurveAux[gargoyleData, MakeConicAux, $Conic];
}; -- end SetConic

SetBezier: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
MakeBezierAux: MakeCurveProc = {
length: REAL;
dir: Point;
p1, p2: Point;
length _ GGVector.Distance[lo, hi];
dir _ GGVector.Sub[hi,lo];
p1 _ GetPt[lo, dir];
p2 _ GetPt[hi, [-dir.x, -dir.y] ];
seg _ GGSegment.MakeBezier[lo, p1, p2, hi, props];
};
gargoyleData: GargoyleData _ NARROW[clientData];
SetCurveAux[gargoyleData, MakeBezierAux, $Bezier];
}; -- end SetBezier

SegsToSegsMatchCp: PROC [seg: Segment, traj: Traj, makeCurve: MakeCurveProc, type: ATOM] = {
tSeg: Segment;
success: BOOL;
IF seg.class.type = type THEN -- if seg is already the right type, then we don't change it
success _ GGTraj.AddSegment[traj, hi, GGSegment.CopySegment[seg], lo]
ELSE IF type = $Arc AND seg.class.controlPointCount[seg] = 1 THEN { -- if old and new segment types have single control points, keep the control points the same
tSeg _ GGSegment.MakeArc[seg.lo, seg.class.controlPointGet[seg, 0], seg.hi, seg.props];
tSeg.color _ seg.color;  tSeg.strokeWidth _ seg.strokeWidth;
success _ GGTraj.AddSegment[traj, hi, tSeg , lo]
}
ELSE IF type = $Conic AND seg.class.controlPointCount[seg] = 1 THEN { -- if old and new segment types have single control points, keep the control points the same
tSeg _ GGSegment.MakeConic[seg.lo, seg.class.controlPointGet[seg, 0], seg.hi, .7, seg.props];
tSeg.color _ seg.color;  tSeg.strokeWidth _ seg.strokeWidth;
success _ GGTraj.AddSegment[traj, hi, tSeg, lo]
}
ELSE { -- make segment of new type with old endpoint info
tSeg _ makeCurve[seg.lo, seg.hi, seg.props];
tSeg.color _ seg.color;  tSeg.strokeWidth _ seg.strokeWidth;
success _ GGTraj.AddSegment[traj, hi, tSeg, lo];
};
IF NOT success THEN ERROR;
};

SegsAndCpsToSegs: PROC [seg: Segment, traj: Traj, makeCurve: MakeCurveProc, type: ATOM] = {
success: BOOL;
IF seg.class.type = type THEN -- if seg is already the right type, then we don't change it
success _ GGTraj.AddSegment[traj, hi, GGSegment.CopySegment[seg], lo]
ELSE { -- seg isn't the right type, so we convert all of its point/controlpoint spans
tSeg: Segment;
last, next: Point _ seg.lo;
FOR i:INT IN [0..seg.class.controlPointCount[seg]) DO
next _ seg.class.controlPointGet[seg, i];
tSeg _ makeCurve[last, next, seg.props];
tSeg.color _ seg.color;  tSeg.strokeWidth _ seg.strokeWidth;
success _ GGTraj.AddSegment[traj, hi, tSeg, lo];
IF NOT success THEN ERROR;
last _ next;
ENDLOOP;
tSeg _ makeCurve[last, seg.hi, seg.props];
tSeg.color _ seg.color;  tSeg.strokeWidth _ seg.strokeWidth;
success _ GGTraj.AddSegment[traj, hi, tSeg, lo];
IF NOT success THEN ERROR;
};
};

SetCurveAux: PROC [gargoyleData: GargoyleData, makeCurve: MakeCurveProc, type: ATOM] = {
RunOfSegs: GGSelect.RunProc = {
segGen: GGSequence.SegmentGenerator _ GGSequence.SegmentsInSequence[run];
initialSeg: Segment _ GGSequence.NextSegment[segGen];
IF initialSeg = NIL THEN RETURN[NIL]; -- the run is a single vertex
traj _ GGTraj.CreateTraj[initialSeg.lo];
FOR seg: Segment _ initialSeg, GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
SELECT seg.class.type FROM -- choose from old segment type
$Line, $Arc, $Conic, $Bezier => SegsToSegsMatchCp[seg, traj, makeCurve, type]; -- modify traj
$CubicSpline => {
IF type=$Line OR (run.traj.segCount=1 AND run.traj.role#open) THEN SegsAndCpsToSegs[seg, traj, makeCurve, type] -- Splines are changed to multiple lines...(or multiple segs if spline was cyclic)
ELSE SegsToSegsMatchCp[seg, traj, makeCurve, type];  -- ...but single everything else
};
ENDCASE => ERROR;
ENDLOOP;
};
bBox: BoundBox;
bBox _ GGSelect.ForEachOutlineRun[gargoyleData.scene, gargoyleData.caret, normal, RunOfSegs, TRUE, TRUE];
gargoyleData.refresh.startBoundBox^ _ bBox^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};

PatternProc: TYPE = PROC [seg: Segment, traj: Traj] RETURNS [patternTraj: Traj];
SetPatternAux: PROC [gargoyleData: GargoyleData, pattern: PatternProc] = {
RunOfSegs: GGSelect.RunProc = {
segGen: GGSequence.SegmentGenerator _ GGSequence.SegmentsInSequence[run];
initialSeg: Segment _ GGSequence.NextSegment[segGen];
IF initialSeg = NIL THEN RETURN[NIL]; -- the run is a single vertex
traj _ GGTraj.CreateTraj[initialSeg.lo];
FOR seg: Segment _ initialSeg, GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
SELECT seg.class.type FROM -- choose from old segment type
$Line => traj _ pattern[seg, traj];
ENDCASE => NULL;
ENDLOOP;
};
bBox: BoundBox;
bBox _ GGSelect.ForEachOutlineRun[gargoyleData.scene, gargoyleData.caret, normal, RunOfSegs, TRUE, TRUE];
gargoyleData.refresh.startBoundBox^ _ bBox^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE];
};

SetNaturalSpline: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
SetSpline[splineType: naturalAL, gargoyleData: gargoyleData];
};

SetBSpline: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
SetSpline[splineType: bspline, gargoyleData: gargoyleData];
};

SetSpline: PROC [splineType: CubicSplines.SplineType, gargoyleData: GargoyleData] = {
RunToSpline: GGSelect.RunProc = {
X: NAT = CubicSplines.X;
Y: NAT = CubicSplines.Y;
tSeg: Segment;
controlPoint: Point;
cyclic: BOOL _ run.traj.role#open AND GGSequence.IsComplete[run]; 
cps: CubicSplines.KnotSequence _ NEW[CubicSplines.KnotSequenceRec[IF cyclic THEN run.jointCount+run.controlPointCount+1 ELSE run.jointCount+run.controlPointCount]];
segGen: GGSequence.SegmentGenerator _ GGSequence.OrderedSegmentsInSequence[run];
initialSeg: Segment _ GGSequence.NextSegment[segGen];
success: BOOL;
cpCount: NAT _ 0;
IF initialSeg = NIL THEN RETURN[NIL];
IF cyclic AND splineType = naturalAL THEN splineType _ cyclicAL;
traj _ GGTraj.CreateTraj[initialSeg.lo];
cps[cpCount] _ [initialSeg.lo.x, initialSeg.lo.y];
cpCount _ cpCount + 1;
FOR seg: Segment _ initialSeg, GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
FOR i:INT IN [0..seg.class.controlPointCount[seg]) DO
controlPoint _ seg.class.controlPointGet[seg, i];
cps[cpCount] _ [controlPoint.x, controlPoint.y];
cpCount _ cpCount + 1;
ENDLOOP;
cps[cpCount] _ [seg.hi.x, seg.hi.y];
cpCount _ cpCount + 1;
ENDLOOP;
IF cyclic THEN cps[cps.length-1] _ cps[0]; -- cumulative error sometimes causes small differences.  DJK.
tSeg _ GGSegment.MakeCubicSpline[cps, splineType, NIL];
tSeg.color _ initialSeg.color;  tSeg.strokeWidth _ initialSeg.strokeWidth;
success _ GGTraj.AddSegment[traj, hi, tSeg, lo];
IF NOT success THEN ERROR;
};
gargoyleData.refresh.startBoundBox^ _ GGSelect.ForEachOutlineRun[gargoyleData.scene, gargoyleData.caret, normal, RunToSpline, TRUE, TRUE]^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: TRUE]
};
SelectMatchingCurve: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
name: Rope.ROPE _ IF event.rest = NIL THEN ViewerTools.GetSelectionContents[] ELSE NARROW[event.rest.first];
trajGen: TrajGenerator _ GGObjects.TrajsInScene[gargoyleData.scene];
GGSelect.DeselectAll[gargoyleData.scene, normal];
FOR traj: Traj _ GGObjects.NextTraj[trajGen], GGObjects.NextTraj[trajGen] UNTIL traj = NIL DO
segGen: SegmentGenerator _ GGSequence.SegmentsInTraj[traj];
FOR segAndIndex: SegAndIndex _ GGSequence.NextSegmentAndIndex[segGen], GGSequence.NextSegmentAndIndex[segGen] UNTIL segAndIndex.seg = NIL DO
IF Rope.Equal[segAndIndex.seg.class.describe[segAndIndex.seg, TRUE, TRUE, TRUE, NIL], name, FALSE] THEN {
seq: Sequence _ GGSequence.CreateFromSegment[traj, segAndIndex.index];
GGSelect.SelectSequence[seq, gargoyleData.scene, normal];
};
ENDLOOP;
ENDLOOP;
GGError.PutFHerald[gargoyleData.feedback, oneLiner, "Curves of type %g selected", [rope[name]] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, gargoyleData: gargoyleData, remake: none, backgndOK: TRUE, edited: FALSE, okToClearFeedback: FALSE];
};

Close: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
chair: REF ANY;
traj: Traj;
firstPoint, lastPoint: Point;
seg: Segment;
success: BOOL;
chair _ GGCaret.GetChair[gargoyleData.caret];
BEGIN
IF chair = NIL THEN GOTO NoCaretTraj;
WITH chair SELECT FROM
oD: OutlineDescriptor => {
[success, ----, traj] _ GGOutline.UnpackSimpleDescriptorOld[oD];
IF NOT success THEN ERROR;
};
sD: SliceDescriptor => {
IF sD.slice.class.type # $Outline THEN GOTO NoCaretTraj;
[success, ----, traj] _ GGOutline.UnpackSimpleDescriptor[sD];
IF NOT success THEN GOTO NoCaretTraj;
};
ENDCASE => ERROR;
IF traj.role = fence OR traj.role = hole THEN GOTO AlreadyClosed;
GGError.AppendHerald[gargoyleData.feedback, "The caret trajectory will be closed.", oneLiner];
firstPoint _ GGTraj.FetchJointPos[traj, 0];
lastPoint _ GGTraj.LastJointPos[traj];
IF firstPoint # lastPoint THEN {
seg _ GGSegment.MakeLine[lastPoint, firstPoint, NIL];
GGTraj.CloseWithSegment[traj, seg, lo];
GGSelect.ReselectTraj[traj, hi, gargoyleData.scene, TRUE];
}
ELSE {
GGOutline.SaveSelectionsInOutline[traj.parent, gargoyleData.scene];
GGSelect.DeselectEntityAllClasses[traj.parent, gargoyleData.scene];
GGTraj.CloseByDistorting[traj, hi];
GGOutline.RemakeSelectionsFromOutline[traj.parent, gargoyleData.scene];
};
GGOutline.OutlineOfTraj[traj].class.setFillColor[GGOutline.OutlineOfTraj[traj], GGObjects.fillColor];
GGSelect.SelectTraj[traj, gargoyleData.scene, normal];
GGCaret.SitOn[gargoyleData.caret, NIL];
GGCaret.NoAttractor[caret: gargoyleData.caret];
gargoyleData.refresh.startBoundBox^ _ traj.boundBox^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: FALSE];
EXITS
NoCaretTraj => {
GGError.AppendHerald[gargoyleData.feedback, "There is no caret trajectory to close.", oneLiner];
GGError.Blink[gargoyleData.feedback];
};
AlreadyClosed => {
GGError.AppendHerald[gargoyleData.feedback, "That trajectory is already closed.", oneLiner];
GGError.Blink[gargoyleData.feedback];
};
END;
}; -- end Close

Refresh: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
doNotClear: BOOL _ event#NIL AND event.rest#NIL AND event.rest.first=$DoNotClearFeedback;
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: FALSE, okToClearFeedback: NOT doNotClear];
};

DisableRefresh: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
gargoyleData.refresh.suppressRefresh _ TRUE;
};

EnableRefresh: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
gargoyleData.refresh.suppressRefresh _ FALSE;
};

CloseToTranslation: PROC [s, t: ImagerTransformation.Transformation, range: REAL] RETURNS [BOOL] ~ {
OPEN ImagerTransformation;
WithinQuarterPixel: PROC [p, q: VEC] RETURNS [BOOL] ~ {
RETURN [ABS[p.x-q.x] <= 0.25 AND ABS[p.y-q.y] <= 0.25]
};
p10: VEC _ TransformVec[s, InverseTransformVec[t, [range, 0]]];
p01: VEC _ TransformVec[s, InverseTransformVec[t, [0, range]]];
RETURN [
WithinQuarterPixel[p10, [range, 0]] AND
WithinQuarterPixel[p01, [0, range]]
]
};

defaultFontData: FontData _ NIL;

Init: PROC [] = {
defaultFontData _ GGFont.CreateFontData[];
defaultFontData^ _ ["xerox/pressfonts/helvetica-mrr", "xerox/pressfonts/", "helvetica-mrr", "helvetica", "helvetica", ImagerTransformation.Scale[10.0], 1.0,1.0,1.0, TRUE, FALSE, FALSE, TRUE];
GGStatistics.AddInterval[GGStatistics.CreateInterval[$SelectAll, NIL], GGStatistics.GlobalTable[]];
GGStatistics.AddInterval[GGStatistics.CreateInterval[$Delete, NIL], GGStatistics.GlobalTable[]];
};

Init[];

END.
@NGGEventImplA.mesa
Contents:  Once an event reaches the front of the slack-process queue, it is dispatched to one of the procedures in this module.
Bier, February 9, 1987 5:50:24 pm PST
Ken Pier, February 18, 1987 11:34:11 pm PST
Kurlander August 28, 1986 6:31:20 pm PDT
Stone, August 9, 1985 2:38:57 pm PDT

If we ever allow text slices to have hot joints, we will have to be more careful here.
If we ever allow text slices to have hot joints, we will have to be more careful here.
FONTS
Each text string should have a single font associated with it.  That font may be either a print font or a screen font.  For our purposes here, a font is a collection of shapes, defined in some font coordinate system, together with a transformation to apply to a string of those shapes when the string is rendered.
File Format
Ignoring user interface for the moment, here is what we will store in .gargoyle files:  If the font is a resolution-independent font (e.g. press font), we store:

FontPrefix			FontFamily	Face			Transformation		Preferred Size
Xerox/PressFonts/	Helvetica			-BI	M = [a, b, c, d, e, f]		1.0
Xerox/xc1-2-2/		Modern			-BI	M = [a, b, c, d, e, f]		1.0

The shapes of the font are assumed to be 1 unit large in font master coordinates.  If the named FontPrefix/FontFamily does not obey this property, the font will be scaled to be a unit font before the Transformation is applied.  Hence, if M = Scale[12], the font will appear as 12 screen dots high.  Our units are 1/72.0 of an inch.  Tioga uses 1/72.27 inches.  Life is hard.
If the font is a resolution-dependent font (e.g. screen font, like Tioga10), we store:

FontPrefix			FontFamily	Face			Transformation		Preferred Size
Xerox/TiogaFonts/	Tioga				-BI	M = [a, b, c, d, e, f]		10.0

The shapes of the font are assumed to be 1 unit large in font master coordinates.  This is often not true.  However, the font will be scaled to be a unit font before the Transformation is applied.  Gargoyle will have to know about fonts, but can hide this knowledge from the user.  For instance:  CMR10 is a 1 unit font, which must be scaled by 10 to look good.  Tioga10, however, is stored at 10 units high in font master coordinates.  Gargoyle will scale it by 0.1 to get a unit font, but M will usually be Scale[10] so all will be well.
We store both kinds of fonts in .gargoyle files using the same format with Preferred Size = 1.0 for press fonts.  This is a unique value which signals the fileIn code that it is a resolution independent font.  It's size is one unit, and the appearance scaling is in the transformation.
User Interface for Output
There will be a "look readable" mode which calculates a more readable font from the font in each text string.  As we do now, we will probably cache this font in each string along with the "real font".  However, the readable font will not necessarily be a Screen Font.  For large strings, it may be the same as the real font, for instance.
Setting Fonts
Here's where we have to be flexible.  We'll probably want to have several kinds of SetFont commands, some which are convenient for everyday use and some which let you be very specific.  These four may make a good starting set:
SetPressFont.  The user selects a <FontFamily-FontFace> <scalar> pair such as "Helvetica-BI 12".  The <-FontFace> may be left off, denoting regular font. Gargoyle assumes FontPrefix = Xerox/PressFonts/ and lets transformation M = Scale[<scalar>].  The font is made with ImagerFont.Scale[font,  1] (in all cases I know about).
SetPrintFont.  The user selects a <FontFamily-FontFace> <scalar> pair such as "Helvetica-BI 12".  The <-FontFace> may be left off, denoting regular font. Gargoyle assumes FontPrefix = Xerox/XC1-2-2/ and lets transformation M = Scale[<scalar>].  The font is made with ImagerFont.Scale[font,  1] (in all cases I know about).
SetScreenFont.  The user selects a <FontFamily-FontFace> <preferred size> pair such as "CMR 10".  Gargoyle assumes FontPrefix = Xerox/TiogaFonts/ and lets transformation M = Scale[<preferred size>].  The font is made with ImagerFont.Scale[font,  1] if the font is CMR, with ImagerFont.Scale[font, 1.0/<preferred size>], if the font is Helvetica, TimesRoman, Tioga.  If the font is one of the traditional TiogaFonts (e.g. Helvetica, TimesRoman, Tioga, ...)  Gargoyle will attempt to find the corresponding strike font.  For example, SetScreenFont TimesRoman-BI 9 will find the font in file ///fonts/xerox/tiogafonts/TimesRoman9BI.ks.  If the user requests a TiogaFont not in the Tioga font set (usually an odd size), Gargoyle will fail to change the font.  I don't know which camp Terminal is in.  At any rate, Gargoyle will have to keep track of which fonts are in which camp.
SetPrintFontDetailed.  The user selects a <FontPrefix> <FontFamily-FontFace> <Transformation> triple.  Gargoyle makes no assumptions.  The user must provide a factored transformation.  For example:
xerox/pressfonts/ gacha-bi  [r1: REAL, s: VEC, r2: REAL, t: VEC]
xerox/xc1-2-2/ classic-b  [r1: REAL, s: VEC, r2: REAL, t: VEC]
WHITESPACE IS CRITICAL !!
SetScreenFontDetailed.  The user selects a <FontPrefix> <FontFamily-FontFace> <Transformation> <Preferred Size> quadruple.  Again, Gargoyle uses its information about font camps to successfully make a unit sized font.  Otherwise, Gargoyle makes no assumptions.
Note:  For screen fonts, we may run into trouble when <scalar>*(1.0/<scalar>) isn't quite 1.0.  We can either round within epsilon for screen fonts, or we can keep around an unscaled font when we know we should be hitting the fast case.
Asking About Fonts
A single function PrintFontOfSelected should say exactly what font is being used.  The format of this output should be suitable for selecting and feeding to SetPrintFontDetailed or SetScreenFontDetailed.  Unfortunately, the Gargoyle feedback region isn't selectable.  Of course, the user could open a Typescript first.  Suggestions?

Fonts Menu
In GGEventImplA.SetPrintFont
SetPressFont expects input of the form <FontFamily-FontFace> <scalar>. e.g. "Cream-BI 12"
SetPressFont expects input of the form <FontFamily-FontFace> <scalar>. e.g. "Modern-BI 12"
SetScreenFont expects input of the form <FontFamily-FontFace> <scalar>. e.g. "Cream12-BI 20"
SetFontDetailed expects input of the form <FontPrefix> <FontFamily-FontFace> <Transformation>  e.g. "xerox/myfonts/fontOne-BI [1.0 2.0 3.0 4.0 5.0 6.0].  Gargoyle assumes the designSize and the storedSize can be derived from the <FontPrefix> and <FontFamily-FontFace>; if not, then designSize and storedSize are defaulted to 1.0
SetFontLiteral expects input of the form <FontPrefix> <FontFamily-FontFace> <Transformation> <storedSize> <design size>. Gargoyle accepts this as literal information and makes no attempt at understanding the semantics of the data.
Outputs string in the form <FontPrefix> <FontFamily> <FontFace> transformation preferredSize
Outputs string in the form <FontFullName> <transformation> <storedSize> <designSize>
Copies the fontData from the LAST selected text slice to all the other selected text slices, but preserves the other slice transformation.  Effect is to change font but not transform.
Replicates the font data from the LAST selected text slice to all the other selected text slices
Checks for a single selected GG text slice, then selects all the text slices with fontData matching that slice, excluding translation.
selects all the text slices whose fontData.userFSF contain the Tioga selection as a SUBSTRING.
selects all the text slices whose fontData.literal contain the Tioga selection as a SUBSTRING.
SetDefaultFontValues checks that there is a single GG text slice selected, then copies its font information to the default font
Interpress Utilities
All selected IP Slices are now store-by-reference.
All selected IP Slices are now store-by-value.
Show whether the selected IP Slices is store-by-reference or store-by-value
TIMING VARIABLES
START TIMING
TIMING VARIABLES
START TIMING

Gravity Utilities
Within the bounds of the viewer, randomly choose mouse positions.  See if that mouse position is in range of any object.  If so, draw a dot at that point.  Repeat until 100 points have been drawn.
Hierarchy Menu
PolyType: TYPE = {positive, negative};
PolyData: TYPE = REF PolyDataObj;
PolyDataObj: TYPE = RECORD [
type: PolyType
];
HandleOverlap: PROC [currentClientdata, inputClientdata: REF] RETURNS [resultClientData: REF] = {
resultClientData _ NEW[PolyDataObj _ [positive]];
};
HandleGlue: PROC [clientData1, clientData2: REF ANY] RETURNS [BOOL] = {
RETURN[FALSE];
};

IsPositive: PROC [clientData: REF ANY] RETURNS [BOOL] = {
polyData: PolyData _ NARROW[clientData];
IF polyData = NIL THEN RETURN[FALSE];
RETURN[polyData.type = positive];
};

bBoxOfSelected: BoundBox _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal];
IF bBoxOfSelected=NIL THEN RETURN; -- nothing selected
IF PrincOpsUtils.IsBound[LOOPHOLE[CombinePoly.CreateDatabase]] THEN {
startTime, endTime: BasicTime.GMT;
totalTime: INT;
GGError.PutF[gargoyleData.feedback, begin, "Combining selected convex polygons . . . "];
startTime _ BasicTime.Now[];
UnionCombineAux[gargoyleData];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
GGError.PutF[gargoyleData.feedback, end, " Done in time (%r)", [integer[totalTime]]];
gargoyleData.refresh.startBoundBox^ _ bBoxOfSelected^;
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, gargoyleData: gargoyleData, remake: triggerBag, backgndOK: FALSE, edited: TRUE, okToClearFeedback: FALSE];
}
ELSE {
GGError.Append[gargoyleData.feedback, "Please run BasicCombiner.bcd and retry this operation", oneLiner];
GGError.Blink[gargoyleData.feedback];
};
UnionCombineAux: PROC [clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
Use Arnon's Combiner to find the union of all selected trajectories.  The result of such a union may be a set of outlines with holes.  For now, we assume that the result will be a set of outlines without holes (since holes are not implemented in Gargoyle yet.
dbid: CombinePoly.DBID;
polyID: CombinePoly.PolyID;
seqGen: SequenceGenerator;
regionGen: CombinePoly.RegionGenerator;
jointGen: JointGenerator;
pointGen: CombinePoly.PointGenerator;
point, firstPoint, secondPoint: Point;
polyData: REF ANY;
firstPointAndDone, previousPointAndDone: CombinePoly.PointAndDone;
success: BOOL;
traj: Traj;
seg: Segment;
outline: Outline;
jointNum: INT;
dbid _ CombinePoly.CreateDatabase[];
seqGen _ GGSelect.SelectedSequences[gargoyleData.scene, normal];
FOR seq: Sequence _ GGSequence.NextSequence[seqGen], GGSequence.NextSequence[seqGen] UNTIL seq = NIL DO
IF NOT GGSequence.IsComplete[seq] THEN LOOP;
IF NOT seq.traj.role = fence THEN LOOP;
polyData _ NEW[PolyDataObj _ [positive]];
jointGen _ GGSequence.JointsInSequence[seq];
Create the Polygon
jointNum _ GGSequence.NextJoint[jointGen];
firstPoint _ GGTraj.FetchJointPos[seq.traj, jointNum];
jointNum _ GGSequence.NextJoint[jointGen];
secondPoint _ GGTraj.FetchJointPos[seq.traj, jointNum];
polyID _ CombinePoly.CreatePolygon[firstPoint, secondPoint, polyData];
Add the other points.
FOR jointNum: INT _ GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL jointNum = -1 DO
point _ GGTraj.FetchJointPos[seq.traj, jointNum];
CombinePoly.AddPointToPolygon[point, polyID];
ENDLOOP;
dbid _ CombinePoly.PolygonIntoDatabase[polyID, dbid, HandleOverlap, HandleGlue];
ENDLOOP;
[] _ DeleteAllSelected[gargoyleData];
regionGen _ CombinePoly.MaximalRegions[dbid, IsPositive];
FOR region: CombinePoly.OutlineHolesDataAndDone _ CombinePoly.NextRegion[regionGen], CombinePoly.NextRegion[regionGen] UNTIL region.done DO
pointGen _ region.outline;
previousPointAndDone _ firstPointAndDone _ CombinePoly.NextPoint[pointGen];
IF previousPointAndDone.done THEN LOOP;
traj _ GGTraj.CreateTraj[previousPointAndDone.point];
FOR pointAndDone: CombinePoly.PointAndDone _ CombinePoly.NextPoint[pointGen], CombinePoly.NextPoint[pointGen] UNTIL pointAndDone.done DO
seg _ GGSegment.MakeLine[previousPointAndDone.point, pointAndDone.point, NIL];
success _ GGTraj.AddSegment[traj, hi, seg, lo];
IF NOT success THEN ERROR;
previousPointAndDone _ pointAndDone;
REPEAT
FINISHED => {
seg _ GGSegment.MakeLine[previousPointAndDone.point, firstPointAndDone.point, NIL];
GGTraj.CloseWithSegment[traj, seg, lo];
};
ENDLOOP;
outline _ GGOutline.CreateOutline[traj, round, GGObjects.fillColor];
GGObjects.AddOutline[gargoyleData.scene, outline, -1];
ENDLOOP;
};

OldDeleteAllSelected: PROC [gargoyleData: GargoyleData] RETURNS [bBox: BoundBox]  = {
sliceDescGen: SliceDescriptorGenerator;
outSeqGen: GGSelect.OutlineSequenceGenerator;
oldOutline: Outline;
fenceSeq: Sequence;
thisBox: BoundBox;
bBox _ GGBoundBox.BoundBoxOfSelected[gargoyleData.scene, normal];
Implemented enough for non-gargoyle slices only.
sliceDescGen _ GGSelect.SelectedSlices[gargoyleData.scene, normal];
FOR sliceD: SliceDescriptor _ GGSelect.NextSliceDescriptor[sliceDescGen], GGSelect.NextSliceDescriptor[sliceDescGen] UNTIL sliceD = NIL DO
GGSelect.DeselectEntityAllClasses[sliceD.slice, gargoyleData.scene];
GGSlice.DeleteSlice[gargoyleData.scene, sliceD.slice];
ENDLOOP;
Now delete selected sequences.
outSeqGen _ GGSelect.SelectedOutlineSequences[gargoyleData.scene, normal];
WHILE outSeqGen.list # NIL DO
FOR outSeq: GGSelect.OutlineSequence _ GGSelect.NextOutlineSequences[outSeqGen], GGSelect.NextOutlineSequences[outSeqGen] UNTIL outSeq = NIL DO
fenceSeq _ outSeq.fenceSeq;
FOR holeSeq: Sequence _ GGSequence.NextSequence[outSeq.holeSeqs], GGSequence.NextSequence[outSeq.holeSeqs] UNTIL holeSeq = NIL DO
[oldOutline,----] _ GGInterface.DeleteSequence[holeSeq, gargoyleData.scene];
thisBox _ GGTraj.GetBoundBox[holeSeq.traj];
GGBoundBox.EnlargeByBox[bBox: bBox, by: thisBox];
GOTO SelectionsHaveChanged;
ENDLOOP;
IF fenceSeq # NIL THEN {
[oldOutline,----] _ GGInterface.DeleteSequence[fenceSeq, gargoyleData.scene];
IF fenceSeq.traj.role = open THEN {
GGSequence.UpdateBoundBox[fenceSeq];
GGBoundBox.EnlargeByBox[bBox: bBox, by: fenceSeq.boundBox];
}
ELSE {
thisBox _ GGTraj.GetBoundBox[fenceSeq.traj];
GGBoundBox.EnlargeByBox[bBox: bBox, by: thisBox];
};
GOTO SelectionsHaveChanged;
};
REPEAT
SelectionsHaveChanged => {
outSeqGen _ GGSelect.SelectedOutlineSequences[gargoyleData.scene, normal];
};
ENDLOOP;

ENDLOOP;
};

Implemented enough for non-gargoyle slices only.
Overly conservative.  Just in case the caret was attracted to something that was just deleted.
Curve Menu
Replace segs of the old type with segs of the new type, maintaining control point data if possible
Replace old segments with segments of the new type, but if the old segment had control points, use these also as joints of new segments. 
Use GGSelect.ForEachOutlineRun to replace all selected runs with runs of a new type.
Strategy:  Replace each selected run with a new trajectory which has a segment (of the proper type) for each joints/control point span.  Note that we we copy verbatim all segs which were already of the specified type.  The new segments inherit color and strokeWidth from the old ones.
[run: GGModelTypes.Sequence] RETURNS [traj: GGModelTypes.Traj]
Use GGSelect.ForEachOutlineRun to replace all selected runs with runs of a new type.
Strategy:  Replace each selected run with a new trajectory which has a segment (of the proper type) for each joints/control point span.
[run: GGModelTypes.Sequence] RETURNS [traj: GGModelTypes.Traj]
[run: GGModelTypes.Sequence] RETURNS [traj: GGModelTypes.Traj]

Edit Curve Menu
N.B.  It's a shame we have to remake the triggerBag here.  This is because the closed trajectory might have been hot.  Its hot sequence is obsolete.
ShowPoints: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
seqGen: SequenceGenerator _ GGSelect.SelectedSequences[gargoyleData.scene, normal];
FOR seq: Sequence _ GGSequence.NextSequence[seqGen], GGSequence.NextSequence[seqGen] UNTIL seq = NIL DO
seq.traj.visibleJoints _ TRUE;
ENDLOOP;
};

HidePoints: PUBLIC PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
gargoyleData: GargoyleData _ NARROW[clientData];
seqGen: SequenceGenerator _ GGSelect.SelectedSequences[gargoyleData.scene, normal];
FOR seq: Sequence _ GGSequence.NextSequence[seqGen], GGSequence.NextSequence[seqGen] UNTIL seq = NIL DO
seq.traj.visibleJoints _ FALSE;
ENDLOOP;
};

View Menu
Debug menu ops moved to GGEventImplD

TAKE THIS CODE OUT WHEN MOVING TO CEDAR 7.0 !!
�ÊI3˜Icode™šÏnœx™€
Kš
œ%™%Kš
œ+™+Kšœ%Ïk™(Kšœ!ž™$—K™š
ž	˜	Kš	œ%Ïcœ®ŸœdžœŸœ,˜®K˜—š�œžœ
ž˜Kš
žœŸœâ
ŸœdžœŸœ#˜ÐKšžœž˜—˜Kšœ
žœ˜%Kšœžœ˜!Kšœžœ˜3Kšœžœ ˜5Kšœžœ)˜GKšœžœ ˜5Kšœ
žœ ˜1Kšœžœ!˜3Kšœžœ˜!Kšœžœ˜3Kšœžœ˜&Kšœžœ"˜9Kšœžœ˜(Kšœ	žœ˜%Kšœžœ˜!Kšœžœ˜!Kšœ	žœ˜'Kšœ
žœ˜+Kšœ
žœ˜'Kšœžœ˜+Kšœžœ˜Kšœžœ˜1Kšœžœ!˜7Kšœžœ"˜9Kšœžœ˜#Kšœ
žœ˜!—K˜Kš�œžœ
žœžœ
˜(K˜š�œžœ'žœ
žœ˜Jšžœžœ
žœŸ7˜SK•StartOfExpansion_[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass]š
œ^˜^Kš
œH˜Hšžœžœ
žœ"žœ,žœ
žœ˜mKš
œ`˜`Kš
œ%˜%Kšžœ
˜K˜—K–|[slice: 
GGModelTypes.Slice, gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass]š
œw˜wKšœ7Ÿ"˜YKš	œ1Ïbœ7žœ
žœžœ˜§
Kš
œ
˜
—šžœ˜Kšœ~Ÿ˜—
Kš	žœžœ
žœ
žœŸ'˜AKš
œ6˜6Kš
œ)˜)Kš	œ1 œ;žœ
žœžœ˜¦
Kš
œ˜—KšœŸ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜FKšœžœ
˜0Kš
œ
˜
Kš
œ˜Kšœ	žœ
žœ
˜Kš
žœ
žœžœžœ
žœ
˜1Kšœ
žœ˜#šžœ%žœ
žœ˜1K–ß
[caret: 
GGInterfaceTypes.Caret, point: 
GGBasicTypes.Point, attractor: 
REF ANY _ NIL, on: 
GGInterfaceTypes.CaretOn _ nothing, attractorJointNum: 
NAT _ 999, attractorCPNum: 
NAT _ 999, attractorSegNum: 
NAT _ 999]šœ)Ÿ˜FKš
œ(˜(Kšžœ
˜Kš
œ
˜
—šžœŸ˜Kš
œA˜AKš
œ,˜,Kšœ1Ÿ!˜Ršžœžœ
žœ˜Kš
œ$˜$Kšœ7Ÿ˜UKš
œM˜Mš	œ1 œ;žœ
žœžœ˜¸
Kš
œV™V—Kš
œ
˜
—šžœ˜Kš
œA˜AKšœ7Ÿ"˜YKš
œM˜MKš
œ)˜)š	œ1 œ7žœ
žœžœ˜¢
Kš
œV™V—Kš
œ˜—Kš
œ@˜@Kš
œ˜—KšœŸ˜K˜—š
�œžœ
žœ
žœžœ˜cKš
œ7˜7Kšœ	žœžœ
˜K˜:Kš
œ$˜$Kš
œ[˜[Kšœ "œ)˜RKšžœ
žœ	žœ
žœ
˜Kš
œ2˜2Kš
œ6˜6Kšœ2Ÿ˜IKš
œ)˜)Kšœxžœ
žœžœ˜¦
Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜FKšœžœ
˜0Kš
œžœžœžœ
žœ$žœ
žœ˜lKš
œ&˜&K˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜XKšœžœ
˜0Kš	œžœžœžœ
žœ˜9Kš
œW˜WK–h[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass _ normal]šœbŸ˜€
šžœfžœžœ
ž˜|Kš
œO˜OKšžœ
˜—K–<[bBox: 
GGModelTypes.BoundBox, by: 
GGModelTypes.BoundBox]š
œ‚
˜‚
KšœŒ
žœ
žœžœŸ6˜ò
KšœŸ ˜#K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜PKšœžœ
˜0Kš
œ]˜]Kš
œH˜Hšžœžœ
žœ"žœ,žœ
žœ˜mKš
œo˜oKš
œ%˜%K˜
—Kšžœz˜~K˜K˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜KKšœžœ
˜0Kš	œ	žœžœžœ
žœ˜4Kš	œ	žœžœžœ
žœ˜9Kš
œW˜WK–h[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass _ normal]šœbŸ˜€
šžœfžœžœ
ž˜|Kš
œ7˜7Kšžœ
˜—K–<[bBox: 
GGModelTypes.BoundBox, by: 
GGModelTypes.BoundBox]š
œ‚
˜‚
KšœŒ
žœ
žœžœ˜º
K˜K˜—š�
œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜LKšœžœ
˜0Kš
œW˜WK–h[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass _ normal]šœbŸ˜€
šžœfžœžœ
ž˜|Kš
œ$˜$Kšžœ
˜—K–<[bBox: 
GGModelTypes.BoundBox, by: 
GGModelTypes.BoundBox]š
œ‚
˜‚
KšœŒ
žœ
žœžœ˜º
K˜—K˜
head™Ibodyš
œ¹™¹—š
œ™Mš
œ¡
™¡
J™Jš
œ=™=Jšœžœ™=Jšœžœ™8J™Icontinuationš
œö™öMš
œV™VJ™Jš
œ=™=Jšœžœ™;N™Nš
œ›™›Mš
œ�™�—š
œ™Mš
œÒ™Ò—š
œ
™
Mš
ω
™â
Iitemš
œÅ™ÅOš
œÂ™ÂOšœˆžœ¢žœ½™ìš
ρ
™Å
Oš	œ!žœžœžœžœ
™@Oš	œžœžœžœžœ
™>Ošž
œ
žœ
žœ™—Oš
œ„™„Mš�œè
™ì
—š
œ™Mš
œÌ™Ì—M™š
œ
™
Kš
œ™—š�
œžœžœ
žœ$žœžœ˜ZKšœžœ
˜0Kš
œW˜WK–h[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass _ normal]šœbŸ˜€
šžœfžœžœ
ž˜|KšœžœžœPžœD˜±
Kšžœ
˜—K–<[bBox: 
GGModelTypes.BoundBox, by: 
GGModelTypes.BoundBox]š
œ‚
˜‚
KšœŒ
žœ
žœžœ˜»
Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜KKš
œY™YK–)[rope: 
ROPE, oldStream: 
STREAM _ NIL]šœ
žœ
žœžœ
žœ
žœŸ˜HKš
œ-˜-Kšœ'Ÿ"˜IKšœMžœ	žœ
žœŸ˜…
Kš
œ!˜!Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜KKš
œZ™ZK–)[rope: 
ROPE, oldStream: 
STREAM _ NIL]šœ
žœ
žœžœ
žœ
žœŸ˜IKš
œ-˜-Kšœ$Ÿ"˜FKšœMžœ	žœ
žœŸ˜…
Kš
œ!˜!Kš
œ˜K˜—š�
œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜LKš
œ\™\K–)[rope: 
ROPE, oldStream: 
STREAM _ NIL]šœ
žœ
žœžœ
žœ
žœŸœŸ˜HKš
œ-˜-Kšœ'Ÿ#˜JKšœMžœ	žœ
žœŸ˜…
Kš
œ!˜!Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜NKš
œÈ™ÈKšœ
žœ
žœžœ
žœ
žœ˜7Kš
œ-˜-Kš
œMžœžœ	žœžœŸ"˜¤
Kš
œ!˜!Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜MKš
Ͼ
™æ
K–)[rope: 
ROPE, oldStream: 
STREAM _ NIL]šœ
žœ
žœžœ
žœ
žœ˜7Kš
œ-˜-Kš
œNžœžœžœžœŸ2˜¿
Kš
œ!˜!Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜MKš
œ\™\Kšœžœ
˜0Kš
œ]˜]Kš
œH˜Hšžœžœ
žœ"žœ,žœ
žœ˜mKš
œf˜fKš
œ%˜%Kš
œ
˜
—Kšžœu˜yKš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜TKš
œT™TKšœžœ
˜0Kš
œ]˜]Kš
œH˜Hšžœžœ
žœ"žœ,žœ
žœ˜mKš
œf˜fKš
œ%˜%Kš
œ
˜
—Kšžœ|˜€
Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜HKšœžœ–
™·
Kšœžœ
˜0Kš
œ˜Kš
œ]˜]šžœržœžœ
ž˜ˆ
KšœŸ˜2Kšžœ
˜—š
ž˜Kš
žœ
žœ
žœ!žœ
žœ
˜Išžœ˜Kš
œ3˜3Kš
œ˜Kšœžœ�œ˜?Kšœ�œ˜:K–h[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass _ normal]šœbŸ˜€
Kš
œC˜Cšžœržœžœ
ž˜ˆ
Kšžœžœ
žœ
˜+Kš
œ,˜,Kšœ#Ÿ(˜KKšœCŸ(Ðbc˜Kš
œ#˜#Kš
œT˜TKšžœ
˜—K–<[bBox: 
GGModelTypes.BoundBox, by: 
GGModelTypes.BoundBox]š
œ‚
˜‚
KšœŒ
žœ
žœžœ˜º
K–Û
[feedback: 
ViewerClasses.Viewer, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]š
œm˜mKš
œ˜—š
ž˜˜Kš
œa˜aKš
œ%˜%K˜——Kšžœ
˜—Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜GKšœ"žœ:™`Kšœžœ
˜0Kš
œ˜Kš
œ]˜]šžœržœžœ
ž˜ˆ
KšœŸ˜2Kšžœ
˜—š
ž˜Kš
žœ
žœ
žœ!žœ
žœ
˜Išžœ˜Kšœžœ
˜"Kš
œ˜Kšœžœ�œ˜?Kšœ�œ˜:K–h[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass _ normal]šœbŸ˜€
Kš
œC˜Cšžœržœžœ
ž˜ˆ
Kšžœžœ
žœ
˜+Kš
œ,˜,Kš
œ;˜;KšœCŸ(¡˜Kš
œS˜SKš
œT˜TKšžœ
˜—K–<[bBox: 
GGModelTypes.BoundBox, by: 
GGModelTypes.BoundBox]š
œ‚
˜‚
KšœŒ
žœ
žœžœ˜º
K–Û
[feedback: 
ViewerClasses.Viewer, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]š
œm˜mKš
œ˜—š
ž˜˜Kš
œd˜dKš
œ%˜%K˜——Kšžœ
˜—Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜GKšœžœg™†
Kšœžœ
˜0Kš
œ]˜]Kš
œH˜Hšžœžœ
žœ"žœ,žœ
žœ˜mKš
œa˜aKš
œ%˜%Kš
œ
˜
—šžœŸ4˜;Kš
œ:˜:Kš
œ+˜+Kš
œ˜—Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜PKš
œ^™^Kšœžœ
˜0Kšœžœžœ˜0šžœžœ˜#Kš
œ\˜\Kš
œ%˜%Kš
œ
˜
—Kšžœ3˜7Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜WKš
œ^™^Kšœžœ
˜0Kšœžœžœ˜0šžœžœ˜#Kš
œ_˜_Kš
œ%˜%Kš
œ
˜
—Kšžœ3˜7Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜SKšœ3žœJ™Kšœžœ
˜0Kš
œ]˜]Kš
œH˜Hšžœžœ
žœ"žœ,žœ
žœ˜mKš
œm˜mKš
œ%˜%Kš
œ
˜
—šžœ˜Kš
œL˜LKš
œy˜yKš
œ˜—Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜TKšœžœ
˜0K–ldStream: 
STREAM _ NIL]š	œ	žœ
žœžœ
žœ˜Kš
œN˜NK–Û
[feedback: 
ViewerClasses.Viewer, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]šœyžœb˜Ý
Kš
œ˜K˜—š�œžœžœ"žœ˜UKš
œG˜GKš
œ1˜1šžœMžœžœ
ž˜bKš
œ0˜0K–-[y: 
REAL, x: 
REAL, distance: 
[-126..0]]šžœžœ
žœžœ1žœžœGžœ=˜€Kšžœ
˜—K–Û
[feedback: 
ViewerClasses.Viewer, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]š
œw˜wKšœyžœ
žœžœ˜¨
Kš
œ˜K˜—š�œžœ5˜MKšœžœ˜Kš
œG˜GKš
œ1˜1šžœMžœžœ
ž˜bKš
œ0˜0K–-[y: 
REAL, x: 
REAL, distance: 
[-126..0]]šžœ0žœžœDžœ
ŸœGžœGžœ=˜ïKšžœ
˜—K–Û
[feedback: 
ViewerClasses.Viewer, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]š
œt˜tKšœyžœ
žœžœ˜¨
Kš
œ˜—K˜K™š�œžœžœžœ
žœžœžœžœ˜iš�
œžœ˜.Jš "¡˜<KšœDžœ˜IK˜—Kšœžœ
˜0Kšœžœ
˜"Kšœžœ
˜Kšœžœ
˜"Kšœžœ
˜Kšœ	žœžœ
˜K˜Kš
œo˜oKšžœ
žœ	žœ
žœ
˜Kš
œZ˜ZKšžœ
žœ	žœ
žœ
˜K˜Kš
œ]˜]Kš
œ˜šœ œ/˜KKš
œ9˜9Kšžœ
˜Kš
œ˜—Kš
œ˜Kš
œ1˜1Kš
œU˜UKš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜NKšœžœ
˜0Kšœ
žœžœ˜-Kš
œ=˜=Kšžœ	žœ
žœ
žœ
˜Kš
œ1˜1Kš
œ"˜"Kš
œS˜SKšœžœ
žœžœ˜®
K˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜KKš
œ
˜
Kšœžœ
˜0Kšœžœ
˜Kšœžœ
˜"Kšœžœ
˜Kš
œ˜Kšœ	žœ
˜K˜Kšœžœ˜%Kš
œr˜rKšžœ
žœ	žœ
žœ
˜Kš
œZ˜ZKšžœ
žœ	žœ
žœ
˜Kš
œ1˜1K˜Kš
œW˜WKš
œ˜K˜Kšœ[žœžœžœ˜lKšžœ	žœ
žœ
žœ
˜Kš
œ2˜2K˜Kš
œ˜Kš
œ1˜1Kš
œU˜UK˜Kš
œ>˜>Kš
œ6˜6KšœŠ
žœ
žœžœ˜¹
K˜KšœŸ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜SK™2Kšœžœ
˜0Jš
œ0˜0Jš
œC˜Cšžœ{žœ
žœ
ž˜“
Jšžœžœ)žœ˜UJšžœ
˜—K˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜OK™.Kšœžœ
˜0Jš
œ0˜0Jš
œC˜Cšžœ{žœ
žœ
ž˜“
Jšžœžœ)žœ˜TJšžœ
˜—K˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜PKšœžœ/™KKšœžœ
˜0Jš
œ0˜0Jšœžœ
˜Jš
œC˜Cšžœ{žœ
žœ
ž˜“
šžœžœ˜'Jš
œ9˜9JšžœžœD˜ZJšžœI˜MJ˜J˜—Jšžœ
˜—Jš
œ\˜\Jš
œ%˜%K˜K˜—š
�œžœ+žœžœžœ˜~Kš
œ˜Kšœžœ
˜Kšœ	žœ
˜Kš
œ™Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜K˜Kš
œo˜oKšžœ
žœ	žœ
žœ
˜Kš
œ*˜*Kšœ
žœŸ˜@Kšœ
žœL˜XKš
œ6˜6Kš
œ™Kš
 ˜Kš
œ4˜4Kš
œ˜Kš
 ˜Kš
œ1˜1Kšœ
žœ3˜?Kš
œ4˜4Kšœžœ˜)K˜K˜—šÐbnœžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Cš�œžœ˜/Kš
œ*˜*Kš
œ)˜)Kšœžœ˜#Kš
œ*˜*Kš
œ&˜&Kš
œ-˜-Kš
œ)˜)K˜"Kš
œ2˜2Kš
œ*˜*Kš
œ-˜-K˜—Kšœžœ
˜0Kšœ
žœžœ˜-Kšœžœ!˜EK˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Nš�œžœ˜/Kš
œ*˜*Kš
œ)˜)Kšœžœ˜#Kš
œ*˜*Kš
œ&˜&Kš
œ-˜-Kš
œ)˜)K˜"Kš
œ˜Kš
œ*˜*Kš
œ-˜-K˜—Kšœžœ
˜0Kšœ
žœžœ˜-Kšœžœ!˜EK˜K˜—š¢
œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Iš�œžœ˜/Kš
œ*˜*Kš
œ)˜)Kšœžœ˜#Kš
œ*˜*Kš
œ&˜&K˜Kš
œ-˜-Kš
œ*˜*K˜K˜"Kšœ
 œ˜2K˜Kš
œ*˜*Kš
œ-˜-K˜—Kšœžœ
˜0Kšœ
žœžœ˜-Kšœžœ!˜EK˜K˜—š¢œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Fš�œžœ˜/Kšœ
žœžœ
˜Kš
œ*˜*Kš
œ&˜&Kš
œ-˜-Kš
œ)˜)šžœCžœžœ˜xKšœžœ
˜K˜—K˜"Kš
œ-˜-Kš
œ*˜*Kš
œ-˜-Kšžœ
žœžœ˜=K˜—Kšœžœ
˜0Kš
œ˜Kšœžœ
˜Kšœ	žœ
˜Kšœžœ˜#Kš
œ™Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kš
œ*˜*Kš
œ)˜)Kšœ
žœ˜!K˜Kš
œo˜oKšžœ
žœ	žœ
žœ
˜Kš
œ*˜*Kšœ
žœ:˜FKš
œ6˜6Kš
œ™Kš
 ˜Kš
œ6˜6Kš
œ˜Kš
 ˜Kš
œ1˜1Kšœ
žœ3˜?Kš
œ4˜4Kšœžœ˜)K˜K˜—K™K™š�œžœ
žœ5˜NK™Ä
Kš
œ2˜2Kš
œ˜Kšœžœ
˜
Kšœ3žœ˜;Kš
œ˜Kš
œ&˜&K˜K˜Kš
œ:˜:Kš
œ:˜:Kš
œ2˜2Kšœ$žœŸ3˜_šžœž˜šžœ#žœ˜+Kšœ$žœ
˜*Kšžœ
˜K˜—Kš
œ"˜"Kš
œ"˜"K˜Kš
œW˜WKš
 +˜+Kš
œ7˜7Kš
œ4˜4Kšœ# œXžœ˜‡
K–Ò
[testPoint: 
GGBasicTypes.Point, criticalR: 
REAL, currentObjects: 
GGMultiGravity.ObjectBag, activeObjects: 
GGMultiGravity.TriggerBag, gargoyleData: 
GGInterfaceTypes.GargoyleData, intersections: 
BOOL]šœ œXžœ˜�
š
žœžœ
žœžœ
žœ˜1Kš
œ˜K˜Kšžœ
˜K˜—šžœžœ
žœžœ
žœžœ1žœžœ˜™
Kš
œd˜dK˜K˜Kšžœžœ
žœ#˜=Kšžœžœ
žœ˜7K˜
—šžœ˜Kš
œ"˜"Kš
œ˜K˜Kš
œ+˜+Kš
œ˜K˜—Kšžœ
˜—Kš
œÔ
˜Ô
KšœŸ˜K˜—š�	œžœ9˜HKš
œ&˜&Kš
œ:˜:K˜K˜—š�œžœ9˜NKš
œ&˜&Kš
œ#˜#Kš
œ¤
˜¤
Kš
œ8˜8K˜K˜—š�œžœ9˜KKš
œ&˜&Kš
œ#˜#Kš
œ¤
˜¤
Kš
œE˜EK˜K˜—š�œžœŸ
˜»
šžœžœ
žœ˜Kš
œ+˜+K˜
—šžœ
žœžœ
žœ˜!Kš
œ)˜)K˜
—šžœ
žœžœ˜(Kš
œ+˜+K˜
—šžœ
žœ1žœ˜>Kš
œ+˜+K˜
—šžœ
žœžœ˜$Kš
œ)˜)Kš
œ"˜"Kš
œ+˜+K˜
—Kšžœ
žœ
˜Kš
œ"˜"K˜K˜—K˜K™Kšœ
žœ™&Kšœ
žœžœ
™!šœ
žœžœ™K™Kš
œ™—š
�
œžœ&žœžœžœ™aKšœžœ™1K™—š�
œžœžœ
žœžœžœ™GKšžœ
žœ™K™K™—š�
œžœžœ
žœžœžœ™9Kšœžœ
™(Kš
žœžœ
žœ
žœ
žœ™%Kšžœ™!K™K™—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜KKšœžœ
˜0Kš
œU™UKš	žœžœ
žœ
žœŸ™6šžœžœžœ™EKšœžœ
™"Kšœžœ
™Kš
œX™XKš
 ™Kš
œ™Kš
 ™Kš
œ1™1Kš
œU™UKš
œ6™6KšœŒ
žœ
žœžœ™»
K™
—šžœ™Kš
œi™iKš
œ%™%K™—Kš
œV˜VKš
œ%˜%KšœŸ˜K˜—š�œžœžœ
žœ™/Kšœžœ
™0K™ƒKšœžœ
™Kš
œ™K™Kš
œ'™'K™Kš
œ%™%K™&Kšœ
žœ
žœ
™Kš
œB™BKšœ	žœ
™K™K™
Kš
œ™Kšœ
žœ
™Kš
œ$™$Kš
œ@™@šžœRžœžœ
ž™gKšžœ
žœžœ
žœ
™,Kšžœ
žœžœ
žœ
™'Kšœžœ™)š
œ,™,Kš
 ™—Kš
œ*™*Kš
œ6™6Kš
œ*™*Kš
œ7™7š
œF™FKš
 ™—šžœžœBžœž™iKš
œ1™1Kš
œ-™-Kšžœ
™—Kš
œP™PKšžœ
™—Kš
œ%™%Kš
œ9™9šžœtžœ
ž™‹
Kš
œ™Kš
œK™KKšžœžœ
žœ
™'Kš
œ5™5šžœkžœž™ˆ
KšœIžœ™NKš
œ/™/Kšžœ
žœ	žœ
žœ
™Kš
œ$™$š
ž™šžœ™
KšœNžœ™SKš
œ'™'K™——Kšžœ
™—Kš
œD™DKš
œ6™6Kšžœ
™—™K™——š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜GKšœžœ
˜0Kš
œS˜SKš
œ!˜!Kš
œ˜K˜Kš
œK˜KKš
œ+˜+šžœžœ
žœžœ˜4Kš
œe˜eKšžœ˜K˜—Kš
œ˜Kš
œ)˜)Kš
œ/˜/šžœžœ
žœ˜Kš
œz˜zKšžœ˜Kš
œ˜—šžœCžœžœ
ž˜\Kš
œ˜Kšžœ
žœžœ
žœ
˜,šžœžœ˜!Kš
œc˜cKšžœ
˜K˜—Kš
 A˜AKšžœ
˜—Kšœ;Ÿ&˜aKš
œ,˜,KšœŒ
žœ
žœžœ˜»
š
ž˜Kšœžœ%˜B—KšœŸ˜—K˜š�œžœžœ™UK™'Kš
œ-™-Kš
œ™Kš
œ™K™š
œA™AKš
 0™0—Kš
œC™Cšžœržœ
žœ
ž™Š
Kš
œD™DKš
œ6™6Jšžœ
™Jš
 ™—Jš
œJ™Jšžœžœ
ž™šžœwžœ
žœ
ž™�
Jš
œ™šžœhžœžœ
ž™�
KšœŸœ<™LKš
œ+™+Kš
œ1™1Kšžœ™Jšžœ
™—šžœžœ
žœ™KšœŸœ=™Mšžœžœ™#Kš
œ$™$Kš
œ;™;K™
—šžœ™Kš
œ,™,Kš
œ1™1K™—Kšžœ™K™—š
ž™™Jš
œJ™JJ™——šžœ
™J™——Jšžœ
™—K™K™—K˜š�œžœžœ˜Rš�	œ˜Jšœžœ
˜J˜—K˜'K˜š
œA˜AKš
 0™0—Kš
œC˜Cšžœržœ
žœ
ž˜Š
Kš
œD˜DKš
œ6˜6Jšžœ
˜—š
œ(˜(J™^—Jšœ`žœ˜gKš
œ1˜1K˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜EKšœžœ
˜0Kš
œ˜Kš
œ@˜@Kš
œK˜KKš	žœžœ
žœ
žœŸ˜6Kš
œ=˜=Kšœ& œ˜GKšœŒ
žœ
žœžœ˜º
Kš
œ?˜?KšœŸ
˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜GKšœžœ
˜0Kš
žœ/žœ
žœTžœ
žœ
˜—
Kš
œ3˜3Kš
œ'˜'Kšœžœ
žœžœ˜­
Kš
œ˜K˜—š�	œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜HKšœžœ
˜0Kš
œC˜CKš
œ1˜1Kš
œ/˜/Kšœžœ˜)Kšœyžœ
žœžœ˜§
Kš
œB˜BK˜—K˜Kš
Ïz
™
Kšœžœ˜Kšœžœ˜Kšœžœžœžœ
žœ
žœ
žœžœ˜ZK˜š�œžœžœ˜3Kš
œm˜mKš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Jš�œ˜"Kš
œ(˜(Kš
œ˜—Kšœžœ
˜0Kš
œ2˜2KšœŸ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Eš�
œ˜K˜
Kš
œ@˜@Kš
œ+˜+Kš
œ˜—Kšœžœ
˜0Kš
œ,˜,KšœŸ
˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜KKšžœ
˜š�œžœžœ˜QKšœžœ
˜
Kš
œ˜Kš
œ˜Kš
œ ˜ Kš
œ˜Kš
œ˜Kšœ	žœ
˜Kš
œ"˜"Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ"˜"Kš
œF˜FKš
œ5˜5Kš
œ˜K–N[p0: 
GGBasicTypes.Point, p1: 
GGBasicTypes.Point, props: 
LIST OF REF ANY]š
œ<˜<K–N[p0: 
GGBasicTypes.Point, p1: 
GGBasicTypes.Point, props: 
LIST OF REF ANY]š
œ<˜<K–N[p0: 
GGBasicTypes.Point, p1: 
GGBasicTypes.Point, props: 
LIST OF REF ANY]š
œ<˜<K–N[p0: 
GGBasicTypes.Point, p1: 
GGBasicTypes.Point, props: 
LIST OF REF ANY]š
œ<˜<Kš
œ7˜7Kš
œ7˜7Kš
œ7˜7Kš
œ7˜7Kš
œ˜—Kšœžœ
˜0Kš
œ.˜.Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Gš�œ˜K˜
Kš
œ@˜@Kš
œ2˜2Kš
œ˜—Kšœžœ
˜0Kš
œ0˜0KšœŸ˜K˜—š�	œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜Hš�
œ˜ Kšœžœ
˜
Kš
œ˜K˜Kš
œ#˜#Kš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ2˜2Kš
œ˜—Kšœžœ
˜0Kš
œ2˜2KšœŸ˜K˜—š�œžœ<žœ˜\K™bK˜Kšœ	žœ
˜šžœžœ
Ÿ<˜ZK˜E—š	žœ
žœ
žœ&žœŸ\˜ 
Kš
œW˜WK˜<Kš
œ0˜0K˜
—š	žœ
žœžœ&žœŸ\˜¢
Kš
œ]˜]K˜<Kš
œ/˜/K˜
—šžœŸ2˜9Kš
œ,˜,K˜<Kš
œ0˜0K˜—Kšžœ
žœ	žœ
žœ
˜K˜K˜—š�œžœ<žœ˜[K™‰
Kšœ	žœ
˜šžœžœ
Ÿ<˜ZK˜E—šžœŸN˜UK˜K˜šžœžœ
žœ'ž˜5K˜)Kš
œ(˜(K˜<Kš
œ0˜0Kšžœ
žœ	žœ
žœ
˜K˜Kšžœ
˜—Kš
œ*˜*K˜<Kš
œ0˜0Kšžœ
žœ	žœ
žœ
˜K˜—K˜K˜—š�œžœ>žœ˜XKš
œT™TK™œ–B -- [run: GGModelTypes.Sequence] RETURNS [traj: GGModelTypes.Traj]š�	œ˜Kš
Ðck>™>Kš
œI˜IK˜5Kšžœžœ
žœ
žœ
žœŸ˜CK˜(šžœ;žœžœ
ž˜Pšžœžœ
Ÿ˜:Kš
œ]˜]š
œ˜Kš	žœžœžœžœ.ŸR˜Â
Kšžœ1Ÿ ˜UK˜—Kšžœžœ
˜—Kšžœ
˜—K˜—Kš
œ˜Kšœ]žœžœ˜iKš
œ,˜,KšœŒ
žœ
žœžœ˜º
K˜K˜—Kšœ
žœžœžœ˜Pš�
œžœ7˜JKš
œT™TKš�œ™‡
–B -- [run: GGModelTypes.Sequence] RETURNS [traj: GGModelTypes.Traj]š�	œ˜Kšœžœ™>Kš
œI˜IKš
œ5˜5Kšžœžœ
žœ
žœ
žœŸ˜CKš
œ(˜(šžœ;žœžœ
ž˜Pšžœžœ
Ÿ˜:Kš
œ#˜#Kšžœžœ
˜—Kšžœ
˜—Kš
œ˜—Kš
œ˜Kšœ]žœžœ˜iKš
œ,˜,KšœŒ
žœ
žœžœ˜º
Kš
œ˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜OKšœžœ
˜0K˜=K˜K˜—š�
œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜IKšœžœ
˜0K˜;K˜K˜—š�	œžœF˜Uš�œ˜!Kš
¤>™>Kš�
œžœ˜Kš�
œžœ˜K˜K˜Kšœžœžœ˜BKš	œ!žœžœžœ(žœ(˜¤
Kš
œP˜PKš
œ5˜5Kšœ	žœ
˜Kšœ	žœ˜Kš
žœžœ
žœ
žœ
žœ˜%Kšžœžœžœ˜@Kš
œ(˜(Kš
œ2˜2K˜šžœ;žœžœ
ž˜Pšžœžœ
žœ'ž˜5Kš
œ1˜1K˜0K˜Kšžœ
˜—Jš
œ$˜$J˜Kšžœ
˜—KšžœžœŸ=˜hKšœ2žœ˜7Kš
œJ˜JJš
œ0˜0Jšžœ
žœ	žœ
žœ
˜Kš
œ˜—Kšœ~žœžœ˜‹
KšœŒ
žœ
žœžœ
˜¹
K˜K™—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜RKšœžœ
˜0Kš
œžœžœžœ
žœ$žœ
žœ˜lKš
œD˜DKš
œ1˜1šžœGžœžœ
ž˜]Kš
œ;˜;šžœkžœžœ
ž˜Œ
–[atom: 
ATOM]šžœ<žœžœžœžœ	žœžœ˜iKš
œF˜FKš
œ9˜9Kš
œ˜—Kšžœ
˜—Kšžœ
˜—K–Û
[feedback: 
ViewerClasses.Viewer, msgType: 
GGError.MsgType, format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]š
œa˜aKšœyžœ
žœžœ˜¨
K˜—K˜K™š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜DKšœžœ
˜0Kšœžœ
žœ
˜Kš
œ˜Kš
œ˜K˜
Kšœ	žœ
˜Kš
œ-˜-š
ž˜Kšžœ	žœ
žœ
žœ
˜%šžœžœ
ž˜˜Kš
œ@˜@Kšžœ
žœ	žœ
žœ
˜K˜—šœž
˜Kšžœ žœ
žœ
˜8Kš
œ=˜=Kšžœ
žœ	žœ
žœ
˜%K˜—Kšžœžœ
˜—Kšžœžœžœ˜AKš
œ^˜^Kš
œ+˜+Kš
œ&˜&šžœžœ˜ Kšœ0žœ˜5Kš
œ'˜'Kšœ4žœ˜:K˜
—šžœ˜Kš
œC˜CKš
œC˜CKš
œ#˜#Kš
œG˜GK˜—Kš
œe˜eK–x[traj: 
GGModelTypes.Traj, gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGSegmentTypes.SelectionClass]š
œ6˜6K–£
[caret: 
GGInterfaceTypes.Caret, on: 
GGInterfaceTypes.CaretOn _ nothing, chair: 
REF ANY _ NIL, jointNum: 
NAT _ 999, cpNum: 
NAT _ 999, segNum: 
NAT _ 999]šœ"žœ˜'K–![caret: 
GGInterfaceTypes.Caret]š
œ/˜/Kš
œ5˜5šœŒ
žœ
žœžœ˜»
Kš
œ”
™”
—š
ž˜˜Kš
œ`˜`Kš
œ%˜%K˜—š
œ˜Kš
œ\˜\Kš
œ%˜%K˜——Kšžœ
˜—KšœŸ˜K˜—š�
œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ™IKšœžœ
™0Kš
œS™SšžœRžœžœ
ž™gKšœžœ
™Kšžœ
™—K™K™—š�
œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ™IKšœžœ
™0Kš
œS™SšžœRžœžœ
ž™gKšœžœ
™Kšžœ
™—K™—K™K™	š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜FKšœžœ
˜0Kšœžœ	žœ
žœžœ
žœ&˜YKšœžœ
žœžœ˜¸
K˜K˜—š�œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜MKšœžœ
˜0Kšœ'žœ
˜,K˜K˜—š�
œžœ
žœ	žœ
žœ
žœ
žœžœ
žœ˜LKšœžœ
˜0Kšœ'žœ
˜-K˜—K˜Kš
 $™$K™Kšžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ™.š
�œžœ4žœžœžœ˜dKšžœ˜š
�œžœžœžœžœ˜7Kšžœžœžœ
žœ˜6Kš
œ˜—Kšœžœ7˜?Kšœžœ7˜?šžœ˜Kšœ$ž˜'Kš
œ#˜#Kš
œ
˜
—Kš
œ˜—K˜Kšœžœ
˜ K˜š�œžœ˜K˜*Kš	œ¥
žœžœžœžœ˜¿
KšœAžœ˜cKšœ>žœ˜`K˜—K˜K˜K˜Kšžœ
˜—…—Üþf