DIRECTORY
GGMouseEvent, BiScrollers, CodeTimer, CubicSplines, Feedback, FeedbackTypes, Geom2D, GGAlign, GGBasicTypes, GGBoundBox, GGCaret, GGControlPanelTypes, GGCoreOps, GGCoreTypes, GGDescribe, GGEmbedTypes, GGEvent, GGHistory, GGHistoryTypes, GGInterfaceTypes, GGMeasure, GGModelTypes, GGParent, GGParseIn, GGRefresh, GGRefreshTypes, GGScene, GGSegmentTypes, GGSelect, GGSequence, GGSlice, GGSliceOps, GGState, GGTraj, GGUIUtility, GGUserInput, GGViewerOps, GGWindow, Imager, ImagerBox, ImagerTransformation, IO, Real, Rope, Vectors2d;

GGEventImplB: CEDAR PROGRAM
IMPORTS GGMouseEvent, BiScrollers, CodeTimer, Feedback, GGAlign, GGBoundBox, GGCaret, GGCoreOps, GGDescribe, GGHistory, GGMeasure, GGParent, GGParseIn, GGRefresh, GGScene, GGSelect, GGSequence, GGSlice, GGSliceOps, GGState, GGTraj, GGUIUtility, GGUserInput, GGViewerOps, GGWindow, ImagerBox, ImagerTransformation, IO, Rope, Vectors2d
EXPORTS GGEvent, GGHistoryTypes, GGInterfaceTypes = BEGIN

AlignBag: TYPE = GGInterfaceTypes.AlignBag;
BiScroller: TYPE = BiScrollers.BiScroller;
BoundBox: TYPE = GGModelTypes.BoundBox;
Camera: TYPE = GGModelTypes.Camera;
Caret: TYPE = GGInterfaceTypes.Caret;
Change: PUBLIC TYPE = GGHistory.Change; -- exported to GGHistoryTypes
ControlsObj: PUBLIC TYPE = GGControlPanelTypes.ControlsObj; -- exported to GGInterfaceTypes
DisplayStyle: TYPE = GGModelTypes.DisplayStyle;
EmbedDataObj: PUBLIC TYPE = GGEmbedTypes.EmbedDataObj; -- exported to GGInterfaceTypes
FeatureData: TYPE = GGInterfaceTypes.FeatureData;
MsgRouter: TYPE = FeedbackTypes.MsgRouter;
FilterLists: TYPE = GGAlign.FilterLists;
GGData: TYPE = GGInterfaceTypes.GGData;
GravityType: TYPE = GGInterfaceTypes.GravityType;
HistoryEvent: TYPE = GGHistoryTypes.HistoryEvent;
Point: TYPE = GGBasicTypes.Point;
RefreshDataObj: PUBLIC TYPE = GGRefreshTypes.RefreshDataObj;
Scene: TYPE = GGModelTypes.Scene;
SegAndIndex: TYPE = GGSequence.SegAndIndex;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
Sequence: TYPE = GGModelTypes.Sequence;
SequenceOfReal: TYPE = REF SequenceOfRealObj;
SequenceOfRealObj: TYPE = GGCoreTypes.SequenceOfRealObj;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
SliceParts: TYPE = GGModelTypes.SliceParts;
StrokeEnd: TYPE = Imager.StrokeEnd;
StrokeJoint: TYPE = Imager.StrokeJoint;
Traj: TYPE = GGModelTypes.Traj;
TrajData: TYPE = GGModelTypes.TrajData;
TrajEnd: TYPE = GGModelTypes.TrajEnd;
TrajParts: TYPE = GGModelTypes.TrajParts;
TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
Transformation: TYPE = ImagerTransformation.Transformation;
UserInputProc: TYPE = GGEvent.UserInputProc;
Vector: TYPE = GGBasicTypes.Vector;
WalkProc: TYPE = GGModelTypes.WalkProc;

pointsPerIn: REAL = 72.0;
pointsPerCm: REAL = 72.0/2.54;
reallyBigReal: REAL = 1.0e37;
multipleValues: Rope.ROPE = "multiple values - Aborted!!";
complainAboutIconic: Rope.ROPE = "Viewing transformations not allowed on iconic viewer";

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

GetArg: PROC [diffOK: BOOL _ FALSE, sel: Rope.ROPE, router: MsgRouter] RETURNS [valid: BOOL, arg, arg2: REAL _ 0.0] ~ {
s: IO.STREAM;
valid _ SELECT sel.Length[] FROM
> 1 => TRUE,
> 0 => sel.Fetch[0] IN ['0 .. '9],
ENDCASE => FALSE;
IF NOT valid THEN RETURN;
s _ IO.RIS[sel];
{
ENABLE IO.Error, IO.EndOfStream => {
valid _ FALSE;
Feedback.PutF[router, oneLiner, $Complaint, "Select a number, not %g", IO.refAny[sel]];
CONTINUE};
arg _ arg2 _ s.GetReal[];
IF diffOK AND (NOT s.EndOf[]) AND s.PeekChar[]=': THEN {
IF NOT s.GetChar[]=': THEN ERROR;
arg2 _ s.GetReal[];
valid _ valid};
IF NOT s.EndOf[] THEN IO.Error[ec: SyntaxError, stream: s];
};
s.Close[];
};

GetBiScroller: PROC[ggData: GGData] RETURNS [bs: BiScrollers.BiScroller] = {
iconW, iconH: INT _ 0;
w: INT _ GGState.GetWidth[ggData];
h: INT _ GGState.GetHeight[ggData];
[iconW, iconH] _ GGViewerOps.GetIconSize[];
RETURN [IF w>iconW AND h>iconH THEN GGState.GetBiScroller[ggData] ELSE NIL]; -- NIL means viewer is iconic or pathologically small
};

ScalePop: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
key: REF ANY _ event.rest.first;
sel: Rope.ROPE _ NARROW[event.rest.rest.first];
valid: BOOL;
arg, arg2: REAL;
[valid, arg, arg2] _ GetArg[TRUE, sel, ggData.router];
IF NOT valid THEN arg _ arg2 _ 2.0;
IF key=$Shrink THEN {arg _ 1.0/arg; arg2 _ 1.0/arg2};
BiScrollers.Scale[
bs: bs,
op: SELECT key FROM
$Magnify, $Shrink => IF arg=arg2 THEN [byArg[arg]] ELSE [diff[arg, arg2]],
$Reset => [reset[]],
ENDCASE => ERROR,
paint: FALSE
];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

RotatePop: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
key: REF ANY _ event.rest.first;
sel: Rope.ROPE _ NARROW[event.rest.rest.first];
valid: BOOL;
arg: REAL;
[valid, arg] _ GetArg[FALSE, sel, ggData.router];
IF NOT valid THEN arg _ 90;
BiScrollers.Rotate[
bs: bs,
op: SELECT key FROM
$Left => [byArg[arg]],
$Right => [byArg[-arg]],
$Half => [byArg[180]],
$Reset => [reset[]],
ENDCASE => ERROR,
paint: FALSE
];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

FitPop: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
cw: INT _ GGState.GetWidth[ggData];
ch: INT _ GGState.GetHeight[ggData];
key: REF ANY _ event.rest.first;
limits: Imager.Box;
uniformly: BOOL ~ SELECT key FROM
$FitUniformly => TRUE,
$FitXY => FALSE,
ENDCASE => ERROR;
[limits.xmin, limits.xmax] _ BiScrollers.ViewLimitsOfImage[bs, X];
[limits.ymin, limits.ymax] _ BiScrollers.ViewLimitsOfImage[bs, Y];
BiScrollers.BoxScale[
bs: bs,
from: ImagerBox.RectangleFromBox[limits],
to: [0, 0, cw, ch],
paint: FALSE,
uniformly: uniformly];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

ResetPop: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
key: REF ANY _ event.rest.first;
SELECT key FROM
$Vanilla => {
bs.style.ChangeTransform[bs: bs, new: bs.class.common.vanilla[bs], ageOp: remember, paint: FALSE]; -- don't set paint=TRUE here so queing works properly
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE]; -- paint properly
};
$VanillaAndCenter => {
bs.style.ChangeTransform[bs: bs, new: bs.class.common.vanilla[bs], ageOp: remember, paint: FALSE];
};
$Center => NULL;
ENDCASE => ERROR;
SELECT key FROM
$Center, $VanillaAndCenter => {
BiScrollers.Align[
bs: bs,
client: [fraction[0.5, 0.5]],
viewer: [fraction[0.5, 0.5]],
doX: TRUE,
doY: TRUE,
paint: FALSE,
ageOp: remember];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
};
$Vanilla => NULL;
ENDCASE => ERROR;
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

EdgePop: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
key: REF ANY _ event.rest.first;
loc: fraction BiScrollers.Location _ [fraction[0, 0]];
doX, doY: BOOL _ TRUE;
SELECT key FROM
$Left => {loc.fx _ 0; doY _ FALSE};
$Right => {loc.fx _ 1; doY _ FALSE};
$Bottom => {loc.fy _ 0; doX _ FALSE};
$Top => {loc.fy _ 1; doX _ FALSE};
$BotLeft => loc _ [fraction[0, 0]];
$MidLeft => loc _ [fraction[0, 0.5]];
$TopLeft => loc _ [fraction[0, 1]];
$BotMiddle => loc _ [fraction[0.5, 0]];
$BotRight => loc _ [fraction[1, 0]];
$MidRight => loc _ [fraction[1, 0.5]];
$TopRight => loc _ [fraction[1, 1]];
$TopMiddle => loc _ [fraction[0.5, 1]];
ENDCASE => ERROR;
BiScrollers.Align[bs: bs, client: loc, viewer: loc, doX: doX, doY: doY, paint: FALSE];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

PrevTransform: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
bs.style.ChangeTransform[
bs: bs,
new: bs.style.GetTransforms[bs, previous].clientToViewer,
ageOp: remember,
paint: FALSE];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
};
};

CenterSel: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
bBox: GGBoundBox.BoundBox _ GGScene.BoundBoxOfSelected[scene: ggData.scene, selectClass: normal];
IF bBox.null THEN {
IF GGCaret.Exists[ggData.caret] THEN {
caretPos: Point _ GGCaret.GetPoint[ggData.caret];
BiScrollers.Align[
bs: bs,
client: [variant: coord[x: caretPos.x, y: caretPos.y]],
viewer: [variant: fraction[fx: 0.5, fy: 0.5]],
paint: FALSE];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "CenterSel failed: either a selection or a caret is required to center"];
}
ELSE {
BiScrollers.Align[
bs: bs,
client: [variant: coord[x: (bBox.loX+bBox.hiX)/2.0, y: (bBox.loY+bBox.hiY)/2.0]],
viewer: [variant: fraction[fx: 0.5, fy: 0.5]],
paint: FALSE];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
};
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

CenterCaret: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
IF GGCaret.Exists[ggData.caret] THEN {
caretPos: Point _ GGCaret.GetPoint[ggData.caret];
BiScrollers.Align[
bs: bs,
client: [variant: coord[x: caretPos.x, y: caretPos.y]],
viewer: [variant: fraction[fx: 0.5, fy: 0.5]],
paint: FALSE];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "CenterCaret failed: a caret is required to center"];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

FitSel: PUBLIC UserInputProc = {
bs: BiScrollers.BiScroller = GetBiScroller[ggData];
IF bs#NIL THEN {
tbBox, vBox, tvBox: Geom2D.Rect;
cToV: ImagerTransformation.Transformation;
bBox: GGBoundBox.BoundBox _ GGScene.BoundBoxOfSelected[scene: ggData.scene, selectClass: normal];
IF bBox.null THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "FitSel failed: a selection is required to fit"]
ELSE {
cToV _ BiScrollers.GetStyle[].GetTransforms[bs].clientToViewer;
tbBox _ ImagerTransformation.TransformRectangle[cToV, GGBoundBox.RectangleFromBoundBox[bBox] ];
vBox _ BiScrollers.ViewportBox[bs];
tvBox _ ImagerTransformation.TransformRectangle[cToV, vBox];
BiScrollers.BoxScale[bs: bs, from: tbBox, to: tvBox, paint: FALSE];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
};
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, complainAboutIconic];
};

SetBiScrollersTransform: PUBLIC UserInputProc = {
rope: Rope.ROPE _ NARROW[event.rest.first];
clientToViewer: Imager.Transformation _ GGDescribe.FactoredTransformationFromRope[rope ! GGParseIn.SyntaxError => GOTO SyntaxError];
GGState.SetBiScrollersTransform[ggData, clientToViewer];
EXITS
SyntaxError => Feedback.Append[ggData.router, oneLiner, $Complaint, "SetBiScrollersTransform failed: select a legal factored transformation for SetBiScrollersTransform"]; 
};

ShowBiScrollersTransform: PUBLIC UserInputProc = {
clientToViewer: Imager.Transformation _ GGState.GetBiScrollersTransform[ggData];
Feedback.PutF[ggData.router, oneLiner, $Show, "BiScrollers transform: %g", [rope[GGDescribe.FactoredTransformationToRope[clientToViewer] ]] ];
};

ScrollBar: UserInputProc = {
bs: BiScrollers.BiScroller = GGState.GetBiScroller[ggData];
newEvent: LIST OF REF;
newEvent _ CONS[$First, event]; -- so no paint occurs with clearClient = TRUE
BiScrollers.DoBSUserAction[bs, newEvent];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
};

OneZoom: UserInputProc = {
GGState.BiScrollersTransform[ggData, ggData.embed.scrollDue];
ggData.embed.scrollDue _ ImagerTransformation.Scale[1.0];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
};

identity: Transformation = ImagerTransformation.Scale[1.0];
IsIdentity: PROC [m: Transformation] RETURNS [BOOL] = {
RETURN[ImagerTransformation.Equal[m, identity]];
};

OneScroll: UserInputProc = {
clientToViewer, viewerToClient: Transformation;
caretPoint: Point;
caretViewer: Point;
caretClient: Point;

IF IsIdentity[ggData.embed.scrollDue] THEN RETURN;

clientToViewer _ GGState.GetBiScrollersTransform[ggData];
caretPoint _ GGCaret.GetPoint[ggData.caret];
caretViewer _ ImagerTransformation.Transform[clientToViewer, caretPoint];

GGState.BiScrollersTransform[ggData, ggData.embed.scrollDue];
ggData.embed.scrollDue _ ImagerTransformation.Scale[1.0];
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];

viewerToClient _ GGState.GetBiScrollersTransforms[ggData].viewerToClient;
caretClient _ ImagerTransformation.Transform[viewerToClient, caretViewer];
GGMouseEvent.HandleMouse[ggData, LIST[$During, NEW[Point _ caretClient]]];
};

ViewersPaintEntireScene: PUBLIC UserInputProc = {
GGWindow.RestoreScreenAndInvariants[$ViewersPaintEntireScene, ggData, none, FALSE, TRUE];
};

ViewersPaintAllPlanes: PUBLIC UserInputProc = {
GGWindow.RestoreScreenAndInvariants[$ViewersPaintAllPlanes, ggData, none, FALSE, TRUE];
};

MakeHot: PUBLIC UserInputProc = {
IF GGSelect.NoSelections[ggData.scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "MakeHot failed: select some objects for MakeHot"]
ELSE {
MakeSliceHot: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSelect.SelectSlice[sliceD, ggData.scene, hot];
};
UpdateTriggerAndAlignBags: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
sliceFeature: FeatureData _ GGAlign.AddSliceFeature[sliceD, triggerBag];
alignObjects: LIST OF FeatureData;
alignObjects _ GGAlign.IncrementalNewTrigger[sliceFeature, filterLists, NOT showAlignments, alignBag];
GGRefresh.NoteNewForeground[ggData, alignObjects]; -- fix foreground plane
};

showAlignments: BOOL _ GGState.GetShowAlignments[ggData];
triggerBag: TriggerBag _ ggData.hitTest.triggerBag;
alignBag: AlignBag _ ggData.hitTest.alignBag;
filterLists: FilterLists _ GGState.GetFilterLists[ggData];
CodeTimer.StartInt[$MakeHot, $Gargoyle];
[] _ GGScene.WalkSelectedSlices[ggData.scene, first, MakeSliceHot, normal];
[] _ GGScene.WalkSelectedSlices[ggData.scene, first, UpdateTriggerAndAlignBags, hot];
Feedback.Append[ggData.router, oneLiner, $Feedback, "MakeHot: selected objects made hot"];
GGWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeHot, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: FALSE];
CodeTimer.StopInt[$MakeHot, $Gargoyle];
};
};

MakeAllHot: PUBLIC UserInputProc = {
MakeSliceHot: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
GGSelect.SelectEntireSlice[slice, ggData.scene, hot];
};

triggerBag: TriggerBag _ ggData.hitTest.triggerBag;
alignBag: AlignBag _ ggData.hitTest.alignBag;

CodeTimer.StartInt[$MakeAllHot, $Gargoyle];
[] _ GGScene.WalkSlices[ggData.scene, first, MakeSliceHot];
Feedback.Append[ggData.router, oneLiner, $Feedback, "MakeAllHot: all objects made hot"];
GGWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeHot, ggData: ggData, remake: triggerBagNotSceneBag, edited: FALSE, okToSkipCapture: FALSE];
CodeTimer.StopInt[$MakeAllHot, $Gargoyle];
};

MakeCold: PUBLIC UserInputProc = {
IF GGSelect.NoSelections[ggData.scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "MakeCold failed: select some objects for MakeCold"]
ELSE {
MakeSliceCold: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSelect.DeselectSlice[sliceD.slice, sliceD.parts, ggData.scene, hot];
};

CodeTimer.StartInt[$MakeCold, $Gargoyle];
[] _ GGScene.WalkSelectedSlices[ggData.scene, first, MakeSliceCold, normal];
Feedback.Append[ggData.router, oneLiner, $Feedback, "MakeCold: selected objects made cold"];
GGWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeCold, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: FALSE];
CodeTimer.StopInt[$MakeCold, $Gargoyle];
};
};

MakeAllCold: PUBLIC UserInputProc = {
MakeSliceCold: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
GGSelect.DeselectSlice[sliceD.slice, sliceD.parts, ggData.scene, hot];
};

CodeTimer.StartInt[$MakeAllCold, $Gargoyle];
[] _ GGScene.WalkSelectedSlices[ggData.scene, first, MakeSliceCold, hot];
Feedback.Append[ggData.router, oneLiner, $Feedback, "MakeCold: all objects made cold"];
GGWindow.RestoreScreenAndInvariants[paintAction: $SequencesMadeCold, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: FALSE];
CodeTimer.StopInt[$MakeAllCold, $Gargoyle];
};

DropAnchor: PUBLIC UserInputProc = {
IF GGCaret.Exists[ggData.caret] THEN {
IF GGCaret.Exists[ggData.anchor] THEN GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, anchor: TRUE]
ELSE GGRefresh.NullStartBox[ggData];
GGCaret.Copy[to: ggData.anchor, from: ggData.caret];
[] _ GGAlign.CreateAnchorTrigger[ggData.anchor, ggData.hitTest.triggerBag];
Feedback.Append[ggData.router, oneLiner, $Feedback, "DropAnchor: anchor dropped"];
GGWindow.RestoreScreenAndInvariants[paintAction: $AnchorAdded, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "DropAnchor failed: caret needed to drop anchor"];
};

LiftAnchor: PUBLIC UserInputProc = {
IF GGCaret.Exists[ggData.anchor] THEN {
GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, anchor: TRUE, alignments: TRUE];
GGCaret.Kill[ggData.anchor];
Feedback.Append[ggData.router, oneLiner, $Feedback, "LiftAnchor: anchor lifted"];
GGWindow.RestoreScreenAndInvariants[paintAction: $AnchorRemoved, ggData: ggData, remake: triggerBag, edited: TRUE, okToSkipCapture: TRUE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "LiftAnchor failed: no anchor"];
};
StandardAlignments: PUBLIC UserInputProc = {
StandardSlopes[ggData, event];
StandardAngles[ggData, event];
StandardRadii[ggData, event];
StandardDistances[ggData, event];
IF event.first = $StandardAlignments THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "StandardAlignments: standard alignments set"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: FALSE, okToSkipCapture: TRUE];
};
};

ClearAlignments: PUBLIC UserInputProc = {
ClearSlopes[ggData, event];
ClearAngles[ggData, event];
ClearRadii[ggData, event];
ClearDistances[ggData, event];
IF event.first = $ClearAlignments THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "ClearAlignments:  alignments cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: FALSE, okToSkipCapture: TRUE];
};
};

AllAlignmentsOff: PUBLIC UserInputProc = {
SlopePrompt[ggData, event];
AnglePrompt[ggData, event];
RadiusPrompt[ggData, event];
DistancePrompt[ggData, event];
GGState.SetMidpoints[ggData, FALSE];
IF event.first = $AllAlignmentsOff THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "AllAlignmentsOff: all alignments off"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: FALSE, okToSkipCapture: TRUE];
};
};

InitializeAlignments: PUBLIC UserInputProc = {
AllAlignmentsOff[ggData, event];
IF event.first = $InitializeAlignments THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "InitializeAlignments: alignments initialized"];
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: TRUE];
};
};

DisplayStyleChange: PUBLIC UserInputProc = {
forward: BOOL _ event.rest.first = $FlipForward;
camera: Camera _ ggData.camera;
SetTextDisplayStyle: PROC [slice: Slice] RETURNS [done: BOOL _ FALSE] = {
GGSlice.SetTextDisplayStyle[slice, camera.displayStyle, NIL];
};
GGState.CycleDisplayStyle[ggData, forward];
[] _ GGScene.WalkSlices[scene: ggData.scene, level: leaf, walkProc: SetTextDisplayStyle, classType: $Text];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Display style changed"];
GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: TRUE];
};

ToggleShowAlignments: PUBLIC UserInputProc = {
GGState.SetShowAlignments[ggData, NOT GGState.GetShowAlignments[ggData]];
IF event.first = $ToggleShowAlignments THEN GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: TRUE];
};

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

ToggleMidpoints: PUBLIC UserInputProc = {
GGState.SetMidpoints[ggData, NOT GGState.GetMidpoints[ggData]];
IF event.first = $ToggleMidpoints THEN GGWindow.RestoreScreenAndInvariants[paintAction: $None, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: TRUE];
};

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

ToggleHeuristics: PUBLIC UserInputProc = {
GGState.SetHeuristics[ggData, NOT GGState.GetHeuristics[ggData]];
IF event.first = $ToggleHeuristics THEN GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: triggerBag, edited: FALSE, okToSkipCapture: TRUE];
};

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

SetDisplayStyle: PUBLIC UserInputProc = {
styleRope: Rope.ROPE _ NARROW[event.rest.first];
style: DisplayStyle _ GGUIUtility.DisplayStyleFromRope[styleRope];
GGState.SetDisplayStyle[ggData, style];
};

ScaleUnitAux: PROC [ggData: GGData, distance: REAL, noisy: BOOL] = {
IF distance <=0.0  THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetUnits failed: zero or illegal unit value"]
ELSE {
currentEvent: HistoryEvent _ GGHistory.NewCurrent["Set scale unit", ggData]; -- start new history event;
GGState.SetScaleUnit[ggData, distance, currentEvent]; -- in screen dots
GGHistory.PushCurrent[ggData];
IF noisy THEN PrintScaleUnit[ggData, NIL];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: FALSE, okToSkipCapture: TRUE];
};
};
ScaleUnitFromSegment: PUBLIC UserInputProc = {
IF GGScene.CountSelectedSlices[ggData.scene, leaf, normal]#1 THEN GOTO NoNoNoNoNO
ELSE {
distance: REAL _ 0.0; -- illegal scale unit
firstSliceD: SliceDescriptor _ GGScene.FirstSelectedSlice[ggData.scene, leaf, normal];
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[firstSliceD];
firstSeg: Segment _ GGSliceOps.NextSegment[firstSliceD.slice, segGen].seg;
nextSeg: Segment _ GGSliceOps.NextSegment[firstSliceD.slice, segGen].seg;
IF firstSeg=NIL OR nextSeg#NIL THEN GOTO NoNoNoNoNO;
distance _ Vectors2d.Distance[firstSeg.lo, firstSeg.hi];
ScaleUnitAux[ggData, distance, TRUE];
};
EXITS
NoNoNoNoNO => {
Feedback.Append[ggData.router, oneLiner, $Complaint, "UnitsFromSegment failed: select a single segment to set Units"];
};
};
ScaleUnitFromValue: PUBLIC UserInputProc = {
radius: REAL;
success: BOOL _ FALSE;
[radius, success] _ GGState.GetRadiusValue[ggData];
IF success THEN ScaleUnitAux[ggData, radius*ggData.hitTest.scaleUnit, TRUE];
};

ScaleUnitFromSelection: PUBLIC UserInputProc = {
distance: REAL _ WITH event.rest.first SELECT FROM
real: REF REAL => real^,
int: REF INT => REAL[int^],
ENDCASE => -1.0;
IF distance>reallyBigReal OR distance=LAST[INT] OR distance <= 0.0 THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "UnitsFromSelection failed: select a positive real number (in inches) for unit"]
ELSE ScaleUnitAux[ggData, distance*72.0, TRUE]; -- screen dots
};

SetScaleUnit: PUBLIC UserInputProc = {
points: REAL _ NARROW[event.rest.first, REF REAL]^;
noisy: ATOM _ NARROW[event.rest.rest.first];
ScaleUnitAux[ggData, points, noisy = $Noisy];
};

InchScaleUnit: PUBLIC UserInputProc = {
SetScaleUnit[ggData, LIST[$SetScaleUnit, NEW[REAL _ pointsPerIn], $Quiet]];
};

PrintScaleUnit: PUBLIC UserInputProc = {
scale: REAL _ GGState.GetScaleUnit[ggData: ggData];
Feedback.PutF[ggData.router, oneLiner, $Show, "Current scale is %g points = %g inches = %g centimeters", [real[scale]], [real[scale/pointsPerIn]],  [real[scale/pointsPerCm]] ];
};

standardSlopeDegrees: LIST OF REAL _ LIST[150.0, 135.0, 120.0, 90.0, 60.0, 45.0, 30.0, 0.0];
StandardSlopes: PUBLIC UserInputProc = {
GGState.NewSlopeList[ggData, standardSlopeDegrees];
IF event.first = $StandardSlopes THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Standard slopes installed"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: FALSE, okToSkipCapture: TRUE];
};
};

SetSlopes: PUBLIC UserInputProc = {
slopeRope: Rope.ROPE _ NARROW[event.rest.first];
values: LIST OF REAL;
on: LIST OF BOOL;
[----, values, on] _ GGDescribe.ScalarButtonValuesFromRope[slopeRope];
FOR nextValues: LIST OF REAL _ values, nextValues.rest UNTIL nextValues = NIL DO
AddSlopeInternal[ggData, nextValues.first, on.first];
on _ on.rest;
ENDLOOP;
};

ClearSlopes: PROC [ggData: GGData, event: LIST OF REF ANY] = {
GGState.NewSlopeList[ggData, NIL];
IF event.first = $ClearSlopes THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Slopes cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: FALSE, okToSkipCapture: TRUE];
};
};

SlopePrompt: PUBLIC UserInputProc = {
GGState.SetAllAlignmentStates[ggData, slope, FALSE];
IF event.first = $SlopePrompt THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Slopes cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

AddSlope: PUBLIC UserInputProc = {
slope: REAL;
success: BOOL;
[slope, success] _ GGState.GetSlopeValue[ggData];
IF NOT success THEN RETURN;
[] _ GGState.AddSlope[ggData, slope];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Slope added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

AddSlopeInternal: PUBLIC PROC [ggData: GGData, degrees: REAL, on: BOOL _ FALSE] = {
IF degrees<0.0 THEN degrees _ degrees+180.0;
IF degrees=360.0 THEN degrees _ 0.0;
ggData.measure.slopeViewValue _ degrees;
[] _ GGState.AddSlope[ggData, degrees, on];
};

DeleteSlope: PUBLIC UserInputProc = {
GGState.DeleteSelectedAlignments[ggData, slope];
ggData.measure.slopeViewValue _ Real.LargestNumber; -- invalidate cached value
Feedback.Append[ggData.router, oneLiner, $Feedback, "Slopes deleted"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

GetSlope: PUBLIC UserInputProc = {
IF GGScene.CountSelectedSlices[ggData.scene, leaf, normal]<1 THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Select one or more segments for GetSlope"]
ELSE {
DoGetSlope: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[sliceD];
FOR nextSeg: Segment _ GGSliceOps.NextSegment[sliceD.slice, segGen].seg, GGSliceOps.NextSegment[sliceD.slice, segGen].seg UNTIL nextSeg=NIL DO
[] _ GGState.AddSlope[ggData, GGMeasure.SlopeOfSegment[nextSeg]];
ENDLOOP;
};
[] _ GGScene.WalkSelectedSlices[ggData.scene, leaf, DoGetSlope, normal];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Slopes added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

ToggleSlope: PUBLIC UserInputProc = {
menuValue: REAL;
changedToOn: BOOL _ FALSE;
paintAction: ATOM;
remake: GGWindow.ForegroundParts _ alignBag;
CodeTimer.StartInt[$ToggleSlope, $Gargoyle];
[menuValue, changedToOn, paintAction] _ ToggleAux[ggData, event, slope];
IF changedToOn THEN {
alignObjects: LIST OF FeatureData;
hideAlignments: BOOL _ NOT GGState.GetShowAlignments[ggData];
alignObjects _ GGAlign.IncrementalNewFilter[menuValue, slope, ggData.hitTest.triggerBag, hideAlignments, ggData.hitTest.alignBag];
GGRefresh.NoteNewForeground[ggData, alignObjects];
remake _ none;
}
ELSE remake _ alignBag;
GGWindow.RestoreScreenAndInvariants[paintAction: paintAction, ggData: ggData, remake: remake, edited: TRUE, okToSkipCapture: TRUE];
CodeTimer.StopInt[$ToggleSlope, $Gargoyle];
};

ToggleAux: PROC [ggData: GGData, event: LIST OF REF ANY, type: GGState.AlignmentType] RETURNS [menuValue: REAL _ 777.0, changedToOn: BOOL _ FALSE, paintAction: ATOM] = {
argValue: REAL _ WITH event.rest.first SELECT FROM
real: REF REAL => real^,
int: REF INT => REAL[int^],
ENDCASE => Real.LargestNumber;
IF argValue>reallyBigReal OR argValue=LAST[INT] THEN {
Feedback.Append[ggData.router, oneLiner, $Complaint, "ToggleAux: Unreasonable real argument"];
RETURN;
};
[menuValue, changedToOn] _ GGState.ToggleAlignment[ggData, argValue, type];
IF changedToOn THEN paintAction _ $NewAlignmentsSelected
ELSE paintAction _ $NewAlignmentsDeselected;
};

standardAngles: LIST OF REAL _ LIST[90.0, 60.0, 45.0, 30.0, 0.0, -30.0, -45.0, -60.0, -90.0];
StandardAngles: PUBLIC UserInputProc = {
GGState.NewAngleList[ggData, standardAngles];
IF event.first = $StandardAngles THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Standard angles installed"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

SetAngles: PUBLIC UserInputProc = {
angleRope: Rope.ROPE _ NARROW[event.rest.first];
values: LIST OF REAL;
on: LIST OF BOOL;
[----, values, on] _ GGDescribe.ScalarButtonValuesFromRope[angleRope];
FOR nextValues: LIST OF REAL _ values, nextValues.rest UNTIL nextValues = NIL DO
AddAngleInternal[ggData, nextValues.first, on.first];
on _ on.rest;
ENDLOOP;
};

ClearAngles: PROC [ggData: GGData, event: LIST OF REF ANY] = {
GGState.NewAngleList[ggData, NIL];
IF event.first = $ClearAngles THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Angles cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

AnglePrompt: PUBLIC UserInputProc = {
GGState.SetAllAlignmentStates[ggData, angle, FALSE];
IF event.first = $AnglePrompt THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Angles cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

AddAngle: PUBLIC UserInputProc = {
angle: REAL;
success: BOOL;
[angle, success] _ GGState.GetAngleValue[ggData];
IF NOT success THEN RETURN;
[] _ GGState.AddAngle[ggData, angle];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Angle added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

AddAngleInternal: PUBLIC PROC [ggData: GGData, degrees: REAL, on: BOOL _ FALSE] = {
IF degrees=360.0 THEN degrees _ 0.0;
ggData.measure.angleViewValue _ degrees;
[] _ GGState.AddAngle[ggData, degrees, on];
};

DeleteAngle: PUBLIC UserInputProc = {
GGState.DeleteSelectedAlignments[ggData, angle];
ggData.measure.angleViewValue _ Real.LargestNumber; -- invalidate cached value
Feedback.Append[ggData.router, oneLiner, $Feedback, "Angles deleted"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

GetAngle: PUBLIC UserInputProc = {
IF GGScene.CountSelectedSlices[ggData.scene, leaf, normal]<1 THEN
Feedback.Append[ggData.router, oneLiner, $Complaint, "Select two or more segments for GetAngle"]
ELSE {
DoGetAngle: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[sliceD];
firstSeg, secondSeg: Segment _ NIL;
degrees: REAL _ 0.0;
FOR seg: Segment _ GGSliceOps.NextSegment[sliceD.slice, segGen].seg, GGSliceOps.NextSegment[sliceD.slice, segGen].seg UNTIL seg = NIL DO
IF firstSeg=NIL THEN {firstSeg _ seg; LOOP;};
IF secondSeg=NIL THEN secondSeg _ seg;
degrees _ GGMeasure.CounterClockwiseBetweenSegments[firstSeg, secondSeg];
[] _ GGState.AddAngle[ggData, degrees];
firstSeg _ secondSeg;
secondSeg_ NIL;
ENDLOOP;
};
[] _ GGScene.WalkSelectedSlices[ggData.scene, leaf, DoGetAngle, normal];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Angles added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

ToggleAngle: PUBLIC UserInputProc = {
menuValue: REAL;
changedToOn: BOOL _ FALSE;
paintAction: ATOM;
remake: GGWindow.ForegroundParts _ alignBag;
[menuValue, changedToOn, paintAction] _ ToggleAux[ggData, event, angle];
IF changedToOn THEN {
remake _ alignBag;
}
ELSE remake _ alignBag;
GGWindow.RestoreScreenAndInvariants[paintAction: paintAction, ggData: ggData, remake: remake, edited: TRUE, okToSkipCapture: TRUE];
};

standardRadii: LIST OF REAL _ LIST[1.0/18.0, 1.0/9.0, 0.125, 0.25, 1.0/3.0, 0.5, 2.0/3.0, 0.75, 1.0, 2.0, 4.0];
standardRadiiNames: LIST OF Rope.ROPE _ LIST["1/18", "1/9", "1/8", "1/4", "1/3", "1/2", "2/3", "3/4", "1", "2", "4"];
StandardRadii: PUBLIC UserInputProc = {
GGState.NewRadiusList[ggData, standardRadiiNames, standardRadii];
IF event.first = $StandardRadii THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Standard radii installed"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

SetRadii: PUBLIC UserInputProc = {
radiiRope: Rope.ROPE _ NARROW[event.rest.first];
values: LIST OF REAL;
on: LIST OF BOOL;
names: LIST OF Rope.ROPE;
[names, values, on] _ GGDescribe.ScalarButtonValuesFromRope[radiiRope];
FOR nextValues: LIST OF REAL _ values, nextValues.rest UNTIL nextValues = NIL DO
AddRadiusInternal[ggData, names.first, nextValues.first, on.first];
on _ on.rest;
names _ names.rest;
ENDLOOP;

};

ClearRadii: PROC [ggData: GGData, event: LIST OF REF ANY] = {
GGState.NewRadiusList[ggData, NIL, NIL];
IF event.first = $ClearRadii THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Radii cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

RadiusPrompt: PUBLIC UserInputProc = {
GGState.SetAllAlignmentStates[ggData, radius, FALSE];
IF event.first = $RadiusPrompt THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Radii cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

AddRadius: PUBLIC UserInputProc = {
radius: REAL;
success: BOOL;
[radius, success] _ GGState.GetRadiusValue[ggData];
IF NOT success THEN RETURN;
[] _ GGState.AddRadius[ggData, NIL, radius];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Radius added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

AddRadiusInternal: PUBLIC PROC [ggData: GGData, name: Rope.ROPE, radius: REAL, on: BOOL _ FALSE] = {
ggData.measure.radiusViewValue _ radius;
[] _ GGState.AddRadius[ggData, name, radius, on];
};

DeleteRadius: PUBLIC UserInputProc = {
GGState.DeleteSelectedAlignments[ggData, radius];
ggData.measure.radiusViewValue _ Real.LargestNumber; -- invalidate cached value
Feedback.Append[ggData.router, oneLiner, $Feedback, "Radii deleted"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

GetRadius: PUBLIC UserInputProc = {
IF GGScene.CountSelectedSlices[ggData.scene, leaf, normal]<1 THEN
Feedback.Append[ggData.router, oneLiner, $Complaint, "Select one or more segments for GetRadius"]
ELSE {
DoGetRadius: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[sliceD];
FOR nextSeg: Segment _ GGSliceOps.NextSegment[sliceD.slice, segGen].seg, GGSliceOps.NextSegment[sliceD.slice, segGen].seg UNTIL nextSeg=NIL DO
radius: REAL _ GGMeasure.DistanceBetweenPoints[nextSeg.lo, nextSeg.hi]/ggData.hitTest.scaleUnit;
[] _ GGState.AddRadius[ggData, NIL, radius];
ENDLOOP;
};
[] _ GGScene.WalkSelectedSlices[ggData.scene, leaf, DoGetRadius, normal];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Radii added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

ToggleRadius: PUBLIC UserInputProc = {
menuValue: REAL;
changedToOn: BOOL _ FALSE;
paintAction: ATOM;
remake: GGWindow.ForegroundParts _ alignBag;
[menuValue, changedToOn, paintAction] _ ToggleAux[ggData, event, radius];
IF changedToOn THEN {
remake _ alignBag;
}
ELSE remake _ alignBag;
GGWindow.RestoreScreenAndInvariants[paintAction: paintAction, ggData: ggData, remake: remake, edited: TRUE, okToSkipCapture: TRUE];
};


standardDistances: LIST OF REAL = LIST [0.0, 1.0/18.0, 1.0/9.0, 0.5, 1.0];
standardDistanceNames: LIST OF Rope.ROPE = LIST ["0", "1/18", "1/9", "1/2", "1"];
StandardDistances: PUBLIC UserInputProc = {
GGState.NewLineDistanceList[ggData, standardDistanceNames, standardDistances];
IF event.first = $StandardDistances THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Standard distances installed"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

SetDistances: PUBLIC UserInputProc = {
distanceRope: Rope.ROPE _ NARROW[event.rest.first];
values: LIST OF REAL;
on: LIST OF BOOL;
names: LIST OF Rope.ROPE;
[names, values, on] _ GGDescribe.ScalarButtonValuesFromRope[distanceRope];
FOR nextValues: LIST OF REAL _ values, nextValues.rest UNTIL nextValues = NIL DO
AddDistanceInternal[ggData, names.first, nextValues.first, on.first];
on _ on.rest;
names _ names.rest;
ENDLOOP;
};

ClearDistances: PROC [ggData: GGData, event: LIST OF REF ANY] = {
GGState.NewLineDistanceList[ggData, NIL, NIL];
IF event.first = $ClearDistances THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Distances cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

DistancePrompt: PUBLIC UserInputProc = {
GGState.SetAllAlignmentStates[ggData, lineDistance, FALSE];
IF event.first = $DistancePrompt THEN {
Feedback.Append[ggData.router, oneLiner, $Feedback, "Distances cleared"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

AddDistance: PUBLIC UserInputProc = {
distance: REAL;
success: BOOL;
[distance, success] _ GGState.GetLineDistanceValue[ggData];
IF NOT success THEN RETURN;
[] _ GGState.AddLineDistance[ggData, NIL, distance];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Distance added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

AddDistanceInternal: PUBLIC PROC [ggData: GGData, name: Rope.ROPE, distance: REAL, on: BOOL _ FALSE] = {
ggData.measure.lineDistViewValue _ distance;
[] _ GGState.AddLineDistance[ggData, name, distance, on];
};

DeleteDistance: PUBLIC UserInputProc = {
GGState.DeleteSelectedAlignments[ggData, lineDistance];
ggData.measure.lineDistViewValue _ Real.LargestNumber; -- invalidate cached value
Feedback.Append[ggData.router, oneLiner, $Feedback, "Distances deleted"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsDeselected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};

GetDistance: PUBLIC UserInputProc = {
IF GGScene.CountSelectedSlices[ggData.scene, leaf, normal]<1 THEN
Feedback.Append[ggData.router, oneLiner, $Complaint, "Select one or more segments for GetDistance"]
ELSE {
DoGetDist: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL _ FALSE] = {
segGen: SegmentGenerator _ GGSliceOps.SegmentsInDescriptor[sliceD];
FOR nextSeg: Segment _ GGSliceOps.NextSegment[sliceD.slice, segGen].seg, GGSliceOps.NextSegment[sliceD.slice, segGen].seg UNTIL nextSeg=NIL DO
distance: REAL _ GGMeasure.LengthOfSegment[nextSeg]/ggData.hitTest.scaleUnit;
[] _ GGState.AddLineDistance[ggData, NIL, distance];
ENDLOOP
};
[] _ GGScene.WalkSelectedSlices[ggData.scene, leaf, DoGetDist, normal];
Feedback.Append[ggData.router, oneLiner, $Feedback, "Distances added"];
GGWindow.RestoreScreenAndInvariants[paintAction: $NewAlignmentsSelected, ggData: ggData, remake: alignBag, edited: TRUE, okToSkipCapture: TRUE];
};
};

ToggleDistance: PUBLIC UserInputProc = {
menuValue: REAL;
changedToOn: BOOL _ FALSE;
paintAction: ATOM;
remake: GGWindow.ForegroundParts _ alignBag;
[menuValue, changedToOn, paintAction] _ ToggleAux[ggData, event, lineDistance];
IF changedToOn THEN {
remake _ alignBag;
}
ELSE remake _ alignBag;
GGWindow.RestoreScreenAndInvariants[paintAction: paintAction, ggData: ggData, remake: remake, edited: TRUE, okToSkipCapture: TRUE];
};


MeasureSlopeHit: PUBLIC UserInputProc = {
[] _ GGState.SelectSlope[ggData];
};

MeasureSlopeFromSelection: PUBLIC UserInputProc = {
slope: REAL _ NARROW[event.rest.first, REF REAL]^;
IF slope>reallyBigReal THEN {
Feedback.Append[ggData.router, oneLiner, $Complaint, "SlopeFromSelection failed: select a reasonable value for slope"];
RETURN;
};
GGState.SetSlopeValue[ggData, slope];
AddSlope[ggData, LIST[$AddSlope]];
};

MeasureAngleHit: PUBLIC UserInputProc = {
[] _ GGState.SelectAngle[ggData];
};

MeasureAngleFromSelection: PUBLIC UserInputProc = {
angle: REAL _ NARROW[event.rest.first, REF REAL]^;
IF angle>reallyBigReal THEN {
Feedback.Append[ggData.router, oneLiner, $Complaint, "AngleFromSelection failed: select a reasonable value for angle"];
RETURN;
};
GGState.SetAngleValue[ggData, angle];
AddAngle[ggData, LIST[$AddAngle]];
};

MeasureRadiusHit: PUBLIC UserInputProc = {
[] _ GGState.SelectRadius[ggData];
};

MeasureRadiusFromSelection: PUBLIC UserInputProc = {
radius: REAL _ NARROW[event.rest.first, REF REAL]^;
IF radius>reallyBigReal THEN {
Feedback.Append[ggData.router, oneLiner, $Complaint, "RadiusFromSelection failed: select a reasonable value for radius"];
RETURN;
};
GGState.SetRadiusValue[ggData, radius];
AddRadius[ggData, LIST[$AddRadius]];
};

MeasureLineDistHit: PUBLIC UserInputProc = {
[] _ GGState.SelectLineDistance[ggData];
};

MeasureLineDistFromSelection: PUBLIC UserInputProc = {
lineDist: REAL _ NARROW[event.rest.first, REF REAL]^;
IF lineDist>reallyBigReal THEN {
Feedback.Append[ggData.router, oneLiner, $Complaint, "DistanceFromSelection failed: select a reasonable value for line distance"];
RETURN;
};
GGState.SetLineDistanceValue[ggData, lineDist];
AddDistance[ggData, LIST[$AddDistance]];
};
DeleteCaretSegment: PUBLIC UserInputProc = {
jointNum, newEndJoint: NAT;
traj, shortTraj, smallerOutline: Slice;
smallerOutlines: LIST OF Slice;
trajEnd: TrajEnd;
chairD, trajD: SliceDescriptor;
delSeq: TrajParts;
bBoxOfTraj: BoundBox;
point: Point;
normal: Vector;
caret: Caret _ ggData.caret;
scene: Scene _ ggData.scene;

IF GGCaret.SittingOnEnd[caret] THEN { -- delete the joint and segment near the caret
success: BOOL _ FALSE;
delD: SliceDescriptor;
oldOutline: Slice;
chairD _ GGCaret.GetChair[caret];
[success, trajD, jointNum] _ GGSliceOps.UnpackJoint[chairD];
IF NOT success THEN ERROR Problem[msg: "Chair not simple descriptor"];
traj _ trajD.slice;
oldOutline _ GGParent.GetParent[traj];
bBoxOfTraj _ GGSliceOps.GetBoundBox[traj];
SELECT jointNum FROM
0 => {newEndJoint _ 1; trajEnd _ lo};
GGTraj.HiJoint[traj] => {newEndJoint _ jointNum -1; trajEnd _ hi};
ENDCASE => ERROR Problem[msg: "failed assertion"];
point _ GGTraj.FetchJointPos[traj, newEndJoint];
normal _ GGTraj.FetchJointNormal[traj, newEndJoint];
delSeq _ GGSequence.LastSegAndJoint[NARROW[traj.data, TrajData], trajEnd];

GGHistory.NewCapture["Backspace segment", ggData]; -- capture scene BEFORE UPDATE
GGSelect.SaveSelectionsInSliceAllClasses[chairD.slice, scene];
delD _ GGSlice.DescriptorFromParts[traj, delSeq];
smallerOutlines _ GGTraj.DeleteSequence[delD].openTrajOutlines;
smallerOutline _ IF smallerOutlines = NIL THEN NIL ELSE smallerOutlines.first;
IF smallerOutline = NIL THEN { -- we removed the last segment
GGCaret.SitOn[caret, NIL];
IF GGScene.IsTopLevel[oldOutline] THEN {
GGScene.DeleteSlice[scene, oldOutline];
}
ELSE {
cluster: Slice _ GGParent.GetParent[oldOutline];
smallerCluster: Slice _ GGSlice.RemoveChild[cluster, oldOutline];
IF smallerCluster = NIL THEN GGSlice.PruneNullClusters[scene, cluster];
};
}
ELSE {
jointParts: TrajParts;
jointD, outD: SliceDescriptor;
priority: INT;
IF GGScene.IsTopLevel[oldOutline] THEN {
priority _ GGScene.GetPriority[scene, oldOutline];
GGScene.DeleteSlice[scene, oldOutline];
GGScene.AddSlice[scene, smallerOutline, priority];
GGSelect.ReselectSliceAllClasses[smallerOutline, scene];
}
ELSE {
cluster: Slice _ GGParent.GetParent[oldOutline];
priority _ GGParent.GetChildPriority[cluster, oldOutline];
[] _ GGSlice.RemoveChild[cluster, oldOutline];
GGSlice.AddChildToCluster[cluster, smallerOutline, priority];
GGSelect.ReselectSliceAllClasses[cluster, scene];
};
shortTraj _ GGParent.FirstChild[smallerOutline, first, $Traj];
jointParts _ GGSequence.CreateFromJoint[NARROW[shortTraj.data], IF trajEnd = lo THEN 0 ELSE newEndJoint];
jointD _ GGSlice.DescriptorFromParts[shortTraj, jointParts]; -- traj descriptor
outD _ GGParent.TopLevelDescriptorFromChildDescriptor[jointD];
GGCaret.SitOn[ggData.caret, outD];
};
GGCaret.SetAttractor[ggData.caret, point, normal, NIL];
GGRefresh.NullStartBox[ggData];
GGRefresh.EnlargeStartBox[ggData, bBoxOfTraj, NIL];
GGHistory.PushCurrent[ggData];  -- push captured history event onto history list
Feedback.Append[ggData.router, oneLiner, $Feedback, "Backspace segment: caret segment deleted"];
GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, okToSkipCapture: FALSE];
}
ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "Backspace segment failed: place the caret on the end of a trajectory to backspace"];
};

Nop: UserInputProc ~ {
};

RegisterEventProcs: PROC = {
OPEN GGUserInput;
RegisterAction[$OneScroll, OneScroll, rope2, FALSE, FALSE];
RegisterAction[$OneZoom, OneZoom, rope, FALSE, FALSE];
RegisterAction[$ScalePop, ScalePop, rope2];
RegisterAction[$RotatePop, RotatePop, rope2];
RegisterAction[$FitPop, FitPop, none];
RegisterAction[$ResetPop, ResetPop, none];
RegisterAction[$EdgePop, EdgePop, none];
RegisterAction[$PrevTransform, PrevTransform, none];
RegisterAction[$CenterSel, CenterSel, none];
RegisterAction[$CenterCaret, CenterCaret, none];
RegisterAction[$FitSel, FitSel, none];
RegisterAction[$SetBiScrollersTransform, SetBiScrollersTransform, rope];
RegisterAction[$ShowBiScrollersTransform, ShowBiScrollersTransform, none];
RegisterAction[$AlignFracs, ScrollBar, none];
RegisterAction[$Shift, ScrollBar, none];

RegisterAction[$ViewersPaintEntireScene, ViewersPaintEntireScene, none];
RegisterAction[$ViewersPaintAllPlanes, ViewersPaintAllPlanes, none];

RegisterAction[$MakeHot, MakeHot, none];
RegisterAction[$MakeAllHot, MakeAllHot, none];
RegisterAction[$MakeCold, MakeCold, none];
RegisterAction[$MakeAllCold, MakeAllCold, none];
RegisterAction[$DropAnchor, DropAnchor, none];
RegisterAction[$LiftAnchor, LiftAnchor, none];
RegisterAction[$StandardAlignments, StandardAlignments, none];
RegisterAction[$ClearAlignments, ClearAlignments, none];
RegisterAction[$AllAlignmentsOff, AllAlignmentsOff, none];
RegisterAction[$InitializeAlignments, InitializeAlignments, none];

RegisterAction[$ScreenChoiceChange, DisplayStyleChange, none];
RegisterAction[$ToggleShowColors, Nop, none, FALSE];
RegisterAction[$SetShowColors, Nop, none, FALSE];
RegisterAction[$ToggleMidpoints, ToggleMidpoints, none];
RegisterAction[$SetMidpoints, SetMidpoints, none, FALSE];
RegisterAction[$ToggleHeuristics, ToggleHeuristics, none];
RegisterAction[$SetHeuristics, SetHeuristics, none, FALSE];
RegisterAction[$ToggleShowAlignments, ToggleShowAlignments, none];
RegisterAction[$SetShowAlignments, SetShowAlignments, none];
RegisterAction[$SetDisplayStyle, SetDisplayStyle, rope];

RegisterAction[$RadiusUnitFromSegment, ScaleUnitFromSegment, none];
RegisterAction[$RadiusUnitFromValue, ScaleUnitFromValue, none];
RegisterAction[$RadiusUnitFromSelection, ScaleUnitFromSelection, refReal];
RegisterAction[$InchScaleUnit, InchScaleUnit, none];
RegisterAction[$SetScaleUnit, SetScaleUnit, none];
RegisterAction[$PrintScaleUnit, PrintScaleUnit, none];
RegisterAction[$SlopePrompt, SlopePrompt, none];
RegisterAction[$SetSlopes, SetSlopes, none];
RegisterAction[$AddSlope, AddSlope, none];
RegisterAction[$GetSlope, GetSlope, none];
RegisterAction[$ToggleSlope, ToggleSlope, none];
RegisterAction[$DeleteSlope, DeleteSlope, none];

RegisterAction[$AnglePrompt, AnglePrompt, none];
RegisterAction[$SetAngles, SetAngles, none];
RegisterAction[$AddAngle, AddAngle, none];
RegisterAction[$GetAngle, GetAngle, none];
RegisterAction[$ToggleAngle, ToggleAngle, none];
RegisterAction[$DeleteAngle, DeleteAngle, none];

RegisterAction[$RadiusPrompt, RadiusPrompt, none];
RegisterAction[$SetRadii, SetRadii, none];
RegisterAction[$AddRadius, AddRadius, none];
RegisterAction[$GetRadius, GetRadius, none];
RegisterAction[$ToggleRadius, ToggleRadius, none];
RegisterAction[$DeleteRadius, DeleteRadius, none];

RegisterAction[$DistancePrompt, DistancePrompt, none];
RegisterAction[$SetDistances, SetDistances, none];
RegisterAction[$AddDistance, AddDistance, none];
RegisterAction[$GetDistance, GetDistance, none];
RegisterAction[$ToggleDistance, ToggleDistance, none];
RegisterAction[$DeleteDistance, DeleteDistance, none];
RegisterAction[$MeasureSlopeHit, MeasureSlopeHit, none];
RegisterAction[$MeasureSlopeFromSelection, MeasureSlopeFromSelection, refReal];
RegisterAction[$MeasureAngleHit, MeasureAngleHit, none];
RegisterAction[$MeasureAngleFromSelection, MeasureAngleFromSelection, refReal];
RegisterAction[$MeasureRadiusHit, MeasureRadiusHit, none];
RegisterAction[$MeasureRadiusFromSelection, MeasureRadiusFromSelection, refReal];
RegisterAction[$MeasureLineDistHit, MeasureLineDistHit, none];
RegisterAction[$MeasureLineDistFromSelection, MeasureLineDistFromSelection, refReal];

RegisterAction[$DeleteCaretSegment, DeleteCaretSegment, none];

};

RegisterEventProcs[];

END.


ΦGGEventImplB.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 Σ 1988 by Xerox Corporation.  All rights reserved.
Pier, April 23, 1992 5:11 pm PDT
Bier, June 1, 1992 3:35 pm PDT
Doug Wyatt, June 24, 1988 10:41:43 am PDT

BiScrollers Operations
IF key = $Center THEN remember ELSE ignore -- can't express this in BiScrollers.Align
Change scale and offsets so that client data previously in `from' covers as much as possible of `to' (from and to in viewer coords).
ggData.embed.scrollDue is updated in GGUserImpl.ProcessAndQueueEvent.
ggData.embed.scrollDue is updated in GGUserImpl.ProcessAndQueueEvent.
PROC [ggData: GGData, event: LIST OF REF ANY];
PROC [ggData: GGData, event: LIST OF REF ANY];

Alignment Operations

Make all normal selected slices hot.
Fix the trigger bags, object bags, and Foreground plane (for efficiency).
Make all slices hot.
Make all normal selected slices cold.
Find all hot slices and make them cold.

Does AllAlignmentsOff, turns alignment processing on, sets the gravity extent to a default value, turns gravity on, sets gravity type to PreferPoints, resets the radius unit and turns heuristics on.  This is done before creating or playing a session log to get repeatable results.
Screen style
Units Menu


Slope Line
adds slope from angle viewer in measure line 
If slopeViewValue was set internally, viewer and value will be consistent.
If SlopeValue viewer was set by typein, viewer and value will be inconsistent.
only positive slopes, please
Gets selected segment slopes, adds to slope menu and turns it on
Angle Line
adds angle from angle viewer in measure line 
See comments in AddSlope
Gets selected segment angles, adds to angle menu and turns it on
Radius Line
adds radius from Radius viewer in measure line 
See comments in AddSlope
Distance Line
adds distance from LineDistance viewer in measure line
See comments in AddSlope
Coordinate/Measure Line

Miscellaneous
Build a descriptor for the new chair.
ggData.refresh.startBoundBox^ _ bBoxOfTraj^;

Trackball Actions

BiScrollers Menu
Alignment Operations
Setting Parts of the Gargoyle State
Unit Line

Slope Line
Angle Line
Radius Line
Distance Line

Coordinate Line
Κ1Λ˜Icode™šΟnœx™€
K™<Kš
œ ™ K™K™)—K™š
Οk	˜	Jšœφžœ˜K˜—šœžœ
ž˜Jšžœ³žœ˜ΝKšžœ-ž˜9—˜Kšœ
žœ˜+Kšœžœ˜*Kšœ
žœ˜'Kšœžœ˜#Kšœžœ˜%Kšœžœ
žœΟc˜EKšœ
žœ
žœ$Ÿ˜[Kšœžœ˜/Kšœžœ
žœŸ˜VKšœ
žœ ˜1Jšœžœ˜*Kšœ
žœ˜(Kšœžœ˜'Kšœ
žœ ˜1Kšœžœ˜1Kšœžœ˜!Kšœžœ
žœ!˜<Kšœžœ˜!Kšœ
žœ˜+Kšœ	žœ˜'Kšœžœ!˜7Kšœ
žœ˜'Kšœžœžœ˜-Kšœžœ!˜8Kšœžœ˜!Kšœžœ ˜5Kšœžœ)˜GKšœžœ˜3Kšœžœ˜+Kšœžœ˜#Kšœ
žœ˜'Kšœžœ˜Kšœ
žœ˜'Kšœ	žœ˜%Kšœžœ˜)Kšœžœ˜/Kšœžœ'˜;Kšœžœ˜,Kšœžœ˜#Kšœ
žœ˜'K˜Kšœ
žœ˜Kšœ
žœ
˜Kšœžœ
˜Kšœžœ!˜:Kšœžœ:˜XK˜—Kšœžœžœ˜4K˜K™šœžœ
žœžœžœžœ	žœ
žœ˜wKšœžœ
žœ
˜
šœžœž˜ Kšœžœ
˜Kšœžœ˜"Kšžœžœ
˜—Kšžœ
žœžœ
žœ
˜Kšœžœ
žœ˜š
œ
˜
šžœ
žœžœ˜$Kšœžœ
˜KšœGžœ˜WKšžœ˜
—Kš
œ˜š
žœžœžœžœžœ˜8Kšžœ
žœžœ
žœ
˜!K˜K˜—K•StartOfExpansion&[ec: 
IO.ErrorCode, stream: 
STREAM]šžœ
žœžœ
žœ#˜;Kš
œ˜—K˜
Kš
œ˜K˜—š
œžœžœ!˜LKšœžœ˜Kšœžœ˜"Kšœžœ˜#Kš
œ+˜+Kš
žœžœ	žœ	žœžœ
žœŸ5˜‚
K˜K˜—šœžœ˜"Kš
œ3˜3šžœžœ
žœ˜Kšœžœ
žœ˜ Kšœ
žœžœ˜/Kšœžœ
˜Kšœžœ
˜Kšœžœ˜6Kšžœ
žœžœ˜#Kšžœ
žœ"˜5š
œ˜Kš
œ˜šœžœž˜Kšœžœ
žœžœ˜JKš
œ˜Kšžœžœ
˜—Kšœž˜Kš
œ˜—KšœLžœžœ˜YK˜
—KšžœK˜OK˜K˜—š	œžœ˜#Kš
œ3˜3šžœžœ
žœ˜Kšœžœ
žœ˜ Kšœ
žœžœ˜/Kšœžœ
˜Kšœžœ
˜
Kšœžœ˜1Kšžœ
žœžœ
˜š
œ˜Kš
œ˜šœžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ
˜—Kšœž˜Kš
œ˜—KšœLžœžœ˜YKš
œ
˜
—KšžœK˜OK˜K˜—šœžœ˜ Kš
œ3˜3šžœžœ
žœ˜Kšœžœ˜#Kšœžœ˜$Kšœžœ
žœ˜ K˜šœžœžœž˜!Kšœžœ
˜Kšœ
žœ
˜Kšžœžœ
˜—Kš
œB˜BKš
œB˜Bš
œ˜Kš
œ˜Kš
œ)˜)Kš
œ˜Kšœžœ
˜
Kš
œ˜—KšœLžœžœ˜YK˜
—KšžœK˜OK˜K˜—šœžœ˜"Kš
œ3˜3šžœžœ
žœ˜Kšœžœ
žœ˜ šžœž˜š
œ
˜
Kšœ[žœŸ5˜˜
KšœLžœžœŸ˜kK˜—š
œ˜Kšœ[žœ˜bK˜—Kšœžœ
˜Kšžœžœ
˜—šžœž˜š
œ˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ
˜
Kšœžœ
˜
Kšœžœ
˜
Kš
œ˜—KšœLžœžœ˜YK˜—Kšžœžœ
žœ2™UKšœžœ
˜Kšžœžœ
˜—K˜
—KšžœK˜OK˜K˜—šœžœ˜!Kš
œ3˜3šžœžœ
žœ˜Kšœžœ
žœ˜ Kš
œ6˜6Kšœ
žœžœ
˜šžœž˜Kšœžœ˜#Kšœžœ˜$Kšœžœ˜%Kšœžœ˜"Kš
œ#˜#Kš
œ%˜%Kš
œ#˜#Kš
œ'˜'Kš
œ$˜$Kš
œ&˜&Kš
œ$˜$Kš
œ'˜'Kšžœžœ
˜—KšœOžœ˜VKšœLžœžœ˜YK˜
—KšžœK˜OK˜K˜—š
œžœ˜'Kš
œ3˜3šžœžœ
žœ˜š
œ˜Kš
œ˜Kš
œ9˜9Kš
œ˜Kšœžœ˜—KšœLžœžœ˜YK˜—K˜K˜—š	œžœ˜#Kš
œ3˜3šžœžœ
žœ˜Kš
œa˜a–œ
[bs: 
BiScrollers.BiScroller, client: 
BiScrollers.Location, viewer: 
BiScrollers.Location, doX: 
BOOL _ TRUE, doY: 
BOOL _ TRUE, paint: 
BOOL _ TRUE]šžœžœ˜šžœžœ˜&Kš
œ1˜1š
œ˜Kš
œ˜Kš
œ7˜7Kš
œ.˜.Kšœžœ˜—KšœLžœžœ˜YK˜
—Kšžœ˜ƒ
K˜
—šžœ˜š
œ˜Kš
œ˜Kš
œQ˜QKš
œ.˜.Kšœžœ˜—KšœLžœžœ˜YK˜—K˜
—KšžœK˜OK˜K˜—šœžœ˜%Kš
œ3˜3šžœžœ
žœ˜šžœžœ˜&Kš
œ1˜1š
œ˜Kš
œ˜Kš
œ7˜7Kš
œ.˜.Kšœžœ˜—KšœLžœžœ˜YK˜
—Kšžœk˜oK˜
—KšžœK˜OK˜K˜—šœžœ˜ Kš
œ3˜3–f[gargoyleData: 
GGInterfaceTypes.GargoyleData, selectClass: 
GGSegmentTypes.SelectionClass _ normal]šžœžœ
žœ˜Kš
œ ˜ Kš
œ*˜*Kš
œa˜aKšžœžœf˜wšžœ˜Kš
œ?˜?K–O[m: 
ImagerTransformation.Transformation, r: 
ImagerTransformation.Rectangle]š
œ_˜_Kš
œ#˜#Kš
œ<˜<šœ<žœ˜CKš
œ„
™„
—KšœLžœžœ˜YK˜—K˜
—KšžœK˜OK˜K˜—šœžœ˜1Kšœžœžœ˜+Kšœržœ˜„
Kš
œ8˜8š
ž˜Kš
œ«
˜«
—K˜K˜—šœžœ˜2Kš
œP˜PKš
œŽ
˜Ž
K˜K˜—š	œ˜Kš
œ;˜;Kšœ
žœ
žœ
žœ
˜KšœžœŸ-˜MKš
œ)˜)KšœLžœžœ˜YK˜K˜—šœ˜Kš
œE™EKš
œ=˜=Kš
œ9˜9KšœLžœžœ˜YK˜K˜—Kš
œE™EKš
œ;˜;š
œžœžœžœ˜7Kšžœ*˜0K˜K˜—š	œ˜Kš
œ/˜/Kš
œ˜KšœΟuœ˜Kšœ œ˜K˜Kšžœ$žœ
žœ
˜2K˜Kš
œ9˜9Kš
œ,˜,Kšœ œ>˜IK˜Kš
œ=˜=Kš
œ9˜9KšœLžœžœ˜YK˜Kš
œI˜IKšœ œ7 œ˜JKšœ!žœ
žœ œ˜JK˜K˜—šœžœ˜1Kš
žœžœ
žœ
žœ
žœ™.KšœLžœžœ˜YK˜K˜—šœžœ˜/Kš
žœžœ
žœ
žœ
žœ™.KšœJžœžœ˜WK˜K˜—K™K™šœžœ˜!Kšžœ-žœh˜›
šžœ˜š
œžœžœžœžœ˜MKšœ+Οbœ˜0K˜—š
œžœžœžœžœ˜ZJš
œH˜HKšœžœ
žœ
˜"KšœHžœ˜fKšœ3Ÿ˜JK˜K˜—Kšœžœ%˜9Kš
œ3˜3Kš
œ-˜-Kš
œ:˜:K™K˜(Kš
œ$™$KšœC‘œ˜KKš
œI™IKšœP‘œ˜UK˜ZKšœjžœžœ˜‰
K˜'K˜—K˜K˜—š
œžœ˜$š
œžœžœžœžœ˜BKšœ0‘œ˜5K˜—K˜Kš
œ3˜3Kš
œ-˜-K˜Kš
œ+˜+Kš
œ™Kšœ&‘œ˜;Kš
œX˜XKšœ{žœžœ˜š
Kš
œ*˜*K˜K˜—šœžœ˜"Kšžœ-žœj˜
šžœ˜š

œžœžœžœžœ˜NKšœA‘œ˜FK˜K˜—Kš
œ)˜)Kš
œ%™%KšœD‘œ˜LKš
œ\˜\Kšœqžœžœ˜
Kš
œ(˜(K˜—K˜K˜—šœžœ˜%š

œžœžœžœžœ˜NKš
œF˜FK˜—K˜Kš
œ,˜,Kš
‘'™'KšœD‘œ˜IKš
œW˜WKšœqžœžœ˜
Kš
œ+˜+K˜K˜—š
œžœ˜$šžœžœ˜&šžœžœ7žœ
žœ
˜pKšžœ ˜$—Kš
œ4˜4Kš
œK˜KKš
œR˜RKš	œ2‘œ‘œ
žœžœ˜†
K˜
—Kšžœh˜lK˜K˜—š
œžœ˜$šžœžœ˜'Kšœ6žœ
žœžœ˜]Kš
œ˜Kš
œQ˜QKšœY‘
œ
žœžœ˜Š
K˜
—KšžœV˜ZK˜K™—šœžœ˜,Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!šžœ#žœ˜+Kš
œc˜cKšœužœžœ˜“
K˜—K˜K˜—šœžœ˜)Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜šžœ žœ˜(Kš
œ\˜\Kšœužœžœ˜“
K˜—K˜K˜—šœžœ˜*Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ‘œ	žœ˜$šžœ!žœ˜)Kš
œ\˜\Kšœužœžœ˜“
K˜—K˜K˜—šœžœ˜.Kš
œ˜™˜Kš
œ ˜ šžœ%žœ˜-Kš
œd˜dKšœpžœžœ˜Ž
K˜—Kš
œ˜—K˜K™šœžœ˜,Kšœ	žœ#˜0Kš
œ˜š
œžœžœžœžœ˜IKšœ8žœ˜=K˜—Kšœ‘œ˜+Kš
œk˜kKš
œM˜MKšœjžœžœ˜ˆ
Kš
œ˜K˜—šœžœ˜.Kšœ"žœ$˜IKšžœ%žœqžœžœ˜Ί
K˜K˜—šœžœ˜+Kšœžœžœ˜/Kšœžœ"˜6Kš
œ2˜2K˜K˜—šœžœ˜)Kšœžœ˜?Kšžœ žœežœžœ˜©
K˜K˜—šœžœ˜&Kšœžœžœ˜/Kšœžœ"˜4Kš
œ+˜+K˜K˜—šœžœ˜*Kšœžœ ˜AKšžœ!žœqžœžœ˜Ά
K˜K˜—š
œžœ˜'Kšœžœžœ˜/Kšœžœ"˜5Kš
œ-˜-K˜K˜—šœžœ˜)Kšœžœžœ˜0Kš
œB˜BKš
œ'˜'K˜—K˜K™
šœžœžœ	žœ˜DKšžœžœd˜{šžœ˜Jšœ&‘œΟtœŸ˜hKšœ6Ÿ˜GKšœ	‘œ	˜K–§
[paintAction: 
ATOM, gargoyleData: 
GGInterfaceTypes.GargoyleData, remake: 
GGWindow.ForegroundParts _ triggerBag, backgndOK: 
BOOL _ FALSE, edited: 
BOOL _ TRUE]šžœžœžœ˜*Kšœsžœžœ˜‘
K˜—K˜K™—šœžœ˜.Kšžœ;žœ
žœ˜Qšžœ˜Kšœ
žœŸ˜+Kš
œV˜VK–([sliceD: 
GGModelTypes.SliceDescriptor]š
œH˜HKš
œJ˜JKš
œI˜IKšžœ
žœ
žœ	žœ
žœ
žœ˜4Kš
œ8˜8Kšœžœ˜%K˜—š
ž˜˜Kš
œv˜vK˜——K˜K™—šœžœ˜,Kšœžœ
˜
Kšœ	žœžœ
˜Kš
œ3˜3Kšžœ	žœ7žœ˜LK˜K˜—šœžœ˜0šœ
žœžœžœ
ž˜2Kšœžœ
žœ
˜Kšœžœ
žœžœ˜Kšžœ	˜—Kšžœžœ
žœ
žœžœžœ†
˜Ν
Kšžœ%žœŸ˜>K˜K˜—šœžœ˜&Kš	œžœžœžœ
žœ˜3Kšœžœžœ˜,Kš
œ-˜-K˜K˜—š
œžœ˜'Kšœžœžœ
žœ˜KK˜K˜—šœžœ˜(K–#[ggData: 
GGInterfaceTypes.GGData]šœžœ(˜3Kš
ϡ
˜°
K˜—K˜K™
Kš	œžœ
žœ
žœžœ3˜\šœžœ˜(Kš
œ3˜3šžœžœ˜'K˜QKšœužœžœ˜“
K˜—K˜K˜—š	œžœ˜#Kšœžœžœ˜0Kšœžœ
žœ
žœ
˜Kšœžœ
žœ
žœ
˜Kšœ
ŸœA˜Fš
žœ
žœ
žœ
žœžœžœ
ž˜PJš
œ5˜5J˜
Jšžœ
˜—K˜K˜—šœžœžœ
žœ
žœ
žœ˜>Kšœžœ˜"šžœžœ˜$K˜FKšœužœžœ˜“
K˜—K˜K˜—šœžœ˜%Kšœ-žœ˜4šžœžœ˜$K˜FKšœužœžœ˜’
Kš
œ˜—Kš
œ˜K˜—šœžœ˜"™-Kš
‘J™JKš
‘N™N—Kšœžœ
˜Kšœ	žœ
˜Kš
œ1˜1Kšžœ
žœ	žœ
žœ
˜Kš
œ%˜%K˜CKšœsžœžœ˜
K˜K˜—šœžœ
žœžœžœžœ˜SKš
‘™Kšžœ
žœ˜,Kšžœžœ˜$Kš
œ(˜(Kš
œ+˜+K˜K˜—šœžœ˜%Kš
œ0˜0Kšœ4Ÿ˜NK˜FKšœužœžœ˜’
Kš
œ˜K˜—šœžœ˜"K™@Kšžœ;žœa˜’
šžœ˜š

œžœžœžœžœ˜KK–([sliceD: 
GGModelTypes.SliceDescriptor]š
œC˜Cšžœwžœ	žœ
ž˜Ž
Kš
œA˜AKšžœ
˜—J˜—Kš
œH˜HKš
œD˜DKšœsžœžœ˜
K˜—K˜K˜—šœžœ˜%Kšœžœ
˜Kšœ
žœžœ
˜Kšœ
žœ
˜Kš
œ,˜,Kš
œ,˜,Kš
œH˜Hšžœ
žœ˜Kšœžœ
žœ
˜"Kšœžœžœ#˜=Kš
œ‚
˜‚
Kš
œ2˜2Kš
œ˜K˜
—Kšžœ˜Kšœfžœžœ˜ƒ
Kš
œ+˜+K˜K˜—š	œžœžœ
žœ
žœ
žœžœ
žœžœžœžœ˜©
šœ
žœžœžœ
ž˜2Kšœžœ
žœ
˜Kšœžœ
žœžœ˜Kšžœ˜—š
žœžœ
žœ
žœžœ˜6Kš
œ^˜^Kšžœ
˜K˜—Kš
œK˜KKšžœ
žœ%˜8Kšžœ(˜,K˜—K˜K™
Kš	œžœ
žœ
žœžœ:˜]šœžœ˜(Kš
œ-˜-šžœžœ˜'K˜QKšœužœžœ˜’
K˜—K˜K˜—š	œžœ˜#Kšœžœžœ˜0Kšœžœ
žœ
žœ
˜Kšœžœ
žœ
žœ
˜Kšœ
ŸœA˜Fš
žœ
žœ
žœ
žœžœžœ
ž˜PJš‘œ%˜5J˜
Jšžœ
˜—K˜K˜—šœžœžœ
žœ
žœ
žœ˜>Kšœžœ˜"šžœžœ˜$K˜FKšœužœžœ˜’
K˜—K˜K˜—šœžœ˜%Kšœ-žœ˜4šžœžœ˜$K˜FKšœužœžœ˜’
Kš
œ˜—Kš
œ˜K˜—šœžœ˜"K™-K™Kšœžœ
˜Kšœ	žœ
˜Kš
œ1˜1Kšžœ
žœ	žœ
žœ
˜Kš
œ%˜%Kš
œC˜CKšœsžœžœ˜
K˜K˜—šœžœ
žœžœžœžœ˜SKšžœžœ˜$Kš
œ(˜(Kš
œ+˜+K˜K˜—šœžœ˜%Kš
œ0˜0Kšœ4Ÿ˜NK˜FKšœužœžœ˜’
Kš
œ˜K˜—šœžœ˜"K™@šžœ;ž˜AKš
œ`˜`—šžœ˜š

œžœžœžœžœ˜KK–([sliceD: 
GGModelTypes.SliceDescriptor]š
œC˜CKšœžœ
˜#Kšœ	žœ˜šžœsžœžœ
ž˜ˆ
Kšžœ
žœ
žœžœ˜-Kšžœžœ
žœ˜&Kš
œI˜IKš
œ'˜'Kš
œ˜Kšœžœ
˜Kšžœ
˜—J˜—Kš
œH˜HKš
œD˜DKšœsžœžœ˜
K˜—K˜K˜—šœžœ˜%Kšœžœ
˜Kšœ
žœžœ
˜Kšœ
žœ
˜Kš
œ,˜,Kš
œH˜Hšžœ
žœ˜Kš
œ˜K˜
—Kšžœ˜Kšœfžœžœ˜ƒ
K˜—K˜K™Kš	œžœ
žœ
žœžœM˜oKš	œžœ
žœžœžœI˜uš
œžœ˜'Kš
œA˜Ašžœžœ˜&K˜PKšœužœžœ˜’
K˜—K˜K˜—šœžœ˜"Kšœžœžœ˜0Kšœžœ
žœ
žœ
˜Kšœžœ
žœ
žœ
˜Kšœžœ
žœžœ
˜Kš
œG˜Gš
žœ
žœ
žœ
žœžœžœ
ž˜PJš‘œ2˜CJ˜
Jš
œ˜Jšžœ
˜—K˜K˜K˜—š
œžœžœ
žœ
žœ
žœ˜=Kšœžœžœ˜(šžœžœ˜#Kš
œE˜EKšœužœžœ˜’
K˜—K˜K˜—šœžœ˜&Kšœ.žœ˜5šžœžœ˜%Kš
œE˜EKšœužœžœ˜’
K˜—K˜K˜—š	œžœ˜#K™/K™Kšœžœ
˜
Kšœ	žœ
˜Kš
œ3˜3Kšžœ
žœ	žœ
žœ
˜Kšœžœ
˜,K˜DKšœsžœžœ˜
K˜K˜—šœžœ
žœžœ
žœžœžœ˜dKš
œ(˜(Kš
œ1˜1K˜K˜—šœžœ˜&Kš
œ1˜1Kšœ5Ÿ˜OK˜EKšœužœžœ˜’
Kš
œ˜K˜—š	œžœ˜#šžœ;ž˜AKš
œa˜a—šžœ˜š
œžœžœžœžœ˜LK–([sliceD: 
GGModelTypes.SliceDescriptor]š
œC˜Cšžœwžœ	žœ
ž˜Ž
KšœžœT˜`Kšœžœ
˜,Kšžœ
˜—J˜—Kš
œI˜IKš
œC˜CKšœsžœžœ˜
Kš
œ˜—Kš
œ˜K˜—šœžœ˜&Kšœžœ
˜Kšœ
žœžœ
˜Kšœ
žœ
˜Kš
œ,˜,Kš
œI˜Išžœ
žœ˜Kš
œ˜K˜
—Kšžœ˜Kšœfžœžœ˜ƒ
K˜K˜—K˜K™
Kš	œžœ
žœ
žœžœ$˜JKš	œžœ
žœžœžœ"˜Qšœžœ˜+Kš
œN˜Nšžœ"žœ˜*K˜TKšœužœžœ˜’
K˜—K˜K˜—šœžœ˜&Kšœžœžœ˜3Kšœžœ
žœ
žœ
˜Kšœžœ
žœ
žœ
˜Kšœžœ
žœžœ
˜Kš
œJ˜Jš
žœ
žœ
žœ
žœžœžœ
ž˜PJš‘œ2˜EJ˜
Jš
œ˜Jšžœ
˜—K˜K˜—šœžœžœ
žœ
žœ
žœ˜AKšœ$žœžœ˜.šžœžœ˜'Kš
œI˜IKšœužœžœ˜’
K˜—K˜K˜—šœžœ˜(Kšœ4žœ˜;šžœžœ˜'Kš
œI˜IKšœužœžœ˜’
K˜—K˜K˜—šœžœ˜%K™6K™Kšœ
žœ
˜Kšœ	žœ
˜Kš
œ;˜;Kšžœ
žœ	žœ
žœ
˜Kšœ%žœ˜4Kš
œF˜FKšœsžœžœ˜
K˜K˜—šœžœ
žœžœžœžœžœ˜hKš
œ,˜,Kš
œ9˜9K˜K˜—šœžœ˜(Kš
œ7˜7Kšœ7Ÿ˜QKš
œI˜IKšœužœžœ˜’
Kš
œ˜K˜—šœžœ˜%šžœ;ž˜AKš
œc˜c—šžœ˜š
	œžœžœžœžœ˜JK–([sliceD: 
GGModelTypes.SliceDescriptor]š
œC˜Cšžœwžœ	žœ
ž˜Ž
Kšœ
žœ?˜MKšœ%žœ˜4Kš
ž˜—J˜—Kš
œG˜GKš
œG˜GKšœsžœžœ˜
Kš
œ˜—Kš
œ˜K˜—šœžœ˜(Kšœžœ
˜Kšœ
žœžœ
˜Kšœ
žœ
˜Kš
œ,˜,Kš
œO˜Ošžœ
žœ˜Kš
œ˜K˜
—Kšžœ˜Kšœfžœžœ˜ƒ
K˜K˜—K˜K™šœžœ˜)Kš
œ!˜!K˜K˜—šœžœ˜3Kš	œžœžœžœ
žœ˜2šžœžœ˜Kš
œw˜wKšžœ
˜K˜—Kš
œ%˜%Kšœžœ
˜"K˜K˜—šœžœ˜)Kš
œ!˜!K˜K˜—šœžœ˜3Kš	œžœžœžœ
žœ˜2šžœžœ˜Kš
œw˜wKšžœ
˜K˜—Kš
œ%˜%Kšœžœ
˜"K˜K˜—šœžœ˜*Kš
œ"˜"K˜K˜—šœžœ˜4Kš	œžœžœžœ
žœ˜3šžœžœ˜Kš
œy˜yKšžœ
˜K˜—Kš
œ'˜'Kšœžœ˜$K˜K˜—šœžœ˜,Kš
œ(˜(K˜K˜—šœžœ˜6Kš	œ
žœžœžœ
žœ˜5šžœžœ˜ Kš
œ‚
˜‚
Kšžœ
˜K˜—Kš
œ/˜/Kšœžœ˜(K˜—K™K™
šœžœ˜,Kšœžœ
˜Kš
œ'˜'Kšœžœ
žœ˜K˜Kš
œ˜Kš
œ˜K˜K˜
K˜Kš
œ˜K˜K˜šžœžœŸ.˜TKšœ	žœžœ
˜K˜Kš
œ˜Kš
œ!˜!Kš
œ<˜<Kšžœ
žœ	žœ
žœ-˜FKš
œ˜Kš
œ&˜&Kš
œ*˜*šžœ
ž˜Kš
œ%˜%Kš
œB˜BKšžœžœ"˜2—Kš
œ0˜0Kš
œ4˜4Kšœ$žœ ˜JK˜Kšœ’œŸ˜QKš
œ>˜>Kš
œ1˜1Kš
œ?˜?Kšœžœžœ
žœ
žœ
žœ˜Nšžœžœ
žœŸ˜=Kšœžœ˜šžœ žœ˜(Kš
œ'˜'K˜
—šžœ˜Kš
œ0˜0Kš
œA˜AKšžœžœ
žœ+˜GK˜—K˜
—šžœ˜Kš
œ˜Kš
œ˜Kšœ
žœ
˜šžœ žœ˜(Kš
œ2˜2Kš
œ'˜'Kš
œ2˜2Kš
œ8˜8K˜
—šžœ˜Kš
œ0˜0Kš
œ:˜:Kš
œ.˜.Kš
œ=˜=Kš
œ1˜1K˜—Kš
‘%™%Kš
œ>˜>Kš	œ(žœžœžœžœ˜iKšœ=Ÿ˜OKš
œ>˜>Kš
œ"˜"K˜—Kšœ2žœ˜7Kš
œ,™,Jšœ
‘œ	˜Jšœ
‘œžœ˜3Kšœ	‘œŸ0˜PKš
œ`˜`Kšœ}žœžœ˜›
K˜
—Kšžœ‹
˜
Kš
œ˜—K˜šœ˜K˜—K˜šœžœ˜Kšžœ
˜K™K™Kšœ-žœžœ˜;Kšœ(žœžœ˜6—™K™Kš
œ+˜+Kš
œ-˜-Kš
œ&˜&Kš
œ*˜*Kš
œ(˜(Kš
œ4˜4Kš
œ,˜,Kš
œ0˜0Kš
œ&˜&Kš
œH˜HKš
œJ˜JKš
œ-˜-Kš
œ(˜(K˜Kš
œH˜HKš
œD˜DK˜K™Kš
œ(˜(Kš
œ.˜.Kš
œ*˜*Kš
œ0˜0Kš
œ.˜.Kš
œ.˜.Kš
œ>˜>Kš
œ8˜8Kš
œ:˜:Kš
œB˜BK˜K™#Kš
œ>˜>Kšœ-žœ˜4Kšœ*žœ˜1Kš
œ8˜8Kšœ2žœ˜9Kš
œ:˜:Kšœ4žœ˜;Kš
œB˜BKš
œ<˜<Kš
œ8˜8K˜K™	Kš
œC˜CKš
œ?˜?Kš
œJ˜JKš
œ4˜4Kš
œ2˜2Kš
œ6˜6K™K™
Kš
œ0˜0Kš
œ,˜,Kš
œ*˜*Kš
œ*˜*Kš
œ0˜0Kš
œ0˜0K˜K™
Kš
œ0˜0Kš
œ,˜,Kš
œ*˜*Kš
œ*˜*Kš
œ0˜0Kš
œ0˜0K˜K™Kš
œ2˜2Kš
œ*˜*Kš
œ,˜,Kš
œ,˜,Kš
œ2˜2Kš
œ2˜2K˜K™
Kš
œ6˜6Kš
œ2˜2Kš
œ0˜0Kš
œ0˜0Kš
œ6˜6Kš
œ6˜6K™K™Kš
œ8˜8Kš
œO˜OKš
œ8˜8Kš
œO˜OKš
œ:˜:Kš
œQ˜QKš
œ>˜>Kš
œU˜UK˜Kš
œ>˜>K˜K˜—K˜K˜K˜Kšžœ
˜J˜J˜—…—Ιz