
    <<GGEventImplE.mesa>>
        <<Copyright Ó 1987, 1988, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Contents:  Once an event reaches the front of the slack-process queue, it is dispatched to one of the procedures in this module.>>
        <<Pier, June 30, 1992 2:03 pm PDT>>
        <<Bier, August 23, 1993 5:04 pm PDT>>
        <<Doug Wyatt, April 20, 1992 10:55 am PDT >>
        <<>>
    DIRECTORY
    Ascii, Atom, CodeTimer, ColorTool, CubicSplines, EditSpanSupport, Feedback, FeedbackTypes,  GGAlign, GGBasicTypes, GGBoundBox, 
    GGCaret, GGCoreOps, GGCoreTypes, GGDescribe, GGDragTypes, GGEvent, GGFont, GGHistory, GGHistoryTypes, GGInterfaceTypes, 
    GGModelTypes, GGMultiGravity, GGOutline, GGParent, GGParseIn, GGRefresh, GGRefreshTypes, GGScene, GGSegment, GGSegmentTypes, 
    GGSelect, GGSequence, GGSlice, GGSliceOps, GGState, GGTraj, GGTrajTypes, GGUserInput, GGUserProfile, GGUtility, GGViewerOps, 
    GGWindow, Imager, ImagerColor, ImagerInterpress, ImagerPixel, ImagerPixelArray, ImagerSample, ImagerTransformation, IO, 
    IPMaster, NamedColors, NodeProps, Random, Real, RealFns, Rope, SF, TextNode, TiogaAccess, TiogaAccessViewers, TiogaImager, 
    TiogaOpsDefs, Vectors2d, ViewerClasses, ViewerOps, ViewerTools;

    GGEventImplE: CEDAR PROGRAM
    IMPORTS Atom, ColorTool, EditSpanSupport, Feedback, GGAlign, GGBoundBox, GGCaret, GGHistory, GGOutline, GGParent, GGParseIn, 
    GGRefresh, GGScene, GGSegment, GGSelect, GGSequence, GGSlice, GGSliceOps, GGState, GGTraj, GGUserInput, GGUtility, GGViewerOps, 
    GGWindow, Imager, ImagerColor, ImagerPixel, ImagerPixelArray, ImagerSample, ImagerTransformation, IO, NodeProps, Real, RealFns, 
    Rope, TextNode, TiogaAccess, TiogaAccessViewers, Vectors2d, ViewerOps, ViewerTools
        EXPORTS GGEvent, GGHistoryTypes, GGInterfaceTypes = BEGIN

        DragDataObj: PUBLIC TYPE = GGDragTypes.DragDataObj; -- exported to GGInterfaceTypes
        HistoryToolObj: PUBLIC TYPE = GGHistory.HistoryToolObj; -- exported to GGHistoryTypes

        AlignBag: TYPE = GGInterfaceTypes.AlignBag;
        BitVector: TYPE = GGModelTypes.BitVector;
        BoundBox: TYPE = GGModelTypes.BoundBox;
        Caret: TYPE = GGInterfaceTypes.Caret;
        Color: TYPE = ImagerColor.Color;
        ControlPointGenerator: TYPE = GGModelTypes.ControlPointGenerator;
        FeatureCycler: TYPE = GGInterfaceTypes.FeatureCycler;
        FeatureData: TYPE = GGModelTypes.FeatureData;
        MakeCurveProc: TYPE = GGTrajTypes.MakeCurveProc;
        MsgRouter: TYPE = FeedbackTypes.MsgRouter;
        FontData: TYPE = GGFont.FontData;
        GGData: TYPE = GGInterfaceTypes.GGData;
        HistoryEvent: TYPE = GGHistoryTypes.HistoryEvent;
        HistoryTool: TYPE = REF HistoryToolObj;
        GravityType: TYPE = GGInterfaceTypes.GravityType;
        Joint: TYPE = GGModelTypes.Joint;
        JointGenerator: TYPE = GGModelTypes.JointGenerator;
        Orientation: TYPE = GGModelTypes.Orientation;
        Point: TYPE = GGBasicTypes.Point;
        RefreshDataObj: PUBLIC TYPE = GGRefreshTypes.RefreshDataObj;
        RunProc: TYPE = GGTraj.RunProc;
        Scene: TYPE = GGModelTypes.Scene;
        SegAndIndex: TYPE = GGSequence.SegAndIndex;
        Segment: TYPE = GGSegmentTypes.Segment;
        SegmentGenerator: TYPE = GGModelTypes.SegmentGenerator;
        SelectionClass: TYPE = GGModelTypes.SelectionClass;
        Sequence: TYPE = GGModelTypes.Sequence;
        SequenceOfReal: TYPE = REF SequenceOfRealObj;
        SequenceOfRealObj: TYPE = GGCoreTypes.SequenceOfRealObj;
        Slice: TYPE = GGModelTypes.Slice;
        SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
        SliceDescriptorGenerator: TYPE = GGModelTypes.SliceDescriptorGenerator;
        SliceDescriptorObj: TYPE = GGModelTypes.SliceDescriptorObj;
        SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
        SliceParts: TYPE = GGModelTypes.SliceParts;
        StrokeEnd: TYPE = Imager.StrokeEnd;
        StrokeJoint: TYPE = Imager.StrokeJoint;
        TrajData: TYPE = GGModelTypes.TrajData;
        TrajEnd: TYPE = GGModelTypes.TrajEnd;
        TrajParts: TYPE = GGModelTypes.TrajParts;
        Transformation: TYPE = Imager.Transformation;
        TriggerBag: TYPE = GGInterfaceTypes.TriggerBag;
        UserInputProc: TYPE = GGEvent.UserInputProc;
        Vector: TYPE = GGBasicTypes.Vector;
        Viewer: TYPE = ViewerClasses.Viewer;
        WalkProc: TYPE = GGModelTypes.WalkProc;

        reallyBigReal: REAL = 1.0e37;

    <<Utility Routines>>
    SelectEntireSlice: PUBLIC PROC [slice: Slice, scene: Scene, selectClass: SelectionClass, ggData: GGData]= {
        extender: SliceDescriptor;
        GGSelect.SelectEntireSlice[slice, scene, selectClass];
        GGState.SetExtendMode[ggData, topLevel];
        IF (extender Ź GGState.GetSliceToExtend[ggData])#NIL AND extender.slice#slice THEN {
            sliceD: SliceDescriptor Ź GGSliceOps.NewParts[slice, NIL, slice];
            GGState.SetSliceToExtend[ggData, sliceD];
            };
        };

    SelectSlice: PUBLIC PROC [sliceD: SliceDescriptor, scene: Scene, selectClass: SelectionClass, ggData: GGData]= {
        extender: SliceDescriptor;
        GGSelect.SelectSlice[sliceD, scene, selectClass];
        GGState.SetExtendMode[ggData, topLevel];
        IF (extender Ź GGState.GetSliceToExtend[ggData])#NIL AND extender.slice#sliceD.slice THEN {
            GGState.SetSliceToExtend[ggData, sliceD];
            };
        };

    <<Edit Menu>>
    UndoOne: UserInputProc = {
        GGHistory.UndoN[ggData, 1];
        };

    BuildAHistoryTool: UserInputProc = {
        ggData.history.tool Ź GGHistory.BuildTool[GGState.GetFullName[ggData], ggData];
        };

    GetSelectedWrapRule: PROC [ggData: GGData] RETURNS [odd: BOOL Ź FALSE, success: BOOL Ź TRUE] = {
        DoCheckWrapRule: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            thisOdd: BOOL Ź GGOutline.GetWrapRule[sliceD.slice];
            IF found 
                THEN done Ź thisOdd # odd
                ELSE {
                    found Ź TRUE;
                    odd Ź thisOdd;
                    };
            };
        scene: Scene Ź ggData.scene;
        found: BOOL Ź FALSE;
        success Ź NOT GGScene.WalkSelectedSlices[scene, highest, DoCheckWrapRule, normal, $Outline];
        };

    ShowWrapRule: PUBLIC UserInputProc = {
        scene: Scene Ź ggData.scene;
        odd: BOOL Ź FALSE;
        success: BOOL Ź FALSE;
        IF GGScene.CountSelectedSlices[scene, highest, normal, $Outline] = 0 THEN Feedback.Append[ggData.router, oneLiner, $Complaint, 
        "ShowWrapRule failed: select at least one outline for ShowWrapRule"]
        ELSE {
            [odd, success] Ź GetSelectedWrapRule[ggData];
            IF NOT success THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowWrapRule failed: multiple wrap rules are selected"]
            ELSE
                Feedback.PutF[ggData.router, oneLiner, $Show, "ShowWrapRule: wrap rule is %g", [rope[
                    IF odd THEN "odd wrap" ELSE "non-zero wrap"]] ];
            };
        };

    SetOddWrap: UserInputProc = {
        SetWrapAux[event, ggData, TRUE];
        };

    SetNonZeroWrap: UserInputProc = {
        SetWrapAux[event, ggData, FALSE];
        };

    SetWrapSlice: PROC [slice: Slice, parts: SliceParts, odd: BOOL] = {
        SELECT GGSliceOps.GetType[slice] FROM
            $Cluster => {
                DoSetWrap: PROC [childD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
                    SetWrapSlice[childD.slice, childD.parts, odd];
                    };
                [] Ź GGParent.WalkIncludedChildren[slice, parts, highest, DoSetWrap, $Outline];
                };
            $Outline => {
                GGOutline.SetWrapRule[slice, odd];
                };
            ENDCASE => {};
        };

    SetWrapAux: PROC [event: LIST OF REF, ggData: GGData, odd: BOOL Ź TRUE] = {
        scene: Scene Ź ggData.scene;
        DoSetWrap: PROC [nextSD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            SetWrapSlice[nextSD.slice, nextSD.parts, odd];
            };
        IF GGScene.CountSelectedSlices[scene, highest, normal, $Outline] = 0
            THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetWrapRule failed: select at least one outline for SetWrapRule"]
            ELSE {
                GGHistory.NewCapture["Set wrap rule", ggData]; -- capture scene BEFORE UPDATE
                [] Ź GGScene.WalkSelectedSlices[scene, highest, DoSetWrap, normal, $Outline];
                <<ggData.refresh.startBoundBox^ _ GGScene.BoundBoxOfSelected[scene, normal, TRUE]^;>>
                GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedParts: TRUE];
                GGHistory.PushCurrent[ggData];
                Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetWrapRule: %g wrap set", [rope[
                    IF odd THEN "odd" ELSE "non-zero"]] ];
                GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: none, edited: TRUE, 
                okToSkipCapture: FALSE];
                };
        };

    GetSelectedOrientation: PROC [ggData: GGData] RETURNS [orientation: Orientation Ź cw, success: BOOL Ź TRUE] = {
        DoCheckOrientation: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            thisOrient: Orientation;
            isUnique: BOOL Ź FALSE;
            [thisOrient, isUnique] Ź GGSliceOps.GetOrientation[sliceD.slice, sliceD.parts];
            IF NOT isUnique THEN {
                orientation Ź thisOrient;
                RETURN[TRUE];
                };
            IF found 
                THEN done Ź thisOrient # orientation
                ELSE {
                    found Ź TRUE;
                    orientation Ź thisOrient;
                    };
            };
        scene: Scene Ź ggData.scene;
        found: BOOL Ź FALSE;
        success Ź NOT GGScene.WalkSelectedSlices[scene, first, DoCheckOrientation, normal];
        };

    ShowOrientation: PUBLIC UserInputProc = {
        orientation: Orientation Ź reverse;
        success: BOOL Ź FALSE;
        IF GGSelect.NoSelections[ggData.scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowOrientation failed: 
        select at least one oriented object for ShowOrientation"]
        ELSE {
            [orientation, success] Ź GetSelectedOrientation[ggData];
            IF NOT success THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowOrientation failed: multiple orientations are 
            selected"]
            ELSE
                Feedback.PutF[ggData.router, oneLiner, $Show, "ShowOrientation: orientation is %g", [rope[
                SELECT orientation FROM
                    cw => "cw",
                    ccw => "ccw",
                    reverse => "none",
                    ENDCASE => ERROR
                    ]]
                ];
            };
        };

    OrientCW: PUBLIC UserInputProc = {
        OrientAux[event, ggData, cw];
        };

    OrientCCW: PUBLIC UserInputProc = {
        OrientAux[event, ggData, ccw];
        };

    Reorient: PUBLIC UserInputProc = {
        OrientAux[event, ggData, reverse];
        };

    OrientAux: PROC [event: LIST OF REF, ggData: GGData, orientation: Orientation] = {
        scene: Scene Ź ggData.scene;
        IF GGSelect.NoSelections[scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetOrientation failed: select at 
        least one object for SetOrientation"]
        ELSE {
            DoOrient: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
                GGSelect.SaveSelectionsInSliceAllClasses[sliceD.slice, scene];
                [] Ź GGSliceOps.SetOrientation[sliceD.slice, sliceD.parts, orientation, currentEvent];
                GGSelect.ReselectSliceAllClasses[sliceD.slice, scene];
                };
            currentEvent: HistoryEvent Ź GGHistory.NewCurrent["Orient", ggData];
            [] Ź GGScene.WalkSelectedSlices[scene, first, DoOrient, normal];
            <<ggData.refresh.startBoundBox^ _ GGScene.BoundBoxOfSelected[ggData.scene, normal]^;>>
            GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedParts: TRUE];
            GGHistory.PushCurrent[ggData];
            Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetOrientation: orientation is %g", [rope[
                SELECT orientation FROM
                    cw => "_ cw",
                    ccw => "_ ccw",
                    reverse => "reversed",
                    ENDCASE => ERROR
                    ]]
                ];
            GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, 
            okToSkipCapture: FALSE];
            };
        };
    <<>>
    <<Curve Menu>>
    gScale: REAL Ź 0.33;
    gAngle: REAL Ź 33;

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

    SetStraight: PUBLIC UserInputProc = {
        MakeStraightAux: MakeCurveProc = {
            seg Ź GGSegment.MakeLine[lo, hi, props];
            };
        SetCurveAux[ggData, MakeStraightAux, $Line];
        }; -- end SetStraight

    SetArc: PUBLIC UserInputProc = {
        MakeArcAux: MakeCurveProc = {
            p1: Point;
            p1 Ź Vectors2d.Add[Vectors2d.Scale[Vectors2d.Sub[hi,lo], 0.5], lo];
            seg Ź GGSegment.MakeArc[lo, p1, hi, props];
            };
        SetCurveAux[ggData, MakeArcAux, $Arc];
        }; -- end SetArc

    SetSnowflake: PUBLIC UserInputProc = {
        OPEN Vectors2d;
        MakeSnowflakeAux: PROC [seg: Segment, traj: Slice] RETURNS [patternTraj: Slice] = {
            length: REAL;
            p1, p2, p3: Point;
            sideVec, dir, x: Vector;
            seg1, seg2, seg3, seg4: Segment;
            lo: Point _ seg.lo;
            hi: Point _ seg.hi;
            success: BOOL _ FALSE;
            length _ Vectors2d.Distance[lo,hi];
            dir _ Sub[hi,lo];
            x _ Scale[dir, 1.0/3.0];
            p1 _ Add[lo, x];
            p3 _ Add[lo, Scale[dir, 2.0/3.0]];
            sideVec _ Scale[VectorPlusAngle[dir, 90], length*RealFns.SqRt[3]/6.0];
            p2 _ Add[lo, Vectors2d.Add[Scale[dir, 0.5], sideVec]];
            patternTraj _ traj;
            seg1 _ GGSegment.MakeLine[p0: lo, p1: p1, props: seg.props];
            seg2 _ GGSegment.MakeLine[p0: p1, p1: p2, props: seg.props];
            seg3 _ GGSegment.MakeLine[p0: p2, p1: p3, props: seg.props];
            seg4 _ GGSegment.MakeLine[p0: p3, p1: hi, props: seg.props];
            success _ GGTraj.AddSegment[patternTraj, hi, seg1, lo];
            success _ GGTraj.AddSegment[patternTraj, hi, seg2, lo];
            success _ GGTraj.AddSegment[patternTraj, hi, seg3, lo];
            success _ GGTraj.AddSegment[patternTraj, hi, seg4, lo];
            };
        SetPatternAux[ggData, MakeSnowflakeAux];
        };

    SetConic: PUBLIC UserInputProc = {
        MakeConicAux: MakeCurveProc = {
            p1: Point;
            p1 Ź Vectors2d.Add[Vectors2d.Scale[Vectors2d.Sub[hi,lo], 0.5], lo];
            seg Ź GGSegment.MakeConic[lo, p1, hi, r, props];
            };
        r: REAL Ź NARROW[event.rest.first, REF REAL]­;
        IF r<0.0 OR r>1.0 THEN {
            Feedback.Append[ggData.router, oneLiner, $Complaint, "SetConic failed: select a real number in [0.0 .. 1.0] for conic pointiness"];
            RETURN;
            };
        SetCurveAux[ggData, MakeConicAux, $Conic];
        };

    SetConstraintType: PUBLIC UserInputProc = {
        constraint: Rope.ROPE Ź NARROW[event.rest.first];
        ggData.drag.editConstraints Ź SELECT TRUE FROM
            Rope.Equal[constraint, "length", FALSE] => length,
            Rope.Equal[constraint, "tangent", FALSE] => tangent,
            ENDCASE => none;
         ShowConstraintType[ggData, event];
        };

    SetMakeConstrained: PUBLIC UserInputProc = {
    <<Enforce constraint at selection (joint or CP).>>
        cpGen: ControlPointGenerator;
        jointGen: JointGenerator;
        thisCPNum, thisSegNum: NAT;
        constrained, done: BOOL Ź FALSE;
        scene: Scene Ź ggData.scene;
        DoConstrain: PROC [nextTrajD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            <<GGBoundBox.EnlargeByBox[bBox: ggData.refresh.startBoundBox, by: GGSliceOps.GetBoundBox[nextTrajD.slice]]; -- original bBox>>
            GGRefresh.EnlargeStartBox[ggData, GGSliceOps.GetBoundBox[nextTrajD.slice], NIL];
            constrained Ź FALSE;
            jointGen Ź GGSequence.JointsInSequence[NARROW[nextTrajD.parts]];
            FOR thisJointNum: INT Ź GGSequence.NextJoint[jointGen], GGSequence.NextJoint[jointGen] UNTIL thisJointNum = -1 DO
                constrained Ź GGTraj.ConstrainJoint[nextTrajD.slice, ggData.drag.editConstraints, thisJointNum] OR constrained; -- evaluation order 
                important!!
                ENDLOOP;
            cpGen Ź GGSequence.ControlPointsInSequence[NARROW[nextTrajD.slice.data], NARROW[nextTrajD.parts]];
            done Ź FALSE;
            [thisSegNum, thisCPNum, done] Ź GGSequence.NextSegNumAndCPNum[cpGen]; -- init loop
            UNTIL done DO
                constrained Ź GGTraj.ConstrainCP[nextTrajD.slice, ggData.drag.editConstraints, thisSegNum, thisCPNum] OR constrained; -- evaluation 
                order important!!
                [thisSegNum, thisCPNum, done] Ź GGSequence.NextSegNumAndCPNum[cpGen];
                ENDLOOP;
            <<IF constrained THEN GGBoundBox.EnlargeByBox[bBox: ggData.refresh.startBoundBox, by: GGSliceOps.GetBoundBox[nextTrajD.slice]]; -- 
            constrained bBox>>
            IF constrained THEN GGRefresh.EnlargeStartBox[ggData, GGSliceOps.GetBoundBox[nextTrajD.slice], NIL]; -- constrained bBox
            };

        IF ggData.drag.editConstraints = none THEN RETURN[];
        <<ggData.refresh.startBoundBox^ _ GGBoundBox.emptyBoundBox^; -- null bound box>>
        GGRefresh.NullStartBox[ggData];
        [] Ź GGScene.WalkSelectedSlices[scene, leaf, DoConstrain, normal, $Traj];
        Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetConstraints: curve constrained to type: %g",
            [rope[SELECT ggData.drag.editConstraints FROM
                none => "none",
                tangent => "tangent",
                length => "length",
                ENDCASE => "error"]]
            ];
        GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, 
        okToSkipCapture: FALSE];
        };

    ShowConstraintType: PUBLIC UserInputProc = {
        Feedback.PutF[ggData.router, oneLiner, $Show, "ShowConstraint: Bezier edit constraint is %g",
            [rope[SELECT ggData.drag.editConstraints FROM
                none => "none",
                tangent => "tangent",
                length => "length",
                ENDCASE => "error"]]
            ];
        };

    SetBezier: PUBLIC UserInputProc = {
        MakeBezierAux: MakeCurveProc = {
            length: REAL;
            dir: Point;
            p1, p2: Point;
            length Ź Vectors2d.Distance[lo, hi];
            dir Ź Vectors2d.Sub[hi,lo];
            p1 Ź GetPt[lo, dir];
            p2 Ź GetPt[hi, [-dir.x, -dir.y] ];
            seg Ź GGSegment.MakeBezier[lo, p1, p2, hi, props];
            };
        SetCurveAux[ggData, MakeBezierAux, $Bezier];
        }; -- end SetBezier

    <<Modifying All Selected Runs With A Call-Back Proc>>

    <<ForEachOutlineRun: For each selected run in the scene, apply the runProc, get the result and replace the old run with the result. 
     If the result is NIL, this is a deletion.  The result may have more or fewer segments than the original run, so we must 
    proceed with caution.  Our overall plan is this:  Modify one run at a time removing from the scene the outline to which it 
    belongs and adding to the scene, at appropriate priorities the new outline(s) that results from the change.  This scheme is 
    complicated by the desire to select the newly created outlines.  To get around this, we select as "active" all objects 
    originally selected as "normal" and use the active selections to keep track of the work left to be done.>>

    ForEachOutlineRun: PROC [scene: Scene, selectClass: SelectionClass, runProc: RunProc, segmentsOnly: BOOL Ź TRUE, selectNewRuns: 
    BOOL Ź FALSE] RETURNS [bBox: BoundBox] = {
        DoSaveSelections: PROC [slice: Slice] RETURNS [done: BOOL Ź FALSE] = {
            GGSelect.SaveSelectionsInSliceAllClasses[slice, scene];
            };
        DoReplaceRuns: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            priority: INT;
            newOutline: Slice;
            IF GGScene.IsTopLevel[sliceD.slice] THEN {
                priority Ź GGScene.GetPriority[scene, sliceD.slice];
                newOutline Ź GGOutline.ReplaceRunsInOutline[sliceD, runProc, segmentsOnly, selectNewRuns];
                IF newOutline # NIL THEN {
                    GGScene.DeleteSlice[scene, sliceD.slice];
                    GGScene.AddSlice[scene, newOutline, priority];
                    };
                }
            ELSE {
                parent: Slice Ź GGParent.GetParent[sliceD.slice];
                priority Ź GGParent.GetChildPriority[parent, sliceD.slice];
                newOutline Ź GGOutline.ReplaceRunsInOutline[sliceD, runProc, segmentsOnly, selectNewRuns];
                IF newOutline # NIL THEN {
                    [] Ź GGSlice.RemoveChild[parent, sliceD.slice];
                    GGSlice.AddChildToCluster[parent, newOutline, priority];
                    };
                };
            IF newOutline # NIL THEN
                GGBoundBox.EnlargeByBox[bBox: bBox, by: GGSliceOps.GetBoundBox[newOutline]];
            };
        DoRestoreSelections: PROC [slice: Slice] RETURNS [done: BOOL Ź FALSE] = {
            GGSelect.ReselectSliceAllClasses[slice, scene];
            };
        bBox Ź GGScene.BoundBoxOfSelected[scene, normal];
        GGSelect.DuplicateSelections[scene, normal, active]; -- all normal selected objects become active

    <<[] _ GGScene.WalkSelectedSlices[scene, first, DoSaveSelections, normal];>>
        [] Ź GGScene.WalkSlices[scene, first, DoSaveSelections];
        [] Ź GGScene.WalkSelectedSlices[scene, leaf, DoReplaceRuns, active, $Outline];
        [] Ź GGScene.WalkSlices[scene, first, DoRestoreSelections];
        };

    SetCurveAux: PROC [ggData: GGData, makeCurve: MakeCurveProc, type: ATOM] = {
        <<Use ForEachOutlineRun to replace all selected runs with runs of a new type.>>
        <<Strategy:  Replace each selected run with a new trajectory which has a segment (of the proper type) for each joints/control point 
        span.  Note that we we copy verbatim all segs which were already of the specified type.  The new segments inherit color and 
        stroke properties from the old ones.>>
        RunOfSegs: RunProc = {
            <<[run: GGModelTypes.Sequence] RETURNS [traj: GGModelTypes.Slice]>>
            runData: TrajData Ź NARROW[run.slice.data];
            runParts: TrajParts Ź NARROW[run.parts];
            segGen: SegmentGenerator Ź GGSequence.SegmentsInSequence[runData, runParts];
            initialSeg: Segment Ź GGSequence.NextSegment[segGen];
            IF initialSeg = NIL THEN RETURN[NIL]; -- the run is a single vertex
            traj Ź GGTraj.CreateTraj[initialSeg.lo];
            FOR seg: Segment Ź initialSeg, GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
                SELECT seg.class.type FROM -- choose from old segment type
                    $Line, $Arc, $Conic, $Bezier => GGTraj.SegToSegMatchCp[seg, traj, makeCurve, type]; -- modify traj
                    $CubicSpline => {
                        IF type=$Line OR (runData.segCount=1 AND runData.role#open) THEN GGTraj.SegAndCpsToSegs[seg, traj, makeCurve, type] -- Splines are 
                        changed to multiple lines...(or multiple segs if spline was cyclic)
                        ELSE GGTraj.SegToSegMatchCp[seg, traj, makeCurve, type];  -- ...but single everything else
                        };
                    ENDCASE => ERROR;
                ENDLOOP;
            GGSliceOps.SetStrokeJoint[traj, NIL, runData.strokeJoint, NIL];
            };

        IF GGSelect.NoSelections[ggData.scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetCurveType failed: 
        select some curves"]
        ELSE {
            GGHistory.NewCapture["Set curve type", ggData]; -- capture scene BEFORE UPDATE
            GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
                <<need to bound selectedCPs here because curve bound boxes may not include CPs.>>
            GGRefresh.EnlargeStartBox[ggData, ForEachOutlineRun[ggData.scene, normal, RunOfSegs, TRUE, TRUE], NIL];
            GGCaret.NoAttractor[ggData.caret];
            GGCaret.SitOn[ggData.caret, NIL];
            GGHistory.PushCurrent[ggData];
            Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetCurve: curves modified to %gs", [rope[Atom.GetPName[type]]] ];
            GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, 
            okToSkipCapture: FALSE];
            };
        };

    PatternProc: TYPE = PROC [seg: Segment, traj: Slice] RETURNS [patternTraj: Slice];
    SetPatternAux: PROC [ggData: GGData, pattern: PatternProc] = {
        <<Use ForEachOutlineRun to replace all selected runs with new runs determined by a graphical replacement pattern>>
        RunOfSegs: RunProc = {
            <<[run: SliceDescriptor] RETURNS [traj: Slice]>>
            <<Replace each selected straight line segment with the result of applying the graphical replacement to that segment.  Weld together 
            the resulting new pieces, so that each selected run maps to a single new trajectory.>>
            runData: TrajData Ź NARROW[run.slice.data];
            runParts: TrajParts Ź NARROW[run.parts];
            segGen: SegmentGenerator Ź GGSequence.SegmentsInSequence[runData, runParts];
            initialSeg: Segment Ź GGSequence.NextSegment[segGen];
            IF initialSeg = NIL THEN RETURN[NIL]; -- the run is a single vertex
            traj Ź GGTraj.CreateTraj[initialSeg.lo];
            FOR seg: Segment Ź initialSeg, GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
                SELECT seg.class.type FROM -- choose from old segment type
                    $Line => traj Ź pattern[seg, traj];
                    ENDCASE => [] Ź GGTraj.AddSegment[traj, hi, GGSegment.CopySegment[seg], lo];
                ENDLOOP;
            GGSliceOps.SetStrokeJoint[traj, NIL, runData.strokeJoint, NIL];
            };
        bBox: BoundBox;
        GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
            <<need to bound selectedCPs here because curve bound boxes may not include CPs.>>
        bBox Ź ForEachOutlineRun[ggData.scene, normal, RunOfSegs, TRUE, TRUE];
        GGRefresh.EnlargeStartBox[ggData, bBox, NIL];
        GGCaret.NoAttractor[ggData.caret];
        GGCaret.SitOn[ggData.caret, NIL];
        Feedback.Append[ggData.router, oneLiner, $Feedback, "Pattern modified"];
        GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, 
        okToSkipCapture: FALSE];
        };

    SetNaturalSpline: PUBLIC UserInputProc = {
        SetSpline[splineType: naturalAL, ggData: ggData];
        };

    SetBSpline: PUBLIC UserInputProc = {
        SetSpline[splineType: bspline, ggData: ggData];
        };

    SetSpline: PROC [splineType: CubicSplines.SplineType, ggData: GGData] = {
        RunToSpline: RunProc = {
            <<[run: GGModelTypes.Sequence] RETURNS [traj: GGModelTypes.Slice]>>
            X: NAT = CubicSplines.X;
            Y: NAT = CubicSplines.Y;
            runData: TrajData Ź NARROW[run.slice.data];
            runParts: TrajParts Ź NARROW[run.parts];
            tSeg: Segment;
            controlPoint: Point;
            cyclic: BOOL Ź runData.role#open AND GGSequence.IsComplete[runParts]; 
            cps: CubicSplines.KnotSequence Ź NEW[CubicSplines.KnotSequenceRec[IF cyclic THEN runParts.jointCount+runParts.controlPointCount+1 
            ELSE runParts.jointCount+runParts.controlPointCount]];
            segGen: SegmentGenerator Ź GGSequence.OrderedSegmentsInSequence[runData, runParts];
            initialSeg: Segment Ź GGSequence.NextSegment[segGen];
            success: BOOL Ź FALSE;
            cpCount: NAT Ź 0;
            IF initialSeg = NIL THEN RETURN[NIL];
            IF cyclic AND splineType = naturalAL THEN splineType Ź cyclicAL;
            traj Ź GGTraj.CreateTraj[initialSeg.lo];
            cps[cpCount] Ź [initialSeg.lo.x, initialSeg.lo.y];
            cpCount Ź cpCount + 1;
            FOR seg: Segment Ź initialSeg, GGSequence.NextSegment[segGen] UNTIL seg = NIL DO
                FOR i:INT IN [0..seg.class.controlPointCount[seg]) DO
                    controlPoint Ź seg.class.controlPointGet[seg, i];
                    cps[cpCount] Ź [controlPoint.x, controlPoint.y];
                    cpCount Ź cpCount + 1;
                    ENDLOOP;
                cps[cpCount] Ź [seg.hi.x, seg.hi.y];
                cpCount Ź cpCount + 1;
                ENDLOOP;
            IF cyclic THEN cps[cps.length-1] Ź cps[0]; -- cumulative error sometimes causes small differences.  DJK.
            tSeg Ź GGSegment.MakeCubicSpline[cps, splineType, NIL];
            GGSegment.CopyLooks[initialSeg, tSeg];
            success Ź GGTraj.AddSegment[traj, hi, tSeg, lo];
            IF NOT success THEN ERROR;
            GGSliceOps.SetStrokeJoint[traj, NIL, runData.strokeJoint, NIL];
            };
        IF GGScene.CountSelectedSlices[ggData.scene, leaf, normal, $Outline]<1 THEN Feedback.Append[ggData.router, oneLiner, $Complaint, 
        "SetSplineType failed: select some curves"]
        ELSE {
            GGHistory.NewCapture["Set spline type", ggData]; -- capture scene BEFORE UPDATE
            GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
                <<need to bound selectedCPs here because curve bound boxes may not include CPs.>>
            GGRefresh.EnlargeStartBox[ggData, ForEachOutlineRun[ggData.scene, normal, RunToSpline, TRUE, TRUE], NIL];
            GGCaret.NoAttractor[ggData.caret];
            GGCaret.SitOn[ggData.caret, NIL];
            GGHistory.PushCurrent[ggData];
            Feedback.Append[ggData.router, oneLiner, $Feedback, "MakeSpline: splines created"];
            GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, 
            okToSkipCapture: FALSE];
            };
        };
        <<>>
    SelectMatchingCurve: PUBLIC UserInputProc = {
        name: Rope.ROPE Ź NARROW[event.rest.first];
        DoSelectMatching: PROC [traj: Slice] RETURNS [done: BOOL Ź FALSE] = {
            segGen: SegmentGenerator Ź GGSequence.SegmentsInTraj[NARROW[traj.data]];
            FOR segAndIndex: SegAndIndex Ź GGSequence.NextSegmentAndIndex[segGen], GGSequence.NextSegmentAndIndex[segGen] UNTIL segAndIndex.seg 
            = NIL DO
                IF Rope.Equal[segAndIndex.seg.class.describe[segAndIndex.seg, TRUE, TRUE, TRUE, NIL], name, FALSE] THEN {
                    seq: TrajParts Ź GGSequence.CreateFromSegment[NARROW[traj.data], segAndIndex.index];
                    sliceD: SliceDescriptor Ź GGSlice.DescriptorFromParts[traj, seq];
                    GGSelect.SelectSlice[sliceD, ggData.scene, normal];
                    };
                ENDLOOP;
            };
        GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedCPs: TRUE];
        GGSelect.DeselectAll[ggData.scene, normal];
        [] Ź GGScene.WalkSlices[ggData.scene, leaf, DoSelectMatching, $Traj];
        Feedback.PutF[ggData.router, oneLiner, $Feedback, "SelectMatchingCurve: curves of type %g selected", [rope[name]] ];
        GGWindow.RestoreScreenAndInvariants[paintAction: $SelectionChanged, ggData: ggData, remake: none, edited: FALSE, selectionChanged: 
        TRUE, okToSkipCapture: FALSE];
        };

    <<Text Menu>>
    TiogaFillFromSelection: UserInputProc = {
        complaint: Rope.ROPE = "FillBoxesFromSelection failed: select exactly one leaf object (with boxes) for filling";
        selectCount: NAT Ź GGScene.CountSelectedSlices[ggData.scene, first, normal];
        IF selectCount#1 THEN Feedback.Append[ggData.router, oneLiner, $Complaint, complaint]
        ELSE {
            aborted: BOOL Ź FALSE;
            myRef: TextNode.Ref;
            selectedD: SliceDescriptor Ź GGScene.FirstSelectedSlice[ggData.scene, first, normal];
            IF Rope.Length[GGViewerOps.GetSelectionContents[]]#0 THEN {
                reader: TiogaAccess.Reader = TiogaAccessViewers.FromSelection[];
                ref: TextNode.Ref Ź IF TiogaAccess.EndOf[reader] THEN NIL ELSE TextNode.Root[TiogaAccess.GetLocation[reader].node];
                myRef Ź CopyDocument[ref]; -- make a copy that GG owns. System will finalize its own copy.
                };
            GGHistory.NewCapture["FillBoxesFromSelection", ggData]; -- capture scene BEFORE UPDATE
            SELECT GGSliceOps.GetType[selectedD.slice] FROM
                $Box => {
                    <<complete document to topLevel Box>>
                    GGSlice.SetBoxText[selectedD.slice, [myRef, 0], GGSlice.GetBoxText[selectedD.slice].screenStyle, NIL];
                    };
                $Outline => {
                    <<complete document to topLevel Outline and its Box children>>
                    GGOutline.SetFillText[selectedD.slice, myRef, GGSlice.GetBoxText[selectedD.slice].screenStyle, NIL];
                    };
                $Cluster => {
                    <<tricky case.  Walk all the leaf boxes in the cluster.  If they do not share a single parent, abort.  If there is a single parent, 
                    it is either an outline or a cluster.  If the parent is an outline, then fill it.  If the parent is a cluster 
                    with a single Box child, then fill the box. Otherwise, abort.>>
                    CheckParent: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
                        child Ź sliceD.slice; -- sliceD describes a child Box slice.  The parts don't matter.
                        IF parent=NIL THEN parent Ź GGParent.GetParent[child]; -- record first parent
                        IF parent#GGParent.GetParent[child] THEN RETURN [TRUE]; -- abort if more than one parent is selected
                        childCount Ź childCount+1;
                        };
                    parent: Slice;
                    child: Slice; -- child Box. Needed below
                    childCount: NAT Ź 0;
                    aborted Ź GGParent.WalkIncludedChildren[selectedD.slice, selectedD.parts, leaf, CheckParent, $Box];
                    IF parent=NIL THEN aborted Ź TRUE ELSE IF NOT aborted THEN {
                        <<if you get here, a single parent was selected.  It could be an outline or a cluster>>
                        SELECT GGSliceOps.GetType[parent] FROM
                            $Outline => { -- complete document to parent Outline and its Box children
                                GGOutline.SetFillText[parent, myRef, GGSlice.GetBoxText[parent].screenStyle, NIL];
                                };
                            $Cluster => { -- if a single leaf Box of a cluster is selected, then fill it.
                                IF childCount=1 THEN {
                                    <<complete document to Box>>
                                    GGSlice.SetBoxText[child, [myRef, 0], GGSlice.GetBoxText[child].screenStyle, NIL];
                                    }
                                ELSE aborted Ź TRUE;
                                };
                            ENDCASE => ERROR;
                        };
                    };
                ENDCASE => aborted Ź TRUE;
            IF aborted THEN Feedback.Append[ggData.router, oneLiner, $Complaint, complaint]
            ELSE {
                GGSelect.SelectEntireSlice[selectedD.slice, ggData.scene, normal];
                GGHistory.PushCurrent[ggData];
                Feedback.Append[ggData.router, oneLiner, $Feedback, "FillBoxesFromSelection: completed"];
                <<ggData.refresh.startBoundBox^ _ GGScene.BoundBoxOfSelected[ggData.scene, normal]^;>>
                GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedParts: TRUE];
                GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: none, edited: TRUE, 
                okToSkipCapture: FALSE];
                };
            };
        };

    EditTiogaFill: UserInputProc = {
        complaint: Rope.ROPE = "EditTiogaFill failed: select exactly one filled box object for EditTiogaFill";
        selectCount: NAT Ź GGScene.CountSelectedSlices[ggData.scene, first, normal];
        IF selectCount#1 THEN Feedback.Append[ggData.router, oneLiner, $Complaint, complaint]
        ELSE {
            MakeViewer: PROC [slice: Slice] = {
                boxText: TextNode.Location Ź GGSlice.GetBoxText[slice].loc;
                IF boxText.node=NIL THEN aborted Ź TRUE
                ELSE {
                    viewer: Viewer Ź ViewerTools.MakeNewTextViewer[info: [name: "TiogaFromGargoyle", column: right], paint: FALSE ];
                    viewer.class.set[viewer, CopyDocument[boxText.node], FALSE, $TiogaDocument];
                    ViewerOps.OpenIcon[viewer];
                    };
                };
            aborted: BOOL Ź FALSE;
            selectedD: SliceDescriptor Ź GGScene.FirstSelectedSlice[ggData.scene, first, normal];
            SELECT GGSliceOps.GetType[selectedD.slice] FROM
                $Box, $Outline => {
                    <<complete document from top level slice>>
                    MakeViewer[selectedD.slice];
                    };
                $Cluster => {
                    <<tricky case.  Walk all the leaf boxes in the cluster.  If they do not share a single parent, abort.  If there is a single parent, 
                    it is either an outline or a cluster.  If the parent is an outline, then show it.  If the parent is a cluster 
                    with a single selected Box child, then show the box. Otherwise, abort.>>
                    CheckParent: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
                        child Ź sliceD.slice; -- sliceD describes a child Box slice.  The parts don't matter.
                        IF parent=NIL THEN parent Ź GGParent.GetParent[child]; -- record first parent
                        IF parent#GGParent.GetParent[child] THEN RETURN [TRUE]; -- abort if more than one parent is selected
                        childCount Ź childCount+1;
                        };
                    parent: Slice;
                    child: Slice; -- child Box. Needed below
                    childCount: NAT Ź 0;
                    aborted Ź GGParent.WalkIncludedChildren[selectedD.slice, selectedD.parts, leaf, CheckParent, $Box];
                    IF parent=NIL THEN aborted Ź TRUE ELSE IF NOT aborted THEN {
                        <<if you get here, a single parent with some selected Box children was selected.  It could be an outline or a cluster>>
                        SELECT GGSliceOps.GetType[parent] FROM
                            $Outline => { -- complete document from parent Outline and its Box children
                                MakeViewer[parent];
                                };
                            $Cluster => { -- if a single leaf Box of a cluster is selected, then show it.
                                IF childCount=1 THEN {
                                    <<complete document from child Box>>
                                    MakeViewer[child];
                                    }
                                ELSE aborted Ź TRUE;
                                };
                            ENDCASE => ERROR;
                        };
                    };
                ENDCASE => aborted Ź TRUE;
            IF aborted THEN Feedback.Append[ggData.router, oneLiner, $Complaint, complaint]
            ELSE {
                Feedback.Append[ggData.router, oneLiner, $Feedback, "EditTiogaFill: Tioga document opened"];
                GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedInPlace, ggData: ggData, remake: none, edited: TRUE, 
                okToSkipCapture: FALSE];
                };
            };
        };

    CopyDocument: PROC [root: TextNode.Ref] RETURNS [TextNode.Ref] ~ {
        IF root=NIL THEN RETURN[NIL]
        ELSE {
            CopyAction: NodeProps.MapPropsAction = {
                <<MapPropsAction: TYPE = PROC [name: ATOM, value: REF] RETURNS [quit: BOOL _ FALSE];>>
                newValue: REF Ź NodeProps.CopyInfo[name, value];
                NodeProps.PutProp[newRoot, name, newValue];
                RETURN[FALSE];
                };
            span: TextNode.Span Ź TextNode.MakeNodeSpan[first: TextNode.FirstChild[root], last: TextNode.LastLocWithin[root].node];
            copy: TextNode.Span Ź EditSpanSupport.CopySpan[span];
            newRoot: TextNode.Ref Ź TextNode.Root[copy.start.node];
            [] Ź NodeProps.MapProps[n: root, action: CopyAction];
            RETURN [newRoot];
            };
        };

    PrintStyleKind: UserInputProc = {
        SetStyleKind[FALSE, ggData];
        };

    ScreenStyleKind: UserInputProc = {
        SetStyleKind[TRUE, ggData];
        };

    SetStyleKind: PROC [wantScreenStyle: BOOL, ggData: GGData] = {
        scene: Scene Ź ggData.scene;
        IF GGSelect.NoSelections[scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetStyleKind failed: select some 
        boxes to set style kind"]
        ELSE {
            DoSetStyleKind: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
                parent: Slice Ź GGParent.GetParent[sliceD.slice]; -- parent of Box
                [loc, refIsScreenStyle] Ź GGSlice.GetBoxText[sliceD.slice];
                IF refIsScreenStyle#wantScreenStyle THEN {
                    IF parent#NIL AND GGSliceOps.GetType[parent]=$Outline THEN {
                        loc Ź GGSlice.GetBoxText[parent].loc;
                        GGOutline.SetFillText[parent, loc.node, wantScreenStyle, NIL]
                        }
                    ELSE GGSlice.SetBoxText[sliceD.slice, loc, wantScreenStyle, NIL];
                    };
                };
            loc: TextNode.Location;
            refIsScreenStyle: BOOL Ź FALSE;
            GGHistory.NewCapture["Set style kind", ggData]; -- capture scene BEFORE UPDATE
            [] Ź GGScene.WalkSelectedSlices[scene, leaf, DoSetStyleKind, normal, $Box];
            GGHistory.PushCurrent[ggData];
            Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetStyleKind: style kind set to %g", [rope[IF wantScreenStyle THEN "screen" ELSE 
            "print"] ]];
            GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedInPlace, ggData: ggData, remake: none, edited: TRUE, 
            okToSkipCapture: FALSE];
            };
        };

    ShowStyleKind: UserInputProc = {
        CheckStyleKind: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            box: Slice Ź sliceD.slice;
            screenStyle: BOOL Ź FALSE;
            loc: TextNode.Location;
            [loc, screenStyle] Ź GGSlice.GetBoxText[box];
        <<IF loc.node=NIL THEN RETURN [FALSE]; -- not filled at all>>
            IF NOT firstFound THEN {foundScreenStyle Ź screenStyle; firstFound Ź TRUE};
            RETURN[screenStyle#foundScreenStyle];
            };
        firstFound: BOOL Ź FALSE;
        foundScreenStyle: BOOL Ź FALSE;
        aborted: BOOL Ź GGScene.WalkSelectedSlices[ggData.scene, leaf, CheckStyleKind, normal, $Box];
        IF NOT firstFound THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowStyleKind failed: no boxes in selected objects"]
        ELSE IF aborted THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowStyleKind failed: multiple style kinds are 
        selected"] ELSE Feedback.PutF[ggData.router, oneLiner, $Show, "ShowStyleKind: %g style", [rope[IF foundScreenStyle THEN 
        "screen" ELSE "print"] ]];
        };

    SetNewlineFactor: UserInputProc = {
        scene: Scene Ź ggData.scene;
        r: REAL Ź NARROW[event.rest.first, REF REAL]­;
        IF GGSelect.NoSelections[scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetNewlineFactor failed: select 
        some text objects for setting newline factor"]
        ELSE IF r>reallyBigReal THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetNewlineFactor failed: select a reasonable 
        multiplier"]
        ELSE {
            DoSetNewlineFactor: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
                GGSlice.SetTextLineSpacing[sliceD.slice, r, NIL];
                };
            GGHistory.NewCapture["Set newline factor", ggData]; -- capture scene BEFORE UPDATE
            [] Ź GGScene.WalkSelectedSlices[scene, leaf, DoSetNewlineFactor, normal, $Text];
            GGHistory.PushCurrent[ggData];
            Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetNewlineFactor: newline spacing set to %g", [real[r]] ];
            };
        };

    ShowNewlineFactor: UserInputProc = {
        factor: REAL Ź Real.LargestNumber;
        aborted: BOOL Ź FALSE;
        scene: Scene Ź ggData.scene;
        CheckNewlineFactor: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            IF factor = Real.LargestNumber THEN factor Ź GGSlice.GetTextLineSpacing[sliceD.slice]
            ELSE RETURN[factor # GGSlice.GetTextLineSpacing[sliceD.slice]];
            };
        aborted Ź GGScene.WalkSelectedSlices[scene, leaf, CheckNewlineFactor, normal, $Text];
        IF factor = Real.LargestNumber THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowNewlineFactor failed: no text objects 
        selected"]
        ELSE IF aborted THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "ShowNewlineFactor failed: multiple factors are selected"]
        ELSE Feedback.PutF[ggData.router, oneLiner, $Show, "ShowNewlineFactor: %g", [real[factor]]];
        };

    ConvertTextToSplines: UserInputProc = {
        ConvertToSplines: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            <<GGSelect.SliceWalkProc>>
            priority: INT;
            IF GGScene.IsTopLevel[sliceD.slice] THEN {
                theseShadows, theseOutlines: LIST OF Slice;
                [theseShadows, theseOutlines] Ź GGSlice.OutlinesFromTextString[sliceD.slice];
                priority Ź GGScene.GetPriority[scene, sliceD.slice];
                GGScene.DeleteSlice[scene, sliceD.slice];
                GGScene.AddSlices[scene, theseOutlines, priority];
                IF theseShadows # NIL THEN GGScene.AddSlices[scene, theseShadows, priority];
                outlines Ź GGUtility.AppendSliceList[theseOutlines, outlines];
                outlines Ź GGUtility.AppendSliceList[theseShadows, outlines];
                }
            ELSE {
                theseShadows, theseOutlines: LIST OF Slice;
                cluster: Slice Ź GGParent.GetParent[sliceD.slice];
                [theseShadows, theseOutlines] Ź GGSlice.OutlinesFromTextString[sliceD.slice];
                priority Ź GGParent.GetChildPriority[cluster, sliceD.slice];
                [] Ź GGSlice.RemoveChild[cluster, sliceD.slice];
                [] Ź GGSlice.AddChildrenToCluster[cluster, theseOutlines, priority];
                IF theseShadows # NIL THEN [] Ź GGSlice.AddChildrenToCluster[cluster, theseShadows, priority];
                outlines Ź GGUtility.AppendSliceList[theseOutlines, outlines];
                outlines Ź GGUtility.AppendSliceList[theseShadows, outlines];
                };
            };
        outlines: LIST OF Slice Ź NIL;
        scene: Scene Ź ggData.scene;
        IF GGScene.CountSelectedSlices[ggData.scene, leaf, normal, $Text]<1 THEN Feedback.Append[ggData.router, oneLiner, $Complaint, 
        "ConvertTextToSplines failed: select at least one text object"]
        ELSE {
            GGHistory.NewCapture["Text to splines", ggData];
            <<ggData.refresh.startBoundBox _ GGScene.BoundBoxOfSelected[scene, normal, TRUE];>>
            GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, selectedParts: TRUE];
            [] Ź GGScene.WalkSelectedSlices[scene, leaf, ConvertToSplines, normal, $Text];
            <<Leave only the new outlines selected.>>
            GGSelect.DeselectAll[scene, normal]; -- de-selects any non-text slices that were selected
            FOR list: LIST OF Slice Ź outlines, list.rest UNTIL list = NIL DO
                GGSelect.SelectEntireSlice[list.first, scene, normal];
                ENDLOOP;
            GGCaret.NoAttractor[ggData.caret];
            <<bBox _ GGScene.BoundBoxOfSelected[scene, normal];>>
            <<GGBoundBox.EnlargeByBox[ggData.refresh.startBoundBox, bBox];>>
            GGRefresh.EnlargeStartBox[ggData, GGScene.BoundBoxOfSelected[scene, normal], NIL];
            GGHistory.PushCurrent[ggData];
            Feedback.Append[ggData.router, oneLiner, $Feedback, "ConvertTextToSplines: completed"];
            GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedBoundBoxProvided, ggData: ggData, remake: triggerBag, edited: TRUE, 
            okToSkipCapture: FALSE];
            };
        };

    <<Color Menus>>
    RGBFromColor: PROC [color: ImagerColor.ConstantColor] RETURNS [ImagerColor.RGB] ~ {
        RETURN[ImagerColor.RGBFromColor[ImagerColor.NarrowToOpConstantColor[color]]];
        };

    CreateColorWash: PROC [startColor: Imager.ConstantColor, regionWidth: REAL, toAtom: ATOM, vec: Imager.VEC] RETURNS [success: BOOL Ź 
    TRUE, wash: Imager.SampledColor] ~ {
        ENABLE Imager.Error => GOTO Abort;

        FillSampleMap: PROC [size: INT, startSample, endSample: REAL, maxSample: INT] RETURNS [map: ImagerSample.SampleMap] = {
            <<startSample, endSample IN [0.0 .. 1.0]>>
            step: REAL Ź 1.0/size;
            alpha: REAL Ź 0.0;
            map Ź ImagerSample.NewSampleMap[box: box, bitsPerSample: 8];
            FOR index: INT IN [0..size) DO
                nextVec: SF.Vec Ź [0, index];
                nextValue: REAL Ź alpha*endSample + (1.0-alpha)*startSample;
                nextSample: INTEGER Ź Real.Floor[maxSample*nextValue];
                ImagerSample.Put[map: map, index: nextVec, value: nextSample];
                alpha Ź alpha+step;
                ENDLOOP;
            };

        maxSample: INT Ź 255;
        size: INT Ź Real.Floor[regionWidth];
        fudgeFactor: REAL;
        startRGB, endRGB: ImagerColor.RGB;
        redMap, grnMap, bluMap: ImagerSample.SampleMap;
        box: SF.Box Ź [min: [s: 0, f: 0], max: [s: 1, f: size] ];
        pixelMap: ImagerPixel.PixelMap;
        pixelArray: ImagerPixelArray.PixelArray;
        um: ImagerTransformation.Transformation;

        startRGB Ź RGBFromColor[startColor];
        SELECT toAtom FROM
            $White => endRGB Ź [1.0, 1.0, 1.0];
            $Black => endRGB Ź [0.0, 0.0, 0.0];
            $ColorTool => {
                endColor: Imager.ConstantColor Ź NIL;
                endColor Ź ColorTool.GetColor[ ! ColorTool.NoColorToolViewer => CONTINUE;];
                IF endColor=NIL THEN endColor Ź Imager.black;
                endRGB Ź RGBFromColor[endColor];
                };
            ENDCASE => ERROR;
        redMap Ź FillSampleMap[size, startRGB.R, endRGB.R, maxSample];
        grnMap Ź FillSampleMap[size, startRGB.G, endRGB.G, maxSample];
        bluMap Ź FillSampleMap[size, startRGB.B, endRGB.B, maxSample];
        pixelMap Ź ImagerPixel.MakePixelMap[redMap, grnMap, bluMap];
        pixelArray Ź ImagerPixelArray.FromPixelMap[pixelMap: pixelMap, box: box, scanMode: [down, right], immutable: TRUE];
        fudgeFactor Ź regionWidth/REAL[size];
        um Ź ImagerTransformation.PreScale[ImagerTransformation.Translate[vec], fudgeFactor];
        wash Ź ImagerColor.MakeSampledColor[pa: pixelArray, um: um, colorOperator: ImagerColor.NewColorOperatorRGB[sWhite: maxSample]];
        EXITS
            Abort => success Ź FALSE;
        };

    SetWash: UserInputProc = {
        newSelectList, ptr: LIST OF Slice;
        currentEvent: HistoryEvent;
        toAtom: ATOM Ź NARROW[event.rest.first];
        wash: Imager.SampledColor;
        scene: Scene Ź ggData.scene;
        SetWashSlice: PROC [sliceD: SliceDescriptor] RETURNS [done: BOOL Ź FALSE] = {
            color: Imager.Color;
            success: BOOL Ź FALSE;
            [color, success] Ź GGSliceOps.GetFillColor[sliceD.slice, sliceD.parts];
            IF NOT success OR color=NIL OR NOT ISTYPE[color, Imager.ConstantColor] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, 
            "SetColorWash failed: select only shapes filled with a constant color"]
            ELSE {
                box: BoundBox Ź GGSliceOps.GetTightBox[sliceD.slice];
                regionWidth: REAL Ź ABS[box.hiX-box.loX];
                success: BOOL Ź FALSE;
                [success, wash] Ź CreateColorWash[NARROW[color], regionWidth, toAtom, [box.loX, box.loY]];
                IF success THEN {
                    [] Ź GGSliceOps.SetFillColor[sliceD.slice, sliceD.parts, wash, $Set, currentEvent];
                    [newSelectList, ptr] Ź GGUtility.AddSlice[sliceD.slice, newSelectList, ptr];
                    }
                ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "SetColorWash failed: Imager ERROR during CreateColorWash"]
                };
            };
        IF toAtom = $ColorTool AND NOT GGState.ColorToolIsBound[ggData] THEN {
            Feedback.Append[ggData.router, oneLiner, $Complaint, "SetColorWash failed: please install ColorTool and retry"];
            RETURN;
            };
        IF GGSelect.NoSelections[scene, normal] THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "SetColorWash failed: select at 
        least one colored object"]
        ELSE {
            currentEvent Ź GGHistory.NewCurrent["Wash color", ggData];
            [newSelectList, ptr] Ź GGUtility.StartSliceList[];
            [] Ź GGScene.WalkSelectedSlices[scene, first, SetWashSlice, normal];
            FOR list: LIST OF Slice Ź newSelectList, list.rest UNTIL list = NIL DO
                GGSelect.SelectEntireSlice[list.first, ggData.scene, normal];
                ENDLOOP;
            GGHistory.PushCurrent[ggData];
            Feedback.PutF[ggData.router, oneLiner, $Feedback, "SetColorWash: fill color washed to %g", [rope[Atom.GetPName[toAtom]]] ];
            GGWindow.RestoreScreenAndInvariants[paintAction: $ObjectChangedInPlace, ggData: ggData, remake: none, edited: TRUE, 
            okToSkipCapture: FALSE];
            };
        };

    <<Caret Menu>>
    UpdateCaretPosition: PROC [ggData: GGData, point: Point, normal: Vector] = {
        GGRefresh.SetStartBox[ggData: ggData, dragInProgress: FALSE, caret: TRUE, attractor: TRUE];
        GGCaret.SetAttractor[ggData.caret, point, normal, NIL];
        ShowCaretValues[ggData, NIL];
        GGWindow.NewCaretPos[ggData];
        GGCaret.SitOn[ggData.caret, NIL];
        GGWindow.RestoreScreenAndInvariants[paintAction: $CaretMovedStatic, ggData: ggData, remake: none, edited: FALSE, okToSkipCapture: 
        TRUE];
        };

    CaretPositionFromSelection: UserInputProc = {
        ENABLE GGParseIn.SyntaxError => GOTO SomeError;
        point: Point;
        rope: Rope.ROPE = NARROW[event.rest.first];
        arg: Point = GGParseIn.ReadPoint[IO.RIS[rope]];
        IF arg.x>reallyBigReal OR arg.y>reallyBigReal THEN GOTO SomeError;
        point Ź Vectors2d.Scale[arg, GGState.GetScaleUnit[ggData]];
        UpdateCaretPosition[ggData, point, [0,-1]]; -- or leave normal unchanged?
        EXITS
            SomeError => Feedback.Append[ggData.router, oneLiner, $Complaint, "Set caret position failed: select a legal caret position [<x>, 
            <y>] (including brackets)"]; 
        };

    CaretAngleFromSelection: UserInputProc = {
        IF GGCaret.Exists[ggData.caret] THEN {
            real: REAL ~ NARROW[event.rest.first, REF REAL]­;
            IF real>reallyBigReal THEN Feedback.Append[ggData.router, oneLiner, $Complaint, "Set caret angle failed: select a reasonable real 
            number for caret angle"]
            ELSE {
                normal: Vector ~ Vectors2d.Negate[Vectors2d.VectorFromAngle[real]];
                UpdateCaretPosition[ggData, GGCaret.GetPoint[ggData.caret], normal];
                };
            }
        ELSE Feedback.Append[ggData.router, oneLiner, $Complaint, "Set caret angle failed: caret required for set caret angle"];
        };

    ShowValuesOfCaret: PROC [ggData: GGData, caret: Caret, name: Rope.ROPE] = {
        IF GGCaret.Exists[caret] THEN {
            scale: REAL ~ GGState.GetScaleUnit[ggData];
            point: Point ~ GGCaret.GetPoint[caret];
            normal: Vector ~ GGCaret.GetNormal[caret];
            angle: REAL ~ Vectors2d.AngleFromVector[Vectors2d.Negate[normal]];
            Feedback.PutFL[ggData.router, oneLiner, $Show, "%g position: [%g, %g], angle: %g", LIST[[rope[name]], [real[point.x/scale]], 
            [real[point.y/scale]], [real[angle]]]];
            }
        ELSE {
            Feedback.PutFL[ggData.router, oneLiner, $Show, 
            "Show%g: no %g", LIST[[rope[name]], [rope[name]] ]];
            };
        };

    ShowCaretValues: UserInputProc = {
        ShowValuesOfCaret[ggData, ggData.caret, "Caret"];
        };

    ShowAnchorValues: UserInputProc = {
        ShowValuesOfCaret[ggData, ggData.anchor, "Anchor"];
        };

    GrabInputFocus: UserInputProc = {
        GGState.GrabInputFocus[ggData];
        };

    <<>>
    <<Debug2 Menu>>
    SceneState: UserInputProc = {
        scene: Scene Ź ggData.scene;
        DescendASlice: PROC [slice: Slice] RETURNS [done: BOOL Ź FALSE] = {
            objects Ź objects+1;
            IF slice.class=NIL THEN trashedObjects Ź trashedObjects+1
            ELSE {
                CheckTrashed: PROC [nextChild: Slice] RETURNS [done: BOOL Ź FALSE] = {
                    IF nextChild.class=NIL THEN trashedSubObjects Ź trashedSubObjects+1;
                    };
                [] Ź GGParent.WalkChildren[slice, first, CheckTrashed];
                };
            };
        AddEmUp: PROC [slice: Slice] RETURNS [done: BOOL Ź FALSE] = {
            leafCount Ź leafCount + 1;
            };

        objects, trashedObjects, trashedSubObjects, leafCount: INT Ź 0;
        [] Ź GGScene.WalkSlices[scene, first, DescendASlice];
        [] Ź GGScene.WalkSlices[scene, leaf, AddEmUp];
        Feedback.PutFL[ggData.router, oneLiner, $Show, "Scene: %g objects, %g trashed objects, %g trashed children, %g leaf objects", 
        LIST[[integer[objects]], [integer[trashedObjects]], [integer[trashedSubObjects]], [integer[leafCount]] ]]; 
        };

    SceneBagState: UserInputProc = {
        IsObsolete: PUBLIC PROC [seq: Sequence] RETURNS [BOOL] = {
            <<TEST if this sequence cannot possibly encode its trajectory, probably because the trajectory has been modified. Not a guarantee 
            that it accurately encodes anything.>>
            j: NAT Ź 0;
            trajData: TrajData Ź NARROW[seq.slice.data];
            trajParts: TrajParts Ź NARROW[seq.parts];
            segGen: SegmentGenerator;
            IF trajParts.segments.len # trajData.segCount THEN RETURN[TRUE];
            IF trajParts.joints.len # (GGTraj.HiJoint[seq.slice] + 1) THEN RETURN[TRUE];
            segGen Ź GGSequence.SegmentsInTraj[trajData];
            FOR nextSeg: Segment Ź GGSequence.NextSegment[segGen], GGSequence.NextSegment[segGen] UNTIL nextSeg=NIL DO
                IF nextSeg.class.controlPointCount[nextSeg]#trajParts.controlPoints[j].len THEN RETURN[TRUE];
                j Ź j+1;
                ENDLOOP;
            RETURN[FALSE];
            };

        DescendAFeature: PROC [feature: FeatureData] RETURNS [done: BOOL Ź FALSE] = {
            IF feature.type=slice THEN {
                shapeD: SliceDescriptor Ź NARROW[feature.shape];
                objects Ź objects+1;
                IF shapeD.slice.class=NIL THEN trashedObjects Ź trashedObjects+1
                ELSE {
                    dList: LIST OF SliceDescriptor;
                    classType: ATOM Ź GGSliceOps.GetType[shapeD.slice];
                    IF classType=$Outline OR classType = $Cluster THEN {
                        dList Ź GGParent.ListIncludedChildren[shapeD.slice, shapeD.parts, first];
                        FOR childList: LIST OF Slice Ź GGParent.ListChildren[shapeD.slice, first], childList.rest UNTIL childList = NIL DO
                            nextPart: SliceDescriptor Ź dList.first;
                            nextChild: Slice Ź childList.first;
                            IF nextChild.class=NIL THEN trashedSubObjects Ź trashedSubObjects+1;
                            IF nextChild#nextPart.slice THEN obsoleteDs Ź obsoleteDs+1;
                            IF GGSliceOps.GetType[nextChild]=$Traj THEN IF IsObsolete[nextPart] THEN obsoleteSeqs Ź obsoleteSeqs+1;
                            dList Ź dList.rest;
                            ENDLOOP;
                        };
                    };
                };
            };

        objects, obsoleteDs, obsoleteSeqs, trashedObjects, trashedSubObjects: INT Ź 0;
        GGAlign.WalkSliceTriggers[ggData.hitTest.sceneBag, DescendAFeature];
        Feedback.PutFL[ggData.router, oneLiner, $Show, "SceneBag: %g objects, %g obsolete outline descriptors, %g obsolete sequences, %g 
        trashed objects, %g trashed children", LIST[[integer[objects]], [integer[obsoleteDs]],  [integer[obsoleteSeqs]], 
        [integer[trashedObjects]], [integer[trashedSubObjects]] ]]; 
        };

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

    UserTraceOn: PUBLIC UserInputProc = {
        GGUserInput.SetUserTraceOn[TRUE];
        };
    UserTraceOff: PUBLIC UserInputProc = {
        GGUserInput.SetUserTraceOn[FALSE];
        };

    RegisterEventProcs: PROC = {
        OPEN GGUserInput;
        <<>>
        <<Caret Menu>>
        RegisterAction[$CaretPositionFromSelection, CaretPositionFromSelection, rope];
        RegisterAction[$CaretAngleFromSelection, CaretAngleFromSelection, refReal];
        RegisterAction[$ShowCaretValues, ShowCaretValues, none];
        RegisterAction[$ShowAnchorValues, ShowAnchorValues, none];
        RegisterAction[$GrabInputFocus, GrabInputFocus, none];

        <<Debug2 Menu>>
        RegisterAction[$SceneState, SceneState, none];
        RegisterAction[$SceneBagState, SceneBagState, none];
        RegisterAction[$DrawPolylines, DrawPolylines, none];
        RegisterAction[$UserTraceOn, UserTraceOn, none];
        RegisterAction[$UserTraceOff, UserTraceOff, none];

        <<Curve Menu>>
        RegisterAction[$SetStraight, SetStraight, none];
        RegisterAction[$SetArc, SetArc, none];
        RegisterAction[$SetSnowflake, SetSnowflake, none];
        RegisterAction[$SetConic, SetConic, refReal];
        RegisterAction[$SetBezier, SetBezier, none];
        RegisterAction[$SetConstraintType, SetConstraintType, rope];
        RegisterAction[$SetMakeConstrained, SetMakeConstrained, none];
        RegisterAction[$ShowConstraintType, ShowConstraintType, none];
        RegisterAction[$SetNaturalSpline, SetNaturalSpline, none];
        RegisterAction[$SetBSpline, SetBSpline, none];
        RegisterAction[$SelectMatchingCurve, SelectMatchingCurve, rope];


        <<Edit Menu>>
        RegisterAction[$OrientCW, OrientCW, none];
        RegisterAction[$OrientCCW, OrientCCW, none];
        RegisterAction[$Reorient, Reorient, none];
        RegisterAction[$ShowOrientation, ShowOrientation, none];
        RegisterAction[$SetOddWrap, SetOddWrap, none];
        RegisterAction[$SetNonZeroWrap, SetNonZeroWrap, none];
        RegisterAction[$ShowWrapRule, ShowWrapRule, none];
        RegisterAction[$HistoryTool, BuildAHistoryTool, none];
        RegisterAction[$UndoOne, UndoOne, none];
        RegisterAction[$ConvertTextToSplines, ConvertTextToSplines, none];

        <<Text Menu>>
        RegisterAction[$TiogaFillFromSelection, TiogaFillFromSelection, none];
        RegisterAction[$EditTiogaFill, EditTiogaFill, none];
        RegisterAction[$ScreenStyleKind, ScreenStyleKind, none];
        RegisterAction[$PrintStyleKind, PrintStyleKind, none];
        RegisterAction[$ShowStyleKind, ShowStyleKind, none];
        RegisterAction[$SetNewlineFactor, SetNewlineFactor, refReal];
        RegisterAction[$ShowNewlineFactor, ShowNewlineFactor, refReal];

        <<Color/Fill Menus>>
        RegisterAction[$SetWash, SetWash, rope];
        };

    RegisterEventProcs[];

    END.