DIRECTORY
Atom, BasicTime, BiScrollers, CodeTimer, ColorTool, CubicSplines, Feedback, FeedbackOps, FeedbackTypes, FileNames, FS, GGAlign, GGBasicTypes, GGBoundBox, GGCaret, GGControlPanelTypes, GGCoreOps, GGDescribe, GGEvent, GGEventExtras, GGFileIn, GGFileOps, GGFileOut, GGHistory, GGHistoryTypes, GGInterfaceTypes, GGModelTypes, GGMultiGravity, GGOutline, GGParent, GGRefresh, GGRefreshTypes, GGScene, GGSegmentTypes, GGSelect, GGSessionLog, GGShapes, GGSlice, GGSliceOps, GGState, GGStateExtras, GGUIUtility, GGUserInput, GGUserProfile, GGUtility, GGWindow, Imager, ImagerColor, ImagerColorFns, ImagerDitherContext, IO, NamedColors, Random, Real, RealFns, Rope, SlackProcess, SystemNames, TiogaOpsDefs, ViewersWorld, ViewerTools;

GGEventImplD: CEDAR PROGRAM
IMPORTS Atom, BasicTime, CodeTimer, ColorTool, Feedback, FeedbackOps, FileNames, FS, GGAlign, GGCaret, GGCoreOps, GGDescribe, GGEvent, GGFileIn, GGFileOps, GGFileOut, GGHistory, GGMultiGravity, GGOutline, GGParent, GGRefresh, GGScene, GGSelect, GGSessionLog, GGSlice, GGSliceOps, GGState, GGStateExtras, GGUIUtility, GGUserInput, GGUserProfile, GGUtility, GGWindow, Imager, ImagerColor, ImagerColorFns, IO, NamedColors, Random, Real, RealFns, Rope, SlackProcess, SystemNames, ViewersWorld, ViewerTools
EXPORTS GGEvent, GGEventExtras, GGInterfaceTypes = BEGIN

AlignBag: TYPE = GGInterfaceTypes.AlignBag;
BoundBox: TYPE = GGBoundBox.BoundBox;
ControlsObj: PUBLIC TYPE = GGControlPanelTypes.ControlsObj; -- exported to GGInterfaceTypes
FeatureData: TYPE = GGInterfaceTypes.FeatureData;
MsgRouter: TYPE = FeedbackTypes.MsgRouter;
GGData: TYPE = GGInterfaceTypes.GGData;
HistoryEvent: TYPE = GGHistoryTypes.HistoryEvent;
Joint: TYPE = GGModelTypes.Joint;
JointGenerator: TYPE = GGModelTypes.JointGenerator;
Point: TYPE = GGBasicTypes.Point;
RefreshDataObj: PUBLIC TYPE = GGRefreshTypes.RefreshDataObj;
ROPE: TYPE = Rope.ROPE;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
SelectionClass: TYPE = GGSegmentTypes.SelectionClass;
Sequence: TYPE = GGModelTypes.Sequence;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
SliceParts: TYPE = GGModelTypes.SliceParts;
Traj: TYPE = GGModelTypes.Traj;
TrajData: TYPE = GGModelTypes.TrajData;
TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
UserInputProc: TYPE = GGEvent.UserInputProc;
Vector: TYPE = GGBasicTypes.Vector;
WalkProc: TYPE = GGModelTypes.WalkProc;


OpenAutoScript: PUBLIC PROC [ggData: GGData, openNoMatterWhat: BOOL _ FALSE] = {
IF GGUserProfile.GetAutoScriptingOn[] THEN {
time: BasicTime.Unpacked _ BasicTime.Unpack[BasicTime.Now[]];
userName: Rope.ROPE _ SystemNames.UserName[];
name: Rope.ROPE _ IO.PutFR["%g%02g%02g%02g-%02g-", [rope[userName]], [integer[time.year-1900]], [integer[ORD[time.month]+1]], [integer[time.day]], [integer[time.hour]] ];
IF NOT openNoMatterWhat AND ggData.debug.autoScriptActionCount = ggData.debug.lastAutoScriptActionCount THEN RETURN; -- the user is just repeatedly hitting Clear
ggData.debug.lastAutoScriptActionCount _ ggData.debug.autoScriptActionCount;
name _ Rope.Concat[name, IO.PutFR["%02g-%02g.script", [integer[time.minute]], [integer[time.second]] ] ];
[ggData.debug.autoScriptStream, ggData.debug.autoScriptName] _ GGSessionLog.OpenScript[name, ggData, ggData.debug.autoScriptStream, ggData.debug.autoScriptName];
GGCoreOps.AppendRope[ggData.debug.autoScriptName, ggData.debug.autoScriptNames];
[] _ SlackProcess.EnableSessionLogging[ggData.slackHandle];
};
};

FileNameFromEvent: PUBLIC PROC [opName: Rope.ROPE, event: LIST OF REF ANY, currentWDir: Rope.ROPE, router: MsgRouter, emergency: BOOL _ FALSE] RETURNS [fileName, fullName: Rope.ROPE _ NIL, success: BOOL _ FALSE, versionSpecified: BOOL _ FALSE, noName: BOOL _ FALSE] = {
RopeFromRef: PROC [ref: REF ANY] RETURNS [rope: Rope.ROPE] ~ {
WITH ref SELECT FROM
text: REF TEXT => RETURN[Rope.FromRefText[text] ];
r: Rope.ROPE => RETURN[r];
ENDCASE => ERROR;
};
fileName _ IF event#NIL AND event.first#NIL THEN RopeFromRef[event.first] ELSE NIL;
IF Rope.Equal[fileName, NIL] THEN noName _ TRUE
ELSE [fullName, success, versionSpecified] _ GGFileOps.GetGargoyleFileName[opName, fileName, currentWDir, router, emergency];
};

Get: PUBLIC UserInputProc = {
fullName: Rope.ROPE;
success, versionSpecified, noName: BOOL _ FALSE;
CodeTimer.StartInt[$Get, $Gargoyle];
[----, fullName, success, versionSpecified, noName] _ FileNameFromEvent["Get", event.rest, ggData.currentWDir, ggData.router];
IF noName THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Get failed: no filename specified"]
ELSE IF success THEN {
startTime, endTime: BasicTime.GMT;
totalTime: INT;
Feedback.Append[ggData.router, begin, $Statistics, "Clearing ..."];
startTime _ BasicTime.Now[];
ClearAux[event, ggData];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
Feedback.Append[ggData.router, end, $Statistics, IO.PutFR[" done (%r)", [integer[totalTime]] ]];
ggData.debug.autoScriptNames _ GGCoreOps.NewRopeListt[]; -- clear script list
GetMergeAux[fullName, versionSpecified, $Get, "Getting", ggData, event];
GGState.NotNewVersion[ggData, $clean]; -- could be folded in to GGState.ClearAdvisory ??
OpenAutoScript[ggData, FALSE]; -- close the last script and open a new one.  Add it to list.
};
CodeTimer.StopInt[$Get, $Gargoyle];
};

Store: PUBLIC UserInputProc = {
tKeep: CARDINAL _  0;
f: IO.STREAM;
fullName, fsName: Rope.ROPE;
success, versionSpecified, noName: BOOL _ FALSE;
startTime, endTime: BasicTime.GMT;
totalTime: INT;
msgRope, opName: Rope.ROPE;
ofile: FS.OpenFile;
emergency: BOOL _ event.first=$Emergency;
[----, fullName, success, versionSpecified, noName] _ FileNameFromEvent[Atom.GetPName[NARROW[event.first]], event.rest, ggData.currentWDir, ggData.router, emergency];
IF noName AND NOT emergency THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Store failed: no filename specified"]
ELSE IF versionSpecified AND NOT emergency THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Store failed: store to explicit version forbidden"]
ELSE IF success THEN {
tKeep _ FS.FileInfo[name: fullName ! FS.Error => CONTINUE].keep;
ofile _ FS.Create[name: fullName, setPages: FALSE, setKeep: TRUE, keep: MAX[tKeep, 2] !
FS.Error => {
msgRope _ IO.PutFR["%g failed: could not create: %g [FS.Error: %g]",
[rope[opName]], [rope[fullName]], [rope[error.explanation]]];
IF NOT emergency THEN Feedback.Append[ggData.router, oneLiner, $Complaint, msgRope];
GOTO Abort;
};
];
fsName _ FS.GetName[ofile].fullFName;
f _ FS.StreamFromOpenFile[openFile: ofile, accessRights: $write];
opName _ IF event.first = NIL THEN "someSave" ELSE Atom.GetPName[NARROW[event.first]];
msgRope _ IO.PutFR["%g: %g . . . ", [rope[opName]], [rope[fullName]]];
IF NOT emergency THEN Feedback.Append[ggData.router, begin, $Statistics, msgRope];
GGEvent.SawTextFinish[ggData, NIL]; -- do this before fileout
startTime _ BasicTime.Now[];
GGFileOut.FileoutSceneAndOptions[f, ggData, fullName];
GGUIUtility.SafeClose[f, ggData.router];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
msgRope _ IO.PutFR[" Done in time (%r)", [integer[totalTime]]];
IF NOT emergency THEN Feedback.Append[ggData.router, end, $Statistics, msgRope];
GGState.StoreAdvisory[ggData, fsName, versionSpecified];
GGHistory.CapTool[GGState.GetFullName[ggData], ggData];
GGState.NotNewVersion[ggData, $clean];
OpenAutoScript[ggData, FALSE]; -- close the current script.  Open a new one and add to list.
EXITS
Abort => NULL;
};
};

CleanVersion:  UserInputProc = {
GGState.NotNewVersion[ggData, $clean];
};

Save: PUBLIC UserInputProc = {
IF GGState.GetFullName[ggData]#NIL THEN Store[event: LIST[$Save, FileNames.StripVersionNumber[GGState.GetFullName[ggData]]], ggData: ggData]
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "Save failed: can't save unnamed viewer; try Store"];
};

Destroy: PUBLIC UserInputProc = {
ggData.controls _ NIL; -- prevent unwanted actions on active control panels
ClearAux[event, ggData]; -- for garbage collection
};

Clear: PUBLIC UserInputProc = {
ClearAux[event, ggData];
IF event.first=$Clear THEN GGEvent.StandardAlignments[ggData, event];
GGState.ClearAdvisory[ggData];
GGHistory.CapTool[GGState.GetFullName[ggData], ggData];
GGEvent.SawTextFinish[ggData, NIL];
IF event.first=$Clear THEN GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: TRUE];
GGState.NotNewVersion[ggData, $clear]; -- could be folded in to GGState.ClearAdvisory ??
ggData.debug.autoScriptNames _ GGCoreOps.NewRopeListt[];
OpenAutoScript[ggData, FALSE]; -- close the last script and open a new one.  Add it to list.
IF event.first=$Clear THEN Feedback.Append[ggData.router, oneLiner, $Feedback, "Clear: completed"];
};

ConfirmClear: UserInputProc = {
Feedback.Append[ggData.router, oneLiner, $Confirm, "Confirm deletion of all objects"];
};

Reset: PUBLIC UserInputProc = {
IF GGState.AdviseRestore[ggData] THEN {
fileName: Rope.ROPE _ GGState.GetFullName[ggData];
CodeTimer.StartInt[$Restore, $Gargoyle];
ClearAux[event, ggData];
ggData.debug.autoScriptNames _ GGCoreOps.NewRopeListt[]; -- clear script list
GetMergeAux[fileName, FALSE, $Get, "Restoring", ggData, event]; -- makes new script list
GGState.NotNewVersion[ggData, $clean];
OpenAutoScript[ggData, FALSE]; -- close the last script and open a new one.  Add it to list.
CodeTimer.StopInt[$Restore, $Gargoyle];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Restore: completed"];
};
};

ConfirmReset: UserInputProc = {
filename: Rope.ROPE _ GGState.GetFullName[ggData];
IF Rope.Equal[filename, NIL] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Restore failed: no file loaded. Do not confirm."] 
ELSE Feedback.Append[ggData.router, oneLiner, $Confirm, "Confirm restore to original file"];
};

ConfirmGet: UserInputProc = {
fullName: Rope.ROPE;
success: BOOL _ FALSE;
filename: Rope.ROPE _ ViewerTools.GetSelectionContents[];
IF Rope.Equal[filename, NIL] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Get failed: no filename specified. Do not confirm."]
ELSE {
[fullName, success, ----] _ GGFileOps.GetGargoyleFileName["Get", filename, ggData.currentWDir, ggData.router, FALSE];
IF NOT success THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Get failed: bad filename specified. Do not confirm."]
ELSE Feedback.PutF[ggData.router, oneLiner, $Confirm, "Confirm Get of %g as a new scene", [rope[fullName]] ];
};
};

FileExists: PROC [fileName: Rope.ROPE] RETURNS [answer: BOOL _ TRUE] = {
[] _ FS.FileInfo[fileName !
FS.Error => IF error.code=$unknownFile THEN { answer _ FALSE; CONTINUE };
];
};

ConfirmStore: UserInputProc = {
fullName: Rope.ROPE;
success: BOOL _ FALSE;
filename: Rope.ROPE _ ViewerTools.GetSelectionContents[];
IF Rope.Equal[filename, NIL] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Store failed: no filename specified. Do not confirm."]
ELSE {
[fullName, success, ----] _ GGFileOps.GetGargoyleFileName["Store", filename, ggData.currentWDir, ggData.router, FALSE];
IF NOT success THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Store failed: bad filename specified. Do not confirm."]
ELSE Feedback.PutF[ggData.router, oneLiner, $Confirm, "Confirm Store to %g [%g File]", [rope[fullName]], [rope[IF FileExists[fullName] THEN "Old" ELSE "New"]] ];
};
};

ClearAux: PROC [event: LIST OF REF ANY, ggData: GGData] = {
GGState.SetActive[ggData, FALSE]; -- for now.  This will prevent most (but not all) race conditions with the Input Notify process.
ggData.refresh.overlayList _ NIL;
GGState.SetExtendMode[ggData, none];
GGState.SetSliceToExtend[ggData, NIL]; -- forget sliceToExtend
ggData.caret _ GGCaret.Create[]; -- forget caret and attractor
ggData.anchor _ GGCaret.Create[]; -- forget anchor
ggData.behavior.activeDoc _ NIL; -- next time this field is needed it will be recomputed
GGHistory.ResetHistory[ggData]; -- do this before MakeSceneGarbage, in order to synchronize with any outstanding advance captures by history mechanism
GGScene.MakeSceneGarbage[ggData.scene]; -- important unlink of circular garbage
GGAlign.MakeFiltersGarbage[ggData.hitTest]; -- important unlink of circular garbage
ggData.scene _ GGScene.CreateScene[]; -- drop old scene refs on floor
ggData.rootSlice _ GGSlice.MakeCircleSlice[[999.0, 999.0], [99.0, 99.0]].slice;
ggData.aborted _ ALL[FALSE];
ggData.refresh.dragInProgress _ FALSE;
ggData.refresh.caretIsMoving _ FALSE;
ggData.refresh.overlayList _ NIL;
ggData.refresh.orderedOverlayList _ NIL;
ggData.refresh.addedObject _ NIL;
ggData.refresh.recentFeature _ NIL;
ggData.refresh.textInProgress _ NIL;
ggData.refresh.areaFollowColorTool _ FALSE;
ggData.refresh.lineFollowColorTool _ FALSE;
GGRefresh.InvalidateForeground[ggData];
GGRefresh.InvalidateBackground[ggData];
};

MergeAll: PUBLIC UserInputProc = {
MergeAux[event, ggData, $MergeAll, "MergeAll"];
};

MergeShapes: PUBLIC UserInputProc = {
MergeAux[event, ggData, $MergeShapes, "MergeShapes"];
};

MergeOptions: PUBLIC UserInputProc = {
MergeAux[event, ggData, $MergeOptions, "MergeOptions"];
};

MergeAlignments: PUBLIC UserInputProc = {
MergeAux[event, ggData, $MergeAlignments, "MergeAlignments"];
};

MergeAux: PROC [event: LIST OF REF ANY, ggData: GGData, op: ATOM, opName: Rope.ROPE] = {
fullName: Rope.ROPE;
success, versionSpecified, noName: BOOL _ FALSE;
[----, fullName, success, versionSpecified, noName] _ FileNameFromEvent[opName, event.rest, ggData.currentWDir, ggData.router];
IF noName THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Merge failed: no filename specified"]
ELSE IF success THEN GetMergeAux[fullName, versionSpecified, op, opName, ggData, event];
};

GetMergeAux: PROC [fullName: Rope.ROPE, versionSpecified: BOOL _ FALSE, op: ATOM, opName: Rope.ROPE, ggData: GGData, event: LIST OF REF ANY] = {
f: IO.STREAM;
fsName: Rope.ROPE;
startTime: BasicTime.GMT;
endTime: BasicTime.GMT;
totalTime: INT;
success: BOOL _ FALSE;
successRope: Rope.ROPE;
failedRope: Rope.ROPE = "failed: malformed file";

Feedback.PutF[ggData.router, begin, $Statistics, " Opening %g ...", [rope[fullName]]];
startTime _ BasicTime.Now[];
f _ FS.StreamOpen[fullName, $read ! FS.Error, IO.Error => {
Feedback.PutF[ggData.router, oneLiner, $Complaint, "%g failed: could not find %g (FS or IO Error)", [rope[opName]],  [rope[fullName]]];
GOTO Abort;
};];
fsName _ FS.GetName[FS.OpenFileFromStream[f]].fullFName;
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
Feedback.PutF[ggData.router, end, $Statistics, " done (%r)", [integer[totalTime]]];

Feedback.PutF[ggData.router, begin, $Statistics, "%g %g . . . ", [rope[opName]], [rope[fsName]]];

startTime _ BasicTime.Now[];
BEGIN
SELECT op FROM
$Get => {
GGEvent.ClearAlignments[ggData, LIST[NIL]];
[success, successRope] _ GGFileIn.FileinSceneAndOptions[f, ggData, FALSE, FALSE];  -- NIL if filein aborted
IF success THEN {
directory: ROPE _ FileNames.Directory[fsName];
GGStateExtras.SetWorkingDirectory[ggData, directory];
}
ELSE { -- filein aborted
Clear[ggData, LIST[$ClearForFailedGet]];
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: TRUE];
Feedback.Append[ggData.router, end, $Statistics, failedRope];
GOTO FileinFailed;
};
};
$MergeAll => {
[success, successRope] _ GGFileIn.FileinSceneAndOptions[f, ggData, TRUE, TRUE];  -- NIL if filein aborted
IF NOT success THEN {
Feedback.Append[ggData.router, end, $Statistics, failedRope]; GOTO FileinFailed;
};
};
$MergeShapes => {
[success, successRope] _ GGFileIn.FileinSceneOnly[f, ggData.scene, TRUE, ggData.camera];  -- NIL if filein aborted
IF NOT success THEN {
Feedback.Append[ggData.router, end, $Statistics, failedRope]; GOTO FileinFailed;
};
};
$MergeOptions => {
[success, successRope] _ GGFileIn.FileinOptionsOnly[f, ggData, FALSE];
IF NOT success THEN {
Feedback.Append[ggData.router, end, $Statistics, failedRope]; GOTO FileinFailed;
};
};
$MergeAlignments => {
[success, successRope] _ GGFileIn.FileinOptionsOnly[f, ggData, TRUE];
IF NOT success THEN {
Feedback.Append[ggData.router, end, $Statistics, failedRope]; GOTO FileinFailed;
};
};
ENDCASE => ERROR;
GGUIUtility.SafeClose[f, ggData.router];
endTime _ BasicTime.Now[];
totalTime _ BasicTime.Period[startTime, endTime];
Feedback.PutF[ggData.router, end, $Statistics, " Done in time (%r)", [integer[totalTime]]];
IF op=$Get THEN { -- update viewer name on Get
GGState.GetAdvisory[ggData, fsName, versionSpecified];
GGHistory.CapTool[GGState.GetFullName[ggData], ggData];
};
GGEvent.SawTextFinish[ggData, LIST[$SawTextFinish]];
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintSceneNoBuffer, ggData: ggData, remake: triggerBag, edited: op#$Get, okToSkipCapture: FALSE];
EXITS
FileinFailed => GGUIUtility.SafeClose[f, ggData.router];
END;
EXITS
Abort => GGWindow.RestoreScreenAndInvariants[paintAction: $PaintSceneNoBuffer, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: FALSE]; -- needed in case of failure to read to clean out bags
};

AddToGroup: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
IF GGSelect.NoSelections[ggData.scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "AddToGroup failed: no objects selected"]
ELSE IF Rope.Equal[name, NIL] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "AddToGroup failed: can't AddToGroup, no group name selected"]
ELSE {
AddSegments: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[sliceD];
FOR seg: Segment _ GGSliceOps.NextSegment[sliceD.slice, segGen].seg, GGSliceOps.NextSegment[sliceD.slice, segGen].seg UNTIL seg=NIL DO
duplicate: BOOL _ FALSE;
FOR prop: LIST OF REF ANY _ seg.props, prop.rest UNTIL prop=NIL DO
nextProp: Rope.ROPE _ NARROW[prop.first];
IF Rope.Equal[name, nextProp, FALSE] THEN {
duplicate _ TRUE; -- already in this group
EXIT;
};
ENDLOOP;
IF NOT duplicate THEN seg.props _ CONS[name, seg.props];
someAddition _ TRUE;
ENDLOOP;
};
someAddition: BOOL _ FALSE;
scene: Scene _ ggData.scene;
[] _ GGScene.WalkSelectedSlices[scene, first, AddSegments, normal];
Feedback.PutF[ggData.router, oneLiner, $Feedback, IF someAddition THEN "AddToGroup: added selected segments to group %g" ELSE "AddToGroup: no segments added to group %g", [rope[name]] ];
IF someAddition THEN GGWindow.RestoreScreenAndInvariants[paintAction: $None, ggData: ggData, remake: none, edited: TRUE, okToSkipCapture: TRUE];
};
};

SelectGroup: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
IF Rope.Equal[name, NIL] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectGroup failed: can't SelectGroup, no group name selected"]
ELSE {
SelectSegments: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
FindProp: PROC [seg: Segment, transform: Imager.Transformation] RETURNS [keep: BOOL] = {
FOR prop: LIST OF REF ANY _ seg.props, prop.rest UNTIL prop=NIL DO
nextProp: Rope.ROPE _ NARROW[prop.first];
IF Rope.Equal[name, nextProp, FALSE] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};
withProps: SliceDescriptor _ GGSliceOps.WalkSegments[slice, FindProp];
IF withProps#NIL THEN GGSelect.SelectSlice[withProps, ggData.scene, normal];
};
scene: Scene _ ggData.scene;
GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
GGSelect.DeselectAll[ggData.scene, normal]; -- get rid of old selection
[] _ GGScene.WalkSlices[scene, first, SelectSegments];
IF GGSelect.NoSelections[ggData.scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectGroup failed: no such group"]
ELSE Feedback.PutF[ggData.router, oneLiner, $Feedback, "SelectGroup: group %g selected", [rope[name]] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: FALSE];
};
};

RemoveFromGroup: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
IF GGSelect.NoSelections[ggData.scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "RemoveFromGroup failed: no objects selected"]
ELSE IF Rope.Equal[name, NIL] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "RemoveFromGroup failed: can't RemoveFromGroup, no group name selected"]
ELSE {
RemoveSegments: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[sliceD];
FOR seg: Segment _ GGSliceOps.NextSegment[sliceD.slice, segGen].seg, GGSliceOps.NextSegment[sliceD.slice, segGen].seg UNTIL seg=NIL DO
newProps _ NIL;
FOR prop: LIST OF REF ANY _ seg.props, prop.rest UNTIL prop=NIL DO
nextProp: Rope.ROPE _ NARROW[prop.first];
IF NOT Rope.Equal[name, nextProp, FALSE] THEN newProps _ CONS[nextProp, newProps] ELSE someRemoval _ TRUE;
ENDLOOP;
seg.props _ newProps;
ENDLOOP;
};
someRemoval: BOOL _ FALSE;
newProps: LIST OF REF ANY;
scene: Scene _ ggData.scene;
[] _ GGScene.WalkSelectedSlices[scene, first, RemoveSegments, normal];
Feedback.PutF[ggData.router, oneLiner, $Feedback, IF someRemoval THEN "RemoveFromGroup: removed selected segments from group %g" ELSE "RemoveFromGroup: no member segments selected to remove from group %g", [rope[name]] ];
IF someRemoval THEN GGWindow.RestoreScreenAndInvariants[paintAction: $None, ggData: ggData, remake: none, edited: TRUE, okToSkipCapture: TRUE];
};
};

PrintGroupsOfSelected: PUBLIC UserInputProc = {
scene: Scene _ ggData.scene;
IF GGSelect.NoSelections[scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowGroupsOfSelected failed: no selections to show groups"]
ELSE {
DoPrintGroups: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[sliceD];
FOR seg: Segment _ GGSliceOps.NextSegment[sliceD.slice, segGen].seg, GGSliceOps.NextSegment[sliceD.slice, segGen].seg UNTIL seg=NIL DO
FOR prop: LIST OF REF ANY _ seg.props, prop.rest UNTIL prop=NIL DO
nextProp: Rope.ROPE _ NARROW[prop.first];
duplicate: BOOL _ FALSE;
FOR group: LIST OF REF ANY _ groupList, group.rest UNTIL group=NIL DO
nextGroup: Rope.ROPE _ NARROW[group.first];
IF Rope.Equal[nextGroup, nextProp, FALSE] THEN {
duplicate _ TRUE; -- already on the group list
EXIT;
};
ENDLOOP;
IF NOT duplicate THEN groupList _ CONS[nextProp, groupList];
ENDLOOP;
ENDLOOP;
};
groupList: LIST OF REF ANY;
[] _ GGScene.WalkSelectedSlices[scene, first, DoPrintGroups, normal];
IF groupList#NIL THEN {
Feedback.Append[ggData.router, begin, $Show, "ShowGroupsOfSelected: "];
FOR group: LIST OF REF ANY _ groupList, group.rest UNTIL group=NIL DO
nextGroup: Rope.ROPE _ NARROW[group.first];
Feedback.PutF[ggData.router, middle, $Show, "%g ", [rope[nextGroup]] ];
ENDLOOP;
Feedback.Append[ggData.router, end, $Show, ""];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Show, "ShowGroupsOfSelected: no groups of selected"];
};
};

PrintAllGroups: PUBLIC UserInputProc = {
groupList: LIST OF REF ANY;
scene: Scene _ ggData.scene;
EnumerateGroups: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
FindGroups: PROC [seg: Segment, transform: Imager.Transformation] RETURNS [keep: BOOL _ FALSE] = {
FOR prop: LIST OF REF ANY _ seg.props, prop.rest UNTIL prop=NIL DO
nextProp: Rope.ROPE _ NARROW[prop.first];
duplicate: BOOL _ FALSE;
FOR group: LIST OF REF ANY _ groupList, group.rest UNTIL group=NIL DO
nextGroup: Rope.ROPE _ NARROW[group.first];
IF Rope.Equal[nextGroup, nextProp, FALSE] THEN {
duplicate _ TRUE; -- already on the group list
EXIT;
};
ENDLOOP;
IF NOT duplicate THEN groupList _ CONS[nextProp, groupList];
ENDLOOP;
};
[] _ GGSliceOps.WalkSegments[slice, FindGroups];
};
[] _ GGScene.WalkSlices[scene, first, EnumerateGroups];
Feedback.Append[ggData.router, begin, $Show, "ShowAllGroups: "];
IF groupList#NIL THEN {
FOR group: LIST OF REF ANY _ groupList, group.rest UNTIL group=NIL DO
nextGroup: Rope.ROPE _ NARROW[group.first];
Feedback.PutF[ggData.router, middle, $Show, "%g ", [rope[nextGroup]] ];
ENDLOOP;
Feedback.Append[ggData.router, end, $Show, ""];
}
ELSE Feedback.Append[ggData.router, end, $Show, "no groups"];
};

Cluster: PUBLIC UserInputProc = {
IF GGSelect.NoSelections[ggData.scene, normal] THEN 
Feedback.Append[ggData.router, oneLiner, $Complaint, "Cluster failed: no selections to Cluster"]
ELSE {
AddSelectedToCluster: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
IF GGSelect.IsSelectedInPart[slice, ggData.scene, normal] THEN {
justFound _ TRUE;
[childList, ptr] _ GGUtility.AddSlice[slice, childList, ptr];
}
ELSE {
IF justFound THEN {
sliceInFront _ slice;
justFound _ FALSE;
};
};
};
cluster: Slice _ GGSlice.CreateCluster[frozen: FALSE];
scene: Scene _ ggData.scene;
childList, ptr: LIST OF Slice;
sliceInFront: Slice _ NIL;
priority: INT _ -1;
justFound: BOOL _ FALSE;
GGHistory.NewCapture["Cluster", ggData]; -- capture scene BEFORE UPDATE
GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedParts: TRUE];
[childList, ptr] _ GGUtility.StartSliceList[];
[] _ GGScene.WalkSlices[scene, first, AddSelectedToCluster];
FOR list: LIST OF Slice _ childList, list.rest UNTIL list = NIL DO
GGSelect.SaveSelectionsInSliceAllClasses[list.first, scene];
GGScene.DeleteSlice[scene, list.first];
GGSlice.AddChildToCluster[cluster, list.first, -1];
ENDLOOP;
IF sliceInFront = NIL OR justFound
THEN priority _ -1
ELSE priority _ GGScene.GetPriority[scene, sliceInFront];
GGScene.AddSlice[scene, cluster, priority];
GGSelect.ReselectSliceAllClasses[cluster, scene];
GGSelect.SelectEntireSlice[cluster, scene, normal];
GGCaret.SitOn[ggData.caret, NIL];
GGCaret.NoAttractor[ggData.caret];
GGHistory.PushCurrent[ggData];  -- push captured history event onto history list
Feedback.Append[ggData.router, oneLiner, $Feedback, "Cluster: new cluster created"];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, okToSkipCapture: FALSE];
};
};

ClusterAndFreeze: PUBLIC UserInputProc = {
IF GGSelect.NoSelections[ggData.scene, normal] THEN 
Feedback.Append[ggData.router, oneLiner, $Complaint, "Cluster failed: no selections to Cluster"]
ELSE {
Cluster[ggData, event];
FreezeCluster[ggData, event];
Feedback.Append[ggData.router, oneLiner, $Feedback, "ClusterAndFreeze: new cluster created and frozen"];
};
};

UnCluster: PUBLIC UserInputProc = {
IF GGSelect.NoSelections[ggData.scene, normal] THEN 
Feedback.Append[ggData.router, oneLiner, $Complaint, "UnCluster failed: no selections to UnCluster"]
ELSE {
BreakUpCluster: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
cluster: Slice _ sliceD.slice;
childList: LIST OF Slice _ GGParent.ListChildren[cluster, first];
priority _ GGScene.GetPriority[scene, cluster];
GGSelect.SaveSelectionsInSliceAllClasses[cluster, scene];
GGScene.DeleteSlice[scene, cluster];
GGScene.AddSlices[scene, childList, priority];
FOR list: LIST OF Slice _ childList, list.rest UNTIL list = NIL DO
GGSelect.ReselectSliceAllClasses[list.first, scene];
ENDLOOP;
newSlices _ GGUtility.AppendSliceList[newSlices, childList];
};
priority: INT _ -1;
scene: Scene _ ggData.scene;
newSlices: LIST OF Slice; -- build a list then select elements after to avoid modifying selection list during WalkSelectedSlices
GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
GGHistory.NewCapture["UnCluster", ggData];
[] _ GGScene.WalkSelectedSlices[scene, first, BreakUpCluster, normal, $Cluster];
FOR newSelections: LIST OF Slice _ newSlices, newSelections.rest UNTIL newSelections=NIL DO
GGSelect.SelectEntireSlice[newSelections.first, scene, normal]; -- better be topLevel slices
ENDLOOP;
GGCaret.SitOn[ggData.caret, NIL];
GGCaret.NoAttractor[ggData.caret];
GGHistory.PushCurrent[ggData];  -- push captured history event onto history list
Feedback.Append[ggData.router, oneLiner, $Feedback, "UnCluster: cluster unmade and components selected"];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, ggData: ggData, remake: triggerBag, edited: TRUE, okToSkipCapture: FALSE];
};
};

FreezeCluster: PUBLIC UserInputProc = {
scene: Scene _ ggData.scene;
IF GGSelect.NoSelections[scene, normal] THEN 
Feedback.Append[ggData.router, oneLiner, $Complaint, "FreezeCluster failed: no selections to Freeze"]
ELSE {
DoFreeze: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSlice.SetFrozen[sliceD.slice, TRUE];
};
[] _ GGScene.WalkSelectedSlices[scene, highest, DoFreeze, normal, $Cluster];
Feedback.Append[ggData.router, oneLiner, $Complaint, "FreezeCluster failed: frozen clusters Not Yet Implemented"];
};
};

ThawCluster: PUBLIC UserInputProc = {
scene: Scene _ ggData.scene;
IF GGSelect.NoSelections[scene, normal] THEN 
Feedback.Append[ggData.router, oneLiner, $Complaint, "ThawCluster failed: no selections to Thaw"]
ELSE {
DoThaw: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSlice.SetFrozen[sliceD.slice, FALSE];
};
[] _ GGScene.WalkSelectedSlices[scene, highest, DoThaw, normal, $Cluster];
Feedback.Append[ggData.router, oneLiner, $Feedback, "ThawCluster: selected clusters are now thawed"];
};
};

ShowFrozen: PUBLIC UserInputProc = {
BEGIN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowFrozen failed: frozen clusters Not Yet Implemented"]; RETURN; END;
<<
frozen: BOOL _ FALSE;
success: BOOL _ TRUE;
sliceD: SliceDescriptor _ NIL;
aborted: BOOL _ FALSE;
scene: Scene _ ggData.scene;
opName: Rope.ROPE _ "ShowFrozen failed: ";
DoCheckFrozen: PROC [thisD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
thisFrozen: BOOL _ FALSE;
IF sliceD = NIL THEN {
sliceD _ thisD;
frozen _ GGSlice.GetFrozen[thisD.slice];
}
ELSE {
thisFrozen _ GGSlice.GetFrozen[thisD.slice];
IF thisFrozen # frozen THEN done _ TRUE
};
};
aborted _ GGScene.WalkSelectedSlices[scene, highest, DoCheckFrozen, normal, $Cluster];
IF aborted THEN {
success _ FALSE;
Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowFrozen failed: more than one frozen state is selected"]];
}
ELSE IF sliceD = NIL THEN {
success _ FALSE;
Feedback.Append[ggData.router, oneLiner, $Complaint, Rope.Concat["ShowFrozen: no frozen clusters are selected"]];
};
IF NOT success THEN RETURN;
Feedback.PutF[ggData.router, Rope.Concat["ShowFrozen: ", GGCoreOps.BoolToRope[frozen]], oneLiner];
>>
};

RGBFromRopeError: SIGNAL = CODE;
CMYKFromRopeError: SIGNAL = CODE;
IntensityFromRopeError: SIGNAL = CODE;
ctRope: Rope.ROPE = "ColorTool operation failed: please create a ColorTool and retry";

AreaColorFromColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
color: ImagerColor.Color;
color _ ImagerColor.ColorFromRGB[ColorTool.GetRGBValue[NIL ! ColorTool.NoColorToolViewer => CONTINUE;]];
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope]
ELSE AreaColorAux[ggData, color, GGDescribe.ColorToRope[color]];
};
};

FillHueFromColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
color: ImagerColor.Color;
color _ ImagerColor.ColorFromRGB[ColorTool.GetRGBValue[NIL ! ColorTool.NoColorToolViewer => CONTINUE;]];
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope]
ELSE AreaColorAux[ggData, color, GGDescribe.ColorToRope[color], TRUE, $ChangeHue];
};
};

LineColorFromColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
color: ImagerColor.Color;
color _ ImagerColor.ColorFromRGB[ColorTool.GetRGBValue[NIL ! ColorTool.NoColorToolViewer => CONTINUE;]];
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope]
ELSE LineColorAux[ggData, color, GGDescribe.ColorToRope[color]];
};
};

StrokeHueFromColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
color: ImagerColor.Color;
color _ ImagerColor.ColorFromRGB[ColorTool.GetRGBValue[NIL ! ColorTool.NoColorToolViewer => CONTINUE;]];
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope]
ELSE LineColorAux[ggData, color, GGDescribe.ColorToRope[color], TRUE, $ChangeHue];
};
};

mapIndex: CARDINAL _ LAST[CARDINAL];
SpecialPixel: TYPE ~ ImagerDitherContext.SpecialPixel;
GetSpecialColor: PROC RETURNS [color: Imager.Color _ NIL] ~ {
ordinaryColor: Imager.ConstantColor;
ordinaryColor _ ImagerColor.ColorFromRGB[ColorTool.GetRGBValue[NIL ! ColorTool.NoColorToolViewer => CONTINUE;]];
IF ordinaryColor#NIL THEN  {
vw: ViewersWorld.Ref _ ViewersWorld.GetViewersWorld[];
IF mapIndex=LAST[CARDINAL] THEN mapIndex _ ViewersWorld.AllocateColorMapIndex[vw, 0, NIL, NIL]; -- try to allocate a color map index to keep
IF mapIndex=LAST[CARDINAL] THEN RETURN[NIL]; -- AllocateColorMapIndex failed
color _ MakeSpecialColor[specialPixel: [value: mapIndex, dstFunc: null], ordinaryColor: ordinaryColor];
ColorTool.RegisterNotifyProc[$GG, TrackPatch, NIL, NIL ! ColorTool.NoColorToolViewer => CONTINUE;]; -- proc will be unregistered by SawTextFinish
};
};

MakeSpecialColor: PROC [ordinaryColor: Imager.ConstantColor, specialPixel: SpecialPixel, name: Rope.ROPE _ NIL] RETURNS [Imager.SpecialColor] ~ {
pixelData: REF SpecialPixel _ NEW[SpecialPixel _ specialPixel];
color: ImagerColor.SpecialColor ~ NEW[ImagerColor.ColorRep.constant.special _ [constant[special[type: $Pixel, name: name, data: pixelData, substitute: ordinaryColor]]]];
RETURN [color];
};

gamma: REAL _ 2.2; -- value stolen from Zebra
ApplyGamma:  PROC [v: REAL, gamma: REAL] RETURNS [BYTE] ~ {
g: REAL ~ MIN[MAX[gamma, 0.01], 100.0];
uncorrected: REAL ~ MIN[MAX[v, 0.0], 1.0];
corrected: REAL ~ RealFns.Power[uncorrected, 1.0/g];
RETURN [Real.Round[MIN[MAX[corrected, 0.0], 1.0]*BYTE.LAST]];
};

TrackPatch: PROC[rgb: ImagerColor.RGB, clientData: REF] = { -- ColorTool.NotifyProc
ToByte: PROC[v: REAL] RETURNS[INTEGER] = {
IF v<=0.0 THEN RETURN[0];
IF v>=1.0 THEN RETURN[255];
RETURN[ApplyGamma[v, gamma]];
};
vw: ViewersWorld.Ref _ ViewersWorld.GetViewersWorld[];
IF mapIndex#LAST[CARDINAL] THEN ViewersWorld.SetColorMapEntry[vw, mapIndex, 0, ToByte[rgb.R], ToByte[rgb.G], ToByte[rgb.B] ];
};
AreaColorFollowColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
color: Imager.Color;
color _ GetSpecialColor[ ! ColorTool.NoColorToolViewer => CONTINUE;]; -- "animation" color;
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope]
ELSE {
ggData.refresh.areaFollowColorTool _ TRUE;
AreaColorAux[ggData, color, NIL, FALSE];
Feedback.Append[ggData.router, oneLiner, $Feedback, "FollowColorTool: selected objects fill color will follow ColorTool"];
};
};
};

LineColorFollowColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
color: Imager.Color;
color _ GetSpecialColor[ ! ColorTool.NoColorToolViewer => CONTINUE;]; -- "animation" color;
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope]
ELSE {
ggData.refresh.lineFollowColorTool _ TRUE;
LineColorAux[ggData, color, NIL, FALSE];
Feedback.Append[ggData.router, oneLiner, $Feedback, "FollowColorTool: selected objects stroke color will follow ColorTool"];
};
};
};

AreaColorToColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
success: BOOL _ FALSE;
color: Imager.Color;
[color, success] _ GetSelectedFillColor[ggData, "FillColorToColorTool"];
IF success THEN {
noColorTool: BOOL _ FALSE;
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "FillColorToColorTool: selected objects have NO fill color"] ELSE {
ColorTool.SetColor[color, NIL ! ColorTool.NoColorToolViewer => {
noColorTool _ TRUE;
CONTINUE;
};];
IF noColorTool THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope] ELSE Feedback.PutF[ggData.router, oneLiner, $Feedback, "FillColorToColorTool: %g sent to ColorTool", [rope[GGDescribe.ColorToRope[color]]] ];
};
}
};
};

LineColorToColorTool: PUBLIC UserInputProc = {
IF GGState.ColorToolIsBound[ggData] THEN {
color: Imager.Color;
success: BOOL _ FALSE;
[color, success] _ GetSelectedStrokeColor[ggData, "StrokeColorToColorTool"];
IF success THEN {
noColorTool: BOOL _ FALSE;
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Selected objects have NO stroke color"] ELSE {
ColorTool.SetColor[color, NIL ! ColorTool.NoColorToolViewer => {
noColorTool _ TRUE;
CONTINUE;
};];
IF noColorTool THEN Feedback.Append[ggData.router, oneLiner, $Complaint, ctRope] ELSE Feedback.PutF[ggData.router, oneLiner, $Feedback, "StrokeColorToColorTool: %g sent to ColorTool", [rope[GGDescribe.ColorToRope[color]]] ];
};
}
};
};

GetSelectedFillColor: PROC [ggData: GGData, opName: Rope.ROPE] RETURNS [color: ImagerColor.Color, success: BOOL _ TRUE] = {
sliceD: SliceDescriptor _ NIL;
aborted: BOOL _ FALSE;
someNotFilled: BOOL _ FALSE;
scene: Scene _ ggData.scene;
CheckColor: PROC [thisD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
thisColor: ImagerColor.Color;
firstChild: Slice;
IF sliceD = NIL THEN {
sliceD _ thisD;
[color, success] _ GGSliceOps.GetFillColor[thisD.slice, thisD.parts];
done _ NOT success;
}
ELSE {
[thisColor, success] _ GGSliceOps.GetFillColor[thisD.slice, thisD.parts];
IF NOT success OR NOT GGCoreOps.EquivalentColors[thisColor, color] THEN done _ TRUE
};
IF
(GGSliceOps.GetType[thisD.slice]=$Traj AND
NARROW[thisD.slice.data, TrajData].role=open) OR
(GGSliceOps.GetType[thisD.slice]=$Outline AND
GGSliceOps.GetType[(firstChild _ GGParent.FirstChild[thisD.slice, first])]=$Traj AND
NARROW[firstChild.data, TrajData].role=open)
THEN someNotFilled _ TRUE;
};
aborted _ GGScene.WalkSelectedSlices[scene, first, CheckColor, normal];
IF someNotFilled THEN {
success _ FALSE;
Feedback.PutF[ggData.router, oneLiner, $Complaint, "%g failed: select only CLOSED objects to specify fill color", [rope[opName]] ];
}
ELSE IF aborted THEN {
success _ FALSE;
Feedback.PutF[ggData.router, oneLiner, $Complaint, "%g failed: more than one fill colors are selected", [rope[opName]] ];
}
ELSE IF sliceD = NIL THEN {
success _ FALSE;
Feedback.PutF[ggData.router, oneLiner, $Complaint, "%g failed: no fill colors are selected", [rope[opName]] ];
};
};

GetSelectedStrokeColor: PROC [ggData: GGData, opName: Rope.ROPE] RETURNS [color: ImagerColor.Color, success: BOOL _ TRUE] = {
sliceD: SliceDescriptor _ NIL;
aborted: BOOL _ FALSE;
scene: Scene _ ggData.scene;
CheckColor: PROC [thisD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
thisColor: ImagerColor.Color;
IF sliceD = NIL THEN {
sliceD _ thisD;
[color, success] _ GGSliceOps.GetStrokeColor[thisD.slice, thisD.parts];
done _ NOT success;
}
ELSE {
[thisColor, success] _ GGSliceOps.GetStrokeColor[thisD.slice, thisD.parts];
IF NOT success OR NOT GGCoreOps.EquivalentColors[thisColor, color] THEN done _ TRUE
};
};
aborted _ GGScene.WalkSelectedSlices[scene, leaf, CheckColor, normal];
IF aborted THEN {
success _ FALSE;
Feedback.PutF[ggData.router, oneLiner, $Complaint, "%g failed: more than one stroke colors are selected", [rope[opName]] ];
}
ELSE IF sliceD = NIL THEN {
success _ FALSE;
Feedback.PutF[ggData.router, oneLiner, $Complaint, "%g failed: no stroke colors are selected", [rope[opName]] ];
};
};

AreaColorFromSelectedName: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ ParseColorName[name, ggData.router, "FillColorFromName"]; 
IF color#NIL THEN AreaColorAux[ggData, color, name];
};

LineColorFromSelectedName: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ ParseColorName[name, ggData.router, "StrokeColorFromName"]; 
IF color#NIL THEN LineColorAux[ggData, color, name];
};

ParseColorName: PROC [name: Rope.ROPE, router: MsgRouter, opRope: Rope.ROPE] RETURNS [color: Imager.Color _ NIL] ~ {
IF Rope.Equal[name, NIL] THEN Feedback.PutF[router, oneLiner, $Complaint, "%g failed: select a color name", [rope[opRope]] ]
ELSE {
IF Rope.Match["*/*", name] THEN {	--try for a registered name
GOTO UnImplementedColors;
}
ELSE color _ ImagerColor.ColorFromRGB[ImagerColorFns.RGBFromHSL[NamedColors.RopeToHSL[name !
NamedColors.UndefinedName => GOTO UndefinedName;
NamedColors.BadGrammar => GOTO BadGrammar;
]]];
EXITS
UnImplementedColors => Feedback.PutF[router, oneLiner, $Complaint, "%g failed: hierarchical names UNIMPLEMENTED in PCedar", [rope[opRope]] ];
UndefinedName => Feedback.PutF[router, oneLiner, $Complaint, "%g failed: undefined color name", [rope[opRope]] ];
BadGrammar => Feedback.PutF[router, oneLiner, $Complaint, "%g failed: bad color name syntax", [rope[opRope]] ];
};
};

AreaColorFromSelectedRGB: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ ImagerColor.ColorFromRGB[RGBFromRope[name ! RGBFromRopeError => GOTO SyntaxError]];
AreaColorAux[ggData, color, name];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "FillColorFromRGB failed: RGB syntax is [0.0..1.0] [0.0..1.0] [0.0..1.0]"];
};

LineColorFromSelectedRGB: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ ImagerColor.ColorFromRGB[RGBFromRope[name ! RGBFromRopeError => GOTO SyntaxError]];
LineColorAux[ggData, color, name];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "StrokeColorFromRGB failed: RGB syntax is [0.0..1.0] [0.0..1.0] [0.0..1.0]"];
};

FillColorFromSelectedCMYK: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ ImagerColorFns.ColorFromCMYK[CMYKFromRope[name ! CMYKFromRopeError => GOTO SyntaxError]];
AreaColorAux[ggData, color, name];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "FillColorFromCMYK failed: CMYK syntax is [0.0..1.0] [0.0..1.0] [0.0..1.0] [0.0..1.0]"];
};

FillColorFromSelectedIntensity: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
intensity: REAL _ IntensityFromRope[name ! IntensityFromRopeError => GOTO SyntaxError];
SetFillColorFromIntensity[ggData, intensity];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "FillColorFromIntensity failed: Intensity syntax is [0.0..1.0]"];
};

SetFillColorFromIntensity: PUBLIC PROC [ggData: GGData, intensity: REAL] = {
color: Imager.Color _ ImagerColor.ColorFromGray[1.0-intensity];
name: Rope.ROPE _ GGUtility.DescribeColor[color];
AreaColorAux[ggData, color, name];
};

StrokeColorFromSelectedCMYK: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ ImagerColorFns.ColorFromCMYK[CMYKFromRope[name ! CMYKFromRopeError => GOTO SyntaxError]];
LineColorAux[ggData, color, name];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "StrokeColorFromCMYK failed: CMYK syntax is [0.0..1.0] [0.0..1.0] [0.0..1.0] [0.0..1.0]"];
};

StrokeColorFromSelectedIntensity: PUBLIC UserInputProc = {
name: Rope.ROPE _ NARROW[event.rest.first];
intensity: REAL _ IntensityFromRope[name ! IntensityFromRopeError => GOTO SyntaxError];
SetStrokeColorFromIntensity[ggData, intensity];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "StrokeColorFromIntensity failed: Intensity syntax is [0.0..1.0]"];
};

SetStrokeColorFromIntensity: PUBLIC PROC [ggData: GGData, intensity: REAL] = {
color: Imager.Color _ ImagerColor.ColorFromGray[1.0-intensity];
name: Rope.ROPE _ GGUtility.DescribeColor[color];
LineColorAux[ggData, color, name];
};

SelectMatchingAreaColor: PUBLIC UserInputProc = {
rgb: ImagerColor.RGB;
name: Rope.ROPE _ NARROW[event.rest.first];
noneFlag: BOOL _ Rope.Equal[name, "none", FALSE];
scene: Scene _ ggData.scene;
DoSelect: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
fillColor: Imager.Color;
success: BOOL _ TRUE;
tallyD: SliceDescriptor;
DoMatchFillColor: PROC [slice: Slice] RETURNS [visitChildren: BOOL, keep: BOOL, done: BOOL _ FALSE] = {
IF GGSliceOps.GetType[slice] = $Cluster THEN {
visitChildren _ TRUE;
keep _ FALSE;
}
ELSE {
visitChildren _ FALSE;
fillColor _ GGSliceOps.GetFillColor[slice, NIL].color;
keep _ RGBEqualsColor[rgb, fillColor, noneFlag];
};
};
tallyD _ GGParent.TallyChildren[slice, DoMatchFillColor].tallyD;
IF tallyD#NIL THEN GGEvent.SelectSlice[tallyD, scene, normal, ggData];
};
IF NOT noneFlag THEN
rgb  _ SELECT event.first FROM
$SelectMatchingAreaCNS =>
ImagerColorFns.RGBFromHSL[NamedColors.RopeToHSL[name !
NamedColors.UndefinedName => GOTO UndefinedName;
NamedColors.BadGrammar => GOTO BadGrammar;
]],
$SelectMatchingAreaRGB =>
RGBFromRope[name ! RGBFromRopeError => GOTO SyntaxError]
ENDCASE => ERROR;
GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
GGSelect.DeselectAll[scene, normal];
[] _ GGScene.WalkSlices[scene, first, DoSelect];
Feedback.PutF[ggData.router, oneLiner, $Feedback, "SelectMatchingFill: fill color %g selected", [rope[name]] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: FALSE];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectMatchingFill failed: RGB syntax is [0.0..1.0] [0.0..1.0] [0.0..1.0]"];
UndefinedName => Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectMatchingFill failed: undefined color name"];
BadGrammar => Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectMatchingFill failed: bad color name syntax"];
};

SelectMatchingLineColor: PUBLIC UserInputProc = {
rgb: ImagerColor.RGB;
name: Rope.ROPE _ NARROW[event.rest.first];
scene: Scene _ ggData.scene;
noneFlag: BOOL _ Rope.Equal[name, "none", FALSE];
DoSelect: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
ColorProc: WalkProc = {
 RETURN [RGBEqualsColor[rgb, seg.color, noneFlag]];
};
sliceD: SliceDescriptor _ GGSliceOps.WalkSegments[slice, ColorProc]; -- get a descriptor of matching parts
GGSelect.SelectSlice[sliceD, ggData.scene, normal]; -- and select it
};
IF NOT noneFlag THEN rgb _ SELECT event.first FROM
$SelectMatchingLineCNS =>
ImagerColorFns.RGBFromHSL[NamedColors.RopeToHSL[name !
NamedColors.UndefinedName => GOTO UndefinedName;
NamedColors.BadGrammar => GOTO BadGrammar;
]],
$SelectMatchingLineRGB =>
RGBFromRope[name ! RGBFromRopeError => GOTO SyntaxError]
ENDCASE => ERROR;
GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
GGSelect.DeselectAll[ggData.scene, normal];
[] _ GGScene.WalkSlices[scene, first, DoSelect];
Feedback.PutF[ggData.router, oneLiner, $Feedback, "SelectMatchingStroke: stroke color %g selected", [rope[name]] ];
GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: FALSE];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectMatchingStroke failed: RGB syntax is [0.0..1.0] [0.0..1.0] [0.0..1.0]"];
UndefinedName => Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectMatchingStroke failed: undefined color name"];
BadGrammar => Feedback.Append[ggData.router, oneLiner, $Complaint, "SelectMatchingStroke failed: bad color name syntax"];
};

SetDefaultFillColor: PUBLIC UserInputProc = {
color: Imager.Color;
success: BOOL _ FALSE;
[color, success] _ GetSelectedFillColor[ggData, "SetDefaultFillColor"];
IF success THEN {
GGState.SetDefaultFillColor[ggData, color];
ShowDefaultFillColor[ggData, NIL];
};
};

SetDefaultFillColorFromRope: PUBLIC UserInputProc = {
rope: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ GGDescribe.ColorFromRope[rope];
GGState.SetDefaultFillColor[ggData, color];
};

SetDefaultLineColor: PUBLIC UserInputProc = {
color: Imager.Color;
success: BOOL _ FALSE;
[color, success] _ GetSelectedStrokeColor[ggData, "SetDefaultStrokeColor"];
IF success THEN {
GGState.SetDefaultStrokeColor[ggData, color];
ShowDefaultLineColor[ggData, NIL];
};
};

SetDefaultLineColorFromRope: PUBLIC UserInputProc = {
rope: Rope.ROPE _ NARROW[event.rest.first];
color: Imager.Color _ GGDescribe.ColorFromRope[rope];
GGState.SetDefaultStrokeColor[ggData, color];
};

ShowDefaultFillColor: PUBLIC UserInputProc = {
color: Imager.Color _ ggData.defaults.fillColor;
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Show, "Default Fill Color: none"]
ELSE Feedback.PutF[ggData.router, oneLiner, $Show, "Default Fill Color: %g", [rope[GGUtility.DescribeColor[color]]] ];
};

ShowDefaultLineColor: PUBLIC UserInputProc = {
color: Imager.Color _ ggData.defaults.strokeColor;
IF color=NIL THEN Feedback.Append[ggData.router, oneLiner, $Show, "Default Stroke Color: none"]
ELSE Feedback.PutF[ggData.router, oneLiner, $Show, "Default Stroke Color: %g", [rope[GGUtility.DescribeColor[color]]] ];
};


AreaColorBlack: PUBLIC UserInputProc = {
AreaColorAux[ggData, Imager.black, GGDescribe.ColorToRope[Imager.black]];
};

LineColorBlack: PUBLIC UserInputProc = {
LineColorAux[ggData, Imager.black, GGDescribe.ColorToRope[Imager.black]];
};

AreaColorWhite: PUBLIC UserInputProc = {
AreaColorAux[ggData, Imager.white, GGDescribe.ColorToRope[Imager.white]];
};

LineColorWhite: PUBLIC UserInputProc = {
LineColorAux[ggData, Imager.white, GGDescribe.ColorToRope[Imager.white]];
};

AreaColorGray: PUBLIC UserInputProc = {
AreaColorAux[ggData, GGOutline.fillColor, GGDescribe.ColorToRope[GGOutline.fillColor]];
};

LineColorGray: PUBLIC UserInputProc = {
LineColorAux[ggData, GGOutline.fillColor, GGDescribe.ColorToRope[GGOutline.fillColor]];
};

AreaColorNone: PUBLIC UserInputProc = {
AreaColorAux[ggData, NIL, NIL];
};

LineColorNone: PUBLIC UserInputProc = {
LineColorAux[ggData, NIL, NIL];
};

CopyStrokeColor: PUBLIC UserInputProc = {
currentEvent: HistoryEvent;
lastSliceD: SliceDescriptor;
color: Imager.Color;
scene: Scene _ ggData.scene;
success: BOOL _ FALSE;
ApplyColor: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSliceOps.SetStrokeColor[sliceD.slice, sliceD.parts, color, $Set, currentEvent];
};
lastSliceD _ GGSelect.GetLastSelection[scene];
IF lastSliceD#NIL THEN [color, success] _ GGSliceOps.GetStrokeColor[lastSliceD.slice, lastSliceD.parts];
IF success THEN {
currentEvent _ GGHistory.NewCurrent["Copy stroke color", ggData]; -- start new history event
[] _ GGScene.WalkSelectedSlices[scene, first, ApplyColor, normal];
GGHistory.PushCurrent[ggData];
Feedback.PutF[ggData.router, oneLiner, $Feedback, "CopyStrokeColor: color copied to selected objects"];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedInPlace, ggData: ggData, remake: none, edited: TRUE, okToSkipCapture: FALSE];
}
ELSE {
Feedback.Append[ggData.router, oneLiner, $Complaint, Rope.Concat["CopyStrokeColor failed: make a final selection that has a unique stroke color to copy"]];
};
};

CopyFillColor: PUBLIC UserInputProc = {
currentEvent: HistoryEvent;
lastSliceD: SliceDescriptor;
color: Imager.Color;
scene: Scene _ ggData.scene;
success: BOOL _ FALSE;
ApplyColor: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSliceOps.SetFillColor[sliceD.slice, sliceD.parts, GGCoreOps.CopyColor[color], $Set, currentEvent];
};
lastSliceD _ GGSelect.GetLastSelection[scene];
IF lastSliceD#NIL THEN [color, success] _ GGSliceOps.GetFillColor[lastSliceD.slice, lastSliceD.parts];
IF success THEN {
currentEvent _ GGHistory.NewCurrent["Copy fill color", ggData]; -- start new history event
[] _ GGScene.WalkSelectedSlices[scene, first, ApplyColor, normal];

GGHistory.PushCurrent[ggData];
Feedback.PutF[ggData.router, oneLiner, $Feedback, "CopyFillColor: color copied to selected objects"];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedInPlace, ggData: ggData, remake: none, edited: TRUE, okToSkipCapture: FALSE];
}
ELSE {
Feedback.Append[ggData.router, oneLiner, $Complaint, "CopyFillColor failed: make a final selection that has a unique fill color to copy"];
};
};

ShowFillColor: UserInputProc = {
color: Imager.Color;
success: BOOL _ FALSE;
[color, success] _ GetSelectedFillColor[ggData, "ShowFillColor"];
IF success THEN {
IF color#NIL THEN Feedback.PutF[ggData.router, oneLiner, $Show, "ShowFillColor: %g", [rope[GGUtility.DescribeColor[color]]] ]
ELSE Feedback.Append[ggData.router, oneLiner, $Show, "ShowFillColor: no fill color"];
};
};

ShowStrokeColor: PUBLIC UserInputProc = {
color: Imager.Color;
success: BOOL _ FALSE;
[color, success] _ GetSelectedStrokeColor[ggData, "ShowStrokeColor"];
IF success THEN {
IF color#NIL THEN Feedback.PutF[ggData.router, oneLiner, $Show, "ShowStrokeColor: %g", [rope[GGUtility.DescribeColor[color]]] ]
ELSE Feedback.Append[ggData.router, oneLiner, $Show, "ShowStrokeColor: no stroke color"];
};
};

ExtendToOutlineLevel: PROC [sliceD: SliceDescriptor] RETURNS [extendedD: SliceDescriptor] = {
DoExtendSelection: PROC [sliceD: SliceDescriptor] RETURNS [visitChildren: BOOL, keepD: SliceDescriptor, done: BOOL _ FALSE] = {
classType: ATOM _ GGSliceOps.GetType[sliceD.slice];
SELECT classType FROM
$Cluster => {
visitChildren _ TRUE;
keepD _ NIL;
};
ENDCASE => {
visitChildren _ FALSE;
keepD _ GGSliceOps.NewParts[sliceD.slice, NIL, slice];
};
};
[extendedD, ----] _ GGParent.TallyIncludedChildren[sliceD.slice, sliceD.parts, DoExtendSelection];
};

AreaColorAux: PUBLIC PROC [ggData: GGData, color: Imager.Color, name: Rope.ROPE _ NIL, noisy: BOOL _ TRUE, setHow: ATOM _ $Set] = {
IF GGSelect.NoSelections[ggData.scene, normal] THEN IF noisy THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetFillColor failed: no selections to set fill color"] ELSE NULL
ELSE {
currentEvent: HistoryEvent;
scene: Scene _ ggData.scene;
newSelectList, ptr: LIST OF SliceDescriptor;
extendToOutlinesD: SliceDescriptor;
DoApplyColor: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSliceOps.SetFillColor[sliceD.slice, sliceD.parts, color, setHow, currentEvent];
[newSelectList, ptr] _ GGUtility.AddSliceDescriptor[sliceD, newSelectList, ptr];
};
currentEvent _ GGHistory.NewCurrent["Set fill color", ggData]; -- start new history event
[newSelectList, ptr] _ GGUtility.StartSliceDescriptorList[];
[] _ GGScene.WalkSelectedSlices[scene, first, DoApplyColor, normal];
FOR list: LIST OF SliceDescriptor _ newSelectList, list.rest UNTIL list = NIL DO
extendToOutlinesD _ ExtendToOutlineLevel[list.first];
GGSelect.SelectSlice[extendToOutlinesD, scene, normal];
ENDLOOP;
GGHistory.PushCurrent[ggData];
IF noisy THEN Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetFillColor: fill color _ %g", IF name#NIL THEN [rope[name]] ELSE [rope["none"]]];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedInPlace, ggData: ggData, remake: none, edited: TRUE, okToSkipCapture: FALSE];
};
};

LineColorAux: PUBLIC PROC [ggData: GGData, color: Imager.Color, name: Rope.ROPE, noisy: BOOL _ TRUE, setHow: ATOM _ $Set] = {
IF GGSelect.NoSelections[ggData.scene, normal] THEN 
IF noisy THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetStrokeColor failed: no selections to set stroke color"] ELSE NULL
ELSE {
currentEvent: HistoryEvent;
scene: Scene _ ggData.scene;
DoApplyColor: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSliceOps.SetStrokeColor[sliceD.slice, sliceD.parts, color, setHow, currentEvent];
};
currentEvent _ GGHistory.NewCurrent["Set stroke color", ggData]; -- start new history event
[] _ GGScene.WalkSelectedSlices[scene, first, DoApplyColor, normal];
IF noisy THEN Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetStrokeColor: stroke color _ %g", IF name#NIL THEN [rope[name]] ELSE [rope["none"]]];
GGHistory.PushCurrent[ggData];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedInPlace, ggData: ggData, remake: none, edited: TRUE, okToSkipCapture: FALSE];
};
};
RGBEqualsColor: PROC [rgb: ImagerColor.RGB, color: Imager.Color, noneFlag: BOOL] RETURNS [BOOL] = {
epsilon: REAL = 1.0E-2;
IF color=NIL THEN RETURN [noneFlag]; -- color is none => RETURN[looking for none]
IF noneFlag THEN RETURN [FALSE] -- looking for none, but color is non-NIL
ELSE {
r, g, b: REAL;
WITH color SELECT FROM
constant: ImagerColor.ConstantColor => {
[r,g,b] _ GGCoreOps.ExtractRGB[constant];
RETURN[(r=rgb.R AND g=rgb.G AND b=rgb.B) OR (ABS[r-rgb.R]<epsilon AND ABS[g-rgb.G]<epsilon AND ABS[b-rgb.B]<epsilon)];
};
ENDCASE => RETURN[FALSE];
};
};

RGBFromRope: PROC [name: Rope.ROPE] RETURNS [rgb: ImagerColor.RGB] = {
ENABLE IO.Error, IO.EndOfStream => GOTO RGBError;
Check: PROC [x: REAL] = {
IF x NOT IN [0.0..1.0] THEN SIGNAL RGBFromRopeError;
};
rs: IO.STREAM _ IO.RIS[name];
rgb.R _ rs.GetReal[]; [] _ rs.SkipWhitespace[];
rgb.G _ rs.GetReal[]; [] _ rs.SkipWhitespace[];
rgb.B _ rs.GetReal[];
Check[rgb.R]; Check[rgb.G]; Check[rgb.B];
EXITS
RGBError => SIGNAL RGBFromRopeError;
};

CMYKFromRope: PROC [name: Rope.ROPE] RETURNS [cmyk: ImagerColorFns.CMYK] = {
ENABLE IO.Error, IO.EndOfStream => GOTO CMYKError;
Check: PROC [x: REAL] = {
IF x NOT IN [0.0..1.0] THEN SIGNAL CMYKFromRopeError;
};
rs: IO.STREAM _ IO.RIS[name];
[] _ rs.SkipWhitespace[];
cmyk.C _ rs.GetReal[]; [] _ rs.SkipWhitespace[];
cmyk.M _ rs.GetReal[]; [] _ rs.SkipWhitespace[];
cmyk.Y _ rs.GetReal[]; [] _ rs.SkipWhitespace[];
cmyk.K _ rs.GetReal[];
Check[cmyk.C]; Check[cmyk.M]; Check[cmyk.Y]; Check[cmyk.K];
EXITS
CMYKError => SIGNAL CMYKFromRopeError;
};

IntensityFromRope: PROC [name: Rope.ROPE] RETURNS [intensity: REAL] = {
ENABLE IO.Error, IO.EndOfStream => GOTO IntensityError;
Check: PROC [x: REAL] = {
IF x NOT IN [0.0..1.0] THEN SIGNAL IntensityFromRopeError;
};
rs: IO.STREAM _ IO.RIS[name];
intensity _ rs.GetReal[];
Check[intensity];
EXITS
IntensityError => SIGNAL IntensityFromRopeError;
};


TestGravity: PUBLIC UserInputProc = {
xRandomStream, yRandomStream: Random.RandomStream;
desiredCount: INT _ NARROW[event.rest.first, REF INT]^;
testPoint: Point;
x, y: INT;
totalCount, multiHitCount, uniHitCount, diffCount: NAT _ 0;
multiPoint: Point;
normal: Vector;
multiFeature: FeatureData;
currentObjects: AlignBag;
sceneObjects: TriggerBag;

IF desiredCount<=0 OR desiredCount=LAST[INT] THEN RETURN;
xRandomStream _ Random.Create[GGState.GetWidth[ggData]];
yRandomStream _ Random.Create[GGState.GetHeight[ggData]];
ggData.aborted[gravitytest] _ FALSE;  -- in case there was one left over from prior abort
UNTIL totalCount >= desiredCount DO
IF ggData.aborted[gravitytest] THEN {
ggData.aborted[gravitytest] _ FALSE;
EXIT;
};
x _ Random.NextInt[xRandomStream];
y _ Random.NextInt[yRandomStream];
testPoint _ [x, y];
testPoint _ GGWindow.ViewerToWorld[viewerPoint: testPoint, ggData: ggData];
ggData.refresh.spotPoint _ testPoint;
currentObjects _ ggData.hitTest.alignBag;
sceneObjects _ ggData.hitTest.sceneBag;
[multiPoint, normal, multiFeature] _ GGMultiGravity.Map[testPoint, ggData.hitTest.t, currentObjects, sceneObjects, ggData, TRUE];
IF multiFeature = NIL THEN {
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintSpot, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
totalCount _ totalCount + 1;
LOOP;
};
multiHitCount _ multiHitCount + 1;
totalCount _ totalCount + 1;
ggData.refresh.hitPoint _ multiPoint;
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintHitLine, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
ENDLOOP;
Feedback.PutF[ggData.router, oneLiner, $Feedback, "Tested %g total points.  %g unihits.  %g multihits.  %g differences", [integer[totalCount]], [integer[uniHitCount]], [integer[multiHitCount]], [integer[diffCount]]];
}; -- end TestGravity

noisyTestGravity: BOOL _ FALSE;

Statistics: PUBLIC UserInputProc = {
f: IO.STREAM _ FeedbackOps.GetTypescriptStream[$Gargoyle];
IF f#NIL THEN CodeTimer.PrintTable[f, CodeTimer.GetTable[$Gargoyle]];
};

AppendStatistics: PUBLIC UserInputProc = {
completeName: Rope.ROPE;
BEGIN
ENABLE FS.Error => {Feedback.PutF[ggData.router, oneLiner, $Complaint, "FS.Error %g: %g", [rope[error.explanation]], [rope[completeName]] ]; CONTINUE };
fileName: Rope.ROPE _ NARROW[event.rest.first];
f: IO.STREAM;
completeName _ fileName;
f _ FS.StreamOpen[completeName, $append];
IF f#NIL THEN CodeTimer.PrintTable[f, CodeTimer.GetTable[$Gargoyle] ! CodeTimer.Problem => CONTINUE;];
GGUIUtility.SafeClose[f, ggData.router];
END;
};

PrintSelectedStatistic: PUBLIC UserInputProc = {
intervalRope: Rope.ROPE _ NARROW[event.rest.first];
intervalName: ATOM _ Atom.MakeAtom[intervalRope];
f: IO.STREAM _ FeedbackOps.GetTypescriptStream[$Gargoyle];
IF f#NIL AND NOT Rope.Equal[intervalRope, NIL] THEN {
f.PutRope["\n"];
CodeTimer.PrintInt[f, intervalName, $Gargoyle ! CodeTimer.Problem => CONTINUE;];
};
};

AppendSelectedStatistic: PUBLIC UserInputProc = {
completeName: Rope.ROPE;
BEGIN
ENABLE FS.Error => {Feedback.PutF[ggData.router, oneLiner, $Complaint, "FS.Error %g: %g", [rope[error.explanation]], [rope[completeName]] ]; CONTINUE };
fileName: Rope.ROPE _ NARROW[event.rest.first];
intervalName: Rope.ROPE _ NARROW[event.rest.rest.first];
atom: ATOM _ Atom.MakeAtom[intervalName];
f: IO.STREAM;
completeName _ fileName;
f _ FS.StreamOpen[completeName, $append];
IF f#NIL AND NOT Rope.Equal[intervalName, NIL] THEN CodeTimer.PrintInt[f, atom, $Gargoyle ! CodeTimer.Problem => CONTINUE;];
GGUIUtility.SafeClose[f, ggData.router];
END;
};

AppendRope: PUBLIC UserInputProc = {
completeName: Rope.ROPE;
BEGIN
ENABLE FS.Error => {Feedback.PutF[ggData.router, oneLiner, $Complaint, "FS.Error %g: %g", [rope[error.explanation]], [rope[completeName]] ]; CONTINUE };
fileName: Rope.ROPE _ NARROW[event.rest.first];
message: Rope.ROPE _ NARROW[event.rest.rest.first];
f: IO.STREAM;
completeName _ fileName;
f _ FS.StreamOpen[completeName, $append];
IF f#NIL AND NOT Rope.Equal[message, NIL] THEN f.PutRope[message];
GGUIUtility.SafeClose[f, ggData.router];
END;
};

CreateFile: PUBLIC UserInputProc = {
ENABLE FS.Error => {Feedback.PutF[ggData.router, oneLiner, $Complaint, "FS.Error %g", [rope[error.explanation]] ]; CONTINUE };
fileName: Rope.ROPE _ NARROW[event.rest.first];
f: IO.STREAM _ FS.StreamOpen[fileName, $create]; -- merely causes file creation
GGUIUtility.SafeClose[f, ggData.router];
};

ResetStatistics: PUBLIC UserInputProc = {
CodeTimer.ResetTable[CodeTimer.GetTable[$Gargoyle]];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Statistics reset"];
};

DrawTouchPoints: PUBLIC UserInputProc = {
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintTouchPoints, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
};

DrawBoundBoxes: PUBLIC UserInputProc = {
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintBoundBoxes, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
};

DrawTightBoxes: PUBLIC UserInputProc = {
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintTightBoxes, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
};

DrawOutlineBoxes: PUBLIC UserInputProc = {
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintOutlineBoxes, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
};

DrawSelectionBox: PUBLIC UserInputProc = {
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintSelectionBox, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
};

DrawMovingBox: PUBLIC UserInputProc = {
atom: ATOM _ NARROW[event.first];
GGWindow.RestoreScreenAndInvariants[paintAction: atom, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
};
DescribeCaretObject: PUBLIC UserInputProc = {
description: Rope.ROPE _ "no object";
chair: SliceDescriptor  _ GGCaret.GetChair[ggData.caret];
IF chair#NIL THEN description _ GGSliceOps.Describe[chair];
Feedback.PutF[ggData.router, oneLiner, $Show, "Caret is on %g", [rope[description]]];
};

CauseAnError: PUBLIC UserInputProc = {
scene: GGModelTypes.Scene _ ggData.scene;
firstSlice, secondSlice: GGModelTypes.Slice;
index: NAT _ 0;
FirstAndSecond: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
IF index = 0 THEN {
firstSlice _ slice;
index _ index + 1;
}
ELSE IF index = 1 THEN {
secondSlice _ slice;
done _ TRUE;
};
};
[] _ GGScene.WalkSlices[scene, first, FirstAndSecond];
SIGNAL Feedback.Problem[msg: "Client requested SIGNAL"];
};

printAllInput: BOOL _ FALSE; -- controlled by Debug menu

PrintAllInput: PUBLIC UserInputProc = {
IF printAllInput THEN {
FOR list: LIST OF REF ANY _ event, list.rest UNTIL list = NIL DO
WITH list.first SELECT FROM
atom: ATOM => Feedback.PutF[ggData.router, begin, $Typescript, "%g ", [rope[Atom.GetPName[atom]]] ];
int: REF INT => Feedback.PutF[ggData.router, middle, $Typescript, "%g ", [integer[int^]] ];
real: REF REAL => Feedback.PutF[ggData.router, middle, $Typescript, "%g ", [real[real^]]];
card: REF CARD => Feedback.PutF[ggData.router, middle, $Typescript, "%g ", [cardinal[card^]]];
refChar: REF CHAR => Feedback.PutF[ggData.router, middle, $Typescript, "%g ", [character[refChar^]]];
coords: BiScrollers.ClientCoords => Feedback.PutF[ggData.router, middle, $Typescript, "(%g, %g )", [real[coords.x]], [real[coords.y]] ];
ENDCASE => Feedback.Append[ggData.router, middle, $Typescript, "Unknown input type"];
ENDLOOP;
Feedback.Append[ggData.router, end, $Typescript, "" ];
};
};

PrintAllInputOn: PUBLIC UserInputProc = {
printAllInput _ TRUE;
};

PrintAllInputOff: PUBLIC UserInputProc = {
printAllInput _ FALSE;
};

Typescript: PUBLIC UserInputProc = {
GGState.Typescript[ggData];
};

Init: PROC = {
OPEN GGUserInput;

RegisterAction[$Destroy, Destroy, none];
RegisterAction[$Clear, Clear, none];
RegisterAction[$ConfirmClear, ConfirmClear, none];
RegisterAction[$Reset, Reset, none];
RegisterAction[$ConfirmReset, ConfirmReset, none];
RegisterAction[$Get, Get, rope];
RegisterAction[$ConfirmGet, ConfirmGet, none];
RegisterAction[$MergeAll, MergeAll, rope];
RegisterAction[$MergeShapes, MergeShapes, rope];
RegisterAction[$MergeOptions, MergeOptions, rope];
RegisterAction[$MergeAlignments, MergeAlignments, rope];
RegisterAction[$Store, Store, rope];
RegisterAction[$StoreOnPlayback, Store, rope];
RegisterAction[$ConfirmStore, ConfirmStore, none];
RegisterAction[$Save, Save, none];
RegisterAction[$SaveOnPlayback, Save, none];
RegisterAction[$CleanVersion, CleanVersion, none];

RegisterAction[$AddToGroup, AddToGroup, rope];
RegisterAction[$SelectGroup, SelectGroup, rope];
RegisterAction[$RemoveFromGroup, RemoveFromGroup, rope];
RegisterAction[$PrintGroupsOfSelected, PrintGroupsOfSelected, none];
RegisterAction[$PrintAllGroups, PrintAllGroups, none];
RegisterAction[$Cluster, Cluster, none];
RegisterAction[$ClusterAndFreeze, ClusterAndFreeze, none];
RegisterAction[$UnCluster, UnCluster, none];
RegisterAction[$FreezeCluster, FreezeCluster, none];
RegisterAction[$ThawCluster, ThawCluster, none];
RegisterAction[$ShowFrozen, ShowFrozen, none];

RegisterAction[$AreaColorFromColorTool, AreaColorFromColorTool, none];
RegisterAction[$FillHueFromColorTool, FillHueFromColorTool, none];
RegisterAction[$AreaColorFollowColorTool, AreaColorFollowColorTool, none];
RegisterAction[$AreaColorToColorTool, AreaColorToColorTool, none];
RegisterAction[$AreaColorFromSelectedName, AreaColorFromSelectedName, rope];
RegisterAction[$AreaColorFromSelectedRGB, AreaColorFromSelectedRGB, rope];
RegisterAction[$FillColorFromSelectedCMYK, FillColorFromSelectedCMYK, rope];
RegisterAction[$FillColorFromSelectedIntensity, FillColorFromSelectedIntensity, rope];
RegisterAction[$PrintAreaColor, ShowFillColor, none];
RegisterAction[$SelectMatchingAreaRGB, SelectMatchingAreaColor, rope];
RegisterAction[$SelectMatchingAreaCNS, SelectMatchingAreaColor, rope];
RegisterAction[$AreaColorBlack, AreaColorBlack, none];
RegisterAction[$AreaColorWhite, AreaColorWhite, none];
RegisterAction[$AreaColorGray, AreaColorGray, none];
RegisterAction[$AreaColorNone, AreaColorNone, none];
RegisterAction[$CopyFillColor, CopyFillColor, none];
RegisterAction[$SetDefaultFillColor, SetDefaultFillColor, none];
RegisterAction[$SetDefaultFillColorFromRope, SetDefaultFillColorFromRope, rope];
RegisterAction[$ShowDefaultFillColor, ShowDefaultFillColor, none];

RegisterAction[$LineColorFromColorTool, LineColorFromColorTool, none];
RegisterAction[$StrokeHueFromColorTool, StrokeHueFromColorTool, none];
RegisterAction[$LineColorFollowColorTool, LineColorFollowColorTool, none];
RegisterAction[$LineColorToColorTool, LineColorToColorTool, none];
RegisterAction[$LineColorFromSelectedName, LineColorFromSelectedName, rope];
RegisterAction[$LineColorFromSelectedRGB, LineColorFromSelectedRGB, rope];
RegisterAction[$StrokeColorFromSelectedCMYK, StrokeColorFromSelectedCMYK, rope];
RegisterAction[$StrokeColorFromSelectedIntensity, StrokeColorFromSelectedIntensity, rope];
RegisterAction[$SelectMatchingLineRGB, SelectMatchingLineColor, rope];
RegisterAction[$SelectMatchingLineCNS, SelectMatchingLineColor, rope];
RegisterAction[$PrintLineColor, ShowStrokeColor, none];
RegisterAction[$LineColorBlack, LineColorBlack, none];
RegisterAction[$LineColorWhite, LineColorWhite, none];
RegisterAction[$LineColorGray, LineColorGray, none];
RegisterAction[$LineColorNone, LineColorNone, none];
RegisterAction[$CopyStrokeColor, CopyStrokeColor, none];
RegisterAction[$SetDefaultLineColor, SetDefaultLineColor, none];
RegisterAction[$SetDefaultLineColorFromRope, SetDefaultLineColorFromRope, rope];
RegisterAction[$ShowDefaultLineColor, ShowDefaultLineColor, none];

RegisterAction[$TestGravity, TestGravity, refInt];
RegisterAction[$Statistics, Statistics, none];
RegisterAction[$AppendStatistics, AppendStatistics, none];
RegisterAction[$PrintSelectedStatistic, PrintSelectedStatistic, rope];
RegisterAction[$AppendSelectedStatistic, AppendSelectedStatistic, none];
RegisterAction[$AppendRope, AppendRope, none];
RegisterAction[$CreateFile, CreateFile, none];
RegisterAction[$ResetStatistics, ResetStatistics, none];
RegisterAction[$DrawTightBoxes, DrawTightBoxes, none];
RegisterAction[$DrawBoundBoxes, DrawBoundBoxes, none];
RegisterAction[$DrawOutlineBoxes, DrawOutlineBoxes, none];
RegisterAction[$DrawSelectionBox, DrawSelectionBox, none];
RegisterAction[$DrawBackgroundBox, DrawMovingBox, none];
RegisterAction[$DrawOverlayBox, DrawMovingBox, none];
RegisterAction[$DrawRubberBox, DrawMovingBox, none];
RegisterAction[$DrawDragBox, DrawMovingBox, none];
RegisterAction[$Typescript, Typescript, none];
RegisterAction[$DescribeCaretObject, DescribeCaretObject, none];
RegisterAction[$PrintAllInput, PrintAllInputOn, none];
RegisterAction[$ResetAllInput, PrintAllInputOff, none];
RegisterAction[$CauseAnError, CauseAnError, none];

};

Init[];

END.
æGGEventImplD.mesa
Contents:  Once an event reaches the front of the slack-process queue, it is dispatched to one of the procedures in this module.
Copyright Ó 1986, 1987, 1988, 1989, 1990 by Xerox Corporation.  All rights reserved.
Pier, May 14, 1992 12:21 pm PDT
Kurlander, September 1, 1987 3:54:12 pm PDT
Bier, March 18, 1992 6:40 pm PST
Doug Wyatt, February 21, 1990 5:44 pm PST

File Operations

ASSERT: event is either NIL or event.first=filename
ASSERT: event.first=$Get, event.rest=NIL OR filename
ASSERT: event.first=$Store or $Save, event.rest=NIL OR filename
Save is simply Store invoked with event.rest.first=GargoyleFileName.  KAP February 17, 1986
START TIMING
tell the state manager that a Store just completed
called from GGUtilityImplA.GargoyleContainerDestroy
tell the state manager that a Clear just completed
Auto Scripting
ask the state manager if a Restore is possible
This proc is a mess but can't be easily sanitized
DKW: if some other error.code, reject is probably better than unnamed ERROR
This proc is a mess but can't be easily sanitized
ggData.refresh.suppressRefresh _ FALSE; -- interferes with Clear in FastPlayback scripts
ASSERT: event.first=$MergeAll, event.rest=NIL OR filename
ASSERT: op=$Merge* or $Get
TIMING VARIABLES
START TIMING
tell the state manager that a Get just completed
Group Operations
ggData.refresh.startBoundBox^ _ GGScene.BoundBoxOfSelected[scene, normal, TRUE]^;
Feedback.Append[ggData.router, oneLiner, $Feedback, "FreezeCluster: selected clusters are now frozen"];
Fill and Line Colors

Copied from ImagerDitherContextImpl, so that Gargoyle doesn't import ImagerDitherContextImpl, which isn't available for remote Viewers worlds.
N.B.: this code stupidly written to get around compiler.
color _ ImagerColor.Find[name];
IF color=NIL THEN color _ ImagerColor.Find[Rope.Cat["Xerox/Research/", name]];
IF color=NIL THEN GOTO UnregisteredName;
UnregisteredName => Feedback.PutF[router, oneLiner, $Complaint, "%g failed: hierarchical name not registered", [rope[opRope]] ];
WalkProc: TYPE = PROC [seg: Segment] RETURNS [keep: BOOL];
PaletteForFillColor: PUBLIC UserInputProc = {
boolRope: Rope.ROPE _ NARROW[event.rest.first];
paletteForFillColorOn: BOOL _ GGCoreOps.RopeToBool[boolRope];
GGState.SetPalette[ggData, paletteForFillColorOn];
ShowPaletteForFillColor[ggData, event];
};

PaletteForStrokeColor: PUBLIC UserInputProc = {
boolRope: Rope.ROPE _ NARROW[event.rest.first];
paletteForStrokeColorOn: BOOL _ GGCoreOps.RopeToBool[boolRope];
GGState.SetPalette[ggData, paletteForStrokeColorOn];
ShowPaletteForStrokeColor[ggData, event];
};

ShowPaletteForFillColor: PUBLIC UserInputProc = {
paletteForFillColorOn: BOOL _ GGState.GetPalette[ggData];
Feedback.PutF[ggData.router, oneLiner, $Show, "PaletteForFillColor: %g", [rope[GGCoreOps.BoolToRope[paletteForFillColorOn] ]] ];
};

ShowPaletteForStrokeColor: PUBLIC UserInputProc = {
paletteForStrokeColorOn: BOOL _ GGState.GetPalette[ggData];
Feedback.PutF[ggData.router, oneLiner, $Show, "PaletteForStrokeColor: %g", [rope[GGCoreOps.BoolToRope[paletteForStrokeColorOn] ]] ];
};
ggData.refresh.startBoundBox^ _ GGScene.BoundBoxOfSelected[ggData.scene, normal]^;
ObjectChangedInPlace will provide the BoundBoxOfSelected for refresh.
ggData.refresh.startBoundBox^ _ GGScene.BoundBoxOfSelected[ggData.scene, normal]^;
ObjectChangedInPlace will provide the BoundBoxOfSelected for refresh.
For each selected leaf of sliceD, select it in full.  If a selected leaf is contained within an outline, grow the selection to the outermost such outline.
ggData.refresh.startBoundBox^ _ GGScene.BoundBoxOfSelected[ggData.scene, normal]^;
ObjectChangedInPlace will provide the BoundBoxOfSelected for refresh.
ObjectChangedInPlace will provide the BoundBoxOfSelected for refresh.

Debug Menu

TestMultiGravity: PUBLIC UserInputProc = {
};

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 desiredCount points have been drawn.
completeName _ Rope.Concat[ggData.originalWDir, fileName];
Prints the totals for the interval whose name is selected.
completeName _ Rope.Concat[ggData.originalWDir, fileName];
completeName _ Rope.Concat[ggData.originalWDir, fileName];
f: IO.STREAM _ FS.StreamOpen[Rope.Concat[ggData.originalWDir, fileName], $create]; -- merely causes file creation

FSMInfo: PUBLIC UserInputProc = {
mouseMode, state: Rope.ROPE;
mouseMode _ Atom.GetPName[ggData.mouseMode];
state _ Atom.GetPName[ggData.state];
Feedback.PutF[ggData.router, oneLiner, $Show, "mouseMode = %g.  state = %g.", [rope[mouseMode]], [rope[state]]];
};

File Line
Group Menu
Fill Color
Stroke Color

RegisterAction[$PaletteForFillColor, PaletteForFillColor, rope];
RegisterAction[$PaletteForStrokeColor, PaletteForStrokeColor, rope];
RegisterAction[$ShowPaletteForFillColor, ShowPaletteForFillColor, none];
RegisterAction[$ShowPaletteForStrokeColor, ShowPaletteForStrokeColor, none];
Debug Menu
RegisterAction[$TestMultiGravity, TestMultiGravity, none];
RegisterAction[$FSMInfo, FSMInfo, none];
�ÊQ•NewlineDelimiter

–

"cedar" style˜Icodeš
œ™šÏnœx™€
Kš
œT™TKš
œ™Kšœ(Ïk™+K™ K™)—K™š
ž	˜	Jšœsžœížœo˜Ó—K˜š�œžœ
ž˜JšžœJžœÀžœ`˜õKšžœ,ž˜8—˜Kšœ
žœ˜+Kšœ
žœ˜%Kšœ
žœ
žœ$Ïc˜[Kšœ
žœ ˜1Jšœžœ˜*Kšœžœ˜'Kšœžœ˜1Kšœžœ˜!Kšœžœ˜3Kšœžœ˜!Kšœžœ
žœ!˜<Kšžœžœžœ
˜Kšœžœ˜!Kšœ	žœ˜'Kšœžœ!˜7Kšœžœ!˜5Kšœ
žœ˜'Kšœžœ˜!Kšœžœ ˜5Kšœžœ)˜GKšœžœ˜3Kšœžœ˜+Kšœžœ˜Kšœ
žœ˜'Kšœžœ˜/Kšœžœ˜,Kšœžœ˜#Kšœ
žœ˜'—K˜K˜™K™—š
�œžœ
žœ$žœžœ˜Pšžœ$žœ˜,Kš
œ=˜=Kšœžœ˜-KšœžœžœUžœ>˜ª
Kšžœ
žœžœMžœ
žœŸ,˜¡
Kš
œL˜LKšœžœN˜iKš
œ¡
˜¡
KšÏbœ<˜PKš
œ;˜;K˜—K˜K˜—š(�œžœ
žœžœ	žœ
žœ
žœ
žœžœ žœžœžœžœžœžœžœžœžœ
žœžœ˜�Kšžœžœ™3š�œžœžœ
žœžœ
žœ˜>šžœžœ
ž˜Kšœžœ
žœžœ˜2Kšœžœžœ˜Kšžœžœ
˜—K˜—Kšœžœžœ
žœ
žœ
žœžœ
žœ
˜SKšžœžœžœ
ž˜/Kšžœy˜}K˜—K˜š�œžœ˜Kšžœžœ
žœ	™4Kšœžœ
˜Kšœ#žœžœ
˜0K•StartOfExpansion)[intervalName: 
ATOM, tableName: 
ATOM]š
œ$˜$Kšœ
Ÿœy˜~KšžœžœZ˜hšžœ
žœ	žœ˜Kšœžœ
˜"Kšœžœ
˜Kš
œC˜CKš
œ˜Kš
œ˜Kš
œ˜Kš
œ1˜1Kšœ1žœ-˜`Kšœ9Ÿ˜MKš
œH˜HKšœ'Ÿ1˜XKšœžœŸ=˜\Kš
œ˜—K–)[intervalName: 
ATOM, tableName: 
ATOM]š
œ#˜#Kš
œ˜K˜—š�œžœ˜Kšžœ*žœ
žœ	™?KšœFžœ™[Kšœžœ˜Kšœžœ
žœ
˜
Kšœžœ
˜Kšœ#žœžœ
˜0Kšœžœ
˜"Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜)Kšœ
ŸœQžœJ˜¦
Kšžœžœ
žœžœ\˜|Kš
žœ
žœžœ
žœžœj˜™
šžœ
žœ	žœ˜Kšœžœžœ
žœ˜@š	œžœ"žœžœžœ˜Wšžœ˜
Kšœ
žœv˜‚
Kšžœ
žœžœ?˜TKšžœ˜Kš
œ˜—Kš
œ˜—Kš œžœ˜%Kšœžœ;˜AKšœ	žœžœ
žœžœžœ˜VKšœ
žœ:˜FKšžœ
žœžœ=˜RKšžœ
ž™KšœžœŸ˜=Kš
œ˜Kš
œ6˜6K˜(Kš
œ˜Kš
œ1˜1Kšœ
žœ3˜?Kšžœ
žœžœ;˜PK™2Kš
œ8˜8Kš
œ7˜7Kš
œ&˜&KšœžœŸ=˜\š
ž˜Kšœ	žœ
˜—Kš
œ˜—Kš
œ˜K˜—š�œ˜ Kš
œ&˜&Kš
œ˜K˜—š�œžœ˜Kšžœžœ
žœžœS˜Œ
Kšžœk˜oKš
œ˜K˜—š�œžœ˜!Kšœ�™3KšœžœŸ4˜KKšœŸ˜2Kš
œ˜K˜—š�œžœ˜Kš
œ˜Kšžœžœ+˜EK™2Kš
œ˜Kš
œ7˜7Kšœžœ˜#KšžœžœqžœÐbkœ˜©
Kšœ'Ÿ1˜XKš
 ™Kš
œ8˜8KšœžœŸ=˜\K–M[feedback: 
Feedback.FeedbackData, msg: 
ROPE, msgType: 
Feedback.MsgType]šžœžœI˜cKš
œ˜K˜—šÐbnœ˜Kš
œV˜VKš
œ˜K˜—š�œžœ˜K™.šžœžœ˜'Kšœžœ˜2Kš
œ(˜(Kš
œ˜Kšœ9Ÿ˜MKšœžœ%Ÿ˜XKš
œ&˜&KšœžœŸ=˜\Kš
œ'˜'K–M[feedback: 
Feedback.FeedbackData, msg: 
ROPE, msgType: 
Feedback.MsgType]˜JK˜—Kš
œ˜K˜—š�œ˜Kšœžœ˜2Kšžœžœžœi˜Š
KšžœX˜\Kš
œ˜K˜—š�
œ˜K™1Kšœžœ
˜Kšœ	žœžœ
˜Kšœžœ&˜9Kšžœžœžœk˜Œ
šžœ˜KšœŸœVžœ˜uKšžœ
žœ	žœl˜Kšžœi˜mKš
œ˜—Kš
œ˜K˜—š�
œžœžœžœ
žœžœ˜Hšœžœ˜š
žœ
žœžœžœžœ˜IKšžœCž™K—Kš
œ˜—Kš
œ˜K˜—š�œ˜K™1Kšœžœ
˜Kšœ	žœžœ
˜Kšœžœ&˜9Kšžœžœžœm˜Ž
šžœ˜KšœŸœXžœ˜wKšžœ
žœ	žœn˜�
Kšžœkžœžœžœ˜¡
Kš
œ˜—Kš
œ˜K˜—š�œžœ	žœ
žœ
žœ
žœ˜;KšœžœŸ`˜‚
Kšœžœ
˜!Kš
œ$˜$K–K[ggData: 
GGInterfaceTypes.GGData, sliceD: 
GGModelTypes.SliceDescriptor]šœ!žœŸ˜>Kšœ!Ÿ˜>Kšœ"Ÿ˜2KšœžœŸ7˜XKšœ
 œ
Ÿv˜–
Kšœ(Ÿ'˜OKšœ,Ÿ'˜SKšœ&Ÿ˜EKš
œO˜OKšœžœ
žœ˜Kšœ Ït
žœ2™XKšœ£
žœ
˜&Kšœ£
žœ
˜%Kšœ£
žœ
˜!Kšœ#£
žœ
˜(Kšœ£
žœ
˜!Kšœ£
žœ
˜#Kšœ£
žœ
˜$Kšœ$£
žœ
˜+Kšœ$£
žœ
˜+Kš
œ'˜'Kš
œ'˜'Kš
œ˜—K˜š�œžœ˜"Kšžœ$žœ
žœ	™9Kš
œ/˜/K˜K˜—š�œžœ˜%Kš
œ5˜5K˜K˜—š�œžœ˜&Kš
œ7˜7K˜K˜—š�œžœ˜)Kš œ5˜=K˜K˜—š�œžœ	žœ
žœ
žœ
žœžœžœ˜XKšœžœ
˜Kšœ#žœžœ
˜0Kšœ
Ÿœz˜Kšžœžœ\˜jKšžœ
žœ	žœD˜XK˜K˜—š�œžœžœžœžœžœžœžœ
žœ
žœ
žœ˜�
Kšžœ™Kšœžœ
žœ
˜
šœ
žœ
˜Kš¡ 
¡	™—Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœ	žœžœ
˜Kšœžœ
˜Kšœžœ˜1K˜Kšœ œ4˜VKš
 ˜šœžœžœžœ˜;Kš
œ‡
˜‡
Kšžœ˜Kš
œ˜—Kšœ	žœ	žœ"˜8Kš
 ˜Kš
œ1˜1Kšœ œ3˜SK˜Kšœ œ?˜aK˜Kšžœ
ž™Kš
 ˜š
ž˜šžœž˜˜	Kšœ žœ
žœ˜+KšœCžœžœŸ˜kšžœ	žœ˜Kšœžœ˜.Kš
œ5˜5K˜
—šžœŸ˜Kšœžœ˜(Kšœpžœ¡œ˜Ž
Kš
œ=˜=Kšžœ˜Kš
œ˜—K˜—˜KšœCžœžœŸ˜išžœ
žœ	žœ˜Kšœ>žœ˜PKš
œ˜—K˜—˜KšœCžœŸ˜ršžœ
žœ	žœ˜Kšœ>žœ˜PKš
œ˜—K˜—š
œ˜Kšœ?¡œ˜Fšžœ
žœ	žœ˜Kšœ>žœ˜PKš
œ˜—K˜—š
œ˜Kšœ?¡œ˜Ešžœ
žœ	žœ˜Kšœ>žœ˜PKš
œ˜—K˜—Kšžœžœ
˜—Kš
œ(˜(Kš
 ˜Kš
œ1˜1Kš
œ[˜[šžœ	žœŸ˜.K™0Kš
œ6˜6Kš
œ7˜7Kš
œ˜—Kšœžœ˜4Kšœ2 œHžœ˜“
š
ž˜Kš
œ8˜8—Kšžœ
˜—š
ž˜Kšœ; œ.žœžœŸ6˜Ñ
—Kš
œ˜—K˜K™š�
œžœ˜$Kšœžœžœ˜+Kšžœ-žœ_˜’
Kšžœ
žœžœžœt˜–
šžœ˜š
�œžœžœžœžœ˜LKš
œC˜Cšžœsžœžœ
ž˜†
Kšœžœžœ
˜šžœžœ
žœ
žœ
žœžœžœ
ž˜BKšœžœžœ
˜)šžœžœžœ˜+KšœžœŸ˜*Kšžœ
˜K˜—Kšžœ
˜—Kšžœ
žœžœ
žœ˜8Kšœžœ
˜Kšžœ
˜—J˜—Kšœžœžœ
˜K˜Kšœ9£œ£˜CKšœ2žœžœ3žœ=˜º
Kšžœžœ_žœžœ˜�
Kš
œ˜—š
œ˜K˜——š�œžœ˜%Kšœžœžœ˜+Kšžœžœžœv˜“
šžœ˜š
�œžœžœžœžœ˜Dš�œžœ2žœžœ˜Xšžœžœ
žœ
žœ
žœžœžœ
ž˜BKšœžœžœ
˜)Kš
žœžœžœ
žœ
žœ˜7Kšžœ
˜—Kšžœ
žœ˜Kš
œ˜—Kš
œF˜FKšžœžœ
žœ7˜LJ˜—K˜Kšœ
 œ!žœžœ˜PKšœ,Ÿ˜GKšœ$£œ£˜6Kšžœ-žœZ˜�
Kšžœd˜hKšœjžœžœ˜‰
Kš
œ˜—š
œ˜K˜——š�œžœ˜)Kšœžœžœ˜+Kšžœ-žœd˜—
Kšžœ
žœžœžœ~˜ 
šžœ˜š
�œžœžœžœžœ˜OKš
œC˜Cšžœsžœžœ
ž˜†
Kšœžœ
˜šžœžœ
žœ
žœ
žœžœžœ
ž˜BKšœžœžœ
˜)Kšžœ
žœžœžœžœžœžœ
˜jKšžœ
˜—Kš
œ˜Kšžœ
˜—J˜—Kšœ
žœžœ
˜Kš	œ
žœ
žœ
žœ
žœ
˜K˜Kšœ,£œ£œ£˜FKšœ2žœ
žœ<žœX˜Ý
Kšžœ
žœ_žœžœ˜�
Kš
œ˜—š
œ˜K˜——š�œžœ˜/K˜Kšžœ&žœr˜ž
šžœ˜š
�
œžœžœžœžœ˜NKš
œC˜Cšžœsžœžœ
ž˜†
šžœžœ
žœ
žœ
žœžœžœ
ž˜BKšœžœžœ
˜)Kšœžœžœ
˜šžœžœ
žœ
žœ
žœžœžœ
ž˜EKšœžœžœ˜+šžœ!žœžœ˜0KšœžœŸ˜.Kšžœ
˜K˜—Kšžœ
˜—K–4[l1: 
LIST OF REF ANY, l2: 
LIST OF REF ANY _ NIL]šžœ
žœžœ
žœ˜<Kšžœ
˜—Kšžœ
˜—J˜—Kš	œžœ
žœ
žœ
žœ
˜Kšœ,£œ
£œ£˜Ešžœžœ
žœ˜Kš
œG˜Gšžœžœ
žœ
žœ
žœžœžœ
ž˜EKšœžœžœ˜+Kš
œG˜GKšžœ
˜—Kš
œ/˜/Kš
œ
˜
—Kšžœ`˜dKš
œ˜—Kš
œ˜K˜—š�œžœ˜(Kš	œžœ
žœ
žœ
žœ
˜K˜š
�œžœžœžœžœ˜Eš
�
œžœ2žœžœžœ˜bšžœžœ
žœ
žœ
žœžœžœ
ž˜BKšœžœžœ
˜)Kšœžœžœ
˜šžœžœ
žœ
žœ
žœžœžœ
ž˜EKšœžœžœ˜+šžœ!žœžœ˜0KšœžœŸ˜.Kšžœ
˜K˜—Kšžœ
˜—K–4[l1: 
LIST OF REF ANY, l2: 
LIST OF REF ANY _ NIL]šžœ
žœžœ
žœ˜<Kšžœ
˜—Kš
œ˜—Kš
œ0˜0J˜—Kšœ$£œ£˜7Kš
œ@˜@šžœžœ
žœ˜šžœžœ
žœ
žœ
žœžœžœ
ž˜EKšœžœžœ˜+Kš
œG˜GKšžœ
˜—Kš
œ/˜/Kš
œ
˜
—Kšžœ9˜=Kš
œ˜K˜—š�œžœ˜!šžœ-žœ
˜4Kš
œ`˜`—šžœ˜š
�œžœžœžœžœ˜Jšžœ8žœ˜@Kšœžœ
˜Kš
œ=˜=K˜
—šžœ˜šžœžœ˜Kš
œ˜Kšœžœ
˜K˜—K˜—K˜—Kšœ/žœ˜6K˜Kšœžœ
žœ˜Kšœžœ
˜Kšœ
žœ˜Kšœžœžœ
˜Kšœ£œŸ˜GKšœJžœ™QKšœ
 œ!žœžœ˜RKš
œ.˜.Kšœ$£œ£˜<šžœžœ
žœžœžœ
ž˜BJš
œ<˜<Jš
œ'˜'Jš
œ3˜3Jšžœ
˜—šžœžœ
žœ
˜"Jšžœ˜Jšžœ5˜9—Jš
œ+˜+Jš
œ1˜1Jš
œ3˜3Jšœžœ˜!Jš
œ"˜"Kšœ Ÿ0˜PKš
œT˜TKšœ}žœžœ˜›
K˜—K˜K˜—š�œžœ˜*šžœ-žœ
˜4Kš
œ`˜`—šžœ˜K˜Kš
œ˜Kš
œh˜hK˜—K˜K˜—š�	œžœ˜#šžœ-žœ
˜4Kš
œd˜d—šžœ˜š
�œžœžœžœžœ˜OJš
œ˜Jšœžœ
žœ/˜AJš
œ/˜/Jš
œ9˜9Jš
œ$˜$Jš
œ.˜.šžœžœ
žœžœžœ
ž˜BJš
œ4˜4Jšžœ
˜—J–J[list1: 
LIST OF GGModelTypes.Slice, list2: 
LIST OF GGModelTypes.Slice]š
œ<˜<J˜—Kšœ
žœ˜K˜Kšœžœ
žœŸf˜€
Kšœ
 œ!žœžœ˜PKšœ£	œ˜*K–‘
[scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass, walkProc: 
GGModelTypes.SlicePartsWalkProc, classType: 
ATOM _ NIL]šœ,£œ£œ£˜Pšžœžœ
žœ'žœžœ
ž˜[Kšœ@Ÿ˜\Kšžœ
˜—Jšœžœ˜!Jš
œ"˜"Kšœ Ÿ0˜PKš
œi˜iKšœpžœžœ˜Ž
K˜—K˜K˜—š�
œžœ˜'K˜šžœ&žœ
˜-Kš
œe˜e—šžœ˜š
�œžœžœžœžœ˜IJšœ žœ˜&J˜—Kšœ.£œ£œ£˜LKš
œg™gKš
 r˜rK˜—K˜K˜—š�œžœ˜%K˜šžœ&žœ
˜-Kš
œa˜a—šžœ˜š
�œžœžœžœžœ˜GJšœ žœ˜'J˜—Kšœ.£œ£œ£˜JKš
œe˜eK˜—K˜K˜—š�
œžœ˜$Kš¡ q¡ ¡ 
˜‚
Kš
 ˜Kšœžœžœ
˜Kšœ	žœžœ
˜Kšœžœ
˜Kšœ	žœžœ
˜K˜Kšœ
žœ˜*–=[rgb: 
RGB, calibration: 
ImagerColor.RGBCalibration _ NIL]š
�
œžœžœžœžœ˜MJšœžœžœ
˜šžœ
žœ
žœ˜Jš
œ˜Jš
œ(˜(J˜
—šžœ˜Jš
œ,˜,Jšžœžœž˜'J˜—J˜—Kšœ3£œ
£œ£˜Všžœ	žœ˜Kšœ
žœ
˜Kš
œs˜sK˜
—šžœ
žœ
žœ
žœ˜Kšœ
žœ
˜Kš
œq˜qK˜—Kšžœ
žœ	žœ
žœ
˜Kš
œb˜bKš
 ˜K˜—K˜™K™—Kš�œžœžœ
˜ Kš�œžœžœ
˜!Kš�œžœžœ
˜&Kšœ
žœE˜VK˜š�œžœ˜0šžœ"žœ˜*Kš
œ˜Kšœ7žœ"žœ˜hK–0[feedback: 
Feedback.FeedbackData, msg: 
ROPE]šžœžœ
žœ=˜NKšžœ<˜@K˜—K˜K˜—š�œžœ˜.šžœ"žœ˜*Kš
œ˜Kšœ7žœ"žœ˜hK–0[feedback: 
Feedback.FeedbackData, msg: 
ROPE]šžœžœ
žœ=˜NKšžœ<žœ˜RK˜—K˜K˜—š�œžœ˜0šžœ"žœ˜*Kš
œ˜Kšœ7žœ"žœ˜hK–0[feedback: 
Feedback.FeedbackData, msg: 
ROPE]šžœžœ
žœ=˜NKšžœ<˜@K˜—K˜K˜—š�œžœ˜0šžœ"žœ˜*Kš
œ˜Kšœ7žœ"žœ˜hK–0[feedback: 
Feedback.FeedbackData, msg: 
ROPE]šžœžœ
žœ=˜NKšžœ<žœ˜RK˜—K˜K˜—Iprocšœ
žœžœ
žœ˜$Kšœžœ$˜6š�œžœ
žœžœ˜=Lš
œ$˜$Lšœ?žœ"žœ˜pšžœžœ
žœ˜Lš
œ6˜6Kš
žœ
žœ
žœžœ6žœžœŸ,˜Œ
Kš
žœ
žœ
žœžœ
žœ
žœŸ˜LLš
œg˜gLš	œ.žœžœ"žœŸ Ðbc
˜‘
L˜—L˜L˜—š
�œžœNžœžœžœ˜‘
Kš
œŽ
™Ž
Kšœžœžœ˜?Kšœ"žœ„
˜©
Kšžœ	˜Kš
œ˜K˜—KšœžœŸ˜-š�
œžœžœ	žœžœžœ˜;Kšœžœžœ
žœ˜'Kšœ
žœžœ
žœ˜*Kšœžœ%˜4Kš
žœ
žœ
žœžœ
žœ˜=Kš
œ˜K˜—š	�
œžœžœžœŸ˜Sš
�œžœžœžœ
žœ˜*K™8Kšžœžœ
žœ˜Kšžœžœ
žœ˜Kšžœ˜Kš
œ˜—Lš
œ6˜6Kšžœ
žœ
žœžœ^˜}Lš
œ˜—š�œžœ˜2šžœ"žœ˜*Kš
œ˜Kšœ:žœŸ˜[Kšžœžœ
žœ=˜Nšžœ˜Kšœ%žœ
˜*Kšœžœžœ˜(K˜zKš
œ˜—Kš
œ˜—K˜K˜—š�œžœ˜2šžœ"žœ˜*Kš
œ˜Kšœ:žœŸ˜[Kšžœžœ
žœ=˜Nšžœ˜Kšœ%žœ
˜*Kšœžœžœ˜(K˜|Kš
œ˜—Kš
œ˜—K˜K˜—š�œžœ˜.šžœ"žœ˜*Kšœ	žœžœ
˜K˜Kš
œH˜Hšžœ	žœ˜Kšœ
žœžœ
˜šžœžœ
žœsžœ˜Š
šœžœ#˜@Kšœžœ
˜Kšžœ
˜	Kš
œ˜—Kšžœ
žœ>žœ‰
˜Þ
K˜—K˜
—K˜—K˜K˜—š�œžœ˜.šžœ"žœ˜*K˜Kšœ	žœžœ
˜Kš
œL˜Lšžœ	žœ˜Kšœ
žœžœ
˜šžœžœ
žœ_žœ˜všœžœ#˜@Kšœžœ
˜Kšžœ
˜	Kš
œ˜—Kšžœ
žœ>žœ‹
˜à
K˜—K˜
—K˜—K˜K˜—š�œžœžœžœ%žœžœ˜{Kšœžœ
˜Kšœ	žœžœ
˜Kšœžœžœ
˜K˜–=[rgb: 
RGB, calibration: 
ImagerColor.RGBCalibration _ NIL]š
�
œžœžœžœžœ˜JJš
œ˜J˜šžœ
žœ
žœ˜Jš
œ˜Jš
œE˜EJšœžœ	˜J˜
—šžœ˜Jš
œI˜IJšžœ
žœ	žœ
žœ.žœž˜SJ˜—š
ž˜šœ'ž˜*Kšžœ(ž˜0—šœ*ž˜-KšœQž˜TKšžœ&˜,—Kšžœžœ
˜—J˜—Kšœ1£œ
£œ£˜Gšžœžœ˜Kšœ
žœ
˜Kš
œƒ
˜ƒ
K˜
—šžœ
žœ	žœ˜Kšœ
žœ
˜Kš
œy˜yK˜
—šžœ
žœ
žœ
žœ˜Kšœ
žœ
˜Kš
œn˜nK˜—K˜K˜—š�œžœžœžœ%žœžœ˜}Kšœžœ
˜Kšœ	žœžœ
˜K˜–=[rgb: 
RGB, calibration: 
ImagerColor.RGBCalibration _ NIL]š
�
œžœžœžœžœ˜JJš
œ˜šžœ
žœ
žœ˜Jš
œ˜Jš
œG˜GJšœžœ	˜J˜
—šžœ˜Jš
œK˜KJšžœ
žœ	žœ
žœ.žœž˜SJ˜—J˜—Kšœ<£œ£˜Fšžœ	žœ˜Kšœ
žœ
˜Kš
œ{˜{K˜
—šžœ
žœ
žœ
žœ˜Kšœ
žœ
˜Kš
œp˜pK˜—K˜K˜—š�œžœ˜3Kšœžœžœ˜+Kš
œP˜PKšžœžœ
žœ#˜4K˜K˜—š�œžœ˜3Kšœžœžœ˜+Kš
œR˜RKšžœžœ
žœ#˜4K˜K˜—š�œžœ
žœ"žœžœžœ˜tKšžœžœžœ_˜|šžœ˜šžœžœŸ˜=Kšžœ˜Kš
œ™Kšžœžœ
žœ=™NKšžœžœ
žœ
žœ™(K˜
—šžœX˜\Kšœžœ˜0Kšœžœ˜*K˜—š
ž˜Kš
œ�
˜�
Kš
œ€
™€
Kš
œq˜qKš
œo˜o—K˜—K˜K˜—š�œžœ˜2Kšœžœžœ˜+KšœVžœ˜iKš
œ"˜"š
ž˜Kš
œ�
˜�
—K˜K˜—š�œžœ˜2Kšœžœžœ˜+KšœVžœ˜iKš
œ"˜"š
ž˜Kš
œ‘
˜‘
—K˜K˜—š�œžœ˜3Kšœžœžœ˜+Kšœ\žœ˜oKš
œ"˜"š
ž˜Kš
œœ
˜œ
—K˜K˜—š�œžœ˜8Kšœžœžœ˜+Kšœžœ6žœ˜WKš
œ-˜-š
ž˜Kš
œ…
˜…
—K˜K˜—š�œžœ
žœžœ˜LKš
œ?˜?Kšœžœ"˜1Kš
œ"˜"K˜K˜—š�œžœ˜5Kšœžœžœ˜+Kšœ\žœ˜oKš
œ"˜"š
ž˜Kš
œž
˜ž
—K˜K˜—š� œžœ˜:Kšœžœžœ˜+Kšœžœ6žœ˜WKš
œ/˜/š
ž˜Kš
œ‡
˜‡
—K˜K˜—š�œžœ
žœžœ˜NKš
œ?˜?Kšœžœ"˜1Kš
œ"˜"K˜K˜—š�œžœ˜1Kšœžœ
˜Kšœžœžœ˜+Kšœ
žœžœ˜1K˜š
�œžœžœžœžœ˜>Kš
œ˜Kšœ	žœžœ
˜Kš
œ˜š�œžœžœžœžœžœžœ˜gšžœ&žœ˜.Jšœžœ
˜Jšœžœ
˜
J˜
—šžœ˜Kšœžœ
˜Kšœ+žœ˜6Kš
œ0˜0J˜—J˜—Kš
œ@˜@Kšžœžœ
žœ4˜FJ˜—šžœ
žœ
ž˜šœžœ
ž˜š
œ˜Kš
œ6˜6Kšœžœ˜0Kšœžœ˜*K˜—š
œ˜Kšœ'žœ
˜8—Kšžœžœ
˜——Kšœ
 œ!žœžœ˜PKš
œ$˜$Kšœ$£œ£˜0K–Û
[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[]]]š
œo˜oKšœjžœžœ˜‰
š
ž˜Kš
œ‘
˜‘
Kš
œy˜yKš
œw˜w—K˜K˜—š�œžœ˜1Kšœžœ
˜Kšœžœžœ˜+K˜Kšœ
žœžœ˜1š
�œžœžœžœžœ˜>š�	œ˜Kš
 œžœžœžœžœ™:Kšœ
žœ,˜3K˜—KšœEŸ%˜jK–s[sliceD: 
GGModelTypes.SliceDescriptor, scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass]šœ4Ÿ˜DJ˜—š	žœ
žœ
žœžœ
ž˜2š
œ˜Kš
œ6˜6Kšœžœ˜0Kšœžœ˜*K˜—š
œ˜Kšœ'žœ
˜8—Kšžœžœ
˜—Kšœ
 œ!žœžœ˜PKš
œ+˜+Kšœ$£œ£˜0K–Û
[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[]]]š
œs˜sKšœjžœžœ˜‰
š
ž˜Kš
œ“
˜“
Kš
œ{˜{Kš
œy˜y—K˜K˜—š�œžœ˜-K˜Kšœ	žœžœ
˜Kš
œG˜Gšžœ	žœ˜Kš
œ+˜+Kšœžœ˜"K˜—K˜K˜—š�œžœ˜5Kšœžœžœ˜+Kš
œ5˜5Kš
œ+˜+K˜K˜—š�œžœ˜-K˜Kšœ	žœžœ
˜Kš
œK˜Kšžœ	žœ˜Kš
œ-˜-Kšœžœ˜"K˜—K˜K˜—š�œžœ˜5Kšœžœžœ˜+Kš
œ5˜5Kš
œ-˜-K˜K˜—š�œžœ˜.Kš
œ0˜0Kšžœžœ
žœL˜]Kšžœr˜vK˜K˜—š�œžœ˜.Kš
œ2˜2Kšžœžœ
žœN˜_Kšžœt˜xK˜K˜—š�œžœ™-Kšœžœžœ™/Kšœžœ"™=Kš
œ2™2Kš
œ'™'K™K™—š�œžœ™/Kšœžœžœ™/Kšœžœ"™?Kš
œ4™4Kš
œ)™)K™K™—š�œžœ™1Kšœžœ™9Kš
œ€
™€
K™K™—š�œžœ™3Kšœžœ™;Kš
œ„
™„
K™—K˜š�œžœ˜(Kš
œI˜IK˜K˜—š�œžœ˜(Kš
œI˜IK˜K˜—š�œžœ˜(Kš
œI˜IK˜K˜—š�œžœ˜(Kš
œI˜IK˜K˜—š�
œžœ˜'Kš
œW˜WK˜K˜—š�
œžœ˜'Kš
œW˜WK˜K˜—š�
œžœ˜'Kšœžœžœ˜K˜K˜—š�
œžœ˜'Kšœžœžœ˜K˜K˜—š�œžœ˜)Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšœ	žœžœ
˜š
�
œžœžœžœžœ˜KKš
œQ˜QK˜—Kš
œ.˜.Kšžœžœ
žœR˜hšžœ	žœ˜Kšœ œŸ˜\Kšœ,£œ
£œ£˜BK–T[scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass _ normal]š
œR™RKš
œE™EKšœ
 œ	˜Kš
œg˜gKšœnžœžœ˜Œ
K˜
—šžœ˜Kš
œ›
˜›
K˜—K˜K˜—š�
œžœ˜'Kš
œ˜Kš
œ˜Kš
œ˜K˜Kšœ	žœžœ
˜š
�
œžœžœžœžœ˜KKš
œd˜dK˜—Kš
œ.˜.Kšžœžœ
žœP˜fšžœ	žœ˜Kšœ œŸ˜ZKšœ,£œ
£œ£˜BK˜K–T[scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass _ normal]š
œR™RKš
œE™EKšœ
 œ	˜Kš
œe˜eKšœnžœžœ˜Œ
K˜
—šžœ˜Kš
œŠ
˜Š
K˜—K˜K˜—š�
œ˜ Kš
œ˜Kšœ	žœžœ
˜Kš
œA˜Ašžœ	žœ˜Kšžœžœ
žœl˜}KšžœQ˜UK˜—K˜K˜—š�œžœ˜)Kš
œ˜Kšœ	žœžœ
˜Kš
œE˜Ešžœ	žœ˜Kšžœžœ
žœn˜KšžœU˜YK˜—K˜K˜—š�œžœžœ!˜]Kšœƒ
 	œ™š
š�œžœžœžœ žœžœ˜Jšœžœ$˜3šžœž˜˜
Kšœžœ
˜Kšœžœ
˜K˜—šžœ˜Kšœžœ
˜Kšœ*žœ	˜6Kš
œ˜——J˜—KšœŸœR˜bK˜K˜—š�œžœ
žœ2žœžœ	žœžœ
žœ˜ƒ
Kšžœ-žœ
žœžœnžœ
ž˜¸
šžœ˜Kš
œ˜K–_[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass]˜Kšœžœ
žœ˜,Kš
œ#˜#š
�œžœžœžœžœ˜MKš
œQ˜QKš
œP˜PJ˜—Kšœ œŸ˜YKš
œ<˜<Kšœ,£œ£œ£˜Dšžœžœ
žœ,žœžœ
ž˜PJš
œ5˜5Jš
œ7˜7Jšžœ
˜—K–T[scene: 
GGModelTypes.Scene, selectClass: 
GGSegmentTypes.SelectionClass _ normal]š
œR™RKš
œE™EKšœ
 œ	˜KšžœžœTžœžœ
žœžœ˜”
Kšœnžœžœ˜Œ
K˜—K˜K˜—š�œžœ
žœ2žœ	žœžœ
žœ˜}–_[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass]šžœ-žœ
˜4Kšžœžœržœ
ž˜ˆ
—šžœ˜Kš
œ˜K–_[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGInterfaceTypes.SelectionClass]˜š
�œžœžœžœžœ˜MKš
œS˜SJ˜—Kšœ œŸ˜[Kšœ,£œ£œ£˜DKšžœžœXžœžœ
žœžœ˜˜
Kšœ
 œ	˜Kš
œE™EKšœnžœžœ˜Œ
K˜—K˜K™—š�œžœžœ!žœžœžœ˜cKšœ	žœ
˜Kš	žœžœ
žœ
žœ
Ÿ,˜QKš	žœ
žœ
žœžœŸ)˜Išžœ˜Kšœ	žœ
˜šžœžœ
ž˜˜(Kš
œ)˜)Kšžœ
žœ	žœ
žœžœžœ
žœžœ
žœ˜vK˜—Kšžœžœ
žœ˜—K˜—K˜K˜—š
�œžœ
žœžœžœ˜FKšžœ
žœžœžœ
˜1š�œžœžœ˜Kš
žœžœ
žœžœ
žœ˜4K˜—Kš	œžœ
žœžœ
žœ˜K˜/K˜/K˜K˜)š
ž˜Kšœžœ˜$—K˜K˜—š
�œžœ
žœžœžœ˜LKšžœ
žœžœžœ˜2š�œžœžœ˜Kš
žœžœ
žœžœ
žœ˜5K˜—Kš	œžœ
žœžœ
žœ˜K˜Kš
œ0˜0Kš
œ0˜0Kš
œ0˜0Kš
œ˜Kš
œ;˜;š
ž˜Kšœ
žœ˜&—K˜K˜—š
�œžœ
žœžœ
žœ˜GKšžœ
žœžœžœ˜7š�œžœžœ˜Kš
žœžœ
žœžœ
žœ˜:K˜—Kš	œžœ
žœžœ
žœ˜Kš
œ˜Kš
œ˜š
ž˜Kšœžœ˜0—K˜K˜—K˜™
K™—š�œžœ™*K™K™—š�œžœ˜%Kš
œÍ
™Í
Kš
œ2˜2Kš	œžœžœžœ
žœ˜7Kš
œ˜Kšœžœ
˜
Kšœ3žœ˜;Kš
œ˜K˜Kš
œ˜K˜K˜K˜Kšžœžœžœ
žœžœ
žœ
˜9Kš
œ8˜8Kš
œ9˜9KšœžœŸ3˜Yšžœž˜#šžœžœ˜%Kšœžœ
˜$Kšžœ
˜K˜—Kš
œ"˜"Kš
œ"˜"K˜Kš
œK˜KKš
 %˜%Kš
œ)˜)Kš
œ'˜'K–Ò
[testPoint: 
GGBasicTypes.Point, criticalR: 
REAL, currentObjects: 
GGMultiGravity.ObjectBag, activeObjects: 
GGMultiGravity.TriggerBag, gargoyleData: 
GGInterfaceTypes.GargoyleData, intersections: 
BOOL]šœ% œDžœ˜�
šžœžœ
žœ˜Kšœcžœžœ˜�
K˜Kšžœ
˜K˜—Kš
œ"˜"K˜Kš
œ%˜%Kšœfžœžœ˜„
Kšžœ
˜—Kš
ϯ
˜Ø
KšœŸ˜—K˜Kšœžœžœ
˜K˜š�
œžœ˜$Kšœžœ
žœ.˜:Kšžœžœ
žœ8˜EK˜K˜—š�œžœ˜*Kšœžœ
˜š
ž˜Kšžœ
žœ„
žœ˜˜
Kšœžœžœ˜/K–Ø
[name: 
ROPE, lock: 
FS.Lock _ read, wantedCreatedTime: 
GMT _ nullGMT, remoteCheck: 
BOOL _ TRUE, wDir: 
ROPE _ NIL, verifyNow: 
BOOL _ FALSE, checkFileType: 
BOOL _ FALSE, fileType: 
FS.FileType _ [0B (0)]]šœžœ
žœ
˜
Kš
œ:™:Kš
œ˜Kšœžœ#˜)Kšžœžœ
žœNžœ˜fKš
œ(˜(Kšžœ
˜—K˜K˜—š�œžœ˜0K™:Kšœžœžœ˜3Kšœžœ˜1Kšœžœ
žœ.˜:šžœžœ
žœ
žœžœžœ˜5Kš
œ˜KšœEžœ˜PK˜—K˜K˜—š�œžœ˜1Kšœžœ
˜š
ž˜Kšžœ
žœ„
žœ˜˜
Kšœžœžœ˜/Kšœžœžœ˜8Kšœžœ˜)K–Ø
[name: 
ROPE, lock: 
FS.Lock _ read, wantedCreatedTime: 
GMT _ nullGMT, remoteCheck: 
BOOL _ TRUE, wDir: 
ROPE _ NIL, verifyNow: 
BOOL _ FALSE, checkFileType: 
BOOL _ FALSE, fileType: 
FS.FileType _ [0B (0)]]šœžœ
žœ
˜
Kš
œ:™:Kš
œ˜Kšœžœ#˜)Kšžœžœ
žœ
žœžœžœ>žœ˜|Kš
œ(˜(Kšžœ
˜—K˜K˜—š�
œžœ˜$Kšœžœ
˜š
ž˜Kšžœ
žœ„
žœ˜˜
Kšœžœžœ˜/Kšœžœžœ˜3K–Ø
[name: 
ROPE, lock: 
FS.Lock _ read, wantedCreatedTime: 
GMT _ nullGMT, remoteCheck: 
BOOL _ TRUE, wDir: 
ROPE _ NIL, verifyNow: 
BOOL _ FALSE, checkFileType: 
BOOL _ FALSE, fileType: 
FS.FileType _ [0B (0)]]šœžœ
žœ
˜
Kš
œ:™:Kš
œ˜Kšœžœ#˜)K–F[self: 
STREAM, r: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]šžœžœ
žœ
žœžœžœ˜BKš
œ(˜(Kšžœ
˜—K˜K˜—š�
œžœ˜$Kšžœ
žœjžœ˜~Kšœžœžœ˜/K–Ø
[name: 
ROPE, lock: 
FS.Lock _ read, wantedCreatedTime: 
GMT _ nullGMT, remoteCheck: 
BOOL _ TRUE, wDir: 
ROPE _ NIL, verifyNow: 
BOOL _ FALSE, checkFileType: 
BOOL _ FALSE, fileType: 
FS.FileType _ [0B (0)]]šœžœ
žœžœBŸ™qK–Ø
[name: 
ROPE, lock: 
FS.Lock _ read, wantedCreatedTime: 
GMT _ nullGMT, remoteCheck: 
BOOL _ TRUE, wDir: 
ROPE _ NIL, verifyNow: 
BOOL _ FALSE, checkFileType: 
BOOL _ FALSE, fileType: 
FS.FileType _ [0B (0)]]šœžœ
žœžœ Ÿ˜OKš
œ(˜(K˜K˜—š�œžœ˜)Kš
œ4˜4Kš
œH˜HK˜K˜—š�œžœ˜)Kšœjžœžœ˜ˆ
K˜K˜—š�œžœ˜(Kšœižœžœ˜‡
K˜K˜—š�œžœ˜(Kšœižœžœ˜‡
K˜K˜—š�œžœ˜*Kšœkžœžœ˜‰
K˜K˜—š�œžœ˜*Kšœkžœžœ˜‰
K˜K˜—š�
œžœ˜'Kšœžœžœ˜!Kšœ]žœžœ˜{K˜K™—š�œžœ˜-Kšœžœ˜%Kš
œ9˜9Kšžœžœ
žœ*˜;Kš
œU˜UK˜K˜—š�œžœ™!Kšœžœ
™Kš
œ,™,Kš
œ$™$K™pK™K™—š�œžœ˜&Kš
œ)˜)Kš
œ,˜,Kšœžœ˜š
�œžœžœžœžœ˜Dšžœžœ˜Jš
œ˜Jš
œ˜J˜
—šžœ
žœžœ˜Jš
œ˜Jšœžœ
˜J˜—J˜—Jšœ$£œ£˜6Jšžœ2˜8K˜—K˜KšœžœžœŸ˜8K˜š�
œžœ˜'šžœžœ˜šžœžœ
žœ
žœ
žœžœžœ
ž˜@Kšžœžœ
ž˜KšœžœZ˜dKšœžœ
žœO˜[Kšœžœ
žœL˜ZKšœžœ
žœP˜^Kšœ	žœ
žœT˜eKš
œˆ
˜ˆ
KšžœN˜U—Kšžœ
˜Kš
œ6˜6K˜—K˜K˜—š�œžœ˜)Kšœžœ
˜K˜K˜—š�œžœ˜*Kšœžœ
˜K˜K˜—š�
œžœ˜$Kš
œ˜K˜—K˜š�œžœ˜Kšžœ
˜K˜K™	Kš
œ(˜(Kš
œ$˜$Kš
œ2˜2Kš
œ$˜$Kš
œ2˜2Kš
œ ˜ Kš
œ.˜.Kš
œ*˜*Kš
œ0˜0Kš
œ2˜2Kš
œ8˜8Kš
œ$˜$Kš
œ.˜.Kš
œ2˜2Kš
œ"˜"Kš
œ,˜,Kš
œ2˜2K˜K™
Kš
œ.˜.Kš
œ0˜0Kš
œ8˜8Kš
œD˜DKš
œ6˜6Kš
œ(˜(Kš
œ:˜:Kš
œ,˜,Kš
œ4˜4Kš
œ0˜0Kš
œ.˜.K˜K™
Kš
œF˜FKš
œB˜BKš
œJ˜JKš
œB˜BKš
œL˜LKš
œJ˜JKš
œL˜LKš
œV˜VKš
œ5˜5Kš
œF˜FKš
œF˜FKš
œ6˜6Kš
œ6˜6Kš
œ4˜4Kš
œ4˜4Kš
œ4˜4Kš
œ@˜@Kš
œP˜PKš
œB˜BK˜K™Kš
œF˜FKš
œF˜FKš
œJ˜JKš
œB˜BKš
œL˜LKš
œJ˜JKš
œP˜PKš
œZ˜ZKš
œF˜FKš
œF˜FKš
œ7˜7Kš
œ6˜6Kš
œ6˜6Kš
œ4˜4Kš
œ4˜4Kš
œ8˜8Kš
œ@˜@Kš
œP˜PKš
œB˜BK™Kš
œ@™@Kš
œD™DKš
œH™HKš
œL™LK˜K™
Kš
œ2˜2Kš
œ:™:Kš
œ.˜.Kš
œ:˜:Kš
œF˜FKš
œH˜HKš
œ.˜.Kš
œ.˜.Kš
œ8˜8Kš
œ6˜6Kš
œ6˜6Kš
œ:˜:Kš
œ:˜:Kš
œ8˜8Kš
œ5˜5Kš
œ4˜4Kš
œ2˜2Kš
œ.˜.Kš
œ@˜@Kš
œ(™(Kš
œ6˜6Kš
œ7˜7Kš
œ2˜2K˜K˜—K˜K˜K˜Kšžœ
˜—…—ú
vÿ