[Indigo]<Solidviews>Solidviews>SVUserInputImpl.mesa!19

File: SVUserInputImpl.mesa

Last edited by Bier on May 27, 1987 2:50:26 pm PDT

Contents: Procedures for responding to button clicks made in a solidviewer.

DIRECTORY

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

SVUserInputImpl: CEDAR PROGRAM

IMPORTS Atom, Convert, CoordSys, Feedback, IO, RefTab, Rope, SlackProcess, SVEvent, SVMouseEvent, SVSessionLog, SVWindow, ViewerTools

EXPORTS SVUserInput =

BEGIN

Artwork: TYPE = SVModelTypes.Artwork;

ArtworkToolData: TYPE = SVInterfaceTypes.ArtworkToolData;

Slice: TYPE = SVSceneTypes.Slice;

SliceList: TYPE = SVSceneTypes.SliceList;

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 = SVUserInput.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;

SVData: TYPE = SVInterfaceTypes.SVData;

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

Before the Queue (done by InputNotifier, Menu Process or Playback Process)

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.

svData: SVData ← NARROW[self.data];

ProcessAndQueueEvent[input, svData];

};

EventNotify: PUBLIC PROC [clientData: REF ANY, event: LIST OF REF ANY] = {

WITH clientData SELECT FROM

editToolData: EditToolData => ProcessAndQueueEvent[event, editToolData.currentSVData];

svData: SVData => ProcessAndQueueEvent[event, svData];

ENDCASE => ERROR;

};

ProcessAndQueueEvent: PROC [event: LIST OF REF ANY, svData: SVData] = {

The event will be in one of two forms:

1) LIST[REF CHAR].

2) LIST[ATOM, ... ].

handle: SlackHandle ← svData.slackHandle;

optimizeHint: REF ANY;

WITH event.first SELECT FROM

atom: ATOM => {

atomName: Rope.ROPE;

atomName ← Atom.GetPName[atom];

IF atom = $During THEN optimizeHint ← LIST[$During];

IF Rope.Equal[Rope.Substr[atomName, 0, 5], "Start", TRUE] THEN {

SlackProcess.QueueInputAction[handle, Dispatch, LIST[$SawTextFinish], svData, NIL];

need this before selection changes

};

event ← GetAnyArguments[event, svData];

};

ENDCASE => ERROR;

IF printAllInput THEN PrintAllInput[event, svData];

SlackProcess.QueueInputAction[handle, Dispatch, event, svData, optimizeHint];

};

GetAnyArguments: PROC [event: LIST OF REF ANY, svData: SVData] RETURNS [newEvent: LIST OF REF ANY] = {

atom: ATOM;

found: BOOL;

regEvent: RegisteredEvent;

refAny: REF ANY;

camera: Camera ← svData.camera;

atom ← NARROW[event.first];

[found, refAny] ← RefTab.Fetch[eventTable, atom];

regEvent ← NARROW[refAny];

IF NOT found THEN {

NotYetImplementedMessage[atom, svData];

newEvent ← event;

}

ELSE {

SELECT regEvent.argType FROM

none => {

IF event.rest # NIL AND ISTYPE[event.rest.first, TIP.TIPScreenCoords] THEN {

mousePlace: TIP.TIPScreenCoords ← NARROW[event.rest.first];

point: Point2d ← CoordSys.ScreenToCamera[[mousePlace.mouseX, mousePlace.mouseY], camera.screenCS];

refPoint: REF Imager.VEC ← NEW[Imager.VEC ← [point[1], point[2]]];

newEvent ← LIST[event.first, refPoint];

}

ELSE newEvent ← event;

};

refReal => newEvent ← CheckForSelectedReal[atom, event];

refInt => newEvent ← CheckForSelectedInt[atom, event];

rope => newEvent ← CheckForSelectedRope[atom, event];

ENDCASE => ERROR;

};

After the Queue (Done by SlackProcess).

Dispatch: PROC [clientData: REF ANY, event: LIST OF REF ANY] = {

svData: SVData ← NARROW[clientData];

atom: ATOM ← NARROW[event.first];

found: BOOL;

regEvent: RegisteredEvent;

refAny: REF ANY;

[found, refAny] ← RefTab.Fetch[eventTable, atom];

regEvent ← NARROW[refAny];

IF NOT found THEN NotYetImplementedMessage[atom, svData]

ELSE regEvent.eventProc[event, svData];

};

Utility Routines

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

PrintAllInput: PROC [event: LIST OF REF ANY, clientData: REF ANY] = {

svData: SVData ← NARROW[clientData];

FOR list: LIST OF REF ANY ← event, list.rest UNTIL list = NIL DO

WITH list.first SELECT FROM

atom: ATOM => Feedback.AppendTypescript[svData.feedback, Atom.GetPName[atom], oneLiner];

int: REF INT => Feedback.AppendTypescript[svData.feedback, IO.PutFR["%g ", [integer[int^]]], oneLiner];

refChar: REF CHAR => Feedback.AppendTypescript[svData.feedback, IO.PutFR["%g ", [character[refChar^]]], oneLiner];

coords: TIP.TIPScreenCoords => Feedback.AppendTypescript[svData.feedback, IO.PutFR["(%g, %g) ", [real[coords.mouseX]], [real[coords.mouseY]]], oneLiner];

ENDCASE => ERROR;

ENDLOOP;

};

NotYetImplementedMessage: PROC [atom: ATOM, svData: SVData] = {

Feedback.PutF[svData.feedback, oneLiner, "User action %g is not yet implemented", [rope[Atom.GetPName[atom]]]];

Feedback.Blink[svData.feedback];

};

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

};

RegisteredEvent: TYPE = REF RegisteredEventObj;

RegisteredEventObj: TYPE = RECORD [

eventProc: EventProc,

argType: SVUserInput.ArgumentType

];

RegisterAction: PUBLIC PROC [atom: ATOM, eventProc: EventProc, argType: SVUserInput.ArgumentType] = {

regEvent: RegisteredEvent ← NEW[RegisteredEventObj ← [eventProc, argType]];

notAlreadyRegistered: BOOL ← TRUE;

notAlreadyRegistered ← RefTab.Insert[eventTable, atom, regEvent];

IF NOT notAlreadyRegistered THEN SIGNAL Problem[msg: IO.PutFR["Event %g was already registered in Solidviews's event table.", [rope[Atom.GetPName[atom]]] ]];

};

eventTable: RefTab.Ref;

NoOp: EventProc = {};

RegisterSolidviewsActions: PROC = {

There were 91 events on April 28, 1987, and 94 EditUser events, making 185 total events.

eventTable ← RefTab.Create[300];

Special Internal Actions

RegisterAction[$EndOfSessionLogMessage, SVSessionLog.EndOfSessionLogMessage, none];

File Menu

RegisterAction[$Clear, SVEvent.Clear, none];

RegisterAction[$Restore, SVEvent.Restore, none];

RegisterAction[$Get, SVEvent.Get, rope];

RegisterAction[$Store, SVEvent.Store, rope];

RegisterAction[$Save, SVEvent.Save, none];

RegisterAction[$Split, SVEvent.Split, none];

Interpress Menu

RegisterAction[$ToIP, SVEvent.ToIP, rope];

RegisterAction[$StorePoly, SVEvent.StorePoly, none];

SVCastRays Menu

RegisterAction[$RayCast, SVEvent.RayCast, none];

RegisterAction[$StopRays, SVEvent.StopRays, none];

RegisterAction[$ARay, SVEvent.ARay, none];

Debug Menu

RegisterAction[$DrawBoundBoxes, SVEvent.DrawBoundBoxes, none];

RegisterAction[$DrawBoundSpheres, SVEvent.DrawBoundSpheres, none];

RegisterAction[$DrawCoordSystems, SVEvent.DrawCoordSystems, none];

RegisterAction[$DrawPoint, SVEvent.DrawPt, none];

RegisterAction[$CrossHairs, SVEvent.CrossHairs, none];

RegisterAction[$TestGravity, SVEvent.TestGravity, refInt];

RegisterAction[$ResetStatistics, SVEvent.ResetStatistics, none];

RegisterAction[$PrintStatistics, SVEvent.PrintStatistics, none];

Master Line Buttons

RegisterAction[$DrawSceneButton, SVEvent.DrawSceneButton, none];

RegisterAction[$DrawColor, SVEvent.DrawColor, none];

RegisterAction[$DrawBlackAndWhite, SVEvent.DrawBlackAndWhite, none];

RegisterAction[$ShowCoordsMode, SVEvent.ShowCoordsMode, none];

Select Menu

RegisterAction[$SelectAll, SVEvent.SelectAll, none];

Gravity Functions

RegisterAction[$GravityChoiceChange, SVEvent.GravityChoiceChange, none];

RegisterAction[$GravityExtentChange, SVEvent.GravityExtentChange, none];

RegisterAction[$ToggleGravity, SVEvent.ToggleGravity, none];

RegisterAction[$ToggleMidpoints, SVEvent.ToggleMidpoints, none];

Text Prompts

RegisterAction[$StylePrompt, SVEvent.StylePrompt, none];

RegisterAction[$XYZPrompt, SVEvent.XYZPrompt, none];

RegisterAction[$Selected, SVEvent.Selected, none];

RegisterAction[$DoubleBuffer, SVEvent.DoubleBuffer, none];

RegisterAction[$KillSelectionsButton, SVEvent.KillSelectionsButton, none];

RegisterAction[$DeleteJacksButton, SVEvent.DeleteJacksButton, none];

Tip Table Functions

RegisterAction[$ExtendCurrent, SVEvent.ExtendCurrent, none];

RegisterAction[$ReloadTipTable, SVWindow.ReloadTipTable, none];

RegisterAction[$Delete, SVEvent.Delete, none];

RegisterAction[$NoOp, NoOp, none];

RegisterAction[$AddCylinder, SVEvent.AddCylinder, none];

RegisterAction[$Skewer, SVEvent.Skewer, none];

RegisterAction[$MoveUntilTouch, SVEvent.MoveUntilTouch, none];

RegisterAction[$LiftAnchor, SVEvent.LiftAnchor, none];

RegisterAction[$DropAnchor, SVEvent.DropAnchor, none];

RegisterAction[$ArrowShoot, SVEvent.ArrowShoot, none];

RegisterAction[$DropPerpendicular, SVEvent.DropPerpendicular, none];

RegisterAction[$VolleyShoot, NoOp, none];

RegisterAction[$JackPivotX, SVEvent.JackPivotX, refReal];

RegisterAction[$JackPivotY, SVEvent.JackPivotY, refReal];

RegisterAction[$JackPivotZ, SVEvent.JackPivotZ, refReal];

RegisterAction[$SourcePivotX, SVEvent.SourcePivotX, refReal];

RegisterAction[$SourcePivotY, SVEvent.SourcePivotY, refReal];

RegisterAction[$SourcePivotZ, SVEvent.SourcePivotZ, refReal];

RegisterAction[$SourceRotX, SVEvent.SourceRotX, refReal];

RegisterAction[$SourceRotY, SVEvent.SourceRotY, refReal];

RegisterAction[$SourceRotZ, SVEvent.SourceRotZ, refReal];

RegisterAction[$CopyRandomToAllTargets, SVEvent.CopyRandomToAllTargets, none];

RegisterAction[$CopyToAllTargets, SVEvent.CopyToAllTargets, none];

RegisterAction[$CopyToAllTargetsTree, SVEvent.CopyToAllTargetsTree, none];

RegisterAction[$MoveToTarget, SVEvent.MoveToTarget, none];

RegisterAction[$CopyRotate, SVEvent.CopyRotate, none];

RegisterAction[$CycleTool, SVEvent.CycleTool, none];

RegisterAction[$SetTool, SVEvent.SetTool, none];

RegisterAction[$ResetTool, SVEvent.ResetTool, none];

RegisterAction[$ResetSpheres, SVEvent.ResetSpheres, none];

RegisterAction[$SetBoundingSpheres, SVEvent.SetBoundingSpheres, none];

RegisterAction[$SetSphereShadows, SVEvent.SetSphereShadows, none];

RegisterAction[$SkitterMakes, SVEvent.SkitterMakes, none];

RegisterAction[$SkitterMakesSource, SVEvent.SkitterMakesSource, none];

RegisterAction[$SkitterMakesTarget, SVEvent.SkitterMakesTarget, none];

RegisterAction[$SkitterMakesPlane, SVEvent.SkitterMakesPlane, none];

RegisterAction[$SkitterMakesSourceIndirect, SVEvent.SkitterMakesSourceIndirect, none];

RegisterAction[$SkitterMakesTargetIndirect, SVEvent.SkitterMakesTargetIndirect, none];

RegisterAction[$SkitterMakesSourceIndirectOnly, SVEvent.SkitterMakesSourceIndirectOnly, none];

RegisterAction[$SkitterMakesTargetIndirectOnly, SVEvent.SkitterMakesTargetIndirectOnly, none];

RegisterAction[$SkitterMakesPlaneIndirectOnly, SVEvent.SkitterMakesPlaneIndirectOnly, none];

Mouse Actions

RegisterAction[$StartDrag, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartCopyAndDrag, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartRotate, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartScale, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartSelectJoint, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartSelectSegment, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartSelectTraj, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartSelectTopLevel, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartExtendSelection, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartExtendSelectJoint, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartExtendSelectSegment, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartExtendSelectTraj, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartExtendSelectTopLevel, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartFrame, SVMouseEvent.HandleMouse, none];

RegisterAction[$StartSkitter, SVMouseEvent.HandleMouse, none];

RegisterAction[$During, SVMouseEvent.HandleMouse, none];

RegisterAction[$MouseUp, SVMouseEvent.HandleMouse, none];

RegisterAction[$GuardUp, SVMouseEvent.HandleMouse, none];

RegisterAction[$AllUp, SVMouseEvent.HandleMouse, none];

RegisterAction[$Abort, SVMouseEvent.HandleMouseless, none];

}; -- end of RegisterSolidviewsActions

RegisterSolidviewsActions[];

END.