[Cyan]<Gargoyle>GGMenusImpl.mesa!143

File: GGMenusImpl.mesa

Last edited by Bier on April 30, 1987 7:46:54 pm PDT

Contents: Code to create a Gargoyle window. Calls GGContainer to make the container and adds menus at the top. The graphics part of the Gargoyle window is a new viewer of class $ActionArea. The paint proc for a $ActionArea is defined herein.

Pier, May 5, 1987 6:46:39 pm PDT

DIRECTORY

AtomButtons, AtomButtonsTypes, CodeTimer, Feedback, FS, GGBasicTypes, GGCircleCache, GGContainer, GGEditTool, GGEvent, GGInterfaceTypes, GGMenus, GGModelTypes, GGMouseEvent, GGSegmentTypes, GGSessionLog, GGShapes, GGUserInput, GGUtility, GGWindow, GraphicsButton, Imager, IO, Menus, PopUpSelection, Rope, Rules, SlackProcess, VFonts, ViewerClasses, ViewerTools;

GGMenusImpl: CEDAR PROGRAM

IMPORTS AtomButtons, CodeTimer, Feedback, FS, GGCircleCache, GGContainer, GGEditTool, GGEvent, GGMouseEvent, GGSessionLog, GGShapes, GGUserInput, GGUtility, GGWindow, GraphicsButton, Imager, IO, PopUpSelection, Rope, Rules, SlackProcess, VFonts, ViewerTools

EXPORTS GGMenus = BEGIN

Caret: TYPE = REF CaretObj;

CaretObj: TYPE = GGInterfaceTypes.CaretObj;

FeedbackData: TYPE = AtomButtonsTypes.FeedbackData;

ImagerProc: TYPE = GGInterfaceTypes.ImagerProc;

MouseButton: TYPE = Menus.MouseButton;

Outline: TYPE = GGModelTypes.Outline;

Point: TYPE = GGBasicTypes.Point;

Scene: TYPE = REF SceneObj;

SceneObj: TYPE = GGModelTypes.SceneObj;

Segment: TYPE = GGSegmentTypes.Segment;

Sequence: TYPE = GGModelTypes.Sequence;

Traj: TYPE = GGModelTypes.Traj;

GGData: TYPE = REF GargoyleDataObj;

GargoyleDataObj: TYPE = GGInterfaceTypes.GargoyleDataObj;

Viewer: TYPE = ViewerClasses.Viewer;

entryHeight: CARDINAL = 15; -- height of a line of items

entryVSpace: CARDINAL = 2; -- vertical leading between lines

entryHSpace: CARDINAL = 2; -- horizontal space between items on a line

column1: CARDINAL = 200; -- horizontal space between margin and column 1;

column2: CARDINAL = 250; -- horizontal space between margin and column 2.

column3: CARDINAL = 500; -- horizontal space between margin and column 3;

fullColumn: CARDINAL = 600; -- the width of the standard large left column.

nameSize: CARDINAL = 140;

numberSize: CARDINAL = 80;

bigNumberSize: CARDINAL = 160;

smallNumberSize: CARDINAL = 60;

pointSize: CARDINAL = 160;

boldFont: VFonts.Font; -- initialized in Init below;

PopUpMenuEntry: TYPE = RECORD [

input: LIST OF REF ANY

];

ExtractChoiceList: PROC [menu: LIST OF PopUpMenuEntry] RETURNS [choices: LIST OF Rope.ROPE] = {

pos: LIST OF Rope.ROPE;

newCell: LIST OF Rope.ROPE;

Non-destructive (copies the menu names).

IF menu = NIL THEN ERROR;

choices ← CONS[menu.first.name, NIL];

pos ← choices;

FOR l: LIST OF PopUpMenuEntry ← menu.rest, l.rest UNTIL l = NIL DO

newCell ← CONS[l.first.name, NIL];

pos.rest ← newCell;

pos ← newCell;

ENDLOOP;

};

QueuePopUpMenuAction: PROC [label: Rope.ROPE, menu: LIST OF PopUpMenuEntry, ggData: GGData, onceOnly: BOOL ← TRUE] = {

index: NAT;

choices: LIST OF Rope.ROPE ← ExtractChoiceList[menu];

index ← PopUpSelection.Request[header: label, choice: choices];

IF index < 0 THEN ERROR;

IF index = 0 THEN RETURN;

FOR entries: LIST OF PopUpMenuEntry ← menu, entries.rest UNTIL entries = NIL DO

IF index = 1 THEN {

GGUserInput.EventNotify[ggData, entries.first.input];

EXIT;

};

index ← index - 1;

REPEAT

FINISHED => ERROR;

ENDLOOP;

IF onceOnly THEN RETURN;

ENDLOOP;

};

BuildControlPanel: PUBLIC PROC [ggData: GGData, windowMenu: Menus.Menu] = {

BuildFileMenuLine[ggData, windowMenu];

BuildMasterMenuLine[ggData];

BuildStyleMenuLine[ggData];

BuildGravityLine[ggData];

BuildSlopeLine[ggData];

BuildAngleLine[ggData];

BuildRadiusLine[ggData];

BuildDistanceLine[ggData];

BuildMeasureLine[ggData];

BuildFeedbackLine[ggData];

AddARule[ggData];

};

AddARule: PROC [ggData: GGData] = {

rule: Rules.Rule;

rule ← Rules.Create[[

parent: ggData.outer,

wy: ggData.height,

ww: ggData.outer.cw,

wh: 2

]];

GGContainer.ChildXBound[ggData.outer, rule];

ggData.height ← ggData.height + rule.wh + entryVSpace;

}; -- end of AddARule

fudgeX: INTEGER ← 2;

Build All of the Control Panel Menus

BuildFileMenuLine: PROC [ggData: GGData, windowMenu: Menus.Menu] = {

Files: Clear, Reset, Get, Store, Save, Split, Interpress

nextX: INTEGER ← AtomButtons.BuildButtonLine [ggData.outer, 0, ggData.height, ggData, GGUserInput.EventNotify, LIST[

[button["Clear", LIST[LIST[$Clear]], -1, FALSE, NIL, ConfirmClear]],

[button["Restore", LIST[LIST[$Reset]], -1, FALSE, NIL, ConfirmReset]],

[button["Get", LIST[LIST[$Get]], -1, FALSE, NIL, ConfirmGet]], -- guarded in spite of Tioga viewers menus

[button["Merge", LIST[LIST[$Merge]], -1, FALSE, NIL, ConfirmMerge]],

[button["Store", LIST[LIST[$Store]], -1, FALSE, NIL, ConfirmStore]],

[button["Save", LIST[LIST[$Save]] ]],

[button["Split", LIST[$Split] ]],

[button["Stuff", LIST[LIST[$Stuff],NIL,LIST[$StuffScreen]] ]]

]];

nextX ← nextX+fudgeX;

nextX ← AtomButtons.BuildUnQueuedButtonLine [ggData.outer, nextX, ggData.height, ggData, LIST[

["Interpress", button, InterpressMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Script", button, ScriptMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Help", button, HelpMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Revive!", button, ReviveButton]

]];

nextX ← nextX+fudgeX;

nextX ← AtomButtons.BuildButtonLine [ggData.outer, nextX, ggData.height, ggData, GGUserInput.EventNotify, LIST[

[button["Refresh", LIST[LIST[$Refresh]] ]],

[button["Typescript", LIST[LIST[$Typescript]] ]]

]];

ggData.height ← ggData.height + entryHeight;

};

BuildMasterMenuLine: PROC [ggData: GGData] = {

Master: Hierarchy Curve Transform Overlap EditCurve View Debug Abort Revive

overlapMenu: AtomButtons.ButtonLineEntry ←

[popUpButton["Overlap", LIST [

[LIST [$Top], "Top", "Move selected objects to the front"],

[LIST [$NoOp], "", "Does nothing"],

[LIST [$Bottom], "Bottom", "Move selected objects to the back"],

[LIST [$UpOne], "UpOne", "Move selected objects one layer toward the front"],

[LIST [$NoOp], "", "Does nothing"],

[LIST [$DownOne], "DownOne", "Move selected objects one layer toward the back"]

-1, FALSE, NIL]];

nextX: INTEGER ← AtomButtons.BuildUnQueuedButtonLine [ggData.outer, 0, ggData.height, ggData, LIST[

["Hierarchy", button, HierarchyMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Transform", button, TransformMenu, NIL, 0, -1, FALSE, NIL, boldFont]

]];

nextX ← AtomButtons.BuildButtonLine[ggData.outer, nextX+entryHSpace, ggData.height, ggData, GGUserInput.EventNotify, LIST[

overlapMenu

]];

nextX ← AtomButtons.BuildUnQueuedButtonLine [ggData.outer, nextX+entryHSpace, ggData.height, ggData, LIST[

["Overlap", button, OverlapMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Curves", button, CurveTypeMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Shapes", button, ShapesMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Text", button, TextOpsMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Fonts", button, FontOpsMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Groups", button, GroupOpsMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Debug", button, DebugMenu, NIL, 0, -1, FALSE, NIL, boldFont]

]];

ggData.height ← ggData.height + entryHeight;

};

BuildStyleMenuLine: PROC [ggData: GGData] = {

Style: LineEnds LineWidth LineColor Fill TextAlign Font

nextX: INTEGER ← AtomButtons.BuildUnQueuedButtonLine[ggData.outer, 0, ggData.height, ggData, LIST[

["Stroke", button, LineWidthMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Color", button, LineColorMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Arrows", button, ArrowsMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Fill", button, AreaColorMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Edit", button, EditMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Select", button, AreaSelectMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["HotSpots", button, HotSpotsMenu, NIL, 0, -1, FALSE, NIL, boldFont],

["Units", button, UnitsMenu, NIL, 0, -1, FALSE, NIL, boldFont]

]];

[ggData.refresh.showColors, nextX] ← AtomButtons.BuildTwoStateButton[viewer: ggData.outer, x: nextX + entryHSpace, y: ggData.height, clientData: ggData, handleProc: GGUserInput.EventNotify, name: "ShowColors", action: LIST[$ToggleShowColors], init: off];

ggData.refresh.screenStyle ← AtomButtons.BuildEnumTypeSelection[viewer: ggData.outer, x: nextX + entryHSpace, y: ggData.height, maxWidth: 144, clientData: ggData, handleProc: GGUserInput.EventNotify, title: "ScreenStyle:", default: "PrintFonts", borderOnButtons: TRUE, style: flipThru, allInOneRow: TRUE, buttonNames: LIST["PrintFonts", "ScreenFonts", "WYSIWYG"], atom: $ScreenChoiceChange];

ggData.height ← ggData.height + entryHeight + entryVSpace;

};

GravityExtentData: TYPE = REF GravityExtentDataObj;

GravityExtentDataObj: TYPE = GGInterfaceTypes.GravityExtentDataObj;

GravityExtentRepaint: PROC [dc: Imager.Context, clientData: REF ANY, buttonData: REF ANY, button: Viewer] = {

caretPoint: Point;

ged: GravityExtentData ← NARROW[buttonData];

extent: REAL ← ged.extent;

Imager.TranslateT[dc, [button.ww, button.wh/2.0]];

caretPoint ← [-extent, 0.0];

GGShapes.DrawCaret[dc, caretPoint];

};

BuildGravityLine: PROC [ggData: GGData] = {

nextX: NAT ← 0;

ggData.hitTest.gravityTypeMenu ←

AtomButtons.BuildEnumTypeSelection[viewer: ggData.outer, x: 0, y: ggData.height, maxWidth: 144,

clientData: ggData,

handleProc: GGUserInput.EventNotify,

title: "GravType:", default: "PreferPoints",

borderOnButtons: TRUE, style: flipThru, allInOneRow: TRUE,

buttonNames: LIST["StrictDistance", "PreferPoints"],

atom: $GravityChoiceChange];

ggData.hitTest.gravityType ← innerCircle;

nextX ← ggData.hitTest.gravityTypeMenu.nextx;

nextX ← AtomButtons.BuildButtonLine[

ggData.outer, nextX + entryHSpace, ggData.height, ggData, GGUserInput.EventNotify,

LIST[

[label["GravExtent:"]]

]];

nextX ← GraphicsButton.BuildGraphicsButton[

container: ggData.outer,

x: nextX + entryHSpace,

y: ggData.height,

w: 60, -- changed from 72 to make more room in line

h: entryHeight,

clientData: ggData,

choices: LIST[

[LIST[$GravityExtentChange, $ValueUp]],

[LIST[$GravityExtentChange, $InitialValue]],

[LIST[$GravityExtentChange, $ValueDown]]],

handleProc: GGUserInput.EventNotify,

repaintProc: GravityExtentRepaint,

buttonData: NEW[GravityExtentDataObj ← [extent: GGEditTool.GetDefaultGravityExtent[]]],

updateProc: GravityExtentInGGData

];

[ggData.hitTest.gravButton, nextX] ←

AtomButtons.BuildTwoStateButton[viewer: ggData.outer, x: nextX + 2*entryHSpace, y: ggData.height,

clientData: ggData,

handleProc: GGUserInput.EventNotify,

action: LIST[$ToggleGravity],

init: on];

[ggData.refresh.alignments, nextX] ←

AtomButtons.BuildTwoStateButton[viewer: ggData.outer, x: nextX + entryHSpace, y: ggData.height,

clientData: ggData,

handleProc: GGUserInput.EventNotify,

action: LIST[$ToggleAlignments],

init: on];

[ggData.hitTest.midpointButton, nextX] ←

AtomButtons.BuildTwoStateButton[viewer: ggData.outer, x: nextX + entryHSpace, y: ggData.height,

clientData: ggData,

handleProc: GGUserInput.EventNotify,

action: LIST[$ToggleMidpoints],

init: off];

[ggData.hitTest.heuristicsButton, nextX] ←

AtomButtons.BuildTwoStateButton[viewer: ggData.outer, x: nextX + entryHSpace, y: ggData.height,

clientData: ggData,

handleProc: GGUserInput.EventNotify,

action: LIST[$ToggleHeuristics],

init: IF GGEditTool.GetDefaultHeuristics[] THEN on ELSE off];

ggData.height ← ggData.height + entryHeight;

};

BuildSlopeLine: PROC [ggData: GGData] = {

buttonHandle: AtomButtons.ScalarButtonHandle;

nextX: NAT ← AtomButtons.BuildButtonLine[ggData.outer, 0, ggData.height, ggData, GGUserInput.EventNotify,LIST[

[button["Slope:", LIST[LIST[$SlopePrompt]] ]],

[button["Get!", LIST[LIST[$GetSlope]] ]],

[button["Add!", LIST[LIST[$AddSlope]] ]],

[button["Delete!", LIST[LIST[$DeleteSlope]] ]]

]];

buttonHandle ← AtomButtons.CreateScalarButtonViewer[ggData.outer, nextX, ggData.height];

ggData.hitTest.slopeHeader ← buttonHandle;

GGEvent.StandardSlopes[ggData, LIST[$StandardSlopes]];

ggData.height ← ggData.height + entryHeight;

};

BuildAngleLine: PROC [ggData: GGData] = {

buttonHandle: AtomButtons.ScalarButtonHandle;

nextX: NAT ← AtomButtons.BuildButtonLine[ggData.outer, 0, ggData.height, ggData, GGUserInput.EventNotify,LIST[

[button["Angle:", LIST[LIST[$AnglePrompt]] ]],

[button["Get!", LIST[LIST[$GetAngle]] ]],

[button["Add!", LIST[LIST[$AddAngle]] ]],

[button["Delete!", LIST[LIST[$DeleteAngle]] ]]

]];

buttonHandle ← AtomButtons.CreateScalarButtonViewer[ggData.outer, nextX, ggData.height];

ggData.hitTest.angleHeader ← buttonHandle;

GGEvent.StandardAngles[ggData, LIST[$StandardAngles]];

ggData.height ← ggData.height + entryHeight;

};

BuildRadiusLine: PROC [ggData: GGData] = {

buttonHandle: AtomButtons.ScalarButtonHandle;

nextX: NAT ← AtomButtons.BuildButtonLine[ggData.outer, 0, ggData.height, ggData, GGUserInput.EventNotify, LIST[

[button["Radius:", LIST[LIST[$RadiusPrompt]] ]],

[button["Get!", LIST[LIST[$GetRadius]] ]],

[button["Add!", LIST[LIST[$AddRadius]] ]],

[button["Delete!", LIST[LIST[$DeleteRadius]] ]]

]];

buttonHandle ← AtomButtons.CreateScalarButtonViewer[ggData.outer, nextX, ggData.height];

ggData.hitTest.radiusHeader ← buttonHandle;

GGEvent.StandardRadii[ggData, LIST[$StandardRadii]];

ggData.hitTest.radiusCircleCache ← GGCircleCache.Create[];

ggData.height ← ggData.height + entryHeight;

};

BuildDistanceLine: PROC [ggData: GGData] = {

buttonHandle: AtomButtons.ScalarButtonHandle;

nextX: NAT ← AtomButtons.BuildButtonLine[ggData.outer, 0, ggData.height, ggData, GGUserInput.EventNotify, LIST[

[button["LineDistance:", LIST[LIST[$DistancePrompt]] ]],

[button["Get!", LIST[LIST[$GetDistance]] ]],

[button["Add!", LIST[LIST[$AddDistance]] ]],

[button["Delete!", LIST[LIST[$DeleteDistance]] ]]

]];

buttonHandle ← AtomButtons.CreateScalarButtonViewer[ggData.outer, nextX, ggData.height];

ggData.hitTest.distanceHeader ← buttonHandle;

GGEvent.StandardDistances[ggData, LIST[$StandardDistances]];

ggData.height ← ggData.height + entryHeight;

};

BuildMeasureLine: PROC [ggData: GGData] = {

nextX: NAT ← AtomButtons.BuildButtonLine[ggData.outer, 0, ggData.height, ggData, GGUserInput.EventNotify, LIST[

[button["SlopeValue:", LIST[LIST[$MeasureSlopeHit]] ]],

[text["0.0", SlopeViewInGGData, smallNumberSize]],

[button["AngleValue:", LIST[LIST[$MeasureAngleHit]] ]],

[text["0.0", AngleViewInGGData, smallNumberSize]],

[button["RadiusValue:", LIST[LIST[$MeasureRadiusHit]] ]],

[text["0.0", DistanceViewInGGData, smallNumberSize]],

[button["LineDistanceValue:", LIST[LIST[$MeasureLineDistHit]] ]],

[text["0.0", LineDistViewInGGData, smallNumberSize]]

]];

ggData.height ← ggData.height + entryHeight;

};

BuildFeedbackLine: PROC [ggData: GGData] = {

nextX: NAT ← AtomButtons.BuildButtonLine[ggData.outer, 0, ggData.height, ggData, GGUserInput.EventNotify, LIST[

[label["Feedback . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Line", FeedbackLineInGGData, fullColumn]]

]];

ggData.height ← ggData.height + entryHeight;

};

Dummy: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

Feedback.AppendHerald[ggData.feedback, "Menu Level: This feature not yet implemented", oneLiner];

Feedback.Blink[ggData.feedback];

};

File Line:

InterpressMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["MergeIPEditable", LIST [$MergeIPEditable]],

["MergeIPSlice", LIST [$MergeIPSlice]],

["ToIP", LIST [$ToIP]],

["ToIPScreen", LIST [$ToIPScreen]],

["IncludeIPByReference", LIST[$IncludeIPByReference]],

["IncludeIPByValue", LIST[$IncludeIPByValue]],

["ShowIPIncludeMode", LIST[$ShowIPIncludeMode]]

];

QueuePopUpMenuAction["Interpress", menu, ggData, mouseButton#blue];

};

ScriptMenu: Menus.ClickProc = {

ClickProc: TYPE = PROC [parent: REF ANY, clientData: REF ANY ← NIL,
mouseButton: MouseButton ← red, shift, control: BOOL ← FALSE];

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry ← LIST [

["OpenScript", LIST [$ScriptAction, $Open]],

["AppendToScript", LIST [$ScriptAction, $Append]],

["CloseScript", LIST [$ScriptAction, $Close]],

["PlaybackScript", LIST [$ScriptAction, $Playback]],

["FastPlayScript", LIST [$ScriptAction, $FastPlay]]

];

QueuePopUpMenuAction["Script", menu, ggData, mouseButton#blue];

choices: LIST OF Rope.ROPE ← ExtractChoiceList[menu];

index: NAT ← PopUpSelection.Request[header: "Script", choice: choices];

SELECT index FROM

=0 => RETURN;

=1 => OpenScript[parent, clientData, mouseButton, shift, control];

=2 => AppendToScript[parent, clientData, mouseButton, shift, control];

=3 => CloseScript[parent, clientData, mouseButton, shift, control];

=4 => PlaybackScript[parent, clientData, mouseButton, shift, control];

=5 => FastPlayScript[parent, clientData, mouseButton, shift, control];

ENDCASE => ERROR;

};

ConfirmClear: PROC [clientData: REF ANY] = {

ggData: GGData ← NARROW[clientData];

Feedback.AppendHerald[ggData.feedback, "Confirm deletion of all objects", oneLiner];

};

ConfirmReset: PROC [clientData: REF ANY] = {

ggData: GGData ← NARROW[clientData];

Feedback.AppendHerald[ggData.feedback, "Confirm reset to original file", oneLiner];

};

ConfirmGet: PROC [clientData: REF ANY] = {

ggData: GGData ← NARROW[clientData];

filename: Rope.ROPE ← ViewerTools.GetSelectionContents[];

Feedback.AppendHerald[ggData.feedback, Rope.Cat["Confirm getting of file ", filename, " to the current scene."], oneLiner];

};

ConfirmMerge: PROC [clientData: REF ANY] = {

ggData: GGData ← NARROW[clientData];

filename: Rope.ROPE ← ViewerTools.GetSelectionContents[];

Feedback.AppendHerald[ggData.feedback, Rope.Cat["Confirm addition of file ", filename, " to the current scene."], oneLiner];

};

ConfirmStore: PROC [clientData: REF ANY] = {

ggData: GGData ← NARROW[clientData];

fullName, msg: Rope.ROPE;

success, exists: BOOL;

[fullName, success, ----] ← GGUtility.GetGargoyleFileName[ViewerTools.GetSelectionContents[], ggData.currentWDir, ggData.feedback, FALSE];

IF NOT success THEN RETURN;

exists ← FileExists[fullName];

IF exists THEN msg ← IO.PutFR["Confirm Store of %g [Old File]", [rope[fullName]]]

ELSE msg ← IO.PutFR["Confirm Store to %g [New File]", [rope[fullName]]];

Feedback.AppendHerald[ggData.feedback, msg, oneLiner];

};

FileExists: PROC [fileName: Rope.ROPE] RETURNS [answer: BOOL] = {

answer ← TRUE;

[----, ----, ----, ----] ← FS.FileInfo[fileName

! FS.Error => {IF error.code = $unknownFile THEN {answer ← FALSE; CONTINUE}

ELSE ERROR}];

};

Master Line:

HierarchyMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Delete (DEL)", LIST [$Delete]],

["UnDelete", LIST [$Undelete]],

["AddHoles (^h)", LIST [$AddHoles]],

["UnionCombine", LIST [$UnionCombine]],

["Extend Select (^v)", LIST [$ExtendSelect]],

["Undo (SHIFT-ESC)", LIST [$Undo]],

["Redo (ESC)", LIST [$Redo]],

["Cluster", LIST [$Cluster]],

["Un Cluster", LIST [$UnCluster]],

["DescribeSelected", LIST [$DescribeCurve, $Selected]]

];

QueuePopUpMenuAction["Hierarchy", menu, ggData, mouseButton#blue];

};

TransformMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Rotate", LIST [$Rotate]],

["Scale", LIST [$Scale]],

["ScaleX", LIST [$ScaleX]],

["ScaleY", LIST [$ScaleY]],

["TranslateX", LIST [$TranslateX]],

["TranslateY", LIST [$TranslateY]],

["SixPoint", LIST [$SixPointTransform]],

["FourPoint", LIST [$FourPointTransform]]

];

QueuePopUpMenuAction["Transform", menu, ggData, mouseButton#blue];

};

OverlapMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Top", ],

["Bottom", LIST [$Bottom]],

["UpOne", LIST [$UpOne]],

["DownOne", LIST [$DownOne]]

];

QueuePopUpMenuAction["Overlap", menu, ggData, mouseButton#blue];

};

ShapesMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Triangle", LIST [$PolygonInCircle, NEW[INT ← 3] ]],

["Square", LIST [$PolygonInCircle, NEW[INT ← 4] ]],

["Pentagon", LIST [$PolygonInCircle, NEW[INT ← 5] ]],

["Hexagon", LIST [$PolygonInCircle, NEW[INT ← 6] ]],

["Octagon", LIST [$PolygonInCircle, NEW[INT ← 8] ]],

["FromSelectedCount", LIST [$PolygonInCircle, NEW[INT ← -1] ]],

["Knotched Line", LIST [$KnotchedLine, NEW[REAL ← 4.0], NEW[INT ← 8]] ],

["Box", LIST [$NewBox, NEW[REAL ← 1.0] ]],

["Circle", LIST [$NewCircle, NEW[REAL ← 1.0] ]],

["Arrow", LIST [$NewArrow, NEW[REAL ← 0.5], NEW[REAL ← 0.125] ]],

The first parameter is shaft length. The second is barb length. Both in inches.

["8.5 by 11", LIST [$Frame, NEW[REAL ← 8.5*72.0], NEW[REAL ← 11.0*72.0] ]],

["11 by 14", LIST [$Frame, NEW[REAL ← 11.0*72.0], NEW[REAL ← 14.0*72.0] ]],

["38 by 50.66 (Versatec)", LIST [$Frame, NEW[REAL ← 38.0*72.0], NEW[REAL ← 50.666667*72.0] ]],

["640 x 480", LIST [$Frame, NEW[REAL ← 640.0], NEW[REAL ← 480.0] ]],

["1024 x 768", LIST [$Frame, NEW[REAL ← 1024.0], NEW[REAL ← 768.0] ]]

];

QueuePopUpMenuAction["Shapes", menu, ggData, mouseButton#blue];

};

DebugMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Draw Tight Boxes", LIST [$DrawTightBoxes]],

["Draw Bounding Boxes", LIST [$DrawBoundBoxes]],

["Draw Outline Boxes", LIST [$DrawOutlineBoxes]],

["Draw Selection Box", LIST [$DrawSelectionBox]],

["Draw Background Box", LIST [$DrawBackgroundBox]],

["Draw Overlay Box", LIST [$DrawOverlayBox]],

["Draw Rubber Box", LIST [$DrawRubberBox]],

["Draw Drag Box", LIST [$DrawDragBox]],

["Test Gravity", LIST [$TestGravity]],

["ToIPTestGravity", LIST [$ToIPTestGravity]],

["Print Statistics", LIST [$Statistics]],

["Print Selected Statistic", LIST [$PrintSelectedStatistic]],

["Reset Statistics", LIST [$ResetStatistics]],

["SlackLog", LIST [$SlackLog]],

["Describe Caret Object", LIST [$DescribeCaretObject]],

["FSM Info", LIST [$FSMInfo]],

["Print All Input", LIST [$PrintAllInput]],

["Reset All Input", LIST [$ResetAllInput]],

["CauseAnError", LIST [$CauseAnError]]

];

QueuePopUpMenuAction["Debug", menu, ggData, mouseButton#blue];

};

HelpMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Mouse Actions", LIST[$Help, $MouseActions]],

["Fonts", LIST[$Help, $Fonts]]

];

QueuePopUpMenuAction["Help", menu, ggData, mouseButton#blue];

};

RefreshButton: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: triggerBag, backgndOK: FALSE, edited: FALSE, okToClearFeedback: TRUE]

};

ReviveButton: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

GGMouseEvent.ResetMouseMachinery[ggData];

CodeTimer.ResetTable[CodeTimer.GetTable[$Gargoyle]];

SlackProcess.Restart[ggData.slackHandle];

ggData.refresh.suppressRefresh ← FALSE;

ggData.aborted ← ALL[FALSE];

IF mouseButton#blue THEN GGWindow.RestoreScreenAndInvariants[paintAction: $PaintEntireScene, ggData: ggData, remake: triggerBag, backgndOK: FALSE, edited: FALSE, okToClearFeedback: TRUE]

};

Gravity Line:

GravityExtentInGGData: GraphicsButton.UpdateGraphicsButtonProc = {

ggData: GGData ← NARROW[clientData];

ggData.hitTest.gravityExtentButton ← stateInfo;

};

Style Line:

LineWidthMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["0 pt (LOOK 0)", LIST[$LineWidth, NEW[REAL ← 0.0]]],

["1 pt (LOOK 1)", LIST[$LineWidth, NEW[REAL ← 1.0]]],

["2 pt (LOOK 2)" , LIST[$LineWidth, NEW[REAL ← 2.0]]],

["3 pt (LOOK 3)", LIST[$LineWidth, NEW[REAL ← 3.0]]],

["4 pt (LOOK 4)", LIST[$LineWidth, NEW[REAL ← 4.0]]],

["WidthFromSelection", LIST[$LineWidth]],

["EndFromSelection", LIST[$LineEnd]],

["JointFromSelection", LIST[$TrajJoints]],

["DashesFromSelection", LIST[$DashesFromSelection]],

["DashesOff", LIST[$DashesOff]],

["ShowValues", LIST[$PrintStrokeValues]],

["MatchSelectedWidth", LIST[$SelectMatchingWidth]],

["MatchSelectedDashes", LIST[$SelectMatchingDashes]],

["MakeDefaultValues", LIST [$SetDefaultStrokeValues]],

["ShowDefaultValues", LIST [$ShowDefaultStrokeValues]]

];

QueuePopUpMenuAction["Stroke", menu, ggData, mouseButton#blue];

};

LineColorMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["none", LIST[$LineColorNone]],

["black" , LIST[$LineColorBlack]],

["white", LIST[$LineColorWhite]],

["gray", LIST[$LineColorGray]],

["FromColorTool", LIST[$LineColorFromColorTool]],

["FollowColorTool", LIST[$LineColorFollowColorTool]],

["ToColorTool", LIST[$LineColorToColorTool]],

["FromSelectedName", LIST[$LineColorFromSelectedName]],

["FromSelectedRGB", LIST[$LineColorFromSelectedRGB]],

["ShowValue", LIST[$PrintLineColor]],

["MatchSelectedName", LIST[$SelectMatchingLineCNS]],

["MatchSelectedRGB", LIST[$SelectMatchingLineRGB]],

["MakeDefaultColor", LIST [$SetDefaultLineColor]],

["ShowDefaultColor", LIST [$ShowDefaultLineColor]]

];

QueuePopUpMenuAction["Line Color", menu, ggData, mouseButton#blue];

};

AreaColorMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["none", LIST[$AreaColorNone]],

["black" , LIST[$AreaColorBlack]],

["white", LIST[$AreaColorWhite]],

["gray", LIST[$AreaColorGray]],

["FromColorTool", LIST[$AreaColorFromColorTool]],

["FollowColorTool", LIST[$AreaColorFollowColorTool]],

["ToColorTool", LIST[$AreaColorToColorTool]],

["FromSelectedName", LIST[$AreaColorFromSelectedName]],

["FromSelectedRGB", LIST[$AreaColorFromSelectedRGB]],

["ShowValue", LIST[$PrintAreaColor]],

["MatchSelectedName", LIST[$SelectMatchingAreaCNS]],

["MatchSelectedRGB", LIST[$SelectMatchingAreaRGB]],

["MakeDefaultColor", LIST [$SetDefaultFillColor]],

["ShowDefaultColor", LIST [$ShowDefaultFillColor]]

];

QueuePopUpMenuAction["Fill", menu, ggData, mouseButton#blue];

};

ArrowsMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["none", LIST[$Arrows, NEW[INT ← 0]]],

["left/down", LIST[$Arrows, NEW[INT ← 1]]],

["right/up" , LIST[$Arrows, NEW[INT ← 2]]],

["both", LIST[$Arrows, NEW[INT ← 3]]]

];

QueuePopUpMenuAction["Arrows", menu, ggData, mouseButton#blue];

};

AreaSelectMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["New", LIST [$AreaSelectNew]],

["NewWithDelete", LIST [$AreaSelectNewAndDelete]],

["Extend", LIST [$AreaSelectExtend]],

["All (^d)", LIST [$SelectAll]],

["Degenerate", LIST [$AreaSelectDegenerate]]

];

QueuePopUpMenuAction["Area Select", menu, ggData, mouseButton#blue];

};

TextOpsMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["AddText", LIST [$AddText]],

["DropShadowOn 1 pt", LIST [$DropShadowOn, NEW[REAL ← -1.0], NEW[REAL ← -1.0]]],

["DropShadowOn 2 pt", LIST [$DropShadowOn, NEW[REAL ← -2.0], NEW[REAL ← -2.0]]],

["DropShadowOn 3 pt", LIST [$DropShadowOn, NEW[REAL ← -3.0], NEW[REAL ← -3.0]]],

["Drop Shadow From Selection", LIST [$DropShadowFromSelection]],

["DropShadowOff", LIST [$DropShadowOff]],

["AmplifySpaceFromSelection", LIST [$AmplifySpaceFromSelection]],

["ShowAmplifySpace", LIST [$PrintAmplifySpace]]

];

QueuePopUpMenuAction["Text", menu, ggData, mouseButton#blue];

};

FontOpsMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["# SetPressFont", LIST [$SetPressFont]],

["# SetScreenFont", LIST [$SetScreenFont]],

["# SetXCFont", LIST [$SetPrintFont]],

["# SetDetailedFont", LIST [$SetFontDetailed]],

["# SetLiteralFont", LIST [$SetFontLiteral]],

["# ShowFont", LIST [$ShowFontValues]],

["# ShowLiteralFont", LIST [$ShowFontValuesLiteral]],

["# CopyFontAndTransform", LIST [$CopyAll]],

["# CopyFamilyAndFace", LIST [$CopyFont]],

["# MatchLiteral", LIST[$MatchAll]],

[" MatchSelectedName", LIST[$MatchSelectedName]],

[" MatchSelectedNameLiteral", LIST[$MatchSelectedNameLiteral]],

["# MakeDefaultFont", LIST [$SetDefaultFontValues]],

[" ShowDefaultFont", LIST [$ShowDefaultFontValues]]

];

QueuePopUpMenuAction["Fonts", menu, ggData, mouseButton#blue];

};

GroupOpsMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["AddToGroup", LIST [$AddToGroup]],

["FindGroup", LIST [$SelectGroup]],

["RemoveFromGroup", LIST [$RemoveFromGroup]],

["PrintGroupsOfSelected", LIST [$PrintGroupsOfSelected]],

["PrintAllGroups", LIST [$PrintAllGroups]]

];

QueuePopUpMenuAction["Groups", menu, ggData, mouseButton#blue];

};

CurveTypeMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Line (LOOK l)", LIST [$SetStraight]],

["Arc (LOOK a)", LIST [$SetArc]],

["Conic (LOOK c)", LIST [$SetConic]],

["Bezier (LOOK z)", LIST [$SetBezier]],

["B-Spline (LOOK b)", LIST [$SetBSpline]],

["Natural Spline (LOOK n)", LIST [$SetNaturalSpline]],

["MatchSelectedType", LIST [$SelectMatchingCurve]]

];

QueuePopUpMenuAction["Curves", menu, ggData, mouseButton#blue];

};

EditMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["ApplyAllDefaults", LIST [$ApplyAllDefaults]],

["SetAllDefaults", LIST [$SetAllDefaults]],

["ShowAllDefaults", LIST [$ShowAllDefaults]],

["StandardDefaults", LIST [$StandardDefaults]],

["Close (^c)", LIST [$Close]],

["Weld (^w)", LIST [$Weld]],

["Add CP (^p)", LIST [$AddControlPoint]],

["Delete CP (^P)", LIST [$DeleteControlPoint]],

["Add Joint (^j)", LIST [$AddJoint]],

["ReplaceSegment", LIST [$SplitSegment]],

["Splice", LIST [$Splice]]

];

QueuePopUpMenuAction["Edit", menu, ggData, mouseButton#blue];

};

OpenScript: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

GGSessionLog.OpenScript[name, ggData];

IF ggData.debug.logStream#NIL THEN [] ← SlackProcess.EnableSessionLogging[ggData.slackHandle];

};

AppendToScript: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

GGSessionLog.AppendScript[name, ggData];

IF ggData.debug.logStream#NIL THEN [] ← SlackProcess.EnableSessionLogging[ggData.slackHandle];

};

CloseScript: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

[] ← SlackProcess.DisableSessionLogging[ggData.slackHandle];

GGSessionLog.CloseScript[ggData];

};

PlaybackScript: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

GGSessionLog.PlaybackFromFile[name, ggData];

};

FastPlayScript: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

GGUserInput.EventNotify[ggData, LIST[$DisableRefresh]];

GGSessionLog.PlaybackFromFile[name, ggData];

GGUserInput.EventNotify[ggData, LIST[$EnableRefresh]];

GGUserInput.EventNotify[ggData, LIST[$Refresh, $DoNotClearFeedback]];

};

Alignment Line:

HotSpotsMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["Make Hot (^s)", LIST[$MakeHot]],

["Make All Hot (^ss)", LIST[$MakeAllHot]],

["Make Cold (^S)" , LIST[$MakeCold]],

["Make All Cold (^SS)" , LIST[$MakeAllCold]],

["Show Hot", LIST [$ShowHot]],

["Hide Hot", LIST [$HideHot]],

["Drop Anchor (^a)" , LIST[$DropAnchor]],

["Lift Anchor (^A)" , LIST[$LiftAnchor]],

["Standard Alignments" , LIST[$StandardAlignments]]

];

QueuePopUpMenuAction["Hot Spots", menu, ggData, mouseButton#blue];

};

UnitsMenu: Menus.ClickProc = {

ggData: GGData ← NARROW[clientData];

menu: LIST OF PopUpMenuEntry;

menu ← LIST [

["FromSegment", LIST[$RadiusUnitFromSegment]],

["FromRadiusValue", LIST[$RadiusUnitFromValue]],

["FromSelection", LIST[$RadiusUnitFromSelection]],

["Inches", LIST[$InchScaleUnit]],

["Centimeters", LIST[$CentimeterScaleUnit]],

["Points", LIST[$PointsScaleUnit]],

["PrintCurrent", LIST[$PrintScaleUnit]]

];

QueuePopUpMenuAction["Units", menu, ggData, mouseButton#blue];

};

Distance Line:

Caret2InGGData: AtomButtons.UpdateProc = {

ggData: GGData ← NARROW[clientData];

ggData.measure.caret2← button;

};

SlopeViewInGGData: AtomButtons.UpdateProc = {

ggData: GGData ← NARROW[clientData];

ggData.measure.slopeView ← button;

ggData.hitTest.slopeText ← button;

};

AngleViewInGGData: AtomButtons.UpdateProc = {

ggData: GGData ← NARROW[clientData];

ggData.measure.angleView ← button;

ggData.hitTest.angleText ← button;

};

DistanceViewInGGData: AtomButtons.UpdateProc = {

ggData: GGData ← NARROW[clientData];

ggData.measure.radiusView ← button;

ggData.hitTest.radiusText ← button;

};

LineDistViewInGGData: AtomButtons.UpdateProc = {

ggData: GGData ← NARROW[clientData];

ggData.measure.lineDistView ← button;

ggData.hitTest.distanceText ← button;

};

FeedbackLineInGGData: AtomButtons.UpdateProc = {

ggData: GGData ← NARROW[clientData];

feedback: FeedbackData ← Feedback.RegisterFeedback[button, $Gargoyle];

ggData.feedback ← feedback;

};

DistanceOfInterest: Menus.ClickProc = {

};

Init: PROC = {

boldFont ← VFonts.EstablishFont[family: "Helvetica", size: 10, bold: TRUE,
italic: FALSE, defaultOnFailure: TRUE];

};

Init[];

END.