DIRECTORY
Buttons USING [ButtonProc],
EditToolBuilder USING [BadNumber, BuildButton, BuildDataFieldPair, ConvertList, DataFieldButton, GetDataNode, GetInt, HGap, VGap],
EditToolPrivate USING [CheckPSel, DoButton, Info, mainToolInfo, Register, TrySearch],
FS USING [Error, ExpandName, nullOpenFile, Open, OpenFile, StreamFromOpenFile],
IO USING [Close, EndOfStream, GetChar, GetLength, GetRefAny, RIS, STREAM],
List USING [Append, Nconc1],
MessageWindow USING [Append, Blink],
Rope USING [Cat, Concat, Fetch, FromProc, ROPE, Size, Substr],
TEditDocument USING [Selection],
TEditHistory USING [CurrentEventNumber, GetRepeatList, SliceSize],
TEditInput USING [CloseEvent, CommandProc, CurrentEvent, GetCommand, GetRepeatSequence, Interpret, SetCommand],
TEditOps USING [GetSelData, SetTextContents],
TEditProfile USING [GetToken],
TEditSelection USING [LockSel, UnlockSel],
TextEdit USING [GetRope],
TiogaMenuOps USING [CloseAndNewViewer, Empty, Load, New],
TiogaOps USING [FirstChild, SelectDocument, SetSelection, ViewerDoc],
TiogaOpsDefs USING [Ref],
TypeScript USING [IsATypeScript],
UndoEvent USING [Ref, Reset],
ViewerClasses USING [Viewer],
ViewerOps USING [DestroyViewer, SaveViewer];
EditToolOpsImpl: CEDAR PROGRAM
IMPORTS EditToolPrivate, EditToolBuilder, FS, IO, List, MessageWindow, Rope, TEditInput, TEditOps, TextEdit, TEditHistory, TEditSelection, TiogaMenuOps, TiogaOps, TEditProfile, TypeScript, UndoEvent, ViewerOps
EXPORTS EditToolPrivate
= { OPEN ViewerClasses, EditToolBuilder, EditToolPrivate;

ROPE: TYPE = Rope.ROPE;


Flash: PROC[message, message2, message3: ROPE _ NIL] = {
MessageWindow.Append[message, TRUE];
IF message2#NIL THEN MessageWindow.Append[message2];
IF message3#NIL THEN MessageWindow.Append[message3];
MessageWindow.Blink[];
};

opsAtom: LIST OF REF = Register[$Operations,OpsArgOp];
clearOpsAtom: LIST OF REF = Register[$ClearOperations,ClearOpsArgOp];

OpsButton: Buttons.ButtonProc = {
DoButton[opsAtom,clearOpsAtom, mouseButton=red] };

OpsArgOp: TEditInput.CommandProc = { OpsArg[mainToolInfo] };

OpsArg: PROC [info: Info] = { DataFieldButton[info.opsArg,FALSE] };

ClearOpsArgOp: TEditInput.CommandProc = { ClearOpsArg[mainToolInfo] };

ClearOpsArg: PROC [info: Info] = { DataFieldButton[info.opsArg,TRUE] };

BuildOperationField: PUBLIC PROC [info: Info] = { OPEN info;
[,opsArg] _ BuildDataFieldPair[layout, "Operations:", OpsButton, info, 2] };

GetOps: PUBLIC PROC [info: Info] RETURNS [list: LIST OF REF ANY] = { OPEN IO, info;
rope: ROPE _ TextEdit.GetRope[GetDataNode[opsArg]];
h: IO.STREAM _ IO.RIS[rope];
item: REF ANY _ NIL;
DO
item _ IO.GetRefAny[h ! IO.EndOfStream => { item _ NIL; CONTINUE}];
IF item = NIL THEN EXIT;
list _ List.Nconc1[list, item];
ENDLOOP;
};

BuildFileListEntries: PUBLIC PROC [info: Info] = { OPEN info;
[] _ BuildButton[layout, "DoForEachFile", DoFilesListButton, info, TRUE];
[] _ BuildButton[layout, "SearchEachFile", SearchFilesListButton, info, TRUE];
HGap[layout];
[,filesArg] _ BuildDataFieldPair[layout, "Files:", FilesListButton, info, 1];
VGap[layout];
[,wdirArg] _ BuildDataFieldPair[layout, "Working Directory:", WDirButton, info, 1];
};

filesListAtom: LIST OF REF = Register[$FilesList,FilesListOp];
clearFilesListAtom: LIST OF REF = Register[$ClearFilesList,ClearFilesListOp];

FilesListButton: Buttons.ButtonProc = {
DoButton[filesListAtom,clearFilesListAtom, mouseButton=red] };

FilesListOp: TEditInput.CommandProc = { FilesList[mainToolInfo] };

FilesList: PROC [info: Info] = { DataFieldButton[info.filesArg,FALSE] };

ClearFilesListOp: TEditInput.CommandProc = { ClearFilesList[mainToolInfo] };

ClearFilesList: PROC [info: Info] = { DataFieldButton[info.filesArg,TRUE] };

wDirAtom: LIST OF REF = Register[$WDir,WDirOp];
clearWDirAtom: LIST OF REF = Register[$ClearWDir,ClearWDirOp];

WDirButton: Buttons.ButtonProc = {
DoButton[wDirAtom,clearWDirAtom, mouseButton=red] };

WDirOp: TEditInput.CommandProc = { WDir[mainToolInfo] };

WDir: PROC [info: Info] = { DataFieldButton[info.wdirArg,FALSE] };

ClearWDirOp: TEditInput.CommandProc = { ClearWDir[mainToolInfo] };

ClearWDir: PROC [info: Info] = { DataFieldButton[info.wdirArg,TRUE] };

searchFilesListAtom: LIST OF REF = Register[$SearchEachFile,SearchFilesListOp];

SearchFilesListButton: Buttons.ButtonProc = { DoButton[searchFilesListAtom] };

SearchFilesListOp: TEditInput.CommandProc = { SearchFilesListCom[mainToolInfo] };

SearchFilesListCom: PROC [info: Info] = { DoFilesList[info, FALSE] };

doFilesListAtom: LIST OF REF = Register[$DoForEachFile,DoFilesListOp];

DoFilesListButton: Buttons.ButtonProc = { DoButton[doFilesListAtom] };

DoFilesListOp: TEditInput.CommandProc = { DoFilesListCom[mainToolInfo] };

DoFilesListCom: PROC [info: Info] = { DoFilesList[info, TRUE] };

DoFilesList: PROC [info: Info, do: BOOL] = {
params: LIST OF REF ANY;
pSel: TEditDocument.Selection;
viewer: Viewer;
found: BOOL _ FALSE;
event: UndoEvent.Ref = TEditInput.CurrentEvent[];
fileList: ROPE _ TextEdit.GetRope[GetDataNode[info.filesArg]];
wDir: ROPE _ TextEdit.GetRope[GetDataNode[info.wdirArg]];
GetFilesList: PROC [fileName: ROPE] RETURNS [filesList: ROPE] = {
len: INT;
s: IO.STREAM;
readChar: PROC RETURNS [CHAR] = { RETURN [IO.GetChar[s]] };
file: FS.OpenFile _ FS.nullOpenFile;
file _ FS.Open[name: fileName, wDir: wDir
! FS.Error =>
IF error.code=$unknownFile THEN CONTINUE
ELSE { Flash[error.explanation]; GOTO Quit }
];
IF file=FS.nullOpenFile THEN file _ FS.Open[name: fileName.Concat[".cm"], wDir: wDir
! FS.Error =>
IF error.code=$unknownFile THEN CONTINUE
ELSE { Flash[error.explanation]; GOTO Quit }
];
IF file=FS.nullOpenFile THEN { Flash[fileName, " not found"]; GOTO Quit };
s _ FS.StreamFromOpenFile[file];
len _ IO.GetLength[s];
filesList _ Rope.FromProc[len, readChar];
IO.Close[s];
EXITS Quit => { filesList _ NIL };
};
DoEachInList: PROC [list: ROPE] RETURNS [remainder: ROPE] = {
offset: INT _ 0;
DO -- process each file
filename: ROPE;
IF info.interrupt^ THEN RETURN [Rope.Substr[list, offset]];
[filename, offset] _ TEditProfile.GetToken[list, offset];
IF Rope.Size[filename]=0 THEN RETURN [NIL];
IF Rope.Fetch[filename,0]='@ THEN { -- process list
sub: ROPE = DoEachInList[GetFilesList[Rope.Substr[filename,1]]];
IF sub=NIL THEN LOOP; -- finished the sublist
RETURN [Rope.Cat[sub, " ", Rope.Substr[list, offset]]] };
IF viewer.newVersion THEN viewer _ TiogaMenuOps.CloseAndNewViewer[viewer]
ELSE TiogaMenuOps.Empty[viewer];
[fullFName: filename] _ FS.ExpandName[name: filename, wDir: wDir
! FS.Error => { Flash[error.explanation]; filename _ NIL; CONTINUE }];
IF filename#NIL THEN TiogaMenuOps.Load[viewer, filename];
IF viewer.file#NIL THEN { -- got the file
IF do THEN {
TiogaOps.SelectDocument[viewer];
TEditInput.Interpret[viewer, params];
IF viewer.newVersion THEN ViewerOps.SaveViewer[viewer];
UndoEvent.Reset[event] } -- so we don't fill up VM with trash
ELSE { -- search
node: TiogaOpsDefs.Ref = TiogaOps.FirstChild[TiogaOps.ViewerDoc[viewer]];
TiogaOps.SetSelection[viewer, [node,0], [node,0], point];
IF TrySearch[forwards, info] THEN
found _ info.interrupt^ _ TRUE; -- so will stop after this one
}};
ENDLOOP
};
info.interrupt^ _ FALSE;
IF do AND (params _ GetOps[info])=NIL THEN { Flash["Enter operations."]; RETURN };
IF fileList=NIL THEN { Flash["Enter list of files."]; RETURN };
TEditInput.CloseEvent[];
TEditSelection.LockSel[primary, "DoFilesList"];
pSel _ TEditOps.GetSelData[];
viewer _ IF pSel.viewer#NIL AND pSel.viewer.parent=NIL
AND ~TypeScript.IsATypeScript[pSel.viewer]
THEN IF pSel.viewer.file=NIL THEN pSel.viewer
ELSE TiogaMenuOps.CloseAndNewViewer[pSel.viewer]
ELSE TiogaMenuOps.New[];
TEditOps.SetTextContents[info.filesArg, DoEachInList[fileList]];
TEditSelection.UnlockSel[primary];
IF do OR (~found AND ~viewer.newVersion) THEN ViewerOps.DestroyViewer[viewer];
};

BuildGetAndSetOpsEntries: PUBLIC PROC [info: Info] = { OPEN info;
[] _ BuildButton[layout, "GetLast", DoGetLastOpsButton, info];
[] _ BuildButton[layout, "Do", DoOpsButton, info];
[] _ BuildButton[layout, "Begin", DoBeginButton, info];
[] _ BuildButton[layout, "End", DoEndButton, info];
[] _ BuildButton[layout, "SetCom", DoSetOpsButton, info];
[] _ BuildButton[layout, "GetCom", DoGetOpsButton, info];
HGap[layout];
BuildComNumField[info]; -- "Command number [0..9]:" field
};

doGetLastOpsAtom: LIST OF REF = Register[$DoGetLastOps,DoGetLastOpsOp];

DoGetLastOpsButton: Buttons.ButtonProc = {
DoButton[doGetLastOpsAtom] };

DoGetLastOpsOp: TEditInput.CommandProc = {
DoGetLastOpsCom[mainToolInfo]; RETURN [FALSE] };

DoGetLastOpsCom: PROC [info: Info] = { 
ShowOps[TEditInput.GetRepeatSequence[],info] };

ShowOps: PROC [list: LIST OF REF ANY, info: Info] = {
TEditOps.SetTextContents[info.opsArg, ConvertList[list]] };

doOpsAtom: LIST OF REF = Register[$DoOps,DoOpsOp];

DoOpsButton: Buttons.ButtonProc = {
DoButton[doOpsAtom] };

DoOpsOp: TEditInput.CommandProc = { DoOpsCom[mainToolInfo] };

DoOpsCom: PUBLIC PROC [info: Info] = { 
pSel: TEditDocument.Selection _ TEditOps.GetSelData[];
params: LIST OF REF ANY;
IF ~CheckPSel[pSel] THEN { Flash["Make a selection."]; RETURN };
IF (params _ GetOps[info])=NIL THEN { Flash["Enter operations."]; RETURN };
TEditSelection.LockSel[primary, "DoOpsCom"];
TEditInput.Interpret[pSel.viewer, params];
TEditSelection.UnlockSel[primary] };

SetCom: PROC [num: [0..9], info: Info] = {
list: LIST OF REF ANY _ GetOps[info];
TEditInput.SetCommand[num,list];
};

doSetOpsAtom: LIST OF REF = Register[$DoSetOps,DoSetOpsOp];

DoSetOpsButton: Buttons.ButtonProc = {
DoButton[doSetOpsAtom] };

DoSetOpsOp: TEditInput.CommandProc = { DoSetOpsCom[mainToolInfo] };

DoSetOpsCom: PROC [info: Info] = {
num: INT _ GetInt[info.comArg ! BadNumber => GOTO BadNum];
IF num NOT IN [0..9] THEN GOTO BadNum;
SetCom[num,info];
EXITS BadNum => { Flash["Enter number from 0 to 9 in Command Number field"] }
};

doGetOpsAtom: LIST OF REF = Register[$DoGetOps,DoGetOpsOp];

DoGetOpsButton: Buttons.ButtonProc = {
DoButton[doGetOpsAtom] };

DoGetOpsOp: TEditInput.CommandProc = { DoGetOpsCom[mainToolInfo] };

DoGetOpsCom: PROC [info: Info] = {
num: INT _ GetInt[info.comArg ! BadNumber => GOTO BadNum];
IF num NOT IN [0..9] THEN GOTO BadNum;
ShowOps[TEditInput.GetCommand[num],info];
EXITS BadNum => { Flash["Enter number from 0 to 9 in Command Number field"] }
};

doBeginAtom: LIST OF REF = Register[$DoBegin,DoBeginOp];

DoBeginButton: Buttons.ButtonProc = {
DoButton[doBeginAtom] };

DoBeginOp: TEditInput.CommandProc = { DoBeginCom[mainToolInfo] };

beginEvent: INT _ 0;

DoBeginCom: PROC [info: Info] = {
[] _ TEditInput.GetRepeatSequence[]; -- to make sure the event is terminated
beginEvent _ TEditHistory.CurrentEventNumber[];
TEditInput.CloseEvent[] };

doEndAtom: LIST OF REF = Register[$DoEnd,DoEndOp];

DoEndButton: Buttons.ButtonProc = {
DoButton[doEndAtom] };

DoEndOp: TEditInput.CommandProc = { DoEndCom[mainToolInfo] };

DoEndCom: PROC [info: Info] = { 
list: LIST OF REF ANY;
endEvent: INT;
[] _ TEditInput.GetRepeatSequence[]; -- to make sure the event is terminated
endEvent _ TEditHistory.CurrentEventNumber[];
IF endEvent-beginEvent > TEditHistory.SliceSize[] THEN {
Flash["Not all events still recorded.  Some missing at start."];
};
FOR i: INT _ beginEvent+1, i+1 UNTIL i > endEvent DO
list _ List.Append[list, TEditHistory.GetRepeatList[i]];
ENDLOOP;
ShowOps[list,info] };


comNumAtom: LIST OF REF = Register[$CommandNumber,DoComNumOp];
clearComNumAtom: LIST OF REF = Register[$ClearCommandNumber,ClearComNumOp];

ComNumButton: Buttons.ButtonProc = {
DoButton[comNumAtom,clearComNumAtom, mouseButton=red] };

DoComNumOp: TEditInput.CommandProc = { DoComNum[mainToolInfo] };

DoComNum: PROC [info: Info] = { DataFieldButton[info.comArg,FALSE] };

ClearComNumOp: TEditInput.CommandProc = { ClearComNum[mainToolInfo] };

ClearComNum: PROC [info: Info] = { DataFieldButton[info.comArg,TRUE] };

BuildComNumField: PUBLIC PROC [info: Info] = { OPEN info;
[,comArg] _ BuildDataFieldPair[layout, "Command [0..9]:", ComNumButton, info, 1];
TEditOps.SetTextContents[comArg, "1 "]; };

}...
EditToolOpsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Russ Atkinson, September 28, 1983 2:21 pm
Doug Wyatt, March 4, 1985 10:26:32 am PST
Russ Atkinson (RRA) June 18, 1985 4:59:53 pm PDT
--------------------------
--------------------------
--------------------------
--------------------------
--------------------------
--------------------------
--------------------------
make point selection at start of document
--------------------------
--------------------------
--------------------------
ΚY˜
codeš
œ™Kšœ
Οm
œ1™<K™)K™)K™0—K˜š
Οk	˜	Kšœžœ˜Kšœžœm˜‚
Kšœžœ@˜UKšžœ
žœG˜OKšžœ
žœ5žœžœ˜JKšœžœ˜Kšœžœ˜$Kšœžœ žœ˜>Kšœžœ
˜ Kšœ
žœ0˜BKšœžœ_˜oKšœ	žœ˜-Kšœ
žœ˜Kšœžœ˜*Kšœ	žœ˜Kšœ
žœ'˜9Kšœ	žœ7˜EKšœ
žœ˜Kšœžœ˜!Kšœ
žœ˜Kšœžœ
˜Kšœ
žœ˜,—
headšœžœ
ž˜Kšžœ#žœžœ‘
˜Ρ
Kšžœ˜Kšœžœ1˜9—˜Kšžœžœžœ
˜—K˜Kš
œ™K˜šΟnœžœžœžœ˜8Kšœžœ˜$Kšžœ
žœ
žœ ˜4Kšžœ
žœ
žœ ˜4Kš
œ˜K˜K˜—Kš
œ™Kšœ	žœ
žœ
žœ"˜6Kšœžœ
žœ
žœ,˜EK˜˜!K˜2K˜—K˜<K˜KšŸœžœ.žœ˜CK˜K˜FK˜KšŸœžœ.žœ˜GK˜šŸœžœ
žœžœ˜<K˜LK˜—šŸœžœ
žœžœžœ
žœ
žœ
žœžœ
žœ˜SKšœžœ)˜3Kš	œžœ
žœžœ
žœ˜Kšœžœ
žœžœ
˜š
ž˜Kš	œžœžœžœžœ˜CKšžœžœ
žœ
žœ
˜K˜Kšžœ
˜—K˜K˜—Kš
œ™šŸœžœ
žœžœ˜=KšœCžœ˜IKšœHžœ˜NK˜
K˜MK˜
K˜S˜K˜——Kš
œ™Kšœžœ
žœ
žœ$˜>Kšœžœ
žœ
žœ.˜MK˜˜'K˜>K˜—K˜BK˜KšŸ	œžœ0žœ˜HK˜K˜LK˜KšŸœžœ0žœ˜LK˜Kš
œ™Kšœ
žœ
žœ
žœ˜/Kšœžœ
žœ
žœ$˜>K˜˜"K˜4K˜—K˜8K˜KšŸœžœ/žœ˜BK˜K˜BK˜KšŸ	œžœ/žœ˜FK˜Kš
œ™Kšœžœ
žœ
žœ/˜OK˜˜NK˜—K˜QK˜KšŸœžœ$žœ˜EK˜Kš
œ™Kšœžœ
žœ
žœ*˜FK˜˜FK˜—K˜IK˜KšŸœžœ$žœ˜@K˜šŸœžœžœ˜,Kš	œžœ
žœ
žœ
žœ
˜K˜K˜Kšœžœžœ
˜Kš
œ1˜1Kšœ
žœ0˜>Kšœžœ/˜9š
Ÿœžœžœžœ
žœ˜AKšœžœ
˜	Kšœžœ
žœ
˜
Kšœ
žœ
žœžœžœžœ˜;Kšœžœžœ˜$šœžœ ˜)šœžœ	˜
Kšžœžœ
ž˜(Kšžœžœ˜,—Kš
œ˜—šžœžœžœžœ.˜Tšœžœ	˜
Kšžœžœ
ž˜(Kšžœžœ˜,—Kš
œ˜—Kšžœžœžœ"žœ˜JKšœžœ˜ Kšœžœ˜K˜)Kšžœ
˜Kšžœžœ˜"K˜—š
Ÿœžœžœžœ
žœ˜=Kšœžœ˜šžœ
Οc˜Kšœ
žœ
˜Kšžœžœ
žœ˜;Kš
œ9˜9Kšžœžœ
žœžœ˜+šžœžœ ˜3Kšœžœ7˜@Kš	žœžœ
žœ
žœ ˜-Kšžœ3˜9—Kšžœžœ0˜IKšžœ˜ šœžœ&˜@Kšœžœ1žœžœ˜F—Kšžœ
žœ
žœ%˜9šžœ
žœ
žœ ˜)šžœžœ˜K˜ Kš
œ%˜%Kšžœžœ˜7Kšœ $˜=—šžœ 	˜K˜Iš
œ9˜9Kš
œ)™)—šžœž˜!Kšœžœ ˜>—Kš
œ˜——Kš
ž˜—Kš
œ˜—Kšœžœ
˜Kš
žœžœžœ
žœžœ˜RKšžœ
žœ
žœ"žœ˜?Kš
œ˜Kš
œ/˜/K˜šœ	žœ
žœ
žœž˜6Kšžœ'˜*šžœ
žœžœ
žœ˜-Kšžœ,˜0—Kšžœ˜—Kš
œ@˜@Kš
œ"˜"Kšžœžœ	žœžœ!˜NKš
œ˜K˜—Kš
œ™šŸœžœ
žœžœ˜AK˜>K˜2K˜7K˜3K˜9K˜9K˜
šœ !˜9K˜K˜——Kšœžœ
žœ
žœ*˜GK˜˜*K˜K˜—˜*Kšœžœžœ˜0K˜—šŸœžœ˜'K˜/K˜—šŸœžœžœ
žœ
žœ
žœ˜5K˜;K˜—Kšœžœ
žœ
žœ˜2K˜˜#K˜K˜—K˜=K˜šŸœžœ
žœ˜'Kš
œ6˜6Kš	œžœ
žœ
žœ
žœ
˜Kšžœžœžœ˜@Kšžœžœ
žœžœ˜KK˜,K˜*Kš
œ$˜$K˜—šŸœžœ˜*Kš	œžœ
žœ
žœ
žœ˜%K˜ K˜K˜—Kšœžœ
žœ
žœ"˜;K˜˜&K˜K˜—K˜CK˜šŸœžœ˜"Kšœžœ%žœ	˜:Kš
žœžœ
žœžœ
žœ˜&K˜KšžœH˜Mš
œ˜K˜——Kšœžœ
žœ
žœ"˜;K˜˜&K˜K˜—K˜CK˜šŸœžœ˜"Kšœžœ%žœ	˜:Kš
žœžœ
žœžœ
žœ˜&K˜)KšžœH˜M˜K˜——Kšœ
žœ
žœ
žœ ˜8K˜˜%K˜K˜—K˜AK˜Kšœžœ˜K˜šŸ
œžœ˜!Kšœ% '˜LK˜/K˜K˜—Kšœžœ
žœ
žœ˜2K˜˜#K˜K˜—K˜=K˜šŸœžœ˜ Kš	œžœ
žœ
žœ
žœ
˜Kšœ
žœ
˜Kšœ% '˜LK˜-šžœ0žœ˜8Kš
œ@˜@K˜—šžœžœžœž˜4K˜8Kšžœ
˜—K˜K˜K˜—Kš
œ™Kšœžœ
žœ
žœ'˜>Kšœžœ
žœ
žœ/˜KK˜˜$K˜8K˜—K˜@K˜KšŸœžœ.žœ˜EK˜K˜FK˜KšŸœžœ.žœ˜GK˜šŸœžœ
žœžœ˜9K˜QK˜*K˜—Kš
œ™K˜—…—.θ=W