<<>> <> <> <> <> <> <> DIRECTORY ColumnLs, Commander, CommanderOps, Convert, FileNames, FS, G2dBasic, G3dBasic, G3dTimeTrees, G3dTool, IO, PFS, PreDebug, Real, Rope, UserProfile, ViewerOps; G3dToolCmdsImpl: CEDAR PROGRAM IMPORTS ColumnLs, Commander, CommanderOps, Convert, FileNames, FS, G3dTimeTrees, G3dTool, IO, PFS, PreDebug, Real, Rope, UserProfile, ViewerOps EXPORTS G3dTool ~ BEGIN <> ROPE: TYPE ~ Rope.ROPE; Tool: TYPE ~ G3dTool.Tool; <<3d Registration and Dispatch>> Op: TYPE ~ RECORD [proc: Commander.CommandProc, name, usage: ROPE]; OpSequence: TYPE ~ RECORD [length: NAT Ź 0, s: SEQUENCE maxLength: NAT OF Op]; ops: REF OpSequence Ź NIL; Eq: PROC [r1, r2: ROPE] RETURNS [BOOL] ~ {RETURN[Rope.Equal[r1, r2, FALSE]]}; Register: PUBLIC PROC [name: ROPE, proc: Commander.CommandProc, usage: ROPE] ~ { op: Op Ź [proc, name, usage]; IF proc # NIL THEN op.usage Ź Rope.Concat[" ", usage]; IF ops # NIL THEN FOR n: NAT IN [0..ops.length) DO IF NOT Eq[name, ops[n].name] THEN LOOP; ops[n] Ź op; RETURN; ENDLOOP; IF ops = NIL THEN ops Ź NEW[OpSequence[10]]; IF ops.length = ops.maxLength THEN { old: REF OpSequence ~ ops; ops Ź NEW[OpSequence[Real.Round[1.3*old.length]]]; FOR i: NAT IN [0..old.length) DO ops[i] Ź old[i]; ENDLOOP; ops.length Ź old.length; }; ops[ops.length] Ź op; ops.length Ź ops.length+1; }; PrintOps: PROC [cmd: Commander.Handle Ź NIL] ~ { IF ops = NIL THEN IO.PutRope[cmd.out, "no registered commands\n"] ELSE { Alphabetize: PROC [ropes: LIST OF ROPE] RETURNS [ret: LIST OF ROPE] ~ { IF ropes # NIL THEN { l: LIST OF ROPE Ź ropes.rest; ret Ź LIST[ropes.first]; WHILE l # NIL DO name: ROPE Ź l.first; rest: LIST OF ROPE Ź l.rest; IF Rope.Compare[ret.first, name, FALSE] = greater THEN ret Ź CONS[name, ret] ELSE FOR r: LIST OF ROPE Ź ret, r.rest DO IF r.rest = NIL OR Rope.Compare[r.rest.first, name, FALSE] = greater THEN {l.rest Ź r.rest; r.rest Ź l; EXIT}; ENDLOOP; l Ź rest; ENDLOOP; }; }; names: LIST OF ROPE; FOR n: NAT IN [0..ops.length) DO IF ops[n].proc # NIL THEN names Ź CONS[ops[n].name, names]; ENDLOOP; IO.PutF[cmd.out, "\t\t\t\t\t\t\t%l3d commands%l\n\n", IO.rope["bz"], IO.rope["BZ"]]; ColumnLs.ColumnateNames[cmd, Alphabetize[names],, fixed, TRUE,, " "]; IO.PutRope[cmd.out, "\n"]; }; }; <<3d Imaging Commands Using G3dTool>> IsItError: ERROR = CODE; ToolCmd: Commander.CommandProc ~ { t: Tool; { ENABLE { UNCAUGHT => {msg Ź "unknown error"; GOTO Failure}; IsItError => {msg Ź usage; GOTO Failure}; PFS.Error => {msg Ź error.explanation; GOTO Failure}; Convert.Error => {msg Ź "Conversion error"; GOTO Failure}; }; GetInteger: PROC [index: INT] RETURNS [i: INT] ~ {i Ź Convert.IntFromRope[args[index]]}; IsIt: PROC [rope: ROPE, argsNeeded: INT] RETURNS [b: BOOL] ~ { IF index >= args.argc THEN RETURN[FALSE]; b Ź Eq[rope, args[index]]; IF b AND args.argc <= index+argsNeeded THEN ERROR IsItError; }; SkipArgs: PROC [nSkip: INT] ~ {index Ź index+nSkip}; scene, shape, funct: ROPE; index, nViews: INTEGER Ź 1; arcBalls: BOOL Ź UserProfile.Boolean["3dTool.ArcBalls", TRUE]; args: CommanderOps.ArgumentVector Ź CommanderOps.Parse[cmd]; WHILE index < args.argc DO SELECT TRUE FROM IsIt["-shape", 1] => {shape Ź args[index+1]; SkipArgs[2]}; IsIt["-scene", 1] => {scene Ź args[index+1]; SkipArgs[2]}; IsIt["-noArcBalls", 0] => {arcBalls Ź FALSE; SkipArgs[1]}; IsIt["-useArcBalls", 0] => {arcBalls Ź TRUE; SkipArgs[1]}; IsIt["-nViews", 1] => {nViews Ź GetInteger[index+1]; SkipArgs[2]}; ENDCASE => {IF funct = NIL THEN funct Ź args[index]; SkipArgs[1]}; ENDLOOP; IF funct # NIL THEN { Reject: PROC [why: ROPE] RETURNS [reject: BOOL Ź FALSE] ~ { msg Ź why; result Ź $Failure; }; DoOp: PROC ~ { RemoveArgument: PROC [key: ROPE] ~ { once: BOOL Ź FALSE; tmp: CommanderOps.ArgumentVector ~ CommanderOps.Parse[cmd]; cmd.commandLine Ź NIL; FOR i: INTEGER IN [1..tmp.argc) DO -- args[0] is command name IF NOT once AND Eq[tmp[i], key] THEN once Ź TRUE ELSE cmd.commandLine Ź Rope.Cat[cmd.commandLine, " ", tmp[i]] ENDLOOP; }; cmd.command Ź funct; RemoveArgument["3d"]; RemoveArgument[funct]; [result, msg] Ź op.proc[cmd]; }; FunctArg: PROC RETURNS [r: ROPE Ź NIL] ~ { FOR i: INT IN [0..args.argc-1) DO IF Eq[args[i], funct] THEN RETURN[args[i+1]]; ENDLOOP; }; op: Op; IF ops # NIL THEN FOR i: INTEGER IN [0..ops.length) DO IF Eq[funct, ops[i].name] THEN {op Ź ops[i]; EXIT}; ENDLOOP; SELECT TRUE FROM Eq[funct, "?"] => PrintOps[cmd]; op.proc = NIL => RETURN[$Failure, Rope.Concat["no such funct: ", funct]]; Eq[FunctArg[], "?"] AND NOT Eq[op.name, "UseCG6"] => RETURN[$Failure, Rope.Concat["Usage:", op.usage]]; ENDCASE => [] Ź PreDebug.Protect[DoOp, Reject]; } ELSE { name: ROPE Ź Rope.Substr[cmd.command, Rope.FindBackward[cmd.command, "/"]+1]; IF shape # NIL THEN name Ź Rope.Concat["3d ", shape]; t Ź G3dTool.MakeTool[name:name, nViews:nViews, noOpen:TRUE, useArcBalls:arcBalls]; IF shape # NIL THEN { s: ROPE Ź FileNames.ResolveRelativePath[shape]; IF (msg Ź G3dTool.ReadFromShapeFile[t, s, TRUE]) # NIL THEN GOTO Failure; G3dTool.GetShape[t, FileNames.GetShortName[shape]].selected Ź TRUE; }; t.cmd Ź cmd; IF scene # NIL AND NOT DoScene[scene, cmd, t] THEN RETURN[$Failure]; ViewerOps.OpenIcon[t.outer]; }; EXITS Failure => { IF t # NIL THEN ViewerOps.DestroyViewer[t.outer]; result Ź $Failure; }; }; }; DoScene: PROC [sceneFile: ROPE, cmd: Commander.Handle, t: Tool Ź NIL] RETURNS [ok: BOOL Ź TRUE] ~ { ENABLE { FS.Error => {IO.PutF1[cmd.out, "%g\n", IO.rope[error.explanation]]; ok Ź FALSE; CONTINUE}; < {>> <> <> <> <> }; <> op: ROPE Ź PFS.RopeOpen[PFS.PathFromRope[sceneFile]].rope; -- ignore Tioga comments IF t = NIL THEN t Ź G3dTool.MakeTool[ name: Rope.Concat["3dScene ", sceneFile], nViews: 0, useArcBalls: TRUE]; t.cmd Ź cmd; G3dTool.Context3dOk[t]; <> <> <> <> <> G3dTimeTrees.ReportTimeTree[t.timeTree]; G3dTool.PrepareForDrawing[t]; G3dTool.UpdateCamera[t]; }; <> usage: ROPE ~ "Usage: 3d [function] [tool option] no specified function creates a generic 3d tool type '3d ?' to list functions tool options include: -shape -scene -nViews -noArcBalls [default false or as given by user profile] -useArcBalls [default true or as given by user profile]"; Commander.Register["3d", ToolCmd, Rope.Concat["\n", usage]]; END. .. <> <> <> <> <> <> < {msg _ reason; GOTO Quit}]];>> <<>> sceneUsage: ROPE ~ "Usage: 3dScene Parse the scene file."; SceneCmd: Commander.CommandProc ~ { argv: CommanderOps.ArgumentVector Ź CommanderOps.Parse[cmd]; SELECT TRUE FROM argv.argc # 2 => RETURN[$Failure, sceneUsage]; Rope.Equal[argv[1], "?"] => RETURN[msg: sceneUsage]; ENDCASE => [] Ź DoScene[argv[1], cmd]; }; <> <> <> <<[mesa, noLog] _ Args.ArgsGet[cmd, "[s-noLog%b" !>> < {msg _ reason; GOTO Bad}];>> <> <> <<[] _ G3dInterpret.MakeInterpretTool[mesa.rope, left, NOT noLog.bool>> < {msg _ reason; GOTO Bad}];>> < RETURN[$Failure, msg];>> <<};>> <<>> interpretUsage: ROPE ~ "Usage: 3dInterpret [-noLog] Interpret the mesa file."; <> <> <> <>