DIRECTORY Atom, CedarProcess, Commander, CommandTool, Convert, EditedStream, FileNames, FS, IconRegistry, IO, List, Menus, MessageWindow, Process, ReadEvalPrint, Rope, SymTab, SystemVersion, TextReplace, TiogaOps, UserProfile, ViewerClasses, ViewerEvents, ViewerIO, ViewerOps,ViewerTools;

ExecHacks: CEDAR PROGRAM
IMPORTS Atom, CedarProcess, Commander, CommandTool, Convert, EditedStream, FileNames, FS, IconRegistry, IO, List, Menus, MessageWindow, Process, Rope, SymTab, SystemVersion, TextReplace, TiogaOps, UserProfile, ViewerEvents, ViewerIO, ViewerOps, ViewerTools
= BEGIN

ROPE: TYPE = Rope.ROPE;
RopeList: TYPE = LIST OF ROPE;

DoItButtonData: TYPE ~ RECORD [cmd: Commander.Handle, name: ROPE];

doitButtonNames: LIST OF ROPE;
redoButtonName: ROPE;
redoEnabled: BOOL _ TRUE;
saveAndDoItEnabled: BOOL _ TRUE;

historyKey: ATOM = $ExecHacksCommandHistory;

NoteProfile: UserProfile.ProfileChangedProc= {
doitButtonNames _ UserProfile.ListOfTokens["ExecHacks.DoitButtonName", LIST["DoIt"]];
redoButtonName _ UserProfile.Token["ExecHacks.RedoButtonName", "Redo"];
saveAndDoItEnabled _ UserProfile.Boolean["ExecHacks.SaveAndDoIt", TRUE];
};

Blink: PROC = {ViewerOps.BlinkDisplay[]};

DoIt: Menus.MenuProc = {
sel: ROPE _ ViewerTools.GetSelectionContents[];
doitButtonData: REF DoItButtonData ~ NARROW[clientData];
IF Rope.Size[sel] <= 1 THEN {
selViewer: ViewerClasses.Viewer _ ViewerTools.GetSelectedViewer[];
IF selViewer = NIL THEN {Blink[]; RETURN};
sel _ selViewer.name;
};
InternalDoIt[exec: NARROW[parent], sel: sel, cmd: doitButtonData.cmd, name: doitButtonData.name];
};

dummyRope: ROPE ~ "ESN, December 23, 1986 3:02:26 pm PST";
InternalDoIt: PROC [exec: ViewerClasses.Viewer, cmd: Commander.Handle, sel, name: ROPE] = {
function: ROPE;
{
fullFName, ext: ROPE; cp: FS.ComponentPositions; dirOmitted: BOOLEAN;
UPExecHacksLine: PROC [key: ROPE] RETURNS [ROPE] ~ {
upKey: ROPE ~ IF ext.Length[] > 0 THEN IO.PutFR[format: "ExecHacks.%g.%g", v1: [rope[key]], v2: [rope[ext]]] ELSE IO.PutFR[format: "ExecHacks.%gNoExtension", v1: [rope[key]]];
RETURN [UserProfile.Line[key: upKey, default: dummyRope]];
};
FoundIt: PROC [rope: ROPE] RETURNS [BOOL] ~ {
function _ rope;
RETURN [function#dummyRope];
};
DefaultCommands: PROC [ext: ROPE] RETURNS [default: ROPE] ~ {
default _ SELECT TRUE FROM
ext.IsEmpty[] => "RCompile <base>",
ext.Equal["mesa", FALSE], ext.Equal["cedar", FALSE] => "RCompile <base>",
ext.Equal["config", FALSE] => "Bind <base>",
ext.Equal["cm", FALSE], ext.Equal["load", FALSE] => "<base>",
ext.Equal["df", FALSE] => "SModel <base>;\nVerifyDF <base>",
ext.Equal["bcd", FALSE] => "Run <base>",
ext.Equal["profile", FALSE] => IO.PutFR["Copy [User]<<base>>%g.%g> _ ///<base>.profile", IO.card[SystemVersion.release.major], IO.card[SystemVersion.release.minor]],
ENDCASE => "Blink";
};
[fullFName, cp, dirOmitted] _ FS.ExpandName[sel ! FS.Error => CONTINUE];
IF fullFName = NIL THEN {Blink[]; RETURN};
ext _ Rope.Substr[fullFName, cp.ext.start, cp.ext.length];
SELECT TRUE FROM	--When FoundIt returns TRUE, function is set appropriately
FoundIt[UPExecHacksLine[name]] => {};	--First check under the button name
FoundIt[UPExecHacksLine["For"]] => {};	--Next check under "For"
FoundIt[DefaultCommands[ext]] => {};
ENDCASE => ERROR;
IF function.Equal["Blink"] THEN {Blink[]; RETURN};
function _
TextReplace.RopeMapFromPairs[LIST[
["<server>", fullFName.Substr[cp.server.start, cp.server.length], TRUE],
["<dir>", fullFName.Substr[cp.dir.start, cp.dir.length], TRUE],
["<subDirs>", fullFName.Substr[cp.subDirs.start, cp.subDirs.length], TRUE],
["<directory>", fullFName.Substr[0, cp.base.start], TRUE],
["<base>", fullFName.Substr[cp.base.start, cp.base.length], TRUE],
["<ext>", ext, TRUE],
["<short>", fullFName.Substr[cp.base.start, cp.ext.start + cp.ext.length - cp.base.start], TRUE],
["<ver>", fullFName.Substr[cp.ver.start, cp.ver.length], TRUE],
["<fileName>", fullFName, TRUE]
]].Apply[function].Concat["\n"];
};
ViewerTools.SetSelection[exec, NIL];
BackupToPrompt[cmd];
exec.class.notify[exec, LIST[function]];
};

SaveAndDoIt: TiogaOps.CommandProc = {
fileName: ROPE _ viewer.name;
directory: ROPE _ FileNames.Directory[fileName];
commandToolName: ROPE _ Rope.Cat["CommandTool: WD = ", directory];
exec: ViewerClasses.Viewer ~ ViewerOps.FindViewer[commandToolName];
rep: ReadEvalPrint.Handle;
cmd: Commander.Handle;
IF NOT saveAndDoItEnabled THEN RETURN;
IF exec=NIL THEN {MessageWindow.Append["SaveAndDoIt: Can't do it, no CommandTool for this directory", TRUE]; MessageWindow.Blink[]; RETURN};
rep _ NARROW [Atom.GetPropFromList[exec.props, $ReadEvalPrint]];
cmd _ NARROW [rep.clientData];
Process.Yield[];
[] _ CedarProcess.Fork[SaveAndDoItProcess, NEW [SaveAndDoItProcessDataRec _ [viewer: viewer, exec: exec, sel: fileName, cmd: cmd]]];
};

SaveAndDoItProcessData: TYPE = REF SaveAndDoItProcessDataRec;
SaveAndDoItProcessDataRec: TYPE = RECORD [
viewer, exec: ViewerClasses.Viewer,
cmd: Commander.Handle,
sel: ROPE
];

SaveAndDoItProcess: CedarProcess.ForkableProc = {
saveData: SaveAndDoItProcessData _ NARROW [data];
Process.Yield[];
Process.Pause[Process.MsecToTicks[200]]; -- to let the time for the forked save process set the saveInProgress flag
WHILE saveData.viewer.saveInProgress DO
Process.Yield[];
Process.Pause[Process.MsecToTicks[400]]; -- please save ...
MessageWindow.Append["SaveAndDoIt: waiting for save to complete ... ", TRUE]; 
ENDLOOP;
Process.Yield[];
MessageWindow.Append["SaveAndDoIt: save done; doing it !", TRUE]; 
Process.Yield[];
InternalDoIt[exec: saveData.exec, sel: saveData.sel, cmd: saveData.cmd, name: doitButtonNames.first];
};

Redo: Menus.MenuProc = {
ScanAndStuff: PROC = {
exec: ViewerClasses.Viewer ~ NARROW[parent];
cmdList, cmdListTail: LIST OF REF ANY _ NIL;
SELECT mouseButton FROM
red, yellow => {
tsRope: ROPE;
start, end: INT;
startLoc, endLoc: TiogaOps.Location;
selectionViewer: ViewerClasses.Viewer;
[selectionViewer, startLoc, endLoc, , , ] _ TiogaOps.GetSelection[];
IF NOT selectionViewer = exec THEN { --force selection into command window
ViewerTools.SetSelection[exec, NIL];
[selectionViewer, startLoc, endLoc, , , ] _ TiogaOps.GetSelection[];
};
tsRope _ TiogaOps.GetRope[startLoc.node];
start _ startLoc.where;
IF Rope.Find[tsRope, "%", start] = -1 THEN {
start _ start-1;
WHILE Rope.Fetch[tsRope, start]#'% DO start _ start-1; ENDLOOP;
start _ start-1;
};
WHILE Rope.Fetch[tsRope, start]#'% DO start _ start-1; ENDLOOP; --back up to "%" preceeding command of interest
WHILE start+2 < endLoc.where DO
rope: ROPE;
end _ start _ start+2;
WHILE Rope.Fetch[tsRope, end]#15C DO end _ end+1; ENDLOOP; --forward to CR
rope _ Rope.Substr[tsRope, start, end-start+1];
IF cmdListTail = NIL THEN
cmdList _ cmdListTail _ LIST[rope]
ELSE
cmdListTail _ cmdListTail.rest _ LIST[rope];
start _ end;
WHILE Rope.Fetch[tsRope, start]#'% DO start _ start+1; ENDLOOP;
ENDLOOP;
};
blue => {
cmdList _ LIST["History -d 10\n"];
};
ENDCASE => ERROR;
ViewerTools.SetSelection[exec, NIL];
BackupToPrompt[cmd];
exec.class.notify[exec, cmdList];
};
cmd: Commander.Handle ~ NARROW[clientData];
ScanAndStuff[! ANY => {Blink[]; CONTINUE}];
};

UpdateHistoryProc: Commander.CommandProc = {
history: RopeList _ NARROW[List.Assoc[aList: cmd.propertyList, key: historyKey]];
IF List.Assoc[aList: cmd.propertyList, key: $ParentCommander] # NIL THEN RETURN;	--this filters out command files, but not "subcommands"
history _ CONS[cmd.command.Cat[cmd.commandLine], history];
cmd.propertyList _ List.PutAssoc[
aList: cmd.propertyList,
key: historyKey,
val: history
];
};

RedoCmd: Commander.CommandProc = {
history: RopeList _ NARROW[List.Assoc[aList: cmd.propertyList, key: historyKey]];
cls: IO.STREAM = IO.RIS[cmd.commandLine];
trash: INT = cls.SkipWhitespace[];
key: ROPE = IF cls.EndOf[] THEN NIL ELSE cls.GetTokenRope[IO.IDProc].token;
[] _ cls.SkipWhitespace[];
IF NOT cls.EndOf[] THEN GOTO GiveUsage;
cls.Close[];
IF history # NIL THEN history _ history.rest;	--strip this redo itself
FOR hl: RopeList _ history, hl.rest WHILE hl # NIL DO
cr: ROPE = hl.first;
IF key = NIL OR IsCmdPrefix[key, cr] THEN {
result _ CommandTool.DoCommand[cr, cmd];
EXIT;
};
REPEAT
FINISHED => RETURN [$Failure, IO.PutFR["No command in my history begins with \"%q\"", [rope[key]]]];
ENDLOOP;
EXITS
GiveUsage => {result _ $Failure; msg _ "Usage: Redo commandNamePrefix"}
};

IsCmdPrefix: PROC [prefix, command: ROPE] RETURNS [is: BOOL] = {
pLen: INT = prefix.Length[];
cLen: INT = command.Length[];
c: CHAR;
first, afterLast: INT _ 0;
FOR afterLast _ 0, afterLast+1
WHILE afterLast < cLen AND (c _ command.Fetch[afterLast]) # '  DO
SELECT c FROM
'/, '> => first _ afterLast+1;
ENDCASE;
ENDLOOP;
is _ pLen <= afterLast-first AND prefix.Equal[command.Substr[start: first, len: pLen], FALSE];
};

HistoryCmd: Commander.CommandProc = {
to: IO.STREAM = cmd.out;
prompt: ROPE = NARROW[List.Assoc[key: $Prompt, aList: cmd.propertyList]];
history: RopeList _ NARROW[List.Assoc[aList: cmd.propertyList, key: historyKey]];
toGive: RopeList _ NIL;
cls: IO.STREAM = IO.RIS[cmd.commandLine];
includeDuplicates: BOOL _ TRUE;
includePrompt: BOOL _ TRUE;
n: INT _ 10;
seen: SymTab.Ref;
FOR i: INT _ cls.SkipWhitespace[], cls.SkipWhitespace[] WHILE NOT cls.EndOf[] DO
toke: ROPE = cls.GetTokenRope[IO.IDProc].token;
SELECT TRUE FROM
toke.Equal["-%"] => includePrompt _ FALSE;
toke.Equal["+%"] => includePrompt _ TRUE;
toke.Equal["-d"] => includeDuplicates _ FALSE;
toke.Equal["+d"] => includeDuplicates _ TRUE;
ENDCASE => n _ Convert.IntFromRope[toke !Convert.Error => GOTO GiveUsage];
ENDLOOP;
cls.Close[];
IF NOT includeDuplicates THEN seen _ SymTab.Create[case: FALSE];
WHILE n > 0 DO
IF history = NIL THEN EXIT;
IF includeDuplicates OR NOT seen.Fetch[history.first].found THEN {
toGive _ CONS[history.first, toGive];
IF NOT includeDuplicates THEN [] _ seen.Insert[history.first, $seen];
n _ n - 1;
};
history _ history.rest;
ENDLOOP;
FOR toGive _ toGive, toGive.rest WHILE toGive # NIL DO
IF includePrompt THEN to.PutF[prompt, [rope["b"]], [rope["B"]]];
to.PutRope[toGive.first];
ENDLOOP;
result _ $OK;
EXITS
GiveUsage => {result _ $Failure; msg _ "Usage: History [-d] [-%] [number]"}
};

Greet: PROC [v: ViewerClasses.Viewer, cmd: Commander.Handle, paint: BOOL] = {
Add: PROC [me: Menus.MenuEntry, name: ROPE] = {
old: Menus.MenuEntry = Menus.FindEntry[v.menu, name];
IF old = NIL
THEN Menus.AppendMenuEntry[v.menu, me]
ELSE Menus.ReplaceMenuEntry[v.menu, old, me];
};
IF v = NIL THEN RETURN;
IF redoEnabled AND cmd # NIL THEN {
cmd.propertyList _ CommandTool.RemoveProcFromList[aList: cmd.propertyList, listKey: $Before, proc: updateHistory];
cmd.propertyList _ CommandTool.AddProcToList[aList: cmd.propertyList, listKey: $Before, proc: updateHistory];
};
FOR eachButton: LIST OF ROPE _ doitButtonNames, eachButton.rest UNTIL eachButton=NIL DO
name: ROPE ~ eachButton.first;
Add[Menus.CreateEntry[name: name, proc: DoIt, fork: FALSE, clientData: NEW[DoItButtonData _ [cmd: cmd, name: name]]], name];
ENDLOOP;
Add[Menus.CreateEntry[name: redoButtonName, proc: Redo, fork: FALSE, clientData: cmd], redoButtonName];
IF paint THEN ViewerOps.PaintViewer[v, menu];
};

updateHistory: Commander.CommandProcHandle _ NEW [Commander.CommandProcObject _ [proc: UpdateHistoryProc]];


BackupToPrompt: PROC [cmd: Commander.Handle] ={
inStream: IO.STREAM _ GetReadEvalPrint[cmd].in;
bufferContents: REF TEXT _ ViewerIO.GetBuffer[inStream];
IF bufferContents # NIL AND bufferContents.length > 0 AND bufferContents[bufferContents.length - 1] # '\n THEN {
FOR n: NAT DECREASING IN [0..bufferContents.length) DO
IF bufferContents[n] = '\n THEN {
EditedStream.UnAppendBufferChars[
stream: inStream, nChars: bufferContents.length - n - 1];
EXIT;
}
REPEAT
FINISHED => EditedStream.UnAppendBufferChars[stream: inStream, nChars: LAST[NAT]];
ENDLOOP;
};
};

GetReadEvalPrint: PROC [cmd: Commander.Handle] RETURNS [ReadEvalPrint.Handle] = {
DO
WITH CommandTool.GetProp[cmd, $ReadEvalPrintHandle] SELECT FROM
reph: ReadEvalPrint.Handle =>
IF reph # NIL AND reph.viewer # NIL THEN RETURN [reph];
ENDCASE;
WITH CommandTool.GetProp[cmd, $ParentCommander] SELECT FROM
next: Commander.Handle => {cmd _ next; LOOP;};
ENDCASE;
RETURN [NIL];
ENDLOOP;
};

AttachMenuItemsToExecs: PROC = {
PerViewer: ViewerOps.EnumProc = {
Greet[v, NIL, TRUE];
};
ViewerOps.EnumerateViewers[PerViewer];
};

ExecHacksCmd: Commander.CommandProc ~ {
handle: ReadEvalPrint.Handle _ NARROW[
Commander.GetProperty[$ReadEvalPrintHandle, cmd.propertyList]];
Greet[handle.viewer, cmd, TRUE];
};

AlterIcon: ViewerEvents.EventProc = {
IF viewer.parent=NIL AND viewer.file#NIL THEN {
Icon: PROC [r1, r2: ROPE _ NIL] RETURNS [found: BOOL] ~ {
iconName _ UserProfile.Token[key: Rope.Cat["ExecHacks.", r1, r2]];
RETURN [iconName#NIL]
};
cp: FS.ComponentPositions;
fullFName, extension, iconName: ROPE;
[cp: cp, fullFName: fullFName] _ FS.ExpandName[name: viewer.file];
extension _ Rope.Substr[base: fullFName, start: cp.ext.start, len: cp.ext.length];
SELECT TRUE FROM
viewer.newVersion AND Icon["DirtyIcon.", extension] => {};
Icon["Icon.", extension] => {};
viewer.newVersion AND (iconName _ IconRegistry.IsRegistered[Rope.Cat["Dirty", extension]].name)#NIL => {};
(iconName _ IconRegistry.IsRegistered[extension].name)#NIL => {};
viewer.newVersion AND Icon["DefaultDirtyIcon"] => {};
Icon["DefaultIcon"] => {};
ENDCASE;
IF iconName#NIL THEN viewer.icon _ IconRegistry.GetIcon[iconName: iconName, default: viewer.icon];
};
};
UserProfile.CallWhenProfileChanges[NoteProfile];

[] _ ViewerEvents.RegisterEventProc[proc: AlterIcon, event: close, before: TRUE];
[] _ ViewerEvents.RegisterEventProc[proc: AlterIcon, event: save, before: FALSE];
[] _ ViewerEvents.RegisterEventProc[proc: AlterIcon, event: edit, before: FALSE];

TiogaOps.RegisterCommand[name: $BlueSave, proc: SaveAndDoIt, before: FALSE];
Commander.Register[key: "///Commands/ExecHacks", proc: ExecHacksCmd, doc: "registers CommandTool menu buttons for compiling programs and redoing the last command."];
Commander.Register[key: "///Commands/Redo", proc: RedoCmd, doc: "Redo <string>  redoes the last command that begins with string"];
Commander.Register[key: "///Commands/History", proc: HistoryCmd, doc: "History <option>* <n>  lists the last n commands in this CommandTool viewer\n  -% 	omit % prompt\n  +%	include % prompt\n  -d	remove duplicate commands\n  +d	include duplicates"];


END.
ϊExecHacks.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
McGregor on August 17, 1983 5:09 pm
Michael Plass on March 12, 1985 12:53:14 pm PST
Tim Diebert: July 1, 1985 9:27:11 am PDT
Michael Plass, July 23, 1985 2:41:28 pm PDT
Last Edited by: Gasbarro March 11, 1986 11:30:15 am PST
Mike Spreitzer December 9, 1986 6:10:55 pm PST
Eric Nickell, September 30, 1986 3:46:13 pm PDT
Bertrand Serlet August 31, 1986 9:35:24 pm PDT
Spreitzer, January 21, 1986 7:03:22 pm PST
Rick Beach, January 2, 1987 3:16:07 pm PST

[parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]
Does the action wanted by name in the CommandTool cmd (associated with the viewer exec)
Execute all the commands found within the selection
end of typescript, backup to before %
Returns the enclosing ReadEvalPrint.Handle (NIL if no such handle).
[viewer: ViewerClasses.Viewer, event: ViewerEvents.ViewerEvent, before: BOOL] RETURNS [abort: BOOL _ FALSE]
[] _ ViewerEvents.RegisterEventProc[DoMenu, create, $Typescript, FALSE];

CHANGE LOG
Rick Beach, June 14, 1986 3:03:45 pm PDT
cosmetic changes to procedure types and names.
changes to: RedoCmd added capability to execute all commands within selection
Κi˜
codeš
œ™Kšœ
Οm
œ7™BKš
œ#™#K™/K™(K™+K™7K™.K™/K™.K™*K™*—K™KšΟk	œOžœžœ΄
˜ K˜KšΠln	œžœ
ž˜KšžœOžœžœ–
˜€šœž˜K˜Kšžœžœžœ
˜Kš	œ
žœžœ
žœ
žœ
˜K˜Kšœžœžœžœ˜BK˜Kšœžœ
žœ
žœ
˜Kšœžœ
˜Kšœ
žœžœ
˜Kšœžœžœ
˜ K˜Kšœžœ˜,K˜šΟnœ#˜.K•StartOfExpansion,[key: 
ROPE, default: 
LIST OF ROPE _ NIL]šœGžœ
˜UKš
œG˜GKšœBžœ˜HK˜—K˜š œžœ˜)K˜—–‚
 -- [parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]š œ˜Kš
Πck~™~Kšœžœ&˜/Kšœžœžœ
˜8šžœžœ˜Kš
œB˜BKšžœ
žœ
žœžœ˜*Kš
œ˜Kš
œ˜—KšœžœH˜aKš
œ˜K˜—Kš
œW™WKšœžœ+˜:š œžœ@žœ˜[Kšœ
žœ
˜š
œ
˜
Kšœžœžœ!žœ
˜Eš
 œžœžœžœžœ˜4K–
[format: 
ROPE _ NIL, v1: 
IO.Value _ [null[]], v2: 
IO.Value _ [null[]], v3: 
IO.Value _ [null[]], v4: 
IO.Value _ [null[]], v5: 
IO.Value _ [null[]]]šœžœžœžœ
žœ,Οtœ’œžœ
žœ4’œ˜―
K–$[key: 
ROPE, default: 
ROPE _ NIL]šžœ4˜:K˜—š
 œžœžœžœžœ˜-K˜Kšžœ˜K˜—š
 œžœžœžœžœ˜=šœ
žœ
žœ
ž˜Kš
œ#˜#Kšœžœžœ˜IKšœžœ˜,Kšœžœžœ˜=Kšœžœ'˜<Kšœžœ˜(Kš	œžœžœ8žœ$žœ$˜₯
Kšžœ˜—K˜—Kšœžœžœ
žœ˜HKšžœ
žœ
žœžœ˜*Kš
œ:˜:šžœ
žœ
žœ
Οc:˜KKšœ&£#˜IKšœ'£˜?K˜$Kšžœžœ
˜—Kšžœžœžœ˜2š
œ
˜
šœžœ
˜"KšœBžœ˜HKšœ9žœ˜?KšœEžœ˜KKšœ4žœ˜:Kšœ<žœ˜BKšœžœ˜Kšœ[žœ˜aKšœ9žœ˜?Kšœžœ
˜—Kš
œ ˜ —K˜—Kšœžœ˜$K˜Kšœžœ˜(K˜K˜—š œ˜%Kšœ
žœ˜Kšœžœ!˜0Kšœžœ-˜BKš
œC˜CKš
œ˜Kš
œ˜Kšžœ
žœžœ
žœ
˜&Kš
žœžœ
žœVžœžœ˜Œ
Kšœžœ4˜@Kšœžœ˜Kš
œ˜Kšœ+žœV˜„
K˜K˜—Kšœžœžœ˜=šœžœžœ˜*Kš
œ#˜#Kš
œ˜Kšœž˜	K˜K˜—š œ˜1Kšœ#žœ˜1Kš
œ˜Kšœ)£J˜sšžœ ž˜'Kš
œ˜Kšœ)£˜;KšœGžœ˜NKšžœ
˜—Kš
œ˜Kšœ;žœ˜BKš
œ˜Kš
œe˜eK˜K˜—š œ˜š œžœ˜Kšœžœ	˜,Kšœžœ
žœ
žœ
žœžœ
˜,šžœ
ž˜˜Kš
œ3™3Kšœžœ
˜
Kšœžœ
˜J˜$Jš
œ&˜&Kš
œD˜Dšžœ
žœžœ£%˜JJšœžœ˜$Kš
œD˜DJ˜—Kš
œ)˜)Kš
œ˜šžœ$žœ˜,Kš
œ%™%Kš
œ˜Kšžœžœžœ
˜?Kš
œ˜K˜—Kšžœžœžœ£/˜ošžœž˜Kšœžœ
˜Kš
œ˜Kšžœžœžœ£˜JKš
œ/˜/šžœžœ
ž˜Kšœžœ˜"—š
ž˜Kšœ!žœ˜,—Kš
œ˜Kšžœžœžœ
˜?Kšžœ
˜—K˜—˜	Kšœ
žœ˜"K˜—Kšžœžœ
˜—Kšœžœ˜$K˜Kš
œ!˜!Kš
œ˜—Kšœžœ
˜+Kšœžœžœ˜+Kš
œ˜K˜—š œ˜,Kšœžœ7˜QKš	žœ>žœ
žœ
žœ£7˜ˆ
Kšœ
žœ,˜:š
œ!˜!Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜—K˜š œ˜"Kšœžœ7˜QKš	œžœ
žœžœ
žœ˜)Kšœžœ˜"Kš
œžœžœ
žœ
žœ
žœžœ˜KK˜Kšžœ
žœ
žœ
žœ˜'K˜Kšžœžœ
žœ£˜Fšžœ!žœžœ
ž˜5Kšœžœ˜šžœžœ
žœžœ˜+Kš
œ(˜(Kšžœ
˜K˜—š
ž˜KšžœžœžœD˜d—Kšžœ
˜—š
ž˜Kš
œG˜G—K˜—K˜š
 œžœžœžœžœ˜@Kšœžœ˜Kšœžœ˜Kšœžœ
˜Kšœžœ˜šžœ˜Kšžœžœ%ž˜Ašžœž˜
Kš
œ˜Kšžœ
˜—Kšžœ
˜—Kšœžœ7žœ˜^K˜—K˜š 
œ˜%Kšœžœ
žœ˜Kšœžœžœ4˜IKšœžœ7˜QKšœžœ
˜Kš	œžœ
žœžœ
žœ˜)Kšœžœžœ
˜Kšœžœžœ
˜Kšœžœ˜Kš
œ˜š	žœžœ.žœ
žœ
ž˜PKšœžœžœ˜/šžœ
žœ
ž˜Kšœ$žœ
˜*Kšœ$žœ
˜)Kšœ(žœ
˜.Kšœ(žœ
˜-Kšžœ3žœ˜J—Kšžœ
˜—K˜Kšžœ
žœžœžœ˜@šžœž˜Kšžœžœ
žœ
žœ
˜šžœžœ
žœ!žœ˜BKšœ	žœ˜%Kšžœ
žœžœ(˜EK˜
K˜—K˜Kšžœ
˜—šžœžœ
žœ
ž˜6Kšžœžœ+˜@K˜Kšžœ
˜—K˜
š
ž˜K˜K—K˜—K˜š œžœ9žœ˜Mš œžœžœ˜/Kš
œ5˜5šžœž˜Kšžœ"˜&Kšžœ)˜-—K˜—Kšžœžœ
žœ
žœ
˜šžœ
žœžœ
žœ˜#Kš
œr˜rKš
œm˜mK˜—š
žœ
žœ
žœ
žœ$žœžœ
ž˜WKšœžœ˜Kšœ4žœžœ2˜|Kšžœ
˜—Kšœ>žœ$˜gKšžœžœ ˜-K˜—K˜Kšœ-žœ;˜kK˜K˜š œžœ˜/Kšœ
žœ
žœ˜/Kšœžœ
žœ ˜8š
žœžœ
žœžœ1žœ˜pš	žœžœ
ž
œ
žœž˜6šžœžœ˜!š
œ!˜!Kš
œ9˜9—Kšžœ
˜K˜
—Kš
ž˜Kšžœ?žœ
žœ˜RKšžœ
˜—K˜—K˜K˜—š œžœžœ˜QKšœ,žœ™Cš
ž˜šžœ0žœ
ž˜?š
œ˜Kšžœžœ
žœžœ
žœ
žœ˜7—Kšžœ
˜—šžœ,žœ
ž˜;Kšœ'žœ˜.Kšžœ
˜—Kšžœžœ˜
Kšžœ
˜—K˜K˜—š œžœ˜ š 	œ˜!Kšœ	žœžœ˜Kš
œ˜—Kš
œ&˜&Kš
œ˜—K˜š œ˜'KšœžœA˜fKšœžœ˜ K˜—K˜–o -- [viewer: ViewerClasses.Viewer, event: ViewerEvents.ViewerEvent, before: BOOL] RETURNS [abort: BOOL _ FALSE]šΟb	œ˜%Kš
‘k™kš
žœžœ
žœ
žœ
žœ˜/š œžœ
žœžœžœ	žœ˜9K–$[key: 
ROPE, default: 
ROPE _ NIL]˜BKšžœžœ
˜K˜—Kšœžœ˜Kšœ žœ
˜%K–"[name: 
ROPE, wDir: 
ROPE _ NIL]šœ!žœ˜BK–9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]˜Ršžœ
žœ
ž˜K–$[key: 
ROPE, default: 
ROPE _ NIL]šœžœ%˜:K˜K–U[iconName: 
ROPE _ NIL, fileName: 
ROPE _ NIL, index: 
CARDINAL _ 177777B (65535)]šœžœKžœ˜jK–U[iconName: 
ROPE _ NIL, fileName: 
ROPE _ NIL, index: 
CARDINAL _ 177777B (65535)]šœ7žœ˜AKšœžœ ˜5K˜Kšžœ
˜—K–:[iconName: 
ROPE, default: 
Icons.IconFlavor _ 177777B?]šžœ
žœ
žœN˜bKš
œ˜—K˜—Kš
œ0˜0K˜KšœAžœ™HK–s[proc: 
ViewerEvents.EventProc, event: 
ViewerEvents.ViewerEvent, filter: 
REF ANY _ NIL, before: 
BOOL _ TRUE]šœKžœ˜QK–s[proc: 
ViewerEvents.EventProc, event: 
ViewerEvents.ViewerEvent, filter: 
REF ANY _ NIL, before: 
BOOL _ TRUE]šœJžœ˜QK–s[proc: 
ViewerEvents.EventProc, event: 
ViewerEvents.ViewerEvent, filter: 
REF ANY _ NIL, before: 
BOOL _ TRUE]šœJžœ˜QK˜KšœEžœ˜LK˜₯
K˜ƒ
K˜ϋ
—K˜K˜Kšžœ
˜K™Kšžœ
ž™
™(K™.KšœΟrœ:™M——…—7πQS