[Indigo]<Cedar5.3>Walnut>WalnutWindowImpl.mesa!4

File: WalnutWindowImpl.mesa

Contents: Top level Viewer for Walnut; initializes database & displays control window

created February, 1981 by Willie-Sue & Rick

Last edit by:

Willie-Sue on: August 28, 1984 11:44:43 am PDT

Donahue, July 26, 1983 9:13 am

Last Edited by: Woosh, August 23, 1984 2:19:53 pm PDT

DIRECTORY

AlpineWalnutCmds USING [CopyForExpunge],

Buttons USING [ButtonProc],

Commander USING [CommandProc, Handle, Register],

CommandTool USING [Run],

Containers,

DefaultRemoteNames USING [Get],

DB USING [Aborted, Failure, Transaction, AbortTransaction, DeclareSegment,

Initialize, TransactionOf],

Labels USING [Set],

FS USING [Error, SetKeep],

GVRetrieve USING [MBXState],

Icons USING [IconFlavor, NewIconFromFile],

IO,

MBQueue USING [Create, QueueClientAction],

Menus,

MessageWindow USING [Append],

PrincOpsUtils USING [IsBound],

Process USING [Detach],

Rope,

Rules USING [Create],

UserCredentials USING [Get],

UserProfile USING[ProfileChangedProc, Boolean, CallWhenProfileChanges, Token],

ViewerBLT USING[ChangeNumberOfLines],

ViewerClasses USING [Viewer],

ViewerEvents USING [EventProc, EventRegistration, RegisterEventProc, UnRegisterEventProc],

ViewerOps,

ViewerSpecs USING[openLeftWidth, openRightTopY, openRightWidth],

ViewerIO USING [CreateViewerStreams],

WalnutControlPrivate USING [CloseTransactions, ClosingWalnut, FlushWQueue, QuitWalnut,

StartOrRestartWalnut, WalnutNotifier],

WalnutControlMonitorImpl,

WalnutDB USING [RegisterUpdatesPendingProc, UnRegisterUpdatesPendingProc],

WalnutDBLog USING [GetStartExpungePos],

WalnutDisplayerOps USING [msgName, msgSetName],

WalnutLog USING [ExpungeMsgs, LogLength, MarkWalnutTransaction],

WalnutLogExtras USING [onlyOneTempLog, walnutTempLogName, QuietlyMarkTransaction],

WalnutExtras USING [ChangeDBProc, DoWaitCall, DumpProc, EnumWalnutViewers,

EstablishFileNames, ExpungeProc, ReadMailProc, RetrieveNewMailProc,

ScavengeProc, SetWalnutIcons, TakeDownWalnutViewers],

WalnutRetrieve USING [CloseConnection],

WalnutSendOps USING [userRName, RegisterReporter, UnregisterReporter, WalnutSendProc],

WalnutViewer USING [CreateMenuEntry, FirstLabel, MakeRuler, MakeTypescript],

WalnutVoice USING [CheckForWalnuthatch],

WalnutWindow USING [Queue, firstMsgSetButton, lastMsgSetButton, selectedMsgSetButtons,

AppendButtonProc, ArchiveButtonProc, CreateMsgSetButtonProc,

DeleteMsgSetsProc, DestroyAllMsgSetButtons, DoNewMail, PrintMsgSetsProc,

SizeOfMsgSetsProc];

WalnutWindowImpl: CEDAR MONITOR LOCKS walnutControlLock

IMPORTS

AlpineWalnutCmds, DB, FS,

Commander, CommandTool, DefaultRemoteNames,

Containers, Icons, Labels, MBQueue, Menus, MessageWindow, Rules,

IO, PrincOpsUtils, Process, Rope,

UserCredentials, UserProfile,

ViewerBLT, ViewerEvents, ViewerOps, ViewerIO, ViewerSpecs,

walnutControlLock: WalnutControlMonitorImpl,

WalnutControlPrivate, WalnutDB, WalnutDBLog, WalnutDisplayerOps, WalnutExtras,

WalnutLog, WalnutLogExtras, WalnutRetrieve, WalnutSendOps,

WalnutViewer, WalnutVoice, WalnutWindow

EXPORTS WalnutControlPrivate, WalnutExtras, WalnutWindow

SHARES WalnutControlMonitorImpl, WalnutWindow =

BEGIN OPEN WalnutControlPrivate, WalnutExtras, WalnutWindow;

Walnut Viewers types and global data

ROPE: TYPE = Rope.ROPE;

Viewer: TYPE = ViewerClasses.Viewer;

InitialNotifyLabel: PUBLIC ROPE←

" ";

walnutVersion: ROPE← "WalnutWithVoice 4.4.101";

walnutVersion: ROPE← "Walnut";

walnut: PUBLIC Viewer← NIL;

wtsOut: IO.STREAM← NIL;

walnutIcon: PUBLIC Icons.IconFlavor← tool;

newMailIcon: PUBLIC Icons.IconFlavor← tool;

msgSetIcon: PUBLIC Icons.IconFlavor← tool;

msgIcon: PUBLIC Icons.IconFlavor← tool;

iconFilePathName: PUBLIC ROPE← NIL;

walnutEventReg: ViewerEvents.EventRegistration← NIL;

mustQuitWalnut: PUBLIC ROPE← NIL;

previousUser: PUBLIC ROPE← NIL;

doingCheckpoint: PUBLIC BOOL← FALSE;

rollbackFinished: PUBLIC CONDITION;

initialActiveIconic: PUBLIC BOOL← FALSE;

initialActiveRight: PUBLIC BOOL← TRUE;

initialActiveOpen: PUBLIC BOOL← TRUE;

msgSetBorders: PUBLIC BOOL← FALSE;

enableTailRewrite: PUBLIC BOOL← FALSE;

excessBytesInLogFile: PUBLIC INT← 300000;

walnutRulerBefore, walnutRulerAfter, walnutTS: PUBLIC Viewer;

msgSetText: PUBLIC Viewer; -- the text argument for Create MsgSet

fileNameText: PUBLIC Viewer; -- fileName for Archiving

mailNotifyLabel: PUBLIC Viewer; -- is there new mail or not

autoNewMail: BOOL← FALSE;

tryForNewMail: BOOL← FALSE;

doAutoCommit: BOOL← FALSE;

walnutSegmentFile: PUBLIC ROPE;

walnutLogName: PUBLIC ROPE;

readOnlyAccess: PUBLIC BOOL;

logIsAlpineFile: PUBLIC BOOL;

personalMailDB: PUBLIC BOOL;

segmentName: PUBLIC ATOM← $Walnut;

walnutQueue: PUBLIC Queue;

walnutNullTrans: PUBLIC DB.Transaction;

responseSynch: CONDITION;

userHasResponded, userConfirmed: BOOL← FALSE;

alpineServer: ROPE = "[Luther.alpine]"; -- for now

lastStateReported: PUBLIC GVRetrieve.MBXState← unknown;

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

BuildWalnut: PUBLIC ENTRY Commander.CommandProc =

BEGIN ENABLE UNWIND => NULL;

h: IO.STREAM;

dirName, segName, logName, captionName: ROPE;

alpNeeded, logIsAlp: BOOL;

IF doingCheckpoint THEN WAIT rollbackFinished;

personalMailDB← TRUE;

IF cmd # NIL THEN

{ h← IO.RIS[cmd.commandLine];

dirName← h.GetTokenRope[IO.IDProc ! IO.EndOfStream => {dirName← NIL; CONTINUE}].token;

};

[segName, logName, captionName, logIsAlp]← CmdProcCall[dirName, cmd];

IF segName=NIL THEN RETURN;

IF walnut # NIL THEN

IF segName.Equal[walnutSegmentFile, FALSE] THEN

{ Report["\nWalnut is already running"]; RETURN}

ELSE

{ cdb: ChangeDBParams← NEW[ChangeDBObject←

[segName: segName, logName: logName, logIsAlp: logIsAlp, alpNeeded: alpNeeded]];

walnut.name← captionName;

ViewerOps.PaintViewer[walnut, caption];

TRUSTED { Process.Detach[FORK ChangeDB[cdb]]};

WAIT cdb.cond;

IF walnut # NIL THEN ViewerOps.AddProp[walnut, $IconLabel, dirName];

RETURN

};

IF Rope.Length[UserCredentials.Get[].name] = 0 THEN

{ IF cmd # NIL THEN cmd.out.PutRope["Please Login"]; RETURN};

walnutSegmentFile← segName;

walnutLogName← logName;

logIsAlpineFile← logIsAlp;

WalnutDisplayerOps.msgName ← Rope.Concat[walnutSegmentFile, "!Msg!"];

WalnutDisplayerOps.msgSetName ← Rope.Concat[walnutSegmentFile, "!MsgSet!"];

StartUp[FALSE, captionName];

IF walnut # NIL THEN

{ ViewerOps.AddProp[walnut, $IconLabel, dirName];

IF personalMailDB AND autoNewMail THEN

{ tryForNewMail← FALSE;

TRUSTED {Process.Detach[FORK AutoNewMailProc]};

};

END;

CmdProcCall: INTERNAL PROC[dirName: ROPE, cmd: Commander.Handle]

RETURNS[segName, logName, captionName: ROPE, logIsAlp: BOOL] =

BEGIN

sName, lName: ROPE;

alpServer: ROPE = "[Luther.alpine]<";

seg: ROPE = ">Walnut.segment";

log: ROPE = ">Walnut.DBLog";

user: ROPE← UserCredentials.Get[].name;

personalMailDB← TRUE;

IF dirName.Length = 0 THEN

{ sName← UserProfile.Token[key: "Walnut.WalnutSegmentFile", default: ""];

lName← UserProfile.Token[key: "Walnut.WalnutLogFile", default: ""];

IF sName.Length[] = 0 THEN sName← Rope.Cat[alpServer, user, seg];

IF lName.Length[] = 0 THEN lName← Rope.Cat[alpServer, user, log];

captionName← walnutVersion;

}

ELSE

{ sName← Rope.Cat[alpServer, dirName, seg];

lName← Rope.Cat[alpServer, dirName, log];

personalMailDB← FALSE;

captionName← Rope.Cat[walnutVersion, " <", dirName, ">"];

};

[segName, logName, logIsAlp]← EstablishFileNames[sName, lName];

walnutNullTrans← NIL;

IF ~segName.Find[".alpine]", 0, FALSE] > 0 THEN

{ msg: ROPE←

Rope.Concat[segName, ": is not a valid Walnut segment file; it MUST be on alpine"];

IF cmd # NIL THEN {cmd.out.PutRope[msg]; cmd.out.PutChar['\n]}

ELSE ReportRope[msg];

segName← NIL;

};

END;

StartUp: INTERNAL PROC[scavengeFirst: BOOL, captionName: ROPE] =

BEGIN

doAutoCommit← UserProfile.Boolean[key: "Walnut.DoAutoCommit", default: TRUE];

WalnutLogExtras.onlyOneTempLog←

UserProfile.Boolean[key: "Walnut.OnlyOneTempLog", default: TRUE];

SetTempLogName[];

IF ~BuildWalnutControlWindow[captionName] THEN RETURN;

if doAutoCommit is true, then don't show Commit on the menus

IF doAutoCommit THEN

BEGIN

old: Menus.MenuEntry;

IF (old← Menus.FindEntry[mailDBMenu, "Commit"])#NIL THEN

Menus.ReplaceMenuEntry[mailDBMenu, old, NIL];

IF (old← Menus.FindEntry[nonMailDBMenu, "Commit"])#NIL THEN

Menus.ReplaceMenuEntry[nonMailDBMenu, old, NIL];

END

ELSE

BEGIN

IF Menus.FindEntry[mailDBMenu, "Commit"] = NIL THEN

Menus.AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Commit", MyCommitProc]];

IF Menus.FindEntry[nonMailDBMenu, "Commit"] = NIL THEN

Menus.AppendMenuEntry[nonMailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Commit", MyCommitProc]];

END;

IF ~StartOrRestartWalnut[TRUE, scavengeFirst] THEN RETURN;

FlushWQueue[]; -- for good measure

Report[" ...Ready"];

TRUSTED { Process.Detach[FORK WalnutNotifier[]] };

END;

CloseDownWalnut: PUBLIC INTERNAL PROC[doCommit: BOOL] =

clean up after Walnut

BEGIN

v: Viewer← walnut;

walnut.inhibitDestroy← TRUE;

FlushWQueue[];

InternalChangeMenu[workingMenu];

WalnutDB.UnRegisterUpdatesPendingProc[SetWalnutUpdatesPending];

selectedMsgSetButtons← firstMsgSetButton← lastMsgSetButton← NIL;

TakeDownWalnutViewers[];

ReportRope["Closing database and saving log ..."];

BEGIN

CloseTransactions[doCommit !

DB.Failure, IO.Error => GOTO failure; -- IO.Error replaces FileIOAlpine.Failure

UNWIND => CONTINUE ];

EXITS

failure => IF DB.TransactionOf[segmentName] # NIL THEN

DB.AbortTransaction[DB.TransactionOf[segmentName ! IO.Error => CONTINUE]];

END;

IF walnutEventReg # NIL THEN

ViewerEvents.UnRegisterEventProc[walnutEventReg, destroy];

walnutEventReg← NIL;

walnut← NIL; -- don't let others try to use Report

WalnutRetrieve.CloseConnection[]; -- NOP if no open connection

lastStateReported← unknown;

mailNotifyLabel← NIL;

WalnutSendOps.UnregisterReporter[wtsOut];

wtsOut.Close[];

wtsOut← NIL;

mustQuitWalnut← NIL;

MBQueue.QueueClientAction[walnutQueue, ClosingWalnut, NIL];

v.inhibitDestroy← FALSE;

doingCheckpoint← FALSE;

ViewerOps.DestroyViewer[v];

END;

WalnutReadMailFile: PUBLIC ENTRY Commander.CommandProc =

BEGIN ENABLE UNWIND => NULL;

h: IO.STREAM;

fName, messageSet: ROPE;

IF walnut = NIL THEN {NoWalnutReport[cmd, "read old mail files"]; RETURN};

IF doingCheckpoint THEN WAIT rollbackFinished;

h← IO.RIS[cmd.commandLine];

fName← h.GetTokenRope[IO.IDProc ! IO.EndOfStream => GOTO noFile].token;

messageSet← h.GetTokenRope[IO.IDProc ! IO.EndOfStream => CONTINUE].token;

ReadMailFile[fName, messageSet];

EXITS

noFile => Report["No file specified"];

END;

make separate proc so callable by program

ReadMailFile: PUBLIC PROC[fName, msgSet: ROPE] =

BEGIN

mfp: LIST OF ROPE← LIST[fName, IF msgSet=NIL THEN "Active" ELSE msgSet];

DoWaitCall[ReadMailProc, mfp];

END;

WalnutExpunge: PUBLIC ENTRY Commander.CommandProc =

BEGIN ENABLE UNWIND => NULL;

IF walnut = NIL THEN {NoWalnutReport[cmd, "do Expunge"]; RETURN};

IF doingCheckpoint THEN WAIT rollbackFinished;

DoWaitCall[ExpungeProc];

FinishCall[];

END;

WalnutDump: PUBLIC ENTRY Commander.CommandProc =

BEGIN ENABLE UNWIND => NULL;

IF walnut = NIL THEN {NoWalnutReport[cmd, "do Dump"]; RETURN};

IF doingCheckpoint THEN WAIT rollbackFinished;

DoWaitCall[DumpProc];

FinishCall[];

END;

WalnutScavenge: PUBLIC ENTRY Commander.CommandProc =

BEGIN ENABLE UNWIND => NULL;

IF walnut = NIL THEN

{ segName, logName, captionName: ROPE;

logIsAlp: BOOL;

personalMailDB← TRUE;

[segName, logName, captionName, logIsAlp]← CmdProcCall[NIL, cmd];

IF segName=NIL THEN RETURN;

walnutSegmentFile← segName;

walnutLogName← logName;

logIsAlpineFile← logIsAlp;

WalnutDisplayerOps.msgName ← Rope.Concat[walnutSegmentFile, "!Msg!"];

WalnutDisplayerOps.msgSetName ← Rope.Concat[walnutSegmentFile, "!MsgSet!"];

StartUp[TRUE, walnutVersion];

IF walnut # NIL THEN ViewerOps.AddProp[walnut, $IconLabel, NIL];

RETURN

};

IF doingCheckpoint THEN WAIT rollbackFinished;

InternalChangeMenu[workingMenu];

DoWaitCall[ScavengeProc];

FinishCall[];

END;

FinishCall: INTERNAL PROC =

BEGIN

Report["\n... Restarting"];

CloseTransactions[ TRUE ! DB.Failure, IO.Error => CONTINUE];

IF ~StartOrRestartWalnut[TRUE] THEN RETURN;

Report[" ... done"];

END;

GetNewMail: PUBLIC PROC = {[]← WalnutNewMail[NIL]};

WalnutNewMail: PUBLIC ENTRY Commander.CommandProc =

BEGIN ENABLE UNWIND => NULL;

IF walnut = NIL THEN {NoWalnutReport[cmd, "retrieve new mail"]; RETURN};

IF doingCheckpoint THEN WAIT rollbackFinished;

DoWaitCall[RetrieveNewMailProc, NIL]

END;

NoWalnutReport: INTERNAL PROC[cmd: Commander.Handle, msg: ROPE] =

BEGIN

r: ROPE← Rope.Concat["Walnut must be running to ", msg];

IF cmd # NIL THEN cmd.out.PutRope[r] ELSE MessageWindow.Append[r]

END;

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

BuildWalnutControlWindow: INTERNAL PROC[captionName: ROPE] RETURNS[ok: BOOL] =

BEGIN

bt: Viewer;

walnutWidth: INTEGER;

transOK: BOOL← TRUE;

IF iconFilePathName=NIL THEN iconFilePathName← "Walnut.icons"; -- try local one first

IF walnutIcon = tool THEN

{ BEGIN ENABLE FS.Error => GOTO notFound;

walnutIcon← Icons.NewIconFromFile[iconFilePathName, 0];

EXITS

notFound =>

BEGIN ENABLE FS.Error => { iconFilePathName← NIL; CONTINUE};

remote: ROPE← DefaultRemoteNames.Get[].current;

iconFilePathName← Rope.Concat[remote, "Walnut>Walnut.icons"];

walnutIcon ← Icons.NewIconFromFile[iconFilePathName, 0];

END;

IF iconFilePathName#NIL THEN SetWalnutIcons[iconFilePathName];

};

walnut← ViewerOps.CreateViewer[

flavor: $Container,

info: [name: captionName, iconic: FALSE, column: right, scrollable: FALSE,

icon: walnutIcon, openHeight: ViewerSpecs.openRightTopY/4]];

walnut.inhibitDestroy← TRUE;

walnutWidth← IF walnut.column = right THEN ViewerSpecs.openRightWidth ELSE

ViewerSpecs.openLeftWidth;

ViewerOps.SetMenu[walnut, blankMenu];

mailNotifyLabel← WalnutViewer.FirstLabel[name: InitialNotifyLabel, parent: walnut];

bt← walnutRulerBefore← WalnutViewer.MakeRuler[sib: mailNotifyLabel, h: 2];

walnutRulerAfter← Rules.Create[

info: [parent: walnut, wy: bt.wy+bt.wh+14+3, ww: walnutWidth, wh: 1]];

Containers.ChildXBound[walnut, walnutRulerAfter];

walnutTS← WalnutViewer.MakeTypescript[sib: walnutRulerAfter];

FS.SetKeep[tsLogName, 2 ! FS.Error => CONTINUE]; -- if tsLogName doesn't exist

OpenTS[doRegister: FALSE];

TRUSTED

BEGIN

IF ~PrincOpsUtils.IsBound[WalnutSendOps.RegisterReporter] THEN

{IF ~ContinueThisWalnut["WalnutSend"] THEN RETURN[FALSE] ELSE LOOP};

IF ~PrincOpsUtils.IsBound[AlpineWalnutCmds.CopyForExpunge] THEN

{IF ~ContinueThisWalnut["AlpineUserImpls"] THEN RETURN[FALSE] ELSE LOOP};

IF ~PrincOpsUtils.IsBound[DB.DeclareSegment] THEN

{IF ~ContinueThisWalnut["Cypress"] THEN RETURN[FALSE] ELSE LOOP};

EXIT;

ENDLOOP;

END;

ViewerOps.SetMenu[walnut, workingMenu];

walnutEventReg←

ViewerEvents.RegisterEventProc[proc: QuitProc, event: destroy, filter: walnut];

WalnutDB.RegisterUpdatesPendingProc[SetWalnutUpdatesPending];

WalnutSendOps.RegisterReporter[wtsOut];

DB.Initialize[nCachePages: 256];

[]← WalnutVoice.CheckForWalnuthatch[];

RETURN[TRUE];

END;

tsLogName: ROPE = "///Temp/Walnut/Walnut.TypescriptLog";

OpenTS: PUBLIC PROC[msg: ROPE← NIL, doRegister: BOOL← TRUE] =

BEGIN

IF wtsOut = NIL THEN

{ wtsOut← ViewerIO.CreateViewerStreams[NIL, walnutTS, tsLogName].out;

IF msg # NIL THEN wtsOut.PutRope[msg];

IF doRegister THEN WalnutSendOps.RegisterReporter[wtsOut];

};

END;

CloseTS: PUBLIC PROC =

BEGIN

IF wtsOut # NIL THEN wtsOut.Close[];

WalnutSendOps.UnregisterReporter[wtsOut];

wtsOut← NIL;

END;

ContinueThisWalnut: INTERNAL PROC[who: ROPE] RETURNS[reTry: BOOL]=

BEGIN

v: Viewer;

IF InternalLoadBcd[who] THEN RETURN[TRUE];

Report["Click Continue to push on anyway, Quit to quit out of Walnut"];

IF InternalConfirm[startupConfirmMenu] THEN RETURN[TRUE];

mailNotifyLabel← NIL;

v← walnut;

walnut← NIL;

CloseTS[];

ViewerOps.DestroyViewer[v];

RETURN[FALSE]

END;

LoadBcdForWalnut: PUBLIC ENTRY PROC[who: ROPE] RETURNS[ok: BOOL] =

{ ENABLE UNWIND => NULL;

RETURN[InternalLoadBcd[who]]

};

InternalLoadBcd: INTERNAL PROC[who: ROPE] RETURNS[ok: BOOL] =

BEGIN

errMsg: ROPE;

error: BOOL;

[errMsg, error]← CommandTool.Run[who];

Report[errMsg];

IF ~error THEN RETURN[errMsg=NIL];

IF errMsg.Find["unbound imports", 0, FALSE] >= 0 THEN RETURN[TRUE];

RETURN[FALSE]

END;

QueueExecCall: PUBLIC ENTRY PROC[proc: PROC[REF ANY], ra: REF ANY] =

BEGIN ENABLE UNWIND => NULL;

IF walnut # NIL THEN IF doingCheckpoint THEN WAIT rollbackFinished;

MBQueue.QueueClientAction[walnutQueue, proc, ra];

END;

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

ChangeWalnutMenu: PUBLIC ENTRY PROC[menu: Menus.Menu] =

BEGIN ENABLE UNWIND => NULL;

InternalChangeMenu[menu]

END;

InternalChangeMenu: PUBLIC INTERNAL PROC[menu: Menus.Menu] =

BEGIN ENABLE UNWIND => NULL;

oldCount, newCount: Menus.MenuLine;

IF walnut = NIL THEN RETURN;

oldCount← Menus.GetNumberOfLines[walnut.menu];

newCount← Menus.GetNumberOfLines[menu];

walnut.menu ← menu;

IF oldCount # newCount THEN

ViewerBLT.ChangeNumberOfLines[walnut, newCount];

ViewerOps.PaintViewer[walnut, menu];

END;

UserConfirmed: PUBLIC ENTRY PROC RETURNS[BOOL] =

BEGIN ENABLE UNWIND => NULL;

RETURN[InternalConfirm[confirmMenu]];

END;

InternalConfirm: PUBLIC INTERNAL PROC[m: Menus.Menu← NIL] RETURNS[BOOL] =

BEGIN

InternalChangeMenu[IF m = NIL THEN confirmMenu ELSE m];

IF walnut.iconic THEN ViewerOps.BlinkIcon[walnut, 0] ELSE ViewerOps.BlinkIcon[walnutTS];

UNTIL userHasResponded DO WAIT responseSynch; ENDLOOP;

userHasResponded← FALSE;

InternalChangeMenu[workingMenu];

RETURN[userConfirmed];

END;

-------------------------

walnutMenu: PUBLIC Menus.Menu;

workingMenu: PUBLIC Menus.Menu← Menus.CreateMenu[];

confirmMenu: Menus.Menu← Menus.CreateMenu[];

blankMenu: Menus.Menu← Menus.CreateMenu[];

startupConfirmMenu: Menus.Menu← Menus.CreateMenu[];

forceQuitMenu: PUBLIC Menus.Menu← Menus.CreateMenu[];

maybeQuitMenu: PUBLIC Menus.Menu← Menus.CreateMenu[];

scavMenu: PUBLIC Menus.Menu← Menus.CreateMenu[];

mailDBMenu: PUBLIC Menus.Menu← Menus.CreateMenu[];

readOnlyDBMenu: PUBLIC Menus.Menu← Menus.CreateMenu[];

nonMailDBMenu: PUBLIC Menus.Menu← Menus.CreateMenu[];

BuildWalnutMenu: PROC =

{ OPEN Menus;

menu for personal mail database

AppendMenuEntry[mailDBMenu, CreateEntry["NewForm", NewMsgProc]];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "NewMail", NewMailProc]];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Commit", MyCommitProc]];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "CloseAll", CloseAllProc]];

AppendMenuEntry[mailDBMenu, CreateEntry["MessageSetOps", MsgSetOpsProc]];

now for the second line

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[q: walnutQueue, name: "Expunge", proc: MenuExpunge,

guarded: TRUE], 1];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Delete", DeleteMsgSetsProc], 1];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "SizeOf", SizeOfMsgSetsProc], 1];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Print", PrintMsgSetsProc], 1];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Create", CreateMsgSetButtonProc], 1];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Archive", ArchiveButtonProc], 1];

AppendMenuEntry[mailDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Append", AppendButtonProc], 1];

Menus.ChangeNumberOfLines[mailDBMenu, 1];

menu for read only database

AppendMenuEntry[readOnlyDBMenu, CreateEntry["NewForm", NewMsgProc]];

AppendMenuEntry[readOnlyDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "CloseAll", CloseAllProc]];

AppendMenuEntry[readOnlyDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "SizeOf", SizeOfMsgSetsProc]];

AppendMenuEntry[readOnlyDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Print", PrintMsgSetsProc]];

AppendMenuEntry[readOnlyDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Archive", ArchiveButtonProc], 1];

AppendMenuEntry[readOnlyDBMenu,

WalnutViewer.CreateMenuEntry[walnutQueue, "Append", AppendButtonProc], 1];

menu for nonMail writeable database

AppendMenuEntry[nonMailDBMenu, CreateEntry["NewForm", NewMsgProc]];