
<<File: SVUserInputImplA.mesa>>
<<Last edited by Bier on February 24, 1987 10:14:52 pm PST>>
<<Copyright © 1984 by Xerox Corporation.  All rights reserved.>>
<<Contents: Procedures for responding to button clicks made in a solidviewer.>>

DIRECTORY
Atom, Convert, CoordSys, Imager, IO, Menus, Rope, SlackProcess, SV2d, SV3d, SVBasicTypes, SVError, SVEvent, SVInterfaceTypes, 
SVModelTypes, SVMouseEvent, SVRayTypes, SVSceneTypes, SVUserInput, SVWindow, TIP, TIPUser, ViewerClasses, ViewerTools;

SVUserInputImplA: CEDAR PROGRAM
IMPORTS Atom, Convert, CoordSys, IO, Rope, SlackProcess, SVError, SVEvent, SVMouseEvent, SVWindow, ViewerTools
EXPORTS SVUserInput =

BEGIN
Artwork: TYPE = SVModelTypes.Artwork;
ArtworkToolData: TYPE = SVInterfaceTypes.ArtworkToolData;
Assembly: TYPE = SVSceneTypes.Assembly;
AssemblyList: TYPE = SVSceneTypes.AssemblyList;
BoundBox: TYPE = SVBasicTypes.BoundBox;
BoundSphere: TYPE = SVBasicTypes.BoundSphere;
Camera: TYPE = SVModelTypes.Camera;
Classification: TYPE = SVRayTypes.Classification;
Color: TYPE = Imager.Color;
CSGTree: TYPE = SVRayTypes.CSGTree;
EditToolData: TYPE = SVInterfaceTypes.EditToolData;
EventProc: TYPE = SlackProcess.EventProc;
FileCamera: TYPE = SVSceneTypes.FileCamera;
FrameBox: TYPE = SVModelTypes.FrameBox;
MasterObject: TYPE = SVSceneTypes.MasterObject;
Point2d: TYPE = SV2d.Point2d;
Primitive: TYPE = SVRayTypes.Primitive;
Ray: TYPE = SVRayTypes.Ray;
Scene: TYPE = SVSceneTypes.Scene;
Selection: TYPE = SVInterfaceTypes.Selection;
Shape: TYPE = SVSceneTypes.Shape;
SlackHandle: TYPE = SlackProcess.SlackHandle;
TrigLine: TYPE = SV2d.TrigLine;
Vector3d: TYPE = SV3d.Vector3d;
ViewerToolData: TYPE = SVInterfaceTypes.ViewerToolData;


    <<Input from the Outside World>>

    <<From Buttons and Menus>>
MenuNotify: PUBLIC PROC [clientData: REF ANY, action: LIST OF REF ANY] = {
viewerToolData: ViewerToolData _ NARROW[clientData];
handle: SlackHandle _ viewerToolData.slackHandle;
SlackProcess.QueueInputAction[handle, Dispatch, action, viewerToolData, NIL];
    };

    <<From Mouse and Keyboard>>
    InputNotify: PUBLIC PROC [self: ViewerClasses.Viewer, input: LIST OF REF ANY] = {
        <<ViewerClasses.NotifyProc>>
        <<Called by the TIP table machinery when an action is received from mouse or keyboard.  Self is an ActionArea.>>
    viewerToolData: ViewerToolData _ NARROW[self.data];
    handle: SlackHandle _ viewerToolData.slackHandle;
    optimizeHint: REF ANY;
    IF input.rest# NIL THEN {
        WITH input.rest.first SELECT FROM
            atom: ATOM => {
                IF atom = $During THEN optimizeHint _ LIST[$During];
                };
            ENDCASE => optimizeHint _ NIL;
    };
    input _ GetAnyArguments[input];
    SlackProcess.QueueInputAction[handle, Dispatch, input, viewerToolData, optimizeHint];
        };

    GetAnyArguments: PROC [input: LIST OF REF ANY] RETURNS [newInput: LIST OF REF ANY] = {
        WITH input.first SELECT FROM
            atom: ATOM => {
                SELECT atom FROM
                    $JackPivotX, $JackPivotY, $JackPivotZ, $SourcePivotX, $SourcePivotY, $SourcePivotZ, $SourceRotX, $SourceRotY, $SourceRotZ => 
                    newInput _ CheckForSelectedReal[atom, input];
                ENDCASE => newInput _ input;
                };
            ENDCASE => newInput _ input;
        };

Dispatch: PROC [event: LIST OF REF ANY, clientData: REF ANY] = {
viewerToolData: ViewerToolData _ NARROW[clientData];
camera: Camera _ viewerToolData.camera;
    WITH event.first SELECT FROM
        mousePlace: TIP.TIPScreenCoords => {
            controlPoint: Point2d _ [mousePlace.mouseX, mousePlace.mouseY];
        controlPoint _ CoordSys.ScreenToCamera[controlPoint, camera.screenCS];
            <<This puts the control point in camera coordinates.>>
            SVMouseEvent.HandleMouse[event, controlPoint, viewerToolData];
            };
        ENDCASE => HandleMouseless[event, viewerToolData];
};

<<HandleMouse: PUBLIC PROC [input: LIST OF REF ANY, controlPoint: Point2d, viewerToolData: ViewerToolData] = {>>
<<atom: ATOM _ NARROW[event.rest.first];>>
<<SELECT atom FROM>>
<<$SingleRay => SVEvent.SingleRay[viewerToolData, controlPoint];>>
<<$DeleteFrame => SVMouseEvent.DeleteFrame[viewerToolData];>>
<<>>
<<$Paint => SVMouseEvent.Paint[viewerToolData, controlPoint];>>
<<$OpenAISFile => SVArtworkUser.OpenFile[artworkToolData];>>
<<$CloseAISFile => SVArtworkUser.CloseFile[artworkToolData];>>
<<>>
<<$ExtendSkitter => SVMouseEvent.ExtendSkitter[viewerToolData, controlPoint, first];>>
<<$ExtendCoordSkitter => SVMouseEvent.ExtendCoordSkitter[viewerToolData, controlPoint];>>
<<ENDCASE => NotYetImplementedMessage[atom, viewerToolData];>>
<<};>>

    <<Handling Actions>>

    <<From Buttons, Menus, or Keyboard>>
    HandleMouseless: PROC [action: LIST OF REF ANY, viewerToolData: ViewerToolData] = {
        <<Non-mouse actions.  These actions could come from the TIP table or from bugging a menu.>>
        atom: ATOM _ NARROW[action.first];
        slackHandle: REF ANY _ NIL;
        SELECT atom FROM
            <<File Menu>>
            $Clear => SVEvent.Clear[action, viewerToolData];
            $Restore => SVEvent.Reset[action, viewerToolData];
            $Get => SVEvent.Get[action, viewerToolData];
            $Store => SVEvent.Store[action, viewerToolData];
            $Save => SVEvent.Save[action, viewerToolData];
            $Split => SVEvent.Split[action, viewerToolData];
            <<Miscellaneous Functions>>
            $Erase => SVEvent.Erase[action, viewerToolData];
            $RayCast => SVEvent.RayCast[action, viewerToolData];
            $StopRays => SVEvent.Stop[action, viewerToolData];
            $ARay => SVEvent.ARay[action, viewerToolData];
            $ToIP => SVEvent.ToIP[action, viewerToolData];
            $StorePoly => SVEvent.StorePoly[action, viewerToolData];
            <<Drawing for Debugging>>
            $DrawBoundBoxes => SVEvent.DrawBoundBoxes[action, viewerToolData];
            $DrawBoundSpheres => SVEvent.DrawBoundSpheres[action, viewerToolData];
            $DrawSceneButton => SVEvent.DrawSceneButton[action, viewerToolData];
            $DrawCoordSystems => SVEvent.DrawCoordSystems[action, viewerToolData];
            $DrawPoint => SVEvent.DrawPt[action, viewerToolData];
            $CrossHairs => SVEvent.CrossHairs[action, viewerToolData];
            $DrawColor => SVEvent.DrawColor[action, viewerToolData];
            $DrawBlackAndWhite => SVEvent.DrawBlackAndWhite[action, viewerToolData];
            $ShowCoordsMode => SVEvent.ShowCoordsMode[action, viewerToolData];
            <<Gravity Functions>>
            $GravityChoiceChange => SVEvent.GravityChoiceChange[action, viewerToolData];
            $GravityExtentChange => SVEvent.GravityExtentChange[action, viewerToolData];
            $ToggleGravity => SVEvent.ToggleGravity[action, viewerToolData];
            $ToggleMidpoints => SVEvent.ToggleMidpoints[action, viewerToolData];
            <<Text Prompts>>
            $TextPrompt => SVEvent.TextPrompt[action, viewerToolData];
            $StylePrompt => SVEvent.StylePrompt[action, viewerToolData];
            $XYZPrompt => SVEvent.XYZPrompt[action, viewerToolData];
            $Selected => SVEvent.Selected[action, viewerToolData];
            $DoubleBuffer => SVEvent.DoubleBuffer[action, viewerToolData];
            $AISPrompt => SVEvent.AISPrompt[action, viewerToolData];
            $KillSelectionsButton => SVEvent.KillSelectionsButton[action, viewerToolData];
            $DeleteJacksButton => SVEvent.DeleteJacksButton[action, viewerToolData];
        <<Tip Table Functions>>
        $ExtendCurrent => SVEvent.ExtendCurrent[action, viewerToolData];
        $ReloadTipTable =>  SVWindow.ReloadTipTable[action, viewerToolData];
        <<$RestartProcess => SVInputMonitor.Restart[];>>
        <<$ClearAllSelections => SVSelections.KillSkitterAndSelections[viewerToolData.editToolData];>>
        $DeleteSources => SVEvent.DeleteSources[action, viewerToolData];
        $NoOp => {};

        $AddCylinder => SVEvent.AddCylinder[action, viewerToolData];
        $Skewer => SVEvent.Skewer[action, viewerToolData];
        $MoveUntilTouch => SVEvent.MoveUntilTouch[action, viewerToolData];

        $ArrowShoot => SVEvent.ArrowShoot[action, viewerToolData];
        $DropPerpendicular => SVEvent.DropPerpendicular[action, viewerToolData];
        $VolleyShoot => {};

        $JackPivotX => SVEvent.JackPivotX[action, viewerToolData];
        $JackPivotY => SVEvent.JackPivotY[action, viewerToolData];
        $JackPivotZ => SVEvent.JackPivotZ[action, viewerToolData];
        $SourcePivotX => SVEvent.SourcePivotX[action, viewerToolData];
        $SourcePivotY => SVEvent.SourcePivotY[action, viewerToolData];
        $SourcePivotZ => SVEvent.SourcePivotZ[action, viewerToolData];
        $SourceRotX => SVEvent.SourceRotX[action, viewerToolData];
        $SourceRotZ => SVEvent.SourceRotZ[action, viewerToolData];

        $CopyRandomToAllTargets => SVEvent.CopyRandomToAllTargets[action, viewerToolData];
        $CopyToAllTargets => SVEvent.CopyToAllTargets[action, viewerToolData];
        $CopyToAllTargetsTree => SVEvent.CopyToAllTargetsTree[action, viewerToolData];
        $MoveToTarget => SVEvent.MoveToTarget[action, viewerToolData];
        $CopyRotate => SVEvent.CopyRotate[action, viewerToolData];

        $CycleTool => SVEvent.CycleTool[action, viewerToolData];
        $SetTool => SVEvent.SetTool[action, viewerToolData];
        $ResetTool => SVEvent.ResetTool[action, viewerToolData];

        $ResetSpheres => SVEvent.ResetSpheres[action, viewerToolData];
        $SetBoundingSpheres => SVEvent.SetBoundingSpheres[action, viewerToolData];
        $SetSphereShadows => SVEvent.SetSphereShadows[action, viewerToolData];

        $SkitterMakes => SVEvent.SkitterMakes[action, viewerToolData];
        $SkitterMakesSource => SVEvent.SkitterMakesSource[action, viewerToolData];
        $SkitterMakesTarget => SVEvent.SkitterMakesTarget[action, viewerToolData];
        $SkitterMakesPlane => SVEvent.SkitterMakesPlane[action, viewerToolData];
        $SkitterMakesSourceIndirect => SVEvent.SkitterMakesSourceIndirect[action, viewerToolData];
        $SkitterMakesTargetIndirect => SVEvent.SkitterMakesTargetIndirect[action, viewerToolData];
        $SkitterMakesSourceIndirectOnly => SVEvent.SkitterMakesSourceIndirectOnly[action, viewerToolData];
        $SkitterMakesTargetIndirectOnly => SVEvent.SkitterMakesTargetIndirectOnly[action, viewerToolData];
        $SkitterMakesPlaneIndirectOnly => SVEvent.SkitterMakesPlaneIndirectOnly[action, viewerToolData];
            ENDCASE => NotYetImplementedMessage[atom, viewerToolData];
        };

    NotYetImplementedMessage: PROC [atom: ATOM, viewerToolData: ViewerToolData] = {
        SVError.Append["User action ", begin];
        SVError.Append[Atom.GetPName[atom], middle];
        SVError.Append[" is not yet implemented", end];
        SVError.Blink[];
        };

  
    CheckForSelectedReal: PROC [atom: ATOM, action: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
        rope: Rope.ROPE;
        real: REAL;
        IF action.rest = NIL THEN { -- interactive call
            rope _ ViewerTools.GetSelectionContents[];
            real _ Convert.RealFromRope[rope ! Convert.Error => {real _ -1.0; CONTINUE}];
            newAction _ LIST[atom, NEW[REAL _ real]];
            }
        ELSE IF ISTYPE[action.rest.first, REF TEXT] THEN { -- TIP table call
            rope _ Rope.FromRefText[NARROW[action.rest.first]];
            real _ Convert.RealFromRope[rope ! Convert.Error => {real _ -1.0; CONTINUE}];
            newAction _ LIST[atom, NEW[REAL _ real]];
            }
        ELSE newAction _ action; -- SessionLog call
        };

    CheckForSelectedInt: PROC [atom: ATOM, action: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
        rope: Rope.ROPE;
        int: INT;
        IF action.rest = NIL THEN { -- interactive call
            rope _ ViewerTools.GetSelectionContents[];
            int _ IO.GetInt[IO.RIS[rope] ! IO.EndOfStream, IO.Error => {int _ -1; CONTINUE}];
            newAction _ LIST[atom, NEW[INT _ int]];
            }
        ELSE IF ISTYPE[action.rest.first, REF INT] THEN { -- TIP table call or SessionLog call
            newAction _ action;
            }
        ELSE ERROR;
        };

    CheckForSelectedRope: PROC [atom: ATOM, action: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
        IF action.rest = NIL THEN { -- interactive call
            newAction _ LIST[atom, ViewerTools.GetSelectionContents[]];
            }
        ELSE IF ISTYPE[action.rest.first, REF TEXT] THEN { -- TIP table call
            newAction _ LIST[atom, Rope.FromRefText[NARROW[action.rest.first]]];
            }
        ELSE newAction _ action; -- SessionLog call
        };

END.