[_CDCSL_93-16_]<1>Cedar>release>WallTapestry>WalnutMsgSetDisplayerImpl.mesa

WalnutMsgSetDisplayerImpl.mesa

Willie-sue, February 15, 1993 4:41 pm PST

Donahue, May 9, 1986 10:39:11 am PDT

Jack Kent April 9, 1987 4:56:33 pm PDT

Doug Terry, October 2, 1992 10:25 am PDT

Swinehart, April 11, 1993 8:49 pm PDT

Chauser, October 3, 1991 2:57 pm PDT

Contents: Implementation of the WalnutMsgSet displayers.

(Changed message set version number to be part of viewer information, rather than part of message set buttons)

(Display now checks to see if versions match and does not do redisplay if so)

(Changed to use TiogaButtons - May 6, 1985)

(Use new TiogaButtons capability permitting inter-document insertion of new nodes. Use it to sort displayed message sets by date. D. Swinehart February 3, 1991)

DIRECTORY

Basics USING [Comparison],

BasicTime USING [earliestGMT, GMT],

Containers USING [ChildXBound, ChildYBound],

Convert USING [ Error, TimeFromRope ],

EditSpan USING [ Place ],

Menus USING [MouseButton, Menu, MenuEntry, MenuLine, MenuProc, AppendMenuEntry, ChangeNumberOfLines, CreateMenu, CreateEntry, GetNumberOfLines, GetLine, SetLine],

PopUpSelection USING [Request],

Process USING [Pause, PauseMsec, MsecToTicks],

RedBlackTree USING [ Compare, Create, DestroyTable, DuplicateKey, EachNode, EnumerateIncreasing, GetKey, Insert, LookupNextLarger, Table ],

Rope,

SendMailOps USING [CreateSendViewer, GetCRTiogaContents],

TBQueue USING [CreateTiogaButtonAtNode],

TiogaButtons USING [ TiogaButton, TiogaButtonProc, CreateViewer, ChangeButtonLooks, DeleteButton, SetState, SetStyleFromRope],

TiogaMenuOps USING [AllLevels, FewerLevels, FirstLevelOnly, MoreLevels, Normalize, Position, PrevPlace],

TiogaOps USING [CancelSelection, Delete, GetSelection, FindDef, FindText, FindWord, InsertChar, InsertRope, RestoreSelA, SaveSelA, SearchDir, SetSelection],

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

ViewerClasses USING [Column, Viewer],

ViewerBLT USING [ChangeNumberOfLines],

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

ViewerOps USING [AddProp, ComputeColumn, CreateViewer, BlinkIcon, DestroyViewer,

FetchProp, GrowViewer, OpenIcon, PaintViewer, SetMenu],

ViewerSpecs USING [bwScreenHeight, openLeftWidth, openRightWidth],

ViewerTools USING [TiogaContents, TiogaContentsRec, GetSelectedViewer, GetSelectionContents],

WalnutDefs USING [dontCareMsgSetVersion, Error],

WalnutFilter USING [InitialSortOrder, MenuExtras, MessageTOC, MsgInterestLevel, SortCompareProc],

WalnutOps USING [ AcceptNewMail, ActiveName, AddMsg, CreateMsg, DeletedName, dontCareMsgSetVersion, EnumerateMsgsInSet, GenerateUniqueMsgName, GetCategories, GetDisplayProps, GetMsgSize, GetNewMail, MsgExists, MsgSet, MoveMsg, MsgSetExists, RemoveMsg, ServerInfo, SetHasBeenRead, SizeOfMsgSet],

WalnutInternal USING [DisplayMsgFromMsgSet, DoRemoveOverThere, DoWaitCall, GetButton, GetSelectedMsgSets, HowToPrint, initialActiveIconic, initialActiveOpen, msgSetIcon, MsgCategories, MsgSetPrintProc, MsgSetTOCPrintProc, PrintMsgList, SetMailState],

WalnutViewer USING [CreateMenuEntry],

WalnutWindow USING [GetNewMail, GetRootFileForHandle, Report, ReportFormat, ReportRope],

WalnutWindowPrivate USING [MsgAndHandle, MsgSetButton, MsgSetFieldHandle, MsgSetFieldHandleRec, MsgInfo, MsgInfoRec, MsgSetInfo, MsgSetInfoRec, WalnutHandle, WalnutHandleRec];

WalnutMsgSetDisplayerImpl: CEDAR MONITOR

IMPORTS

BasicTime, Convert, Menus, Process, PopUpSelection, RedBlackTree, Rope, SendMailOps, UserProfile,

WalnutDefs, WalnutFilter, WalnutOps,

WalnutInternal, WalnutWindow, WalnutViewer,

Containers, TBQueue, TiogaButtons, TiogaMenuOps, TiogaOps,

ViewerBLT, ViewerEvents, ViewerOps, ViewerSpecs, ViewerTools

EXPORTS

WalnutInternal, WalnutWindow

ViewerClasses =

BEGIN OPEN WalnutInternal;

Types

TiogaButton: TYPE = TiogaButtons.TiogaButton;

Viewer: TYPE = ViewerClasses.Viewer;

ROPE: TYPE = Rope.ROPE;

HowToPrint: TYPE = WalnutInternal.HowToPrint;

MsgSet: TYPE = WalnutOps.MsgSet;

MsgSetButton: TYPE = WalnutWindowPrivate.MsgSetButton;

WalnutHandle: TYPE = WalnutWindowPrivate.WalnutHandle;

WalnutHandleRec: PUBLIC TYPE = WalnutWindowPrivate.WalnutHandleRec;

tocDefaultLooks: PUBLIC ROPE;

tocSelectedLooks: PUBLIC ROPE;

tocUnreadLooks: PUBLIC ROPE;

userWantsQMs: PUBLIC BOOL¬FALSE;

scrollWaitTime: CARDINAL ¬ 500; -- Milliseconds

openHeightForActive: INT ¬ 0;

DisplayingRef: TYPE = REF DisplayingRefRec;

DisplayingRefRec: TYPE = RECORD[userSaidStop: BOOL];

Only common menu used in message set displays

buildingMenu: Menus.Menu ¬ Menus.CreateMenu[];

fillingInMenu: Menus.Menu ¬ Menus.CreateMenu[];

Types used in message set displays

MsgSetInfo: TYPE = WalnutWindowPrivate.MsgSetInfo;

MsgSetInfoRec: TYPE = WalnutWindowPrivate.MsgSetInfoRec;

button: MsgSetButton, -- the button in the control panel that this msgSet is bound to

tiogaViewer: Viewer, -- only child, $TiogaButton viewer

container: Viewer, -- back pointer to msgSet viewer

selected: LIST OF MsgSetFieldHandle,

lastMFH: MsgSetFieldHandle,

lastDeleted: MsgInfo, -- last message deleted from this message set

destroyER: ViewerEvents.EventRegistration

];

MsgSetFieldHandle: TYPE = WalnutWindowPrivate.MsgSetFieldHandle;

MsgSetFieldHandleRec: TYPE = WalnutWindowPrivate.MsgSetFieldHandleRec;

next, prev: MsgSetFieldHandle,

tocButton: TiogaButton, -- TableOfContentsButton

msI: MsgSetInfo, -- back pointer to msgSetInfo

msgInfo: MsgInfo -- constant for a message

];

MsgSetFieldHandles: TYPE ~ LIST OF MsgSetFieldHandle;

May need to be expanded to a record, at some point.

MsgSetOpHandle: TYPE ~ REF MsgSetOpHandleRec;

MsgSetOpHandleRec: TYPE ~ RECORD [

mfH: MsgSetFieldHandle¬NIL,

msI: MsgSetInfo¬NIL,

msViewer: Viewer¬NIL,

wH: WalnutHandle¬NIL,

mouseButton: Menus.MouseButton¬$red,

shift, control: BOOL¬FALSE,

lastSelected: BOOL¬FALSE

];

MsgInfo: TYPE = WalnutWindowPrivate.MsgInfo;

MsgInfoRec: TYPE = WalnutWindowPrivate.MsgInfoRec;

MsgInfoRec: TYPE = RECORD[ msg, tocName: ROPE, startOfSubject: INT, hasBeenRead: BOOL, date: BasicTime.GMT ];

Rope literals

destroyedMsg: ROPE = "Selected msg viewer has been destroyed";

noSelDest: ROPE = "No selected destination message sets";

noSelSource: ROPE = "No selected source messages or message sets";

moreSelSource: ROPE = "More than one selected message; not permitted for this operation";

noMsgRope: ROPE = "Msg is no longer in the MsgSet";

noCurrentSel1: ROPE = "No selection to extend";

noCurrentSel2: ROPE = "Message is not currently selected";

noNext: ROPE = "No Next message";

noUndo: ROPE = "Nothing to undo";

comma: ROPE = ", ";

movedTo: ROPE = "Moved to: ";

movedFrom: ROPE = "Moved from: ";

deletedFrom: ROPE = "Deleted from: ";

addedToRL: ROPE = "Added to: ";

appendedTo: ROPE = "Appended to: ";

removedFrom: ROPE = "Removed from: ";

space: ROPE = " ";

dollarSign: ROPE = "$";

questionMark: ROPE = "?";

atSign: ROPE = "@";

tabChar: ROPE = "\t";

newLine: ROPE = "\n";

walnutDotFancyNewMessageSelect: ROPE = "Walnut.FancyNewMessageSelect";

walnutDotMsgSetColumn: ROPE = "Walnut.MsgSetColumn";

walnutDotActiveMsgSetColumn: ROPE = "Walnut.ActiveMsgSetColumn";

walnutDotMovieMailFrameRate: ROPE = "Walnut.MovieMailFrameRate";

formatGToGNewLine: ROPE = "%g to %g\n";

leftRL: ROPE = "left";

rightRL: ROPE = "right";

findRL: ROPE = "Find";

firstLevelOnlyRL: ROPE = "FirstLevelOnly";

categoriesRL: ROPE = "Categories";

moveToRL: ROPE = "MoveTo";

displayRL: ROPE = "Display";

deleteRL: ROPE = "Delete";

addToRL: ROPE = "AddTo";

placesRL: ROPE = "Places";

levelsRL: ROPE = "Levels";

newMailRL: ROPE = "NewMail";

msgOpsRL: ROPE = "MsgOps";

wordRL: ROPE = "Word";

defRL: ROPE = "Def";

positionRL: ROPE = "Position";

normalizeRL: ROPE = "Normalize";

prevPlaceRL: ROPE = "PrevPlace";

moreLevelsRL: ROPE = "MoreLevels";

fewerLevelsRL: ROPE = "FewerLevels";

allLevelsRL: ROPE = "AllLevels";

defaultMovieMailFrameRate: INT¬1;

Procedures

GetMsgSetName: PUBLIC PROC[v: Viewer] RETURNS[msName: ROPE, rootFile: ROPE] = {

of v is a Viewer for a Walnut Entity, then return its name else NIL

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[v, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

rootFile ¬ WalnutWindow.GetRootFileForHandle[msI.button.wH];

RETURN[msI.button.msgSet.name, rootFile];

};

QDisplayMsgSet: PUBLIC PROC[wH: WalnutHandle, msb: MsgSetButton, oldV: Viewer, shift, repaint: BOOL]

RETURNS[v: Viewer] = {

IF oldV = NIL THEN {

IF msb = NIL THEN RETURN[NIL]; -- no such msgSet

oldV ¬ msb.msViewer

};

IF oldV # NIL THEN

IF oldV.destroyed THEN oldV ¬ msb.msViewer ¬ NIL;

v ¬ MSViewer[wH: wH, msb: msb, oldV: oldV, shift: shift];

msb.msViewer ¬ v;

};

AddNewMsgsToActive: PUBLIC PROC[active: MsgSetButton]

RETURNS[responses: LIST OF WalnutOps.ServerInfo, complete: BOOL, numNew: INT] = {

activeV: Viewer = active.msViewer;

wH: WalnutHandle = active.wH;

msI: MsgSetInfo;

sortTable: RedBlackTree.Table;

NewMsgProc: PROC[msg, tocEntry: ROPE, startOfSubject: INT] = {

msgInfo: MsgInfo;

mfh: MsgSetFieldHandle;

numNew ¬ numNew + 1;

msgInfo ¬ CreateMsgInfo[msg, FALSE, tocEntry, startOfSubject];

mfh ¬ NEW[MsgSetFieldHandleRec ¬ [msgInfo: msgInfo]];

RedBlackTree.Insert[sortTable, mfh, mfh!

RedBlackTree.DuplicateKey => WalnutWindow.Report[wH, "Duplicate Msg ID in message set!"]];

};

AppendMsg: RedBlackTree.EachNode ~ {

mfh: MsgSetFieldHandle ¬ NARROW[data];

BuildMsgLineViewer[msI, mfh.msgInfo];

};

numNew ¬ 0;

IF activeV = NIL OR activeV.destroyed THEN {

numNew ¬ -1; -- don't know, won't count

[responses, complete] ¬ WalnutOps.GetNewMail[wH.opsH, WalnutDefs.dontCareMsgSetVersion, NIL];

IF ~complete THEN RETURN;

WalnutOps.AcceptNewMail[wH.opsH, WalnutDefs.dontCareMsgSetVersion];

RETURN

};

msI ¬ NARROW[ViewerOps.FetchProp[activeV, $MsgSetInfo]];

sortTable ¬ RedBlackTree.Create[getKey: GetKey, compare: WalnutFilter.SortCompareProc[msI.sortby]];

[responses, complete] ¬ WalnutOps.GetNewMail[wH.opsH, active.msgSet.version, NewMsgProc];

RedBlackTree.EnumerateIncreasing[sortTable, AppendMsg];

IF ~complete THEN RETURN;

WalnutOps.AcceptNewMail[wH.opsH, active.msgSet.version];

active.msgSet.version ¬ active.msgSet.version+1;

RedBlackTree.DestroyTable[sortTable];

};

RemoveMsgFromMsgSetDisplayer: PUBLIC PROC[wH: WalnutHandle, msg: ROPE, msgSet: MsgSet] = {

msb: MsgSetButton = GetButton[wH, msgSet.name];

mfH: MsgSetFieldHandle;

msI: MsgSetInfo;

IF msb.msViewer = NIL OR msb.msViewer.destroyed THEN RETURN;

msI ¬ NARROW[ViewerOps.FetchProp[msb.msViewer, $MsgSetInfo]];

mfH ¬ msI.lastMFH;

IF mfH = NIL THEN RETURN; -- not there

IF msg.Equal[mfH.msgInfo.msg, FALSE] THEN EXIT;

mfH ¬ mfH.prev;

ENDLOOP;

RemoveFromDisplayedMsgSet[msI, msb.msViewer, mfH, TRUE];

};

MsgSetNamePrefix: PUBLIC PROC[wH: WalnutHandle] RETURNS[ROPE] =

{ RETURN[wH.msgSetNamePrefix] };

TryToDisplayMsg: PROC[wH: WalnutHandle, mfH: MsgSetFieldHandle] = {

DisplayOneMsg[wH, mfH, FALSE ! WalnutDefs.Error => CONTINUE]

};

DispatchOpOnSelections: PROC[

opProc: PROC[ops: MsgSetOpHandle],

parent: Viewer,

mouseButton: Menus.MouseButton,

shift, control: BOOL] ~ {

ops: MsgSetOpHandle ¬ NEW[MsgSetOpHandleRec ¬ []];

mfHs: MsgSetFieldHandles;

ops.msViewer ¬ NARROW[parent];

IF ops.msViewer#NIL THEN

ops.msI ¬ NARROW[ViewerOps.FetchProp[ops.msViewer, $MsgSetInfo]];

IF ops.msI=NIL THEN RETURN;

ops.mouseButton ¬ mouseButton;

ops.shift ¬ shift;

ops.control ¬ control;

FOR mfHs: MsgSetFieldHandles ¬ ops.msI.selected, mfHs.rest WHILE mfHs#NIL DO

ops.mfH ¬ mfHs.first;

ops.lastSelected ¬ mfHs.rest=NIL;

opProc[ops];

ENDLOOP;

};

MoveToProc: PUBLIC Menus.MenuProc ~ {

DispatchOpOnSelections[MoveToOpProc, parent, mouseButton, shift, control];

};

MoveToOpProc: PROC[ops: MsgSetOpHandle] ~ {

wH: WalnutHandle = ops.msI.button.wH;

selected: MsgSetFieldHandle;

displayProcess: PROCESS;

selected ¬ ops.mfH;

IF selected.tocButton = NIL THEN

{ WalnutWindow.Report[wH, destroyedMsg]; RETURN};

BEGIN

thisMsgSetB: MsgSetButton = ops.msI.button;

thisName: ROPE = thisMsgSetB.msgSet.name;

msgSetList: LIST OF MsgSetButton = GetSelectedMsgSets[wH];

first: BOOL ¬ TRUE;

msg: ROPE = selected.msgInfo.msg;

moveToSelf: BOOL ¬ FALSE;

fromDeleted: BOOL ¬ (thisMsgSetB = wH.deletedMsgSetButton);

IF msgSetList = NIL THEN

{ WalnutWindow.Report[wH, noSelDest]; RETURN};

First display the next message to keep the user busy

IF ops.lastSelected AND ops.mouseButton#red THEN

displayProcess ¬ FORK TryToDisplayMsg[wH, selected.next];

FOR msL: LIST OF MsgSetButton ¬ msgSetList, msL.rest UNTIL msL = NIL DO

IF thisName.Equal[msL.first.msgSet.name, FALSE] THEN moveToSelf ¬ TRUE

ELSE IF ~WalnutOps.AddMsg[wH.opsH, msg, thisMsgSetB.msgSet, msL.first.msgSet] THEN {

IF msL.first.msViewer # NIL THEN

AddToDisplayedMsgSet[msL.first, selected.msgInfo, NIL];

};

ENDLOOP;

IF ~fromDeleted THEN

IF NOT moveToSelf THEN [] ¬ WalnutOps.RemoveMsg[

wH.opsH, msg, thisMsgSetB.msgSet, MsgSetVersion[wH.deletedMsgSetButton] ];

FOR msL: LIST OF MsgSetButton ¬ msgSetList, msL.rest UNTIL msL=NIL DO

IF first THEN

{ ReportDisposition[wH, selected.msgInfo, movedTo]; first ¬ FALSE}

ELSE WalnutWindow.ReportRope[wH, comma];

WalnutWindow.ReportRope[wH, space];

WalnutWindow.ReportRope[wH, msL.first.msgSet.name];

ENDLOOP;

WalnutWindow.ReportRope[wH, newLine];

IF ~moveToSelf OR fromDeleted THEN

RemoveFromDisplayedMsgSet[ops.msI, ops.msViewer, ops.mfH, ops.lastSelected]

ELSE IF ops.lastSelected THEN [] ¬ AdvanceSelection[wH, selected];

Finally, make sure the displaying process is done

IF displayProcess # NIL THEN TRUSTED { [] ¬ JOIN displayProcess }

END;

};

ComeFrom: PUBLIC PROC[msb: MsgSetButton] = {

IF UserProfile.Boolean[walnutDotFancyNewMessageSelect, FALSE] THEN

FancyNewComeFrom[msb]

ELSE BadOldComeFrom[msb]

};

November 11, 1991 8:58:32 am PST; user can select a message from at most one message set at a time (within the same database). ComeFrom operation does not require that a particular message set be selected; the single selection determines the message set. D. Swinehart

FancyNewComeFrom: PROC[msb: MsgSetButton] = {

toName: ROPE ¬ msb.msgSet.name;

moveToSelf: BOOL ¬ FALSE;

wH: WalnutHandle = msb.wH;

fromMsb: MsgSetButton;

fromName: ROPE;

mfHL: LIST OF MsgSetFieldHandle;

mfH: MsgSetFieldHandle;

msgInfo: MsgInfo;

fromDeleted: BOOL;

msgWasDeleted: BOOL¬FALSE;

msI: MsgSetInfo ¬ wH.selectedMsgSet;

IF msI=NIL OR msI.button=NIL OR msI.selected=NIL THEN

{ WalnutWindow.Report[wH, noSelSource]; RETURN};

fromMsb ¬ msI.button;

fromDeleted ¬ fromMsb = wH.deletedMsgSetButton;

fromName ¬ fromMsb.msgSet.name;

FOR mfHL: LIST OF MsgSetFieldHandle ¬ msI.selected, mfHL.rest WHILE mfHL#NIL DO

last: BOOL ¬ mfHL.rest=NIL;

mfH ¬ mfHL.first;

IF toName.Equal[fromName, FALSE] THEN {

IF last THEN []¬AdvanceSelection[wH, mfH];

LOOP;

};

msgInfo ¬ mfH.msgInfo;

IF msb # wH.deletedMsgSetButton THEN

IF ~WalnutOps.AddMsg[wH.opsH, msgInfo.msg, fromMsb.msgSet, msb.msgSet]

THEN AddToDisplayedMsgSet[msb, msgInfo, NIL];

IF ~fromDeleted THEN

msgWasDeleted ¬ WalnutOps.RemoveMsg[wH.opsH, msgInfo.msg, fromMsb.msgSet,

MsgSetVersion[wH.deletedMsgSetButton] ];

IF msgWasDeleted THEN {

AddToDisplayedMsgSet[msb, msgInfo, NIL];

msI.lastDeleted ¬ msgInfo;

};

IF fromMsb.msViewer # NIL AND ~fromMsb.msViewer.destroyed THEN

RemoveFromDisplayedMsgSet[msI, fromMsb.msViewer, mfH, last];

ReportDisposition[wH, msgInfo, movedFrom];

WalnutWindow.ReportFormat[wH, formatGToGNewLine, [rope[fromMsb.msgSet.name]],

[rope[msb.msgSet.name]] ];

ENDLOOP;

};

Standard behavior; selected message from selected message set(s) is/are moved.

Works only when there is but one selected message.

BadOldComeFrom: PUBLIC PROC[msb: MsgSetButton] = {

toName: ROPE = msb.msgSet.name;

moveToSelf: BOOL ¬ FALSE;

wH: WalnutHandle = msb.wH;

fromMsgSetList: LIST OF MsgSetButton = GetSelectedMsgSets[wH];

IF fromMsgSetList = NIL THEN

{ WalnutWindow.Report[wH, noSelSource]; RETURN};

FOR msL: LIST OF MsgSetButton ¬ fromMsgSetList, msL.rest UNTIL msL = NIL DO

fromMsb: MsgSetButton = msL.first;

fromDeleted: BOOL = (fromMsb = wH.deletedMsgSetButton);

IF ~toName.Equal[fromMsb.msgSet.name, FALSE] THEN {

msI: MsgSetInfo = GetMSIFromMSB[fromMsb];

mfH: MsgSetFieldHandle;

msgInfo: MsgInfo;

IF msI # NIL THEN {

mfHL: LIST OF MsgSetFieldHandle ¬ msI.selected;

IF mfHL=NIL THEN {

WalnutWindow.Report[wH, noSelSource]; RETURN; };

mfH ¬ mfHL.first;

IF mfHL.rest#NIL THEN {

WalnutWindow.Report[wH, moreSelSource]; RETURN; };

};

msgInfo ¬ mfH.msgInfo;

IF ~WalnutOps.AddMsg[wH.opsH, msgInfo.msg, fromMsb.msgSet, msb.msgSet] THEN

IF msb.msViewer # NIL THEN AddToDisplayedMsgSet[msb, msgInfo, NIL];

IF ~fromDeleted THEN

[] ¬ WalnutOps.RemoveMsg[wH.opsH, msgInfo.msg, fromMsb.msgSet,

MsgSetVersion[wH.deletedMsgSetButton] ];

IF fromMsb.msViewer # NIL AND ~fromMsb.msViewer.destroyed THEN

RemoveFromDisplayedMsgSet[msI, fromMsb.msViewer, mfH, TRUE];

ReportDisposition[wH, msgInfo, movedFrom];

WalnutWindow.ReportFormat[wH, formatGToGNewLine, [rope[fromMsb.msgSet.name]],

[rope[msb.msgSet.name]] ];

};

ENDLOOP;

};

GetMSIFromMSB: PROC[msb: MsgSetButton] RETURNS[msI: MsgSetInfo] = {

IF msb.msViewer = NIL OR msb.msViewer.destroyed THEN RETURN;

msI ¬ NARROW[ViewerOps.FetchProp[msb.msViewer, $MsgSetInfo]];

};

MsgSetVersion: PROC[msb: MsgSetButton] RETURNS[msgSetVersion: INT] = {

IF msb = NIL OR msb.msViewer = NIL OR msb.msViewer.destroyed THEN

RETURN[WalnutDefs.dontCareMsgSetVersion]

ELSE RETURN[msb.msgSet.version]

};

NewMail: Menus.MenuProc = {

viewer: Viewer = NARROW[parent];

oldM: Menus.Menu = viewer.menu;

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[viewer, $MsgSetInfo]];

ViewerOps.SetMenu[viewer, buildingMenu];

BEGIN ENABLE UNWIND => ViewerOps.SetMenu[viewer, oldM];

WalnutWindow.GetNewMail[msI.button.wH];

ViewerOps.SetMenu[viewer, oldM];

END;

};

DeleteProc: PUBLIC Menus.MenuProc ~ {

DispatchOpOnSelections[DeleteOpProc, parent, mouseButton, shift, control];

};

DeleteOpProc: PROC[ops: MsgSetOpHandle] ~ {

msI: MsgSetInfo ¬ ops.msI;

wH: WalnutHandle ¬ msI.button.wH;

displayProcess: PROCESS;

selected: MsgSetFieldHandle ¬ ops.mfH;

IF selected.tocButton = NIL THEN

{ WalnutWindow.Report[wH, destroyedMsg]; RETURN};

BEGIN

thisMsgSet: MsgSet ¬ msI.button.msgSet;

nowInDeleted: BOOL;

IF thisMsgSet.name.Equal[WalnutOps.DeletedName] THEN RETURN; -- already deleted

IF ops.lastSelected AND ops.mouseButton#red THEN

displayProcess ¬ FORK TryToDisplayMsg[wH, selected.next];

nowInDeleted ¬ WalnutOps.RemoveMsg[

wH.opsH, selected.msgInfo.msg, thisMsgSet,

MsgSetVersion[wH.deletedMsgSetButton] ];

RemoveFromDisplayedMsgSet[msI, ops.msViewer, selected, ops.lastSelected];

ReportDisposition[wH, selected.msgInfo, deletedFrom];

WalnutWindow.Report[wH, thisMsgSet.name];

IF nowInDeleted THEN

AddToDisplayedMsgSet[wH.deletedMsgSetButton, selected.msgInfo, NIL];

IF displayProcess # NIL THEN TRUSTED { [] ¬ JOIN displayProcess }

END;

msI.lastDeleted ¬ selected.msgInfo;

};

AddProc: Menus.MenuProc ~ {

DispatchOpOnSelections[AddOpProc, parent, mouseButton, shift, control];

};

AddOpProc: PROC[ops: MsgSetOpHandle] ~ {

msI: MsgSetInfo ¬ ops.msI;

wH: WalnutHandle ¬ msI.button.wH;

selected: MsgSetFieldHandle ¬ ops.mfH;

displayProcess: PROCESS;

IF selected.tocButton = NIL THEN

{ WalnutWindow.Report[wH, destroyedMsg]; RETURN};

BEGIN

thisMsgSet: MsgSet ¬ msI.button.msgSet;

msgSetList: LIST OF MsgSetButton ¬ GetSelectedMsgSets[wH];

msg: ROPE ¬ selected.msgInfo.msg;

isDeleted: BOOL ¬ thisMsgSet.name.Equal[WalnutOps.DeletedName, FALSE];

removedFromDeleted: BOOL ¬ ~isDeleted;

first: BOOL ¬ TRUE;

addedTo: LIST OF MsgSetButton;

IF msgSetList = NIL THEN

{ WalnutWindow.Report[wH, noSelDest]; RETURN};

IF ops.lastSelected AND ops.mouseButton#red THEN

displayProcess ¬ FORK TryToDisplayMsg[wH, selected.next];

FOR msL: LIST OF MsgSetButton ¬ msgSetList, msL.rest UNTIL msL=NIL DO

exists: BOOL;

msgSet: MsgSet;

exists ¬ WalnutOps.AddMsg[wH.opsH, msg, thisMsgSet, msgSet ¬ msL.first.msgSet];

removedFromDeleted ¬ removedFromDeleted OR ~exists;

IF ~exists THEN

BEGIN

IF first THEN

{ ReportDisposition[wH, selected.msgInfo, addedToRL]; first ¬ FALSE}

ELSE WalnutWindow.ReportRope[wH, comma];

WalnutWindow.ReportRope[wH, msgSet.name];

addedTo ¬ CONS[msL.first, addedTo];

END;

ENDLOOP;

WalnutWindow.ReportRope[wH, newLine];

now update display

FOR msL: LIST OF MsgSetButton ¬ addedTo, msL.rest UNTIL msL=NIL DO

AddToDisplayedMsgSet[msL.first, selected.msgInfo, NIL];

ENDLOOP;

IF ops.lastSelected AND ops.mouseButton # red THEN [] ¬ AdvanceSelection[wH, selected];

IF removedFromDeleted THEN

RemoveMsgFromMsgSetDisplayer[wH, msg, wH.deletedMsgSetButton.msgSet];

IF displayProcess # NIL THEN TRUSTED { [] ¬ JOIN displayProcess }

END;

};

AddorAppendTo: PUBLIC PROC[wH: WalnutHandle, msg: ROPE, isAdd: BOOL,
fromButton, toButton: MsgSetButton] = {

msgInfo: MsgInfo;

adding to deleted doesn't make sense

IF Rope.Equal[toButton.msgSet.name, WalnutOps.DeletedName, FALSE] THEN RETURN;

msgInfo ¬ DoMsgInfo[wH: wH, msg: msg];

IF ~WalnutOps.AddMsg[wH.opsH, msg, fromButton.msgSet, toButton.msgSet].exists THEN {

AddToDisplayedMsgSet[toButton, msgInfo, NIL];

ReportDisposition[wH, msgInfo, IF isAdd THEN addedToRL ELSE appendedTo];

WalnutWindow.Report[wH, toButton.msgSet.name];

};

if this was an addTo from deleted and then remove message from deleted display viewer

IF Rope.Equal[fromButton.msgSet.name, WalnutOps.DeletedName, FALSE] THEN RemoveMsgFromMsgSetDisplayer[wH, msg, fromButton.msgSet];

};

MoveTo: PUBLIC PROC[msg: ROPE, fromButton, toButton: MsgSetButton] = {

msgInfo: MsgInfo;

wH: WalnutHandle = fromButton.wH;

msgInfo ¬ DoMsgInfo[wH, msg];

IF ~WalnutOps.MoveMsg[wH.opsH, msg, fromButton.msgSet, toButton.msgSet].exists THEN {

AddToDisplayedMsgSet[toButton, msgInfo, NIL];

RemoveMsgFromMsgSetDisplayer[wH, msg, fromButton.msgSet];

ReportDisposition[wH, msgInfo, movedTo];

WalnutWindow.Report[wH, toButton.msgSet.name];

};

RemoveFrom: PUBLIC PROC[msg: ROPE, fromButton: MsgSetButton] = {

msgInfo: MsgInfo;

nowInDeleted: BOOL ¬ FALSE;

wH: WalnutHandle = fromButton.wH;

removing from deleted doesn't make sense

IF Rope.Equal[fromButton.msgSet.name, WalnutOps.DeletedName, FALSE] THEN RETURN;

msgInfo ¬ DoMsgInfo[wH, msg];

nowInDeleted ¬

WalnutOps.RemoveMsg[wH.opsH, msg, fromButton.msgSet, WalnutOps.dontCareMsgSetVersion];

RemoveMsgFromMsgSetDisplayer[wH, msg, fromButton.msgSet];

ReportDisposition[wH, msgInfo, removedFrom];

WalnutWindow.Report[wH, fromButton.msgSet.name];

IF nowInDeleted THEN

AddToDisplayedMsgSet[wH.deletedMsgSetButton, msgInfo, NIL];

};

AdvanceSelection: PROC[wH: WalnutHandle, mfH: MsgSetFieldHandle]

RETURNS[next: MsgSetFieldHandle] = {

IF mfH = NIL THEN RETURN[NIL];

next ¬ mfH.next;

IF next = NIL THEN { WalnutWindow.Report[wH, noNext]; RETURN };

SelectMsgInMsgSet[wH, next]

};

DisplayProc: PUBLIC Menus.MenuProc ~ {

DispatchOpOnSelections[DisplayOpProc, parent, mouseButton, shift, control];

};

DisplayOpProc: PROC[ops: MsgSetOpHandle] ~ {

msI: MsgSetInfo ~ ops.msI;

selected: MsgSetFieldHandle ¬ ops.mfH;

wH: WalnutHandle = msI.button.wH;

IF ops.lastSelected AND ops.mouseButton # red THEN

selected ¬ AdvanceSelection[wH, selected];

IF selected = NIL THEN RETURN;

IF selected.tocButton = NIL THEN

{ WalnutWindow.Report[wH, destroyedMsg]; RETURN};

DisplayOneMsg[wH, selected, ops.shift];

IF NOT ops.lastSelected THEN

Process.PauseMsec[1000*UserProfile.Number[walnutDotMovieMailFrameRate, defaultMovieMailFrameRate]];

};

PrintSel: PROC[wH: WalnutHandle,msViewer: Viewer, server: ROPE ¬ NIL,
howToPrint: HowToPrint ¬ press, copies: INT ¬ 1] = {

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

selected: MsgSetFieldHandle;

Ps: PROC = {

[] ¬ PrintMsgList[wH, LIST[selected.msgInfo.msg], msViewer, server, howToPrint, copies];

};

IF msI = NIL THEN RETURN;

FOR mfHL: LIST OF MsgSetFieldHandle ¬ msI.selected, mfHL.rest WHILE mfHL#NIL DO

selected ¬ mfHL.first;

IF selected.tocButton = NIL THEN

{ WalnutWindow.Report[wH, destroyedMsg]; RETURN};

[] ¬ DoWaitCall[wH, Ps];

ENDLOOP;

};

PrintSelCmd: PUBLIC PROC[wH: WalnutHandle,

msgSet: ROPE, server: ROPE, howToPrint: HowToPrint, copies: INT] = {

msb: MsgSetButton = GetButton[wH, msgSet];

IF msb = NIL THEN RETURN;

IF msb.msViewer = NIL THEN RETURN;

PrintSel[wH, msb.msViewer, server, howToPrint, copies];

};

MSPProc: PROC[wH: WalnutHandle, viewer: Viewer, howToPrint: HowToPrint] = {

Mspp: PROC = { MsgSetPrintProc[wH, viewer, howToPrint] };

[] ¬ DoWaitCall[wH, Mspp];

};

MSTPProc: PROC[wH: WalnutHandle, viewer: Viewer, howToPrint: HowToPrint] = {

Mstp: PROC = { MsgSetTOCPrintProc[wH, viewer, howToPrint] };

[] ¬ DoWaitCall[wH, Mstp];

};

DoAppendMsg: PUBLIC PROC[wH: WalnutHandle, curSel: ROPE, curV: Viewer,
msgSetList: LIST OF MsgSetButton] = {

tc: ViewerTools.TiogaContents;

Amp: PROC = {

active: MsgSetButton = wH.activeMsgSetButton;

msgID, msgName: ROPE;

includesActive: BOOL ¬ FALSE;

nowInDeleted: BOOL ¬ FALSE;

IF curSel.Length[] < 2 THEN {

msgAndWH: WalnutWindowPrivate.MsgAndHandle;

IF curV = NIL THEN {

WalnutWindow.Report[wH, noSelSource];

RETURN

};

msgAndWH ¬ NARROW[ViewerOps.FetchProp[curV, $WalnutMsgName]];

IF msgAndWH # NIL THEN {

pos: INT = Rope.Find[msgID ¬ msgAndWH.msg, dollarSign];

IF pos = 0 THEN msgName ¬ msgID

ELSE msgName ¬ msgID.Substr[pos];

}

ELSE {

another: ROPE ¬ NARROW[ViewerOps.FetchProp[curV, $CherryMsgName]];

IF another # NIL THEN {

pos: INT = Rope.Find[msgID ¬ another, dollarSign];

IF pos = 0 THEN msgName ¬ msgID

ELSE msgName ¬ msgID.Substr[pos];

};

tc ¬ SendMailOps.GetCRTiogaContents[curV];

}

ELSE {

tc ¬ NEW[ViewerTools.TiogaContentsRec];

tc.contents ¬ curSel;

};

IF msgID = NIL THEN

msgID ¬ msgName ¬ WalnutOps.GenerateUniqueMsgName[wH.opsH];

IF NOT WalnutOps.MsgExists[wH.opsH, msgName] THEN {

WalnutOps.CreateMsg[wH.opsH, msgID, tc];

WalnutOps.SetHasBeenRead[wH.opsH, msgName];

IF active.msViewer # NIL THEN active.msgSet.version ¬ active.msgSet.version + 1;

};

FOR msL: LIST OF MsgSetButton ¬ msgSetList, msL.rest UNTIL msL = NIL DO

IF msL.first = active THEN {

includesActive ¬ TRUE;

AddToDisplayedMsgSet[active, DoMsgInfo[wH, msgName], NIL];

if active is displayed, then its version number got incremented twice

IF active.msViewer # NIL THEN active.msgSet.version ¬ active.msgSet.version - 1;

}

ELSE AddorAppendTo[wH: wH, msg: msgName, isAdd: FALSE, fromButton: active, toButton: msL.first];

ENDLOOP;

IF NOT includesActive THEN {

nowInDeleted ¬ WalnutOps.RemoveMsg[wH.opsH, msgName, active.msgSet, WalnutOps.dontCareMsgSetVersion];

IF active.msViewer # NIL THEN active.msgSet.version ¬ active.msgSet.version + 1;

};

IF nowInDeleted THEN
AddToDisplayedMsgSet[wH.deletedMsgSetButton, DoMsgInfo[wH, msgName], NIL];

};

[] ¬ DoWaitCall[wH, Amp];

};

FindProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

IF ~TiogaOps.FindText[

viewer: msI.tiogaViewer,

whichDir: GetDirection[mouseButton],

which: feedback,

case: ~shift]

THEN ViewerOps.BlinkIcon[msViewer];

};

WordProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

IF ~TiogaOps.FindWord[

viewer: msI.tiogaViewer,

whichDir: GetDirection[mouseButton],

which: feedback,

case: ~shift]

THEN ViewerOps.BlinkIcon[msViewer];

};

DefProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

IF ~TiogaOps.FindDef[

viewer: msI.tiogaViewer,

whichDir: GetDirection[mouseButton],

which: feedback,

case: ~shift]

THEN ViewerOps.BlinkIcon[msViewer];

};

PositionProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

TiogaMenuOps.Position[msI.tiogaViewer];

};

NormalizeProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

TiogaMenuOps.Normalize[msI.tiogaViewer];

};

PrevPlaceProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

TiogaMenuOps.PrevPlace[msI.tiogaViewer];

};

FirstOnlyProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

TiogaMenuOps.FirstLevelOnly[msI.tiogaViewer];

};

MoreLevelsProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

TiogaMenuOps.MoreLevels[msI.tiogaViewer];

};

FewerLevelsProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

TiogaMenuOps.FewerLevels[msI.tiogaViewer];

};

AllLevelsProc: Menus.MenuProc = {

msViewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[msViewer, $MsgSetInfo]];

IF msI = NIL THEN RETURN;

TiogaMenuOps.AllLevels[msI.tiogaViewer];

};

LevelsProc: Menus.MenuProc = { ChangeTheMenu[v: NARROW[parent], isLevels: TRUE] };

PlacesProc: Menus.MenuProc = { ChangeTheMenu[v: NARROW[parent], isLevels: FALSE] };

GetDirection: PROC[mb: Menus.MouseButton] RETURNS[sd: TiogaOps.SearchDir¬forwards] = {

SELECT mb FROM

red => RETURN[forwards];

yellow => RETURN[anywhere];

blue => RETURN[backwards];

ENDCASE;

};

OpsProc: Menus.MenuProc = {

ChoicesFromMenuEntry: PROC [me: Menus.MenuEntry] RETURNS [choices: LIST OF ROPE] ~ {

l: LIST OF ROPE ¬ NIL;

IF me = NIL THEN RETURN[NIL];

choices ¬ LIST[me.name];

me ¬ me.link;

l ¬ choices;

WHILE me # NIL DO

l.rest ¬ LIST[me.name];

me ¬ me.link;

l ¬ l.rest;

ENDLOOP;

};

ConcatLists: PROC [l1, l2: LIST OF ROPE] RETURNS [LIST OF ROPE] ~ {

l: LIST OF ROPE ¬ l1;

WHILE l.rest # NIL DO l ¬ l.rest; ENDLOOP;

l.rest ¬ l2;

RETURN[l1];

};

viewer: Viewer = NARROW[parent];

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[viewer, $MsgSetInfo]];

wH: WalnutHandle = msI.button.wH;

mouseNotRed: BOOL = (mouseButton # red);

choices: LIST OF ROPE ¬ LIST[

-- 1-- "Sender",

-- 2-- "UndoLastDelete",

-- 3-- "Size Of MsgSet",

-- 4-- "Msg Info",

-- 5-- "Append Msg",

-- 6-- "Interpress3.0PrintMsgSet",

-- 7-- "Interpress3.0PrintSelectedMsg",

-- 8-- "Interpress3.0PrintTOC",

-- 9-- "R.O.T. MsgSet"];

moreChoices: LIST OF ROPE;

moreProcs: Menus.MenuEntry;

which: INT;

moreProcs ¬ WalnutFilter.MenuExtras[$msgsetops];

moreChoices ¬ ChoicesFromMenuEntry[moreProcs];

choices ¬ ConcatLists[choices, moreChoices];

which ¬ PopUpSelection.Request[header: "MessageOps", choice: choices];

SELECT which FROM

1 => [] ¬ SendMailOps.CreateSendViewer[fromExec: FALSE];

2 => {

current: MsgSet;

msg: ROPE;

IF msI = NIL THEN RETURN;

IF msI.lastDeleted = NIL THEN

{ WalnutWindow.Report[wH, noUndo]; RETURN };

msg ¬ msI.lastDeleted.msg;

current ¬ [WalnutOps.GetCategories[wH.opsH, msg].first, WalnutOps.dontCareMsgSetVersion];

[] ¬ WalnutOps.AddMsg[opsHandle: wH.opsH, msg: msg, from: current, to: msI.button.msgSet];

IF current.name.Equal[WalnutOps.DeletedName, FALSE] THEN {

dViewer: Viewer = wH.deletedMsgSetButton.msViewer;

dMsi: MsgSetInfo;

mfH: MsgSetFieldHandle;

IF dViewer # NIL AND ~dViewer.destroyed THEN {

dMsi ¬ NARROW[ViewerOps.FetchProp[dViewer, $MsgSetInfo]];

mfH ¬ dMsi.lastMFH;

IF mfH = NIL THEN EXIT;

IF mfH.msgInfo = msI.lastDeleted THEN EXIT;

mfH ¬ mfH.prev;

ENDLOOP;

IF mfH # NIL THEN RemoveFromDisplayedMsgSet[dMsi, dViewer, mfH, FALSE];

};

AddToDisplayedMsgSet[msI.button, msI.lastDeleted, msI];

ReportDisposition[wH, msI.lastDeleted, addedToRL];

WalnutWindow.Report[wH, msI.button.msgSet.name];

msI.lastDeleted ¬ NIL;

};

3 => {

msgSet: ROPE = msI.button.msgSet.name;

num: INT = WalnutOps.SizeOfMsgSet[wH.opsH, msgSet].messages;

WalnutWindow.ReportFormat[wH,

" %g msgs in MsgSet %g", [integer[num]], [rope[msgSet]] ];

};

4 => {

IF msI = NIL OR msI.selected = NIL THEN { WalnutWindow.Report[wH, noSelSource]; RETURN };

FOR selList: LIST OF MsgSetFieldHandle ¬ msI.selected, selList.rest

WHILE selList#NIL DO

textLen, formatLen: INT;

msg: ROPE;

selected: MsgSetFieldHandle ¬ selList.first;

IF selected.tocButton = NIL THEN

{ WalnutWindow.Report[wH, destroyedMsg]; RETURN };

[textLen, formatLen] ¬ WalnutOps.GetMsgSize[wH.opsH, msg ¬ selected.msgInfo.msg];

WalnutWindow.ReportFormat[wH, "\nPostmark: %g\n", [rope[msg]]];

WalnutWindow.ReportFormat[wH, " TOC: %g\n", [rope[selected.msgInfo.tocName]]];

WalnutWindow.ReportFormat[wH, " Length: %g bytes\n", [integer[textLen]] ];

MsgCategories[wH, msg];

ENDLOOP;

};

5 => DoAppendMsg[wH, ViewerTools.GetSelectionContents[], ViewerTools.GetSelectedViewer[], LIST[msI.button]];

6 => MSPProc[wH: wH, viewer: viewer, howToPrint: ip3];

7 => PrintSel[wH: wH, msViewer: viewer, howToPrint: ip3];

8 => MSTPProc[wH: wH, viewer: viewer, howToPrint: ip3];

9 => DoRemoveOverThere[wH, msI.button.msgSet.name, GetSelectedMsgSets[wH] ];

ENDCASE => IF moreChoices # NIL THEN {

i: INT ¬ 10;

plist: Menus.MenuEntry ¬ moreProcs;

WHILE i < which AND plist # NIL DO

i ¬ i + 1;

plist ¬ plist.link;

ENDLOOP;

IF i = which AND plist # NIL THEN

plist.proc[parent, clientData, mouseButton, shift, control];

};

ReportDisposition: PROC[wH: WalnutHandle, msgInfo: MsgInfo, r: ROPE] = {

msgSubject: ROPE ¬ Rope.Substr[msgInfo.tocName, msgInfo.startOfSubject];

SELECT msgSubject.Length[] FROM

< 2 => msgSubject ¬ "No Subject field";

> 24 => msgSubject ¬ Rope.Concat[msgSubject.Substr[0, 21], " ..."];

ENDCASE => NULL;

WalnutWindow.ReportFormat[wH, "Msg: %g: has been %g", [rope[msgSubject]], [rope[r]] ];

};

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

MSViewer: PROC[wH: WalnutHandle, msb: MsgSetButton, oldV: Viewer, shift: BOOL]

RETURNS[msV: Viewer] = {

col: ROPE = UserProfile.Token[walnutDotMsgSetColumn, leftRL];

aCol: ROPE = UserProfile.Token[walnutDotActiveMsgSetColumn, rightRL];

iconic: BOOL ¬ FALSE;

whichSide: ViewerClasses.Column ¬ left;

msgSet: MsgSet = msb.msgSet;

caption: ROPE = wH.identifierPrefix.Cat[msgSet.name, " Messages"];

msI: MsgSetInfo;

openHeight: INTEGER ¬ 0;

isActive: BOOL = msgSet.name.Equal[WalnutOps.ActiveName, FALSE];

WhichCol: PROC[rp: ROPE, df: ViewerClasses.Column] RETURNS[ViewerClasses.Column] = {

SELECT TRUE FROM

rp.Equal[leftRL, FALSE] => RETURN[left];

rp.Equal["color", FALSE] => RETURN[df]; -- ignores color request

rp.Equal[rightRL, FALSE] => RETURN[right];

ENDCASE => RETURN[df];

};

IF isActive THEN {

iconic ¬ initialActiveIconic AND initialActiveOpen;

whichSide ¬ WhichCol[UserProfile.Token[walnutDotActiveMsgSetColumn, rightRL], right ];

IF openHeightForActive > 0 THEN openHeight ¬ openHeightForActive;

}

ELSE whichSide ¬ WhichCol[UserProfile.Token[walnutDotMsgSetColumn, leftRL], left ];

IF oldV # NIL AND oldV.destroyed THEN oldV ¬ NIL;

IF oldV # NIL THEN {

msI ¬ NARROW[ViewerOps.FetchProp[oldV, $MsgSetInfo]];

IF msI.button.wH # wH THEN {

WalnutWindow.ReportFormat[wH, "MsgSet displayer for %g belongs to a different Walnut Control Window", [rope[msI.button.msgSet.name]] ];

oldV ¬ NIL;

};

IF oldV # NIL THEN { -- must check once more

oldMsgSetName: ROPE;

msI ¬ NARROW[ViewerOps.FetchProp[oldV, $MsgSetInfo]];

oldMsgSetName ¬ msI.button.msgSet.name;

oldV.inhibitDestroy ¬ TRUE;

IF ~Rope.Equal[msgSet.name, oldMsgSetName, FALSE] THEN {

oldV.name ¬ caption;

GetButton[wH, oldMsgSetName].msViewer ¬ NIL;

GetButton[wH, msgSet.name].msViewer ¬ oldV

}

ELSE { -- check the version to see if all's well

IF msI.button.msgSet.version = WalnutOps.MsgSetExists[wH.opsH,

msgSet.name, wH.msgSetsVersion].version THEN {

oldV.inhibitDestroy ¬ FALSE;

RETURN[oldV]

}

};

ViewerOps.DestroyViewer[msI.tiogaViewer];

msI.selected ¬ NIL;

msI.lastMFH ¬ NIL;

msI.tiogaViewer ¬ NIL;

msV ¬ oldV;

}

ELSE {

msV ¬ ViewerOps.CreateViewer[

flavor: $Container,

info: [name: caption, column: whichSide, menu: NIL,

iconic: iconic, icon: msgSetIcon, scrollable: FALSE, inhibitDestroy: TRUE,

openHeight: openHeight

]];

wH.msgSetViewerList ¬ CONS[msV, wH.msgSetViewerList];

msI ¬ NEW[MsgSetInfoRec];

msI.button ¬ msb;

msI.container ¬ msV;

msI.sortby ¬ WalnutFilter.InitialSortOrder[msgSet.name];

msI.destroyER ¬

ViewerEvents.RegisterEventProc[DestroyMSViewer, destroy, msV, TRUE];

IF isActive THEN

[] ¬ ViewerEvents.RegisterEventProc[proc: ResetMailState, event: open, filter: msV];

};

IF msI.tiogaViewer = NIL THEN {

width: INT ¬ IF msV.column = right THEN ViewerSpecs.openRightWidth ELSE

ViewerSpecs.openLeftWidth;

msI.tiogaViewer ¬ TiogaButtons.CreateViewer[

info: [parent: msV, border: FALSE, ww: width, wh: ViewerSpecs.bwScreenHeight]];

TiogaButtons.SetStyleFromRope[v: msI.tiogaViewer, styleRope: msgSetStyle];

Containers.ChildXBound[msV, msI.tiogaViewer];

Containers.ChildYBound[msV, msI.tiogaViewer];

};

ViewerOps.AddProp[msV, $MsgSetInfo, msI];

msV.label ¬ wH.identifierPrefix.Concat[msgSet.name];

MsgSetInViewer[wH, msgSet, msI, shift, isActive];

IF isActive AND NOT iconic THEN [] ¬ ResetMailState[msV, open, TRUE];

};

msgSetStyle: ROPE ¬ "BeginStyle

(Cedar) AttachStyle

(header) \"a message header\" {

default

200 pt restIndent

} StyleRule

EndStyle";

DestroyMSViewer: ViewerEvents.EventProc = {

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[viewer, $MsgSetInfo]];

msI.button.msgSet.version ¬ WalnutDefs.dontCareMsgSetVersion;

msI.button.msViewer ¬ NIL;

ViewerEvents.UnRegisterEventProc[msI.destroyER, destroy];

};

AutoScrollRef: TYPE = REF AutoScrollObject;

AutoScrollObject: TYPE = RECORD

[ eventReg: ViewerEvents.EventRegistration, v: Viewer, firstUnread, last: INT ];

MsgSetInViewer: PROC[wH: WalnutHandle, msgSet: MsgSet, msI: MsgSetInfo, shift, isActive: BOOL] = {

OPEN ViewerOps;

firstUnread, last: INT;

userSaidStop: BOOL;

autoScroll: BOOL = UserProfile.Boolean[key: "Walnut.AutoScrollMsgSets", default: TRUE];

v: Viewer = msI.tiogaViewer;

parent: Viewer = v.parent;

menu: Menus.Menu ¬

IF wH.readOnlyAccess THEN wH.readOnlyMenu ELSE

IF isActive THEN

IF wH.personalMailDB THEN wH.activeMenu ELSE wH.displayerMenu ELSE

IF msgSet.name.Equal[WalnutOps.DeletedName, FALSE] THEN wH.deletedMenu ELSE wH.displayerMenu;

ScrollMsgSet: PROC = {

IF autoScroll AND last#-1 THEN

{ IF v.parent.iconic THEN

{ scroll: ViewerEvents.EventRegistration ¬

ViewerEvents.RegisterEventProc[AutoScroll, open, v.parent, FALSE];

after

ViewerOps.AddProp[v.parent, $autoScroll,

NEW[AutoScrollObject ¬ [scroll, v, firstUnread, last]]];

}

ELSE DoScroll[v, firstUnread, last];

};

SetMenu[parent, menu];

};

[] ¬ v.class.scroll[v, thumb, 0]; -- position at beginning

IF ~parent.iconic THEN ComputeColumn[parent.column, TRUE];

parent.newVersion ¬ TRUE; PaintViewer[parent, caption];

SetMenu[parent, buildingMenu];

[firstUnread, last, userSaidStop] ¬ FillInMsgSetWindow[wH, parent, msI, msgSet.name];

IF userSaidStop THEN {

parent.inhibitDestroy ¬ FALSE;

msI.button.msViewer ¬ NIL;

ViewerEvents.UnRegisterEventProc[msI.destroyER, destroy];

ViewerOps.DestroyViewer[parent];

RETURN;

};

ScrollMsgSet[];

ViewerLocks.CallUnderWriteLock[ScrollMsgSet, v];

parent.newVersion ¬ FALSE; PaintViewer[parent, caption];

IF shift THEN

{ IF parent.iconic THEN ViewerOps.OpenIcon[parent, shift] ELSE ViewerOps.GrowViewer[parent]};

parent.inhibitDestroy ¬ FALSE;

};

DoScroll: PROC[viewer: Viewer, firstUnread, last: INT] = {

top, bottom, howMuch: INTEGER;

count: INTEGER ¬ 0;

[top, bottom] ¬ viewer.class.scroll[viewer, query, 0];

IF (bottom = LAST[INTEGER]) AND ((count ¬ count + 1) < 5) THEN {

Process.Pause[Process.MsecToTicks[scrollWaitTime]];

LOOP

};

EXIT;

ENDLOOP;

IF bottom >= 95 OR last <=0 THEN RETURN;

howMuch ¬ IF firstUnread <= 0 THEN (last - 3) ELSE

IF firstUnread > (last - 3) THEN (last - 3) ELSE firstUnread;

[] ¬ viewer.class.scroll[viewer, thumb, (howMuch*100)/last];

};

ResetMailState: ViewerEvents.EventProc = {

IF ( UserProfile.Boolean[key: "Walnut.AutoNewMail", default: FALSE] ) AND

( NOT viewer.destroyed ) THEN {

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[viewer, $MsgSetInfo]];

IF msI.button.wH.personalMailDB THEN

WalnutInternal.SetMailState[msI.button.wH, noMail];

};

AutoScroll: ViewerEvents.EventProc = {

autoScroll: AutoScrollRef = NARROW[ViewerOps.FetchProp[viewer, $autoScroll]];

ViewerEvents.UnRegisterEventProc[autoScroll.eventReg, open]; -- once only

DoScroll[autoScroll.v, autoScroll.firstUnread, autoScroll.last];

};

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

for adding new messages to displayed MsgSet

AddToDisplayedMsgSet: PROC[msb: MsgSetButton, msgInfo: MsgInfo, msI: MsgSetInfo] = {

IF msb.msViewer # NIL THEN {

IF msb.msViewer.destroyed THEN { msb.msViewer ¬ NIL; RETURN };

IF msI = NIL THEN msI ¬ NARROW[ViewerOps.FetchProp[msb.msViewer, $MsgSetInfo]];

BuildMsgLineViewer[msI, msgInfo];

msI.button.msgSet.version ¬ msb.msgSet.version ¬ msI.button.msgSet.version+1;

};

called with parent & MsgSetFieldHandle 'displaying' msg to be deleted

RemoveFromDisplayedMsgSet: PROC[

msI: MsgSetInfo, msViewer: Viewer, mfH: MsgSetFieldHandle, selectNext: BOOL] = {

prev, next: MsgSetFieldHandle;

bt: TiogaButton;

bt ¬ mfH.tocButton;

prev ¬ mfH.prev;

next ¬ mfH.next;

take which out of chain of mfh's

IF prev # NIL THEN prev.next ¬ next;

IF next # NIL THEN next.prev ¬ prev;

TiogaButtons.DeleteButton[bt];

IF selectNext THEN {

FOR msS: LIST OF MsgSetFieldHandle ¬ msI.selected, msS.rest WHILE msS#NIL DO

IF msS.first=mfH THEN GOTO SelectIt;

REPEAT

SelectIt =>

IF next#NIL THEN {

msI.selected ¬ LIST[next];

TiogaButtons.ChangeButtonLooks[button: next.tocButton,

addLooks: tocSelectedLooks, removeLooks: tocDefaultLooks];

}

ELSE msI.selected ¬ NIL;

ENDLOOP;

};

IF msI.lastMFH = mfH THEN msI.lastMFH ¬ prev;

msI.button.msgSet.version ¬ msI.button.msgSet.version+1;

};

GetKey: RedBlackTree.GetKey ~ { -- can't be an internal procedure in Cedar10.1

mfh: MsgSetFieldHandle ¬ NARROW[data];

RETURN[mfh];

};

FillInMsgSetWindow: PROC[wH: WalnutHandle, parent: Viewer, msI: MsgSetInfo, msgSet: ROPE]

RETURNS[firstUnread, last: INT, userSaidStop: BOOL] = {

version: INT;

displayingRef: DisplayingRef ¬ NEW[DisplayingRefRec ¬ [FALSE]];

sortTable: RedBlackTree.Table;

WantsToStop: ENTRY PROC RETURNS[BOOL] = {

ENABLE UNWIND => NULL;

RETURN[displayingRef.userSaidStop]

};

MsgInfoProc: PROC[msg, tocEntry: ROPE, hasBeenRead: BOOL, startOfSubject: INT] RETURNS[continue: BOOL] = {

oldTB: TiogaButton¬NIL;

where: EditSpan.Place ¬ before;

mfh: MsgSetFieldHandle;

msgInfo: MsgInfo;

IF ( userSaidStop ¬ WantsToStop[] ) THEN RETURN[FALSE];

msgInfo ¬ CreateMsgInfo[msg, hasBeenRead, tocEntry, startOfSubject];

mfh ¬ NARROW[RedBlackTree.LookupNextLarger[sortTable, NEW[MsgSetFieldHandleRec ¬ [msgInfo: msgInfo]]]];

IF mfh#NIL THEN oldTB ¬ mfh.tocButton;

BuildMsgLineViewer[

msI, msgInfo, oldTB, where];

last ¬ last + 1;

IF firstUnread = -1 AND ~msI.lastMFH.msgInfo.hasBeenRead THEN

firstUnread ¬ last;

RedBlackTree.Insert[sortTable, msI.lastMFH, msI.lastMFH!

RedBlackTree.DuplicateKey => WalnutWindow.Report[wH, "Duplicate Msg ID in message set!"]];

RETURN[TRUE];

};

ReorderMsgs: RedBlackTree.EachNode ~ {

mfh: MsgSetFieldHandle ¬ NARROW[data];

mfh.prev ¬ msI.lastMFH;

IF msI.lastMFH#NIL THEN msI.lastMFH.next ¬ mfh;

msI.lastMFH ¬ mfh;

};

sortTable ¬ RedBlackTree.Create[getKey: GetKey, compare: WalnutFilter.SortCompareProc[msI.sortby]];

ViewerOps.AddProp[parent, $DisplayingRef, displayingRef];

ViewerOps.SetMenu[parent, fillingInMenu];

userSaidStop ¬ FALSE;

firstUnread ¬ -1;

last ¬ 0;

version ¬ WalnutOps.EnumerateMsgsInSet[wH.opsH, msgSet, TRUE, MsgInfoProc];

IF NOT userSaidStop THEN msI.button.msgSet.version ¬ version;

ViewerOps.AddProp[parent, $DisplayingRef, NIL];

msI.lastMFH ¬ NIL;

RedBlackTree.EnumerateIncreasing[sortTable, ReorderMsgs];

IF msI.lastMFH#NIL THEN msI.lastMFH.next ¬ NIL;

RedBlackTree.DestroyTable[sortTable];

};

AbortEnumProc: ENTRY Menus.MenuProc = {

ENABLE UNWIND => NULL;

self: Viewer ¬ NARROW[parent];

displayingRef: DisplayingRef ¬ NARROW[ViewerOps.FetchProp[self, $DisplayingRef]];

IF displayingRef = NIL THEN RETURN;

displayingRef.userSaidStop ¬ TRUE;

ViewerOps.SetMenu[self, buildingMenu];

};

DoMsgInfo: PROC[wH: WalnutHandle, msg: ROPE] RETURNS[msgInfo: MsgInfo] = {

tocEntry: ROPE;

hasBeenRead: BOOL;

startOfSubject: INT;

[hasBeenRead, tocEntry, startOfSubject] ¬ WalnutOps.GetDisplayProps[wH.opsH, msg];

RETURN[CreateMsgInfo[msg, hasBeenRead, tocEntry, startOfSubject]];

};

CreateMsgInfo: PROC[msg: ROPE, hasBeenRead: BOOL, tocEntry: ROPE, startOfSubject: INT]
RETURNS[msgInfo: MsgInfo] = {

GetDate: PROC[msg: ROPE] RETURNS [bt: BasicTime.GMT] ~ {

at: INT ¬ Rope.Find[msg, atSign];

IF at = -1 THEN RETURN[BasicTime.earliestGMT];

bt ¬ Convert.TimeFromRope[msg.Substr[start: at+1] ! Convert.Error =>
{ bt ¬ BasicTime.earliestGMT; CONTINUE} ];

};

msgInfo ¬ NEW[MsgInfoRec ¬ [msg, tocEntry, startOfSubject, hasBeenRead, GetDate[msg], WalnutFilter.MsgInterestLevel[msg]]];

};

BuildMsgLineViewer: PROC[msI: MsgSetInfo, msgInfo: MsgInfo,

oldButton: TiogaButton¬NIL, where: EditSpan.Place¬before] = {

tocLooks: ROPE ¬ IF msgInfo.hasBeenRead THEN tocDefaultLooks ELSE tocUnreadLooks;

tocRope: ROPE ¬ msgInfo.tocName;

needsQ: BOOL ¬ userWantsQMs OR (tocUnreadLooks = NIL);

mfh: MsgSetFieldHandle ¬ NEW[MsgSetFieldHandleRec ¬ [

prev: msI.lastMFH,

tocButton: NIL,

msI: msI,

msgInfo: msgInfo]];

tocRope ¬ WalnutFilter.MessageTOC[tocRope, msgInfo];

tocRope ¬ Rope.Concat[tabChar, tocRope];

IF ~msgInfo.hasBeenRead AND needsQ THEN BEGIN

tocRope ¬ Rope.Concat[questionMark, tocRope];

END;

mfh.tocButton ¬ TBQueue.CreateTiogaButtonAtNode[

q: msI.button.wH.walnutQueue,

viewer: msI.tiogaViewer,

oldButton: oldButton,

where: where,

rope: tocRope,

format: "header",

looks: tocLooks,

proc: MsgSetSelectionProc,

clientData: mfh];

IF msI.lastMFH # NIL THEN msI.lastMFH.next ¬ mfh;

msI.lastMFH ¬ mfh;

};

MsgSetSelectionProc: TiogaButtons.TiogaButtonProc = {

mfH: MsgSetFieldHandle = NARROW[clientData];

wH: WalnutHandle;

ctrlSh: INT ¬ IF control THEN 1 ELSE 0;

selOp: SelOp ¬ $none;

IF shift THEN ctrlSh ¬ ctrlSh+2;

IF mfH = NIL THEN RETURN;

wH ¬ mfH.msI.button.wH;

IF button = NIL THEN { WalnutWindow.Report[wH, noMsgRope]; RETURN; };

SELECT mouseButton FROM

red => SELECT ctrlSh FROM

0 => selOp ¬ $selOne;

1 => {

SelectMsgInMsgSet[wH, mfH, $selOne];

DeleteProc[parent: mfH.msI.container, mouseButton: mouseButton];

};

2 => TiogaOps.InsertRope[mfH.msgInfo.tocName];

ENDCASE;

yellow => SELECT ctrlSh FROM

0,2 => {SelectMsgInMsgSet[wH, mfH]; DisplayOneMsg[wH, mfH, shift]; };

1 => {

SelectMsgInMsgSet[wH, mfH, $selOne];

DeleteProc[parent: mfH.msI.container, mouseButton: mouseButton];

};

ENDCASE;

blue => SELECT ctrlSh FROM

0 => selOp ¬ $extend;

1 => NULL;

2 => selOp ¬ $deselect;

3 => selOp ¬ $add;

ENDCASE;

IF selOp#$none THEN SelectMsgInMsgSet[wH, mfH, selOp];

};

SelOp: TYPE ~ { none, selOne, extend, deselect, add };

SelectMsgInMsgSet: PROC[wH: WalnutHandle,

mfH: MsgSetFieldHandle, op: SelOp¬$selOne]~{

IF UserProfile.Boolean[walnutDotFancyNewMessageSelect, FALSE]

THEN FancyNewSelectMsgInMsgSet[wH, mfH, op]

ELSE IF op=$selOne THEN BadOldSelectMsgInMsgSet[wH, mfH];

};

FancyNewSelectMsgInMsgSet: PROC[wH: WalnutHandle, mfH: MsgSetFieldHandle, op: SelOp] ~ {

msI: MsgSetInfo;

prevMSI: MsgSetInfo = wH.selectedMsgSet;

prevSelecteds: LIST OF MsgSetFieldHandle;

IF mfH.tocButton = NIL THEN { WalnutWindow.Report[wH, noMsgRope]; RETURN; };

prevSelecteds ¬

IF prevMSI#NIL AND prevMSI.button#NIL AND prevMSI.button.msViewer#NIL

THEN prevMSI.selected ELSE NIL;

SELECT op FROM

$selOne => {

Turn off previous selection(s)

FOR pS: LIST OF MsgSetFieldHandle ¬ prevSelecteds, pS.rest WHILE pS#NIL DO

prevSelected: MsgSetFieldHandle ¬ pS.first;

IF prevSelected.tocButton#NIL THEN {

TiogaButtons.ChangeButtonLooks[

button: prevSelected.tocButton,

addLooks: tocDefaultLooks,

removeLooks: tocSelectedLooks];

};

ENDLOOP;

IF prevMSI#NIL THEN prevMSI.selected ¬ NIL;

wH.selectedMsgSet ¬ NIL;

IF mfH=NIL THEN RETURN;

msI ¬ mfH.msI;

TiogaButtons.ChangeButtonLooks[button: mfH.tocButton, addLooks: tocSelectedLooks];

msI.selected ¬ LIST[mfH];

wH.selectedMsgSet ¬ msI;

};

$add => {

selKind: SelKind ¬ $none;

prevSelectedMFH: LIST OF MsgSetFieldHandle;

[prevSelectedMFH, selKind] ¬ AnalyzeNewSel[prevSelecteds, mfH];

SELECT selKind FROM

$none => { WalnutWindow.Report[wH, noCurrentSel1]; RETURN; };

$first, $equal => RETURN;

ENDCASE;

TiogaButtons.ChangeButtonLooks[button: mfH.tocButton, addLooks: tocSelectedLooks];

IF selKind=$above THEN prevMSI.selected ¬ CONS[mfH, prevSelecteds]

ELSE {

newSel: LIST OF MsgSetFieldHandle ¬ LIST[mfH];

newSel.rest ¬ prevSelectedMFH.rest;

prevSelectedMFH.rest ¬ newSel;

};

$extend => {

selKind: SelKind ¬ $none;

prevSelectedMFH: LIST OF MsgSetFieldHandle;

tail: LIST OF MsgSetFieldHandle;

stopper: MsgSetFieldHandle;

above: BOOL¬FALSE;

[prevSelectedMFH, selKind] ¬ AnalyzeNewSel[prevSelecteds, mfH];

SELECT selKind FROM

$none => { WalnutWindow.Report[wH, noCurrentSel1]; RETURN; };

$first, $equal => RETURN;

$above => above ¬ TRUE;

ENDCASE;

stopper ¬ prevSelectedMFH.first;

tail ¬ IF above THEN prevSelectedMFH ELSE prevSelectedMFH.rest;

WHILE mfH#stopper DO

TiogaButtons.ChangeButtonLooks[button: mfH.tocButton, addLooks: tocSelectedLooks];

tail ¬ CONS[mfH, tail];

mfH ¬ IF above THEN mfH.next ELSE mfH.prev;

ENDLOOP;

IF above THEN prevMSI.selected ¬ tail ELSE prevSelectedMFH.rest ¬ tail;

};

$deselect => {

selKind: SelKind ¬ $none;

prevSelectedMFH: LIST OF MsgSetFieldHandle;

IF prevSelecteds=NIL THEN { WalnutWindow.Report[wH, noCurrentSel2]; RETURN; };

[prevSelectedMFH, selKind] ¬ AnalyzeNewSel[prevSelecteds, mfH];

SELECT selKind FROM

$none, $above, $below => { WalnutWindow.Report[wH, noCurrentSel2]; RETURN; };

ENDCASE;

TiogaButtons.ChangeButtonLooks[button: mfH.tocButton,

addLooks: tocDefaultLooks, removeLooks: tocSelectedLooks];

IF selKind=$first THEN prevMSI.selected ¬ prevSelecteds.rest

ELSE prevSelectedMFH.rest ¬ prevSelectedMFH.rest.rest;

};

ENDCASE;

};

SelKind: TYPE ~ { none, above, first, below, equal };

AnalyzeNewSel: PROC[selected: LIST OF MsgSetFieldHandle, mfH: MsgSetFieldHandle]

RETURNS [prevSelectedMFH: LIST OF MsgSetFieldHandle¬NIL, selKind: SelKind¬$none] ~ {

prevSelectedMFH ¬ selected;

IF prevSelectedMFH=NIL THEN RETURN;

IF mfH = prevSelectedMFH.first THEN RETURN[NIL, $first];

FOR pSM: MsgSetFieldHandle ¬ prevSelectedMFH.first, pSM.next

WHILE pSM#NIL DO

IF prevSelectedMFH.rest#NIL AND pSM=prevSelectedMFH.rest.first THEN

IF mfH=prevSelectedMFH.rest.first THEN RETURN[prevSelectedMFH, $equal]

ELSE prevSelectedMFH ¬ prevSelectedMFH.rest

ELSE IF pSM=mfH THEN RETURN[prevSelectedMFH, $below];

REPEAT

FINISHED => RETURN[selected, $above];

ENDLOOP;

};

BadOldSelectMsgInMsgSet: PROC[wH: WalnutHandle, mfH: MsgSetFieldHandle] ~ {

IF mfH.tocButton = NIL THEN WalnutWindow.Report[wH, noMsgRope]

ELSE

{ msI: MsgSetInfo = mfH.msI;

prevSelecteds: LIST OF MsgSetFieldHandle ¬ msI.selected;

prevSelected: MsgSetFieldHandle¬NIL;

IF prevSelecteds#NIL THEN prevSelected ¬ prevSelecteds.first;

IF prevSelected = mfH THEN RETURN;

turn off previous selection

IF prevSelected # NIL AND prevSelected.tocButton#NIL THEN

TiogaButtons.ChangeButtonLooks[

button: prevSelected.tocButton,

addLooks: tocDefaultLooks,

removeLooks: tocSelectedLooks];

TiogaButtons.ChangeButtonLooks[button: mfH.tocButton, addLooks: tocSelectedLooks];

msI.selected ¬ LIST[mfH];

};

DisplayOneMsg: PROC[wH: WalnutHandle, mfH: MsgSetFieldHandle, shift: BOOL] = {

IF mfH # NIL THEN {

DisplayMsgFromMsgSet[wH, mfH.msgInfo.msg, mfH.msI.container, shift];

IF NOT mfH.msgInfo.hasBeenRead AND NOT wH.readOnlyAccess THEN MarkMsgAsRead[wH, mfH];

};

MarkMsgAsRead: PROC[wH: WalnutHandle, mfH: MsgSetFieldHandle] = {

used by selection

msI: MsgSetInfo = mfH.msI;

WalnutOps.SetHasBeenRead[wH.opsH, mfH.msgInfo.msg];

mfH.msgInfo.hasBeenRead ¬ TRUE;

IF userWantsQMs THEN {

viewer: Viewer = TiogaOps.GetSelection[].viewer;

IF viewer # NIL THEN TiogaOps.SaveSelA[];

TiogaButtons.SetState[msI.tiogaViewer, editing];

TiogaOps.SetSelection[viewer: msI.tiogaViewer, start: [mfH.tocButton.startLoc.node, 0], end: [mfH.tocButton.endLoc.node, 0]];

TiogaOps.Delete[];

TiogaOps.InsertChar[' ];

IF viewer # NIL THEN TiogaOps.RestoreSelA[] ELSE TiogaOps.CancelSelection[];

TiogaButtons.SetState[msI.tiogaViewer, buttoning];

};

TiogaButtons.ChangeButtonLooks[

button: mfH.tocButton, addLooks: tocDefaultLooks, removeLooks: tocUnreadLooks];

};

Getting the menu changed

ChangeTheMenu: PROC [v: ViewerClasses.Viewer, isLevels: BOOL] = {

menu: Menus.Menu = v.menu;

msI: MsgSetInfo = NARROW[ViewerOps.FetchProp[v, $MsgSetInfo]];

wH: WalnutHandle = msI.button.wH;

subMenu: Menus.MenuEntry = IF isLevels THEN wH.levelsMenuEntry ELSE wH.placesMenuEntry;

found: BOOL ¬ FALSE;

numLines: Menus.MenuLine = Menus.GetNumberOfLines[menu];

newLines: Menus.MenuLine ¬ numLines;

IF v.destroyed THEN RETURN;

FOR i: Menus.MenuLine IN [1..numLines) DO -- see if already showing the submenu

IF Rope.Equal[Menus.GetLine[menu,i].name, subMenu.name] THEN { -- yes, so remove it

FOR j: Menus.MenuLine IN (i..numLines) DO

Menus.SetLine[menu, j-1, Menus.GetLine[menu, j]];

ENDLOOP;

Menus.ChangeNumberOfLines[menu, newLast-1];

newLines ¬ newLines-1;

found ¬ TRUE; EXIT

};

ENDLOOP;

IF ~found THEN { -- add it. do insertion sort to get it in the right place

GoesBefore: PROC [m1, m2: Menus.MenuEntry] RETURNS [BOOL] = {

Priority: PROC [m: Menus.MenuEntry] RETURNS [INTEGER] = {

higher priority means goes above in series of submenus

looks at rope for first item to identify the subMenu.

RETURN [SELECT TRUE FROM

Rope.Equal[m.name, findRL] => 2,

Rope.Equal[m.name, firstLevelOnlyRL] => 1,

Rope.Equal[m.name, categoriesRL] => 0,

ENDCASE => -1 -- unknown menu goes at bottom -- ]

};

RETURN [Priority[m1] > Priority[m2]]

};

newLast: Menus.MenuLine = MIN[numLines, LAST[Menus.MenuLine]];

newLines ¬ newLines+1;

Menus.ChangeNumberOfLines[menu, newLast+1];

FOR i: Menus.MenuLine IN [1..numLines) DO

IF GoesBefore[subMenu, Menus.GetLine[menu, i]] THEN { -- put it here

FOR j: Menus.MenuLine DECREASING IN (i..newLast] DO

Menus.SetLine[menu, j, Menus.GetLine[menu, j-1]]; ENDLOOP;

Menus.SetLine[menu, i, subMenu];

found ¬ TRUE; EXIT

};

ENDLOOP;

IF ~found THEN Menus.SetLine[menu, newLast, subMenu];

};

ViewerBLT.ChangeNumberOfLines[v, newLines];

};

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

CreateMsgSetMenus: PUBLIC PROC[wH: WalnutHandle] = {

added: Menus.MenuEntry;

displayerMenu: Menus.Menu ¬ Menus.CreateMenu[];

activeMenu: Menus.Menu ¬ Menus.CreateMenu[];

deletedMenu: Menus.Menu ¬ Menus.CreateMenu[];

readOnlyMenu: Menus.Menu ¬ Menus.CreateMenu[];

placesMenuEntry: Menus.MenuEntry;

levelsMenuEntry: Menus.MenuEntry;

Menu for generic Displayer

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, moveToRL, MoveToProc]];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, displayRL, DisplayProc]];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, deleteRL, DeleteProc]];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, addToRL, AddProc]];

Menus.AppendMenuEntry[displayerMenu, Menus.CreateEntry[placesRL, PlacesProc]];

Menus.AppendMenuEntry[displayerMenu, Menus.CreateEntry[levelsRL, LevelsProc]];

Menus.AppendMenuEntry[displayerMenu, Menus.CreateEntry[msgOpsRL, OpsProc]];

added ¬ WalnutFilter.MenuExtras[$msgset];

UNTIL added = NIL DO

me: Menus.MenuEntry ¬ added;

added ¬ added.link;

Menus.AppendMenuEntry[displayerMenu, me];

ENDLOOP;

second line

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, findRL, FindProc], 1];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, wordRL, WordProc], 1];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, defRL, DefProc], 1];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, positionRL, PositionProc], 1];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, normalizeRL, NormalizeProc], 1];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, prevPlaceRL, PrevPlaceProc], 1];

placesMenuEntry ¬ Menus.GetLine[displayerMenu, 1];

third line

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, firstLevelOnlyRL, FirstOnlyProc], 2];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, moreLevelsRL, MoreLevelsProc], 2];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, fewerLevelsRL, FewerLevelsProc], 2];

Menus.AppendMenuEntry[displayerMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, allLevelsRL, AllLevelsProc], 2];

levelsMenuEntry ¬ Menus.GetLine[displayerMenu, 2];

Menus.ChangeNumberOfLines[displayerMenu, 1];

Menu for Active

Menus.AppendMenuEntry[activeMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, moveToRL, MoveToProc]];

Menus.AppendMenuEntry[activeMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, displayRL, DisplayProc]];

Menus.AppendMenuEntry[activeMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, deleteRL, DeleteProc]];

Menus.AppendMenuEntry[activeMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, addToRL, AddProc]];

Menus.AppendMenuEntry[activeMenu,

Menus.CreateEntry[newMailRL, NewMail]]; -- "immediate"

Menus.AppendMenuEntry[activeMenu, Menus.CreateEntry[placesRL, PlacesProc]];

Menus.AppendMenuEntry[activeMenu, Menus.CreateEntry[levelsRL, LevelsProc]];

Menus.AppendMenuEntry[activeMenu, Menus.CreateEntry[msgOpsRL, OpsProc]];

added ¬ WalnutFilter.MenuExtras[$msgset];

UNTIL added = NIL DO

me: Menus.MenuEntry ¬ added;

added ¬ added.link;

Menus.AppendMenuEntry[activeMenu, me];

ENDLOOP;

second line

Menus.SetLine[activeMenu, 1, placesMenuEntry];

third line

Menus.SetLine[activeMenu, 2, levelsMenuEntry];

Menus.ChangeNumberOfLines[activeMenu, 1];

Menu for Deleted

Menus.AppendMenuEntry[deletedMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, moveToRL, MoveToProc]];

Menus.AppendMenuEntry[deletedMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, displayRL, DisplayProc]];

Menus.AppendMenuEntry[deletedMenu, Menus.CreateEntry[placesRL, PlacesProc]];

Menus.AppendMenuEntry[deletedMenu, Menus.CreateEntry[levelsRL, LevelsProc]];

Menus.AppendMenuEntry[deletedMenu, Menus.CreateEntry[msgOpsRL, OpsProc]];

added ¬ WalnutFilter.MenuExtras[$msgset];

UNTIL added = NIL DO

me: Menus.MenuEntry ¬ added;

added ¬ added.link;

Menus.AppendMenuEntry[deletedMenu, me];

ENDLOOP;

second line

Menus.SetLine[deletedMenu, 1, placesMenuEntry];

third line

Menus.SetLine[deletedMenu, 2, levelsMenuEntry];

Menus.ChangeNumberOfLines[deletedMenu, 1];

Menu for ReadOnly database

Menus.AppendMenuEntry[readOnlyMenu,

WalnutViewer.CreateMenuEntry[wH.walnutQueue, displayRL, DisplayProc]];

Menus.AppendMenuEntry[readOnlyMenu, Menus.CreateEntry[placesRL, PlacesProc]];

Menus.AppendMenuEntry[readOnlyMenu, Menus.CreateEntry[levelsRL, LevelsProc]];

Menus.AppendMenuEntry[readOnlyMenu, Menus.CreateEntry[msgOpsRL, OpsProc]];

added ¬ WalnutFilter.MenuExtras[$msgset];

UNTIL added = NIL DO

me: Menus.MenuEntry ¬ added;

added ¬ added.link;

Menus.AppendMenuEntry[readOnlyMenu, me];

ENDLOOP;

second line

Menus.SetLine[readOnlyMenu, 1, placesMenuEntry];

third line

Menus.SetLine[readOnlyMenu, 2, levelsMenuEntry];

Menus.ChangeNumberOfLines[readOnlyMenu, 1];

wH.displayerMenu ¬ displayerMenu;

wH.activeMenu ¬ activeMenu;

wH.deletedMenu ¬ deletedMenu;

wH.readOnlyMenu ¬ readOnlyMenu;

wH.placesMenuEntry ¬ placesMenuEntry;

wH.levelsMenuEntry ¬ levelsMenuEntry;

};

WhenProfileChanges: UserProfile.ProfileChangedProc = {

tocDefaultLooks ¬ UserProfile.Token[key: "Walnut.TOCDefaultLooks", default: ""];

tocSelectedLooks ¬ UserProfile.Token[key: "Walnut.TOCSelectedLooks", default: "sb"];

tocUnreadLooks ¬ UserProfile.Token[key: "Walnut.TOCUnreadLooks", default: "i"];

userWantsQMs ¬ UserProfile.Boolean[key: "Walnut.ShowUnreadWithQMs", default: TRUE];

openHeightForActive ¬

UserProfile.Number[key: "Walnut.OpenHeightForActive", default: 0];

};

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

start code

UserProfile.CallWhenProfileChanges[WhenProfileChanges];

Menus.AppendMenuEntry[fillingInMenu, Menus.CreateEntry["AbortEnumeration", AbortEnumProc]];

END.