DIRECTORY
Atom USING [GetPName],
BasicTime USING [Now, Period],
Buttons USING [ButtonProc, Create],
Commander USING [CommandProc, Register],
Icons USING [IconFlavor, NewIconFromFile],
InputFocus USING [GetInputFocus],
List USING [Length, LORA],
MailSend USING [Abort, GetRegisteredSendProcsList, MailSendProcsRef],
MailSendSidedoor USING [AbortSendProc],
Menus USING [AppendMenuEntry, CopyEntry, CreateEntry, FindEntry, Menu, MenuEntry, MenuProc, MouseButton, ReplaceMenuEntry, targetNotFound],
IO,
PFS,
PFSNames,
PopUpSelection USING [Request],
Process USING [Detach, MsecToTicks, SetTimeout, Ticks],
Rope,
TEditInputOps USING [DoFindPlaceholders],
TEditSplit USING[ Split ],
TextEdit USING [GetNewlineDelimiter],
TextNode USING [Root],
Tioga,
TiogaAccess,
TiogaAccessViewers,
TiogaMenuOps USING[ tiogaMenu, Empty, Load, Store ],
TiogaOps USING [ Ref, Location, CancelSelection, GetSelection, IsComment, StepForward, ViewerDoc ],
TypeScript USING [Create],
ViewerEvents USING [EventProc, EventRegistration, RegisterEventProc, UnRegisterEventProc],
ViewerOps USING [AddProp, BlinkIcon, ComputeColumn, CreateViewer, DestroyViewer, FetchProp, MoveBelowViewer, OpenIcon, PaintViewer, SaveViewer, SetMenu, SetNewVersion],
ViewerIO USING [CreateViewerStreams, GetViewerFromStream],
ViewerTools USING [EnableUserEdits, GetSelectionContents, InhibitUserEdits, SelPos, SelPosRec, SetSelection, SetTiogaContents, TiogaContents, TiogaContentsRec],
ViewerClasses USING [Viewer],
UserProfile USING [Boolean, CallWhenProfileChanges, Number, ProfileChangedProc,
ListOfTokens, Token],
SendMailInternal,
SendMailOps;

SendMailControlImpl: CEDAR MONITOR
IMPORTS
Atom, BasicTime, Buttons, Commander, IO, List, PFS, PFSNames, PopUpSelection, Process, Rope, Icons, InputFocus, MailSend, Menus, SendMailInternal, SendMailOps, TEditInputOps, TEditSplit, TextNode, TextEdit, TiogaAccess, TiogaAccessViewers, TiogaMenuOps, TiogaOps, TypeScript, ViewerEvents, ViewerIO, ViewerOps, ViewerTools, UserProfile
EXPORTS
SendMailInternal, SendMailOps
SHARES ViewerClasses =

BEGIN OPEN SendMailOps, SendMailInternal;

-- Global types & variables

STREAM: TYPE = IO.STREAM;
ROPE: TYPE = Rope.ROPE;
Viewer: TYPE = ViewerClasses.Viewer;
TiogaContents: TYPE = ViewerTools.TiogaContents;
OutBoxMsg: TYPE = SendMailOps.OutBoxMsg;
viewerStart: ViewerTools.SelPos = NEW[ViewerTools.SelPosRec ¬ [0, 0]];

alwaysOpenSender: BOOL ¬ FALSE;
destroyAfterSend: BOOL ¬ FALSE;
senderList: LIST OF SenderInfo ¬ NIL;

popUpFormsList: LIST OF ROPE ¬ NIL;
popUpFormsFileNames: LIST OF ROPE ¬ NIL;
sendingSynch: CONDITION;

iconicSender: BOOL ¬ TRUE;		-- make iconic initially only
senderIcon: Icons.IconFlavor ¬ tool;
edittingIcon: Icons.IconFlavor ¬ tool;
notSentIcon: Icons.IconFlavor ¬ tool;
labelFont: PUBLIC ROPE  ¬ NIL; -- font to use for printing of header labels

reporter: STREAM ¬ NIL;
senderTS: Viewer ¬ NIL;

senderEvent: ViewerEvents.EventRegistration;
defaultText: PUBLIC ViewerTools.TiogaContents;
answerText: PUBLIC ViewerTools.TiogaContents;
forwardText: PUBLIC ViewerTools.TiogaContents;

SenderPropRec: TYPE = RECORD[proc: PROC[Viewer, ATOM, REF ANY], data: REF ANY];
SenderPropValue: TYPE = REF SenderPropRec;
SenderProp: TYPE = RECORD[key: ATOM, value: SenderPropValue];
senderPropsList: LIST OF SenderProp ¬ NIL;

FileStatus: TYPE = {illegalName, local, remote, notFound, otherError};


SendMailCmd: Commander.CommandProc = { [] ¬ CreateSendViewer[fromExec: TRUE]};

CreateSendViewer: PUBLIC PROC[fromExec: BOOL, transport: ATOM ¬ NIL]
RETURNS[which: ATOM ¬ NIL] = {
senderInfo: SenderInfo;
IF fromExec THEN fromExec ¬ ~alwaysOpenSender;
IF ~fromExec THEN iconicSender ¬ FALSE;
[] ¬ CheckDefault[];
senderInfo ¬ BuildSender[
paint: TRUE, iconic: iconicSender, form: defaultForm, forceNew: alwaysNewSender];

IF ~iconicSender THEN GrabFocus[senderInfo.senderV];
iconicSender ¬ FALSE;		-- iconic only the first time
};

GrabFocus: PUBLIC ENTRY PROC[senderV: Viewer] = {
ENABLE UNWIND => NULL;
IF senderV.iconic THEN RETURN;
ViewerTools.SetSelection[senderV, viewerStart];
[] ¬ TEditInputOps.DoFindPlaceholders[next: TRUE, gotoend: FALSE];
};

BuildSendViewer: PUBLIC PROC[paint, iconic: BOOL, form: SendMailOps.Form ¬ NIL,
who: Viewer ¬ NIL, forceNew: BOOL ¬ FALSE, transport: ATOM ¬ NIL]
RETURNS[v: Viewer, which: ATOM ¬ NIL] = {
senderInfo: SenderInfo;
newForm: SendMailOps.Form = IF form # NIL THEN form ELSE CheckDefault[];
senderInfo ¬ BuildSender[paint, iconic, newForm, who, forceNew, transport];
RETURN[senderInfo.senderV, which];
};

CheckDefault: PROC RETURNS[form: SendMailOps.Form] = {
IF simpleUserNameList = NIL THEN SendMailInit[firstTime];	-- check for login
IF defaultForm.fields = NIL THEN RETURN;
IF defaultForm.fields.rest = NIL THEN RETURN;
IF defaultForm.fields.rest.rest = NIL THEN RETURN;
RETURN[defaultForm];
};

BuildSender: ENTRY PROC[paint, iconic: BOOL, form: SendMailOps.Form,
who: Viewer ¬ NIL, forceNew: BOOL ¬ FALSE, transport: ATOM ¬ NIL]
RETURNS[senderInfo: SenderInfo] = {
ENABLE UNWIND => IF senderInfo # NIL AND senderInfo.senderV # NIL
THEN senderInfo.senderV.inhibitDestroy ¬ FALSE;

senderV: Viewer;
form1: SendMailOps.Form ¬ form;
trx: ATOM ¬ transport;

IF ~forceNew THEN
FOR sL: LIST OF SenderInfo ¬ senderList, sL.rest UNTIL sL=NIL DO
senderInfo ¬ sL.first;
IF ~(senderInfo.senderV.newVersion) AND (senderInfo.sendHandle = NIL)
AND ~senderInfo.senderV.destroyed AND (senderInfo.senderV.file = NIL )
THEN
{ senderV ¬ senderInfo.senderV;
IF senderV.link # NIL THEN InternalDestroySplits[senderV];
senderV.inhibitDestroy ¬ TRUE;
IF TiogaOps.GetSelection[feedback].viewer = senderV THEN
	TiogaOps.CancelSelection[feedback];
IF senderV.iconic THEN {		-- inlined a call to ClearOpenEvent
ra: REF ANY ¬ ViewerOps.FetchProp[senderV, $SendMailOpsForm];
IF ra # NIL THEN {
form: SendMailOps.Form = NARROW[ra];
ViewerEvents.UnRegisterEventProc[senderInfo.openEvent, open];
senderInfo.openEvent ¬ NIL;
};
IF (who # NIL) AND (senderV.column = who.column) THEN
{ ViewerOps.OpenIcon[icon: senderV, paint: FALSE];
ViewerOps.MoveBelowViewer[altered: senderV, static: who, paint: TRUE] }
ELSE ViewerOps.OpenIcon[senderV];
};
IF form # NIL THEN InsertForm[senderInfo, form, TRUE]
ELSE TiogaMenuOps.Empty[senderV];
ViewerOps.PaintViewer[senderV, menu];
senderV.inhibitDestroy ¬ FALSE;
RETURN };
ENDLOOP;

--  need to create a new sender
senderV ¬ ViewerOps.CreateViewer[
flavor: $Text,
info: [ name: sendCaption,
	column: IF who#NIL THEN who.column ELSE left,
	iconic: iconic,
	icon: senderIcon],
paint: who = NIL];

IF who # NIL THEN {
ViewerOps.MoveBelowViewer[altered: senderV, static: who, paint: FALSE];
ViewerOps.ComputeColumn[column: senderV.column, paint: TRUE]
};
senderV.inhibitDestroy ¬ TRUE;
senderInfo ¬ NEW[SenderInfoObject ¬ [senderV: senderV]];
TRUSTED { Process.SetTimeout[@senderInfo.timeToWait, halfSecTicks] };
HowCanWeSend[senderInfo, transport];
ViewerOps.SetMenu[senderV, senderInfo.thisMenu];
ViewerOps.AddProp[senderV, $SenderInfo, senderInfo];

FOR spl: LIST OF SenderProp ¬ senderPropsList, spl.rest UNTIL spl=NIL DO
ViewerOps.AddProp[senderV, spl.first.key, spl.first.value];
ENDLOOP;

senderList ¬ CONS[senderInfo, senderList];

senderInfo.destroyEvent ¬ ViewerEvents.RegisterEventProc[
  proc: DestroySendViewer, event: destroy, filter: senderV, before: TRUE];

senderInfo.closeEvent ¬ ViewerEvents.RegisterEventProc[
proc: CloseSendViewer, event: close, filter: senderV, before: TRUE];

senderInfo.editEvent ¬ ViewerEvents.RegisterEventProc[
proc: FirstEditSendViewer, event: edit, filter: senderV, before: TRUE];

IF form # NIL THEN InsertForm[senderInfo, form, TRUE] ELSE
TiogaMenuOps.Empty[senderV];
senderV.inhibitDestroy ¬ FALSE;
IF iconic AND ~senderV.iconic THEN ViewerOps.PaintViewer[senderV, all];
};

HowCanWeSend: PROC[senderInfo: SenderInfo, transport: ATOM] = {
senderInfo.thisMenu ¬ sendMenu;
};

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

SendMailInit: UserProfile.ProfileChangedProc = {
defaultFormFile: ROPE ¬ UserProfile.Token[key: "SendMailTool.DefaultForm", default: NIL];
answerFormFile: ROPE ¬ UserProfile.Token[key: "SendMailTool.AnswerForm", default: NIL];
forwardFormFile: ROPE ¬ UserProfile.Token[key: "SendMailTool.ForwardForm", default: NIL];
formContents: ViewerTools.TiogaContents ¬ NIL;
isDefault: BOOL ¬ TRUE;
defaultFields: LIST OF ROPE ¬ NIL;

DoUserNameAndRegistry[];
IF localRNameList # NIL THEN defaultFields ¬ LIST[NIL, NIL, localRNameList.first];
needToAuthenticate ¬ TRUE;
outBoxLength ¬ UserProfile.Number[key: "SendMailTool.OutBoxLength", default: 1];
replyToSelf ¬ UserProfile.Boolean[key: "SendMailTool.ReplyToSelf", default: FALSE];
destroyAfterSend ¬ UserProfile.Boolean[key: "SendMailTool.DestroyAfterSend", default: FALSE];
alwaysNewSender ¬
UserProfile.Boolean[key: "SendMailTool.AlwaysNewSender", default: FALSE];
alwaysOpenSender ¬
UserProfile.Boolean[key: "SendMailTool.AlwaysOpenSender", default: FALSE];

IF defaultFormFile = NIL THEN defaultFormFile ¬ Rope.Concat[initDir, "SendMailStandardSend.form"]
ELSE isDefault ¬ FALSE;
formContents ¬ GetSendForm[defaultFormFile];
IF formContents # NIL THEN {
defaultText ¬ defaultForm.formText ¬ formContents;
defaultForm.fields ¬ IF isDefault THEN defaultFields ELSE NIL;
}
ELSE {
defaultText ¬ defaultForm.formText ¬ standardDefaultText;
defaultForm.fields ¬ defaultFields;
};

formContents ¬ NIL;
IF answerFormFile = NIL THEN answerFormFile ¬ Rope.Concat[initDir, "SendMailStandardAnswer.form"];
formContents ¬ GetSendForm[answerFormFile];
IF formContents # NIL THEN answerText ¬ formContents
ELSE answerText ¬ standardAnswerText;

formContents ¬ NIL;
IF forwardFormFile = NIL THEN forwardFormFile ¬ Rope.Concat[initDir, "SendMailStandardForward.form"];
formContents ¬ GetSendForm[forwardFormFile];
IF formContents # NIL THEN forwardText ¬ formContents
ELSE forwardText ¬ standardForwardText;

labelFont ¬ UserProfile.Token[key: "SendMailTool.MsgHeadersLooks", default: "sb"];
SetFormsList[];
};

DisplayTxtInSender: ENTRY PROC[senderV: Viewer, txt: ROPE] = {
ENABLE UNWIND => NULL;
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[senderV, $SenderInfo]];
tc: ViewerTools.TiogaContents ¬ NEW[ViewerTools.TiogaContentsRec];
tc.contents ¬ txt;
InternalDisplayTioga[senderInfo, tc, TRUE];
};

ClearSendViewer: PUBLIC ENTRY PROC[senderV: Viewer] = {
ENABLE UNWIND => NULL;
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[senderV, $SenderInfo]];
IF senderInfo = NIL THEN RETURN;		-- not a sender
InsertForm[senderInfo, defaultForm, TRUE]
};

StuffForm: PUBLIC ENTRY PROC[v: Viewer, contents: TiogaContents] = {
ENABLE UNWIND => NULL;
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[v, $SenderInfo]];
IF senderInfo = NIL THEN RETURN;		-- not a sender
InternalDisplayTioga[senderInfo, contents, TRUE]
};


AddToSenderProps: PUBLIC ENTRY PROC
[key: ATOM, proc: PROC[Viewer, ATOM, REF ANY], data: REF ANY] = {
ENABLE UNWIND => NULL;
senderPropsList ¬
CONS[[key: key, value: NEW[SenderPropRec ¬ [proc, data]]], senderPropsList];
};

RemoveFromSenderProps: PUBLIC ENTRY PROC[key: ATOM] = {
ENABLE UNWIND => NULL;
sp: LIST OF SenderProp;
IF senderPropsList = NIL THEN RETURN;
FOR spl: LIST OF SenderProp ¬ senderPropsList, spl.rest UNTIL spl = NIL DO
IF spl.first.key = key THEN
IF spl = senderPropsList THEN
{ senderPropsList ¬ senderPropsList.rest; RETURN}
ELSE
{ sp.rest ¬ spl.rest; RETURN};
sp ¬ spl;
ENDLOOP;
};

AddToSendMenu: PUBLIC ENTRY PROC[label: ROPE, proc: Menus.MenuProc] = {
ENABLE UNWIND => NULL;
old: Menus.MenuEntry ¬ Menus.FindEntry[sendMenu, label];
IF old = NIL THEN
Menus.AppendMenuEntry[sendMenu, Menus.CreateEntry[label, proc]];
FOR sL: LIST OF SenderInfo ¬ senderList, sL.rest UNTIL sL = NIL DO
thisMenu: Menus.Menu;
v: Viewer = sL.first.senderV;
IF v = NIL OR v.destroyed THEN LOOP;
old ¬ Menus.FindEntry[thisMenu ¬ sL.first.senderV.menu, label];
IF old = NIL THEN {
Menus.AppendMenuEntry[thisMenu, Menus.CreateEntry[label, proc]];
ViewerOps.PaintViewer[sL.first.senderV, menu];
};
ENDLOOP;
};

ReplaceInSendMenu: PUBLIC ENTRY PROC[label: ROPE, proc: Menus.MenuProc]
	RETURNS[oldFound: BOOL] = {
ENABLE UNWIND => NULL;
DoReplace: PROC[thisMenu: Menus.Menu] RETURNS[foundIt: BOOL ¬ TRUE]= {
old: Menus.MenuEntry = Menus.FindEntry[thisMenu, label];
new: Menus.MenuEntry = Menus.CreateEntry[label, proc];
Menus.ReplaceMenuEntry[thisMenu, old, new ! Menus.targetNotFound =>
{ foundIt ¬ FALSE ; CONTINUE }];
IF NOT foundIt THEN Menus.AppendMenuEntry[thisMenu, new];
};

oldFound ¬ DoReplace[sendMenu];

FOR sL: LIST OF SenderInfo ¬ senderList, sL.rest UNTIL sL = NIL DO
v: Viewer = sL.first.senderV;
thisFound: BOOL;
IF v = NIL OR v.destroyed THEN LOOP;
thisFound ¬ DoReplace[sL.first.senderV.menu];
oldFound ¬ thisFound AND oldFound;
ViewerOps.PaintViewer[sL.first.senderV, menu];
ENDLOOP;
};

RemoveFromSendMenu: PUBLIC ENTRY PROC[name: ROPE] = {
ENABLE UNWIND => NULL;
old: Menus.MenuEntry ¬ Menus.FindEntry[sendMenu, name];
IF old = NIL THEN RETURN;
Menus.ReplaceMenuEntry[sendMenu, old ! Menus.targetNotFound => CONTINUE];
FOR sL: LIST OF SenderInfo ¬ senderList, sL.rest UNTIL sL = NIL DO
thisMenu: Menus.Menu;
v: Viewer = sL.first.senderV;
IF v = NIL OR v.destroyed THEN LOOP;
old ¬ Menus.FindEntry[thisMenu ¬ sL.first.senderV.menu, name];
IF old # NIL THEN {
Menus.ReplaceMenuEntry[thisMenu, old ! Menus.targetNotFound => CONTINUE];
ViewerOps.PaintViewer[sL.first.senderV, menu];
};
ENDLOOP;
};

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
--  Menu procedures

NewMsgFormProc: ENTRY PROC[viewer: Viewer] = {
ENABLE UNWIND => NULL;
NewMsgForm[viewer]
};

PrevMsgProc: ENTRY PROC[viewer: Viewer, blueButton: BOOL]  = {
ENABLE UNWIND => NULL;
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
tc: TiogaContents;
IF viewer.link#NIL THEN InternalDestroySplits[viewer];
ClearFileAssoc[viewer];
[] ¬ CheckDefault[];
IF outBox = NIL THEN InsertForm[senderInfo, defaultForm, TRUE]
 ELSE {
IF outBox.next = NIL THEN tc ¬ IF blueButton THEN outBox.sentTC ELSE outBox.replaceTC 
ELSE {	-- more than one previous message
which: INT;
obm: OutBoxMsg ¬ outBox;
outBoxList: LIST OF ROPE ¬ LIST[outBox.subject];
last: LIST OF ROPE ¬ outBoxList;
FOR oB: OutBoxMsg ¬ outBox.next, oB.next UNTIL oB = NIL DO
last.rest ¬ LIST[oB.subject];
last ¬ last.rest;
ENDLOOP;
which ¬ PopUpSelection.Request[header: "OutBox", choice: outBoxList, position: $Mouse];
IF which = 0 THEN RETURN;
last ¬ outBoxList;
FOR i: INT IN [1..which) DO
obm ¬ obm.next;
ENDLOOP;
tc ¬ IF blueButton THEN obm.sentTC ELSE obm.replaceTC;
};
IF TiogaOps.GetSelection[feedback].viewer = viewer THEN
TiogaOps.CancelSelection[feedback];
ViewerTools.SetTiogaContents[viewer, tc];
UnsetNewVersion[viewer];
};
};

NewSenderClickProc: Buttons.ButtonProc = {
senderInfo: SenderInfo;
[] ¬ CheckDefault[];
senderInfo ¬ BuildSender[paint: TRUE, iconic: FALSE, form: defaultForm, forceNew: TRUE];
GrabFocus[senderInfo.senderV];
};

NewSenderProc: PROC = {
senderInfo: SenderInfo;
[] ¬ CheckDefault[];
senderInfo ¬ BuildSender[paint: TRUE, iconic: FALSE, form: defaultForm, forceNew: TRUE];
GrabFocus[senderInfo.senderV];
};

NewMsgForm: INTERNAL PROC[viewer: Viewer] = {
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
[] ¬ CheckDefault[];
InsertForm[senderInfo, defaultForm, TRUE];
ClearFileAssoc[viewer];
};

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

DestroySendViewer: ViewerEvents.EventProc = {
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
IF senderInfo = NIL THEN RETURN[FALSE];
IF senderInfo.senderV # NIL THEN senderInfo.senderV.file ¬ NIL;
IF ViewerOps.FetchProp[viewer, $DestroySenderProc] = NIL THEN RETURN[FALSE];
TRUSTED {Process.Detach[FORK CheckForDestroy[viewer, senderInfo]]};
RETURN[TRUE];
};

EntryInsertForm: PUBLIC ENTRY PROC[senderInfo: SenderInfo, form: SendMailOps.Form] =
{ ENABLE UNWIND => NULL; InsertForm[senderInfo, form, TRUE] };

EntryPlaceHolders: PUBLIC ENTRY PROC[senderInfo: SenderInfo, fieldsList: LIST OF ROPE] =
{ ENABLE UNWIND => NULL; DoPlaceHolders[senderInfo.senderV, fieldsList] };

CloseSendViewer: ViewerEvents.EventProc = {
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
IF senderInfo = NIL THEN RETURN[FALSE];
IF senderInfo.dontClose THEN
{ SenderReport[format: "  **** Sender cannot be closed right now\n", blink: TRUE];
RETURN[TRUE]
};
viewer.icon ¬ IF viewer.newVersion THEN edittingIcon ELSE senderIcon;
RETURN[FALSE];
};

FirstEditSendViewer: ViewerEvents.EventProc = {
OPEN Menus;
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
IF senderInfo = NIL THEN RETURN[FALSE];
SenderNewVersion[viewer];		-- show as guarded
RETURN[FALSE];
};

CheckForDestroy: ENTRY PROC[senderV: Viewer, senderInfo: SenderInfo] = {
ENABLE UNWIND => NULL;
okToDestroy: BOOL ¬ TRUE;
IF senderV.destroyed THEN RETURN;		-- woops
IF senderV.newVersion THEN
{InternalReport["\nConfirm quitting with last message unsent"];
IF okToDestroy ¬ SendingConfirm[senderInfo] THEN senderV.newVersion ¬ FALSE;
};
IF ~okToDestroy THEN RETURN;

IF senderInfo.destroyEvent # NIL THEN
ViewerEvents.UnRegisterEventProc[senderInfo.destroyEvent, destroy];

IF senderInfo.closeEvent # NIL THEN
ViewerEvents.UnRegisterEventProc[senderInfo.closeEvent, close];

IF senderInfo.editEvent # NIL THEN
ViewerEvents.UnRegisterEventProc[senderInfo.editEvent, edit];

IF senderInfo.openEvent # NIL THEN
ViewerEvents.UnRegisterEventProc[senderInfo.openEvent, open];

IF senderInfo.focusEvent # NIL THEN
ViewerEvents.UnRegisterEventProc[senderInfo.focusEvent, setInputFocus];

senderInfo.destroyEvent ¬ NIL;
senderInfo.closeEvent ¬ NIL;
senderInfo.editEvent ¬ NIL;
senderInfo.openEvent ¬ NIL;
senderInfo.focusEvent ¬ NIL;

TRUSTED {Process.Detach[FORK ViewerOps.DestroyViewer[senderV]]};
};

LockViewerOpen: PUBLIC ENTRY PROC[viewer: Viewer] = {
ENABLE UNWIND => NULL;
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
IF senderInfo = NIL THEN RETURN;
senderInfo.dontClose ¬ TRUE;
};

ReleaseOpenViewer: PUBLIC ENTRY PROC[viewer: Viewer] = {
ENABLE UNWIND => NULL;
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
IF senderInfo = NIL THEN RETURN;
senderInfo.dontClose ¬ FALSE;
};

SenderReport: PUBLIC ENTRY PROC[
format: ROPE, v1, v2,v3: IO.Value ¬ [null[]], blink: BOOL ¬ FALSE] = {
ENABLE UNWIND => NULL;
InternalReport[format, v1, v2, v3, blink]
};

InternalReport: INTERNAL PROC[
format: ROPE, v1, v2,v3: IO.Value ¬ [null[]], blink: BOOL ¬ FALSE] = {
done: BOOL ¬ FALSE;
tries: INT ¬ 0;
ReallyReport: PROC = {
IF reporter = NIL THEN {
senderTS ¬ TypeScript.Create[
info: [name: "SendMail", iconic: FALSE, column: right, openHeight: 64]];
reporter ¬ ViewerIO.CreateViewerStreams[NIL, senderTS].out;
senderEvent ¬ ViewerEvents.RegisterEventProc[
proc: DestroyReporter, event: destroy, filter: senderTS, before: TRUE];
};
IF blink THEN
{ viewer: Viewer = ViewerIO.GetViewerFromStream[reporter];	-- NIL for $Dribble class
IF viewer # NIL THEN ViewerOps.BlinkIcon[viewer];
};
reporter.PutF[format, v1, v2, v3];
done ¬ TRUE;
};
DO
ReallyReport[ ! IO.Error => IF ec = StreamClosed THEN {
reporter ¬ NIL; 
IF ( tries ¬ tries + 1) > 2 THEN REJECT;
CONTINUE } ];
IF done THEN RETURN;
ENDLOOP;
};

ReporterClump: TYPE = RECORD [reporters: SEQUENCE count: CARD16 OF STREAM];
maxReporters: CARD16 ¬ 16;
registeredReporters: REF ReporterClump ¬ NEW[ReporterClump[maxReporters]];

DestroyReporter: ENTRY ViewerEvents.EventProc = {
ENABLE UNWIND => NULL;
IF senderEvent # NIL THEN ViewerEvents.UnRegisterEventProc[senderEvent, destroy];
senderEvent ¬ NIL;
senderTS ¬ NIL;
FOR i: CARD16 IN [0..maxReporters) DO
IF registeredReporters[i] # reporter THEN LOOP;
registeredReporters[i] ¬ NIL;
EXIT;
ENDLOOP;
reporter ¬ NIL;
RETURN[FALSE];
};

RegisterReporter: PUBLIC ENTRY PROC[strm: STREAM] = {
IF senderTS # NIL THEN
{ reporter.Close[];
ViewerEvents.UnRegisterEventProc[senderEvent, destroy];
senderEvent ¬ NIL;
ViewerOps.DestroyViewer[senderTS];
senderTS ¬ NIL;
reporter ¬ NIL;
};
IF reporter = NIL THEN reporter ¬ strm;
FOR i: CARD16 IN [0.. maxReporters) DO
IF registeredReporters[i] = strm THEN EXIT;
IF registeredReporters[i] # NIL THEN LOOP;
registeredReporters[i] ¬ strm;
EXIT;
ENDLOOP;
};

UnregisterReporter: PUBLIC ENTRY PROC[strm: STREAM] = {
ENABLE UNWIND => NULL;
IF reporter = strm THEN reporter ¬ NIL;
FOR i: CARD16 IN [0.. maxReporters) DO
IF registeredReporters[i] # strm THEN LOOP;
registeredReporters[i] ¬ NIL;
ENDLOOP;
IF reporter = NIL THEN
FOR i: CARD16 IN [0.. maxReporters) DO
IF registeredReporters[i] = NIL THEN LOOP;
reporter ¬ registeredReporters[i];
EXIT;
ENDLOOP;
};

DenySendProc: ENTRY Menus.MenuProc = {
ENABLE UNWIND => NULL;
viewer: Viewer ¬ NARROW[parent];
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
senderInfo.confirmed ¬ FALSE;
senderInfo.userResponded ¬ TRUE;
BROADCAST sendingSynch;
};

ConfirmSendProc: ENTRY Menus.MenuProc = {
ENABLE UNWIND => NULL;
viewer: Viewer ¬ NARROW[parent];
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
senderInfo.confirmed ¬ TRUE;
senderInfo.userResponded ¬ TRUE;
BROADCAST sendingSynch;
};

AbortSendProc: ENTRY Menus.MenuProc = {
ENABLE UNWIND => NULL;
viewer: Viewer ¬ NARROW[parent];
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
ViewerOps.SetMenu[viewer, blankMenu];
senderInfo.aborted ¬ TRUE;
};

ReplyToSelfProc: ENTRY Menus.MenuProc = {
ENABLE UNWIND => NULL;
viewer: Viewer ¬ NARROW[parent];
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
senderInfo.replyToResponse ¬ self;
senderInfo.userResponded ¬ TRUE;
BROADCAST sendingSynch;
};

ReplyToAllProc: ENTRY Menus.MenuProc = {
ENABLE UNWIND => NULL;
viewer: Viewer ¬ NARROW[parent];
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
senderInfo.replyToResponse ¬ all;
senderInfo.userResponded ¬ TRUE;
BROADCAST sendingSynch;
};

ReplyToCancelProc: ENTRY Menus.MenuProc = {
ENABLE UNWIND => NULL;
viewer: Viewer ¬ NARROW[parent];
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
senderInfo.replyToResponse ¬ cancel;
senderInfo.userResponded ¬ TRUE;
BROADCAST sendingSynch;
};

ReplyToResponse: PUBLIC ENTRY PROC[senderInfo: SenderInfo] RETURNS [HowToReplyTo] = {
ENABLE UNWIND => NULL;
senderV: Viewer ¬ senderInfo.senderV;
ViewerOps.BlinkIcon[senderV, IF senderV.iconic THEN 0 ELSE 1];
UNTIL senderInfo.userResponded DO WAIT sendingSynch; ENDLOOP;
senderInfo.userResponded ¬ FALSE;
RETURN[senderInfo.replyToResponse];
};

CheckForAbortSend: PUBLIC ENTRY PROC[senderInfo: SenderInfo] RETURNS[BOOL] = {
ENABLE UNWIND => NULL;
IF senderInfo.aborted THEN {
InternalReport[" Aborting delivery ...\n"];
IF senderInfo.sendHandle#NIL THEN MailSend.Abort[senderInfo.sendHandle];
IF senderInfo.aborted THEN senderInfo.senderV.inhibitDestroy ¬ FALSE;
};
RETURN[senderInfo.aborted];
};

halfSecTicks: Process.Ticks = Process.MsecToTicks[500];

SenderAbortProc: PUBLIC ENTRY MailSendSidedoor.AbortSendProc = {
ENABLE UNWIND => NULL;
FOR sL: LIST OF SenderInfo ¬ senderList, sL.rest UNTIL sL = NIL DO
elapsed, waitTime: INT;
IF sL.first.sendHandle # msH THEN LOOP;
IF NOT lastTime THEN RETURN[sL.first.aborted];
IF ( elapsed ¬ BasicTime.Period[sL.first.startSendTime, BasicTime.Now[]] ) <
( waitTime ¬ UserProfile.Number["SendMailTool.SendWaitSeconds", 8] ) THEN {
IF elapsed < 0 THEN RETURN[sL.first.aborted];	-- strange
FOR i: INT IN [0..2*(waitTime-elapsed)) DO
WAIT sL.first.timeToWait;
IF sL.first.aborted THEN RETURN[TRUE];
ENDLOOP;
ViewerOps.SetMenu[sL.first.senderV, blankMenu];
WAIT sL.first.timeToWait;	-- 1/2 sec more
RETURN[sL.first.aborted];
};
ENDLOOP;
RETURN[FALSE];		-- strange but don't argue
};

Confirmation: PUBLIC ENTRY PROC[senderInfo: SenderInfo] RETURNS [BOOL] =
{ ENABLE UNWIND => NULL;  RETURN[SendingConfirm[senderInfo]]};

SendingConfirm: INTERNAL PROC[senderInfo: SenderInfo] RETURNS [BOOL] = {
senderV: Viewer ¬ senderInfo.senderV;
oldM: Menus.Menu ¬ ChangeMenu[senderV, confirmMenu];
ViewerOps.BlinkIcon[senderV, IF senderV.iconic THEN 0 ELSE 1];
UNTIL senderInfo.userResponded DO WAIT sendingSynch; ENDLOOP;
ViewerOps.SetMenu[senderV, oldM];
senderInfo.userResponded ¬ FALSE;
RETURN[senderInfo.confirmed];
};

ChangeMenu: PROC[v: Viewer, menu: Menus.Menu] RETURNS [oldM: Menus.Menu] = {
oldM ¬ v.menu;
ViewerOps.SetMenu[v, menu];
};

MessageSendProc: PUBLIC Menus.MenuProc = {
self: Viewer ¬ NARROW[parent];
transport: ATOM ¬ NARROW[clientData];
iHadFocus: BOOL ¬ InputFocus.GetInputFocus[].owner = self;
ViewerTools.InhibitUserEdits[self];
IF self.link#NIL THEN DestroySplits[self];
IF ( ( transport = $xns ) AND control ) THEN transport ¬ $newXNS;
TRUSTED { Process.Detach[FORK SendProc[self, mouseButton, iHadFocus, transport, TRUE]] };
};

MessageUSendProc: Menus.MenuProc = {
self: Viewer ¬ NARROW[parent];
transport: ATOM ¬ NARROW[clientData];
iHadFocus: BOOL ¬ InputFocus.GetInputFocus[].owner = self;
ViewerTools.InhibitUserEdits[self];
IF self.link#NIL THEN DestroySplits[self];
TRUSTED
{ Process.Detach[FORK SendProc[self, mouseButton, iHadFocus, transport, FALSE]] };
};

MessageSendCheckedProc: Menus.MenuProc = {
self: Viewer ¬ NARROW[parent];
transport: ATOM ¬ NARROW[clientData];
iHadFocus: BOOL ¬ InputFocus.GetInputFocus[].owner = self;
hasComments: BOOL ¬ FALSE;
ViewerTools.InhibitUserEdits[self];
FOR next: TiogaOps.Ref ¬ TiogaOps.ViewerDoc[self], TiogaOps.StepForward[next]
UNTIL next = NIL DO
IF hasComments ¬ TiogaOps.IsComment[next] THEN EXIT;
ENDLOOP;
IF hasComments THEN {
TRUSTED { Process.Detach[FORK CheckProc[self, mouseButton, iHadFocus, transport]] };
RETURN;
};
IF self.link#NIL THEN DestroySplits[self];
TRUSTED {Process.Detach[FORK SendProc[self, mouseButton, iHadFocus, transport, TRUE]]};
};

lf: CHAR ~ '\l;
cr: CHAR ~ '\r;

ForceCRLFProc: Menus.MenuProc = {
self: Viewer ~ NARROW[parent];
input: TiogaAccess.Reader ¬ TiogaAccessViewers.FromViewer[self];
output: TiogaAccess.Writer ¬ TiogaAccess.Create[];
root: Tioga.Node ~ TextNode.Root[TiogaAccess.GetLocation[input].node];
changeTo: CHAR ~ Rope.Fetch[TextEdit.GetNewlineDelimiter[root], 0];
changeFrom: CHAR ~ IF changeTo = lf THEN cr ELSE lf;  
UNTIL input.EndOf[] DO
char: TiogaAccess.TiogaChar ¬ input.Get[];
IF char.charSet = 0 THEN IF char.char = changeFrom THEN char.char ¬ changeTo;
output.Put[char];
ENDLOOP;
TiogaAccess.DoneWith[input];
TiogaAccessViewers.WriteViewer[output, self];
SendMailInternal.SenderNewVersion[self];	-- show as editted
ViewerOps.PaintViewer[self, caption];
};

CheckProc: PROC[self: Viewer, mouseButton: Menus.MouseButton,
iHadFocus: BOOL, transport: ATOM] = {
senderInfo: SenderInfo = NARROW[ViewerOps.FetchProp[self, $SenderInfo]];
SenderReport["\n*** Message to be sent contains comment nodes - are you sure you want to send it?"];
IF ~Confirmation[senderInfo] THEN {
SenderReport[" Message NOT sent"];
ViewerTools.EnableUserEdits[self];
RETURN;
};
IF self.link#NIL THEN DestroySplits[self];
SendProc[self, mouseButton, iHadFocus, transport, TRUE];
};

SendProc: PROC[viewer: Viewer, mouseButton: Menus.MouseButton,
iHadFocus: BOOL, transport: ATOM, sendFormatted: BOOL] = {
OPEN ViewerOps;
sendOK: BOOL;
senderInfo: SenderInfo = NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
viewer.newVersion ¬ TRUE;
viewer.name ¬ "Sending ...";
PaintViewer[viewer, caption];
viewer.file ¬ NIL;

IF sendFormatted THEN
sendOK ¬ SendMailOps.Send[v: viewer, doClose: mouseButton=blue, transport: transport]
ELSE sendOK ¬ SendMailOps.SendUnformatted[v: viewer, doClose: mouseButton=blue, transport: transport];
IF ~sendOK THEN SenderNewVersion[viewer];

viewer.name ¬ viewer.label ¬ sendCaption;
viewer.icon ¬ IF sendOK THEN senderIcon ELSE notSentIcon;
PaintViewer[viewer, caption];
ViewerTools.EnableUserEdits[viewer];
IF sendOK THEN {
AfterSendInsert: ENTRY PROC =
{ ENABLE UNWIND => NULL; InsertForm[senderInfo, defaultForm, FALSE] };
IF mouseButton=blue AND destroyAfterSend THEN {DestroyViewer[viewer]; RETURN};
UnsetNewVersion[viewer];
AfterSendInsert[];
};
};

SenderSplitProc: Menus.MenuProc = {
self: Viewer = NARROW[parent];
newV: Viewer;
nsI, senderInfo: SenderInfo;
TEditSplit.Split[self];
FOR newV ¬ self.link, newV.link UNTIL newV.link = self DO ENDLOOP;

senderInfo ¬ NARROW[ViewerOps.FetchProp[self, $SenderInfo]];
ViewerOps.AddProp[newV, $SenderInfo, nsI ¬ NEW[SenderInfoObject]];

nsI.senderV ¬ newV;
nsI.sendingTransports ¬ senderInfo.sendingTransports;
nsI.thisMenu ¬ senderInfo.thisMenu;
nsI.replyToResponse ¬ senderInfo.replyToResponse;
nsI.numCharsToDelete ¬ senderInfo.numCharsToDelete;
nsI.currentOutBox ¬ senderInfo.currentOutBox;
nsI.dontClose ¬ senderInfo.dontClose;
nsI.successfullySent ¬ senderInfo.successfullySent;
nsI.userResponded ¬ senderInfo.userResponded;
nsI.confirmed ¬ senderInfo.confirmed;
nsI.aborted ¬ senderInfo.aborted;
nsI.startSendTime ¬ senderInfo.startSendTime;
nsI.validateFlag ¬ senderInfo.validateFlag;
nsI.sendHandle ¬ senderInfo.sendHandle;
TRUSTED { Process.SetTimeout[@nsI.timeToWait, halfSecTicks] };

nsI.destroyEvent ¬ ViewerEvents.RegisterEventProc[
	proc: DestroySendViewer, event: destroy, filter: newV, before: TRUE];
nsI.closeEvent ¬ ViewerEvents.RegisterEventProc[
	proc: CloseSendViewer, event: close, filter: newV, before: TRUE];
nsI.editEvent ¬ ViewerEvents.RegisterEventProc[
	proc: FirstEditSendViewer, event: edit, filter: newV, before: TRUE];
newV.icon ¬ self.icon
};

DestroySplits: ENTRY PROC[keepThisOne: Viewer] =
{ ENABLE UNWIND => NULL; InternalDestroySplits[keepThisOne] };

InternalDestroySplits: PUBLIC PROC[keepThisOne: Viewer] = {
next: Viewer ¬ keepThisOne.link;
next2: Viewer;
sI: SenderInfo;
DO
IF next = keepThisOne THEN EXIT;
sI ¬ NARROW[ViewerOps.FetchProp[next, $SenderInfo]];
IF sI # NIL THEN {
IF sI.destroyEvent # NIL THEN
	ViewerEvents.UnRegisterEventProc[sI.destroyEvent, destroy];
IF sI.closeEvent # NIL THEN ViewerEvents.UnRegisterEventProc[sI.closeEvent, close];
IF sI.editEvent # NIL THEN ViewerEvents.UnRegisterEventProc[sI.editEvent, edit];
sI.destroyEvent ¬ NIL;
sI.closeEvent ¬ NIL;
sI.editEvent ¬ NIL;
};
next2 ¬ next.link;
IF sI # NIL THEN ViewerOps.DestroyViewer[next];		-- DON'T FORK here
next ¬ next2;
ENDLOOP;
--  make sure this sender is on the list of senders
FOR sL: LIST OF SenderInfo ¬ senderList, sL.rest UNTIL sL=NIL DO
IF sL.first.senderV = keepThisOne THEN RETURN;
ENDLOOP;

sI ¬ NARROW[ViewerOps.FetchProp[keepThisOne, $SenderInfo]];
IF sI = NIL THEN RETURN;
senderList ¬ CONS[sI, senderList];
};

SenderPlacesProc: Menus.MenuProc =
Menus.CopyEntry[ Menus.FindEntry[ TiogaMenuOps.tiogaMenu, "Places" ] ].proc;

SenderLevelsProc: Menus.MenuProc =
Menus.CopyEntry[ Menus.FindEntry[ TiogaMenuOps.tiogaMenu, "Levels" ] ].proc;

SenderGetFormProc: ENTRY PROC[self: Viewer, filename: ROPE] = {
ENABLE UNWIND => NULL;
fileStatus: FileStatus;
exp, fName: ROPE;
IF filename.Length[] = 0 THEN RETURN;

[fileStatus, exp, fName] ¬ CheckForFile[filename];
IF fileStatus = local OR fileStatus = remote THEN {
tc: ViewerTools.TiogaContents ¬ GetSendForm[fName];
senderInfo: SenderInfo ¬ NARROW[ViewerOps.FetchProp[self, $SenderInfo]];
InternalDisplayTioga[senderInfo, tc, TRUE];
ClearFileAssoc[self];
}
ELSE ErrorReport[exp];
};

SenderGetFileProc: Menus.MenuProc = {
self: Viewer = NARROW[parent];
filename: ROPE ¬ ViewerTools.GetSelectionContents[];
IF filename.Length[] = 0 THEN RETURN;
LoadFile[self, filename];
};

SenderFormsProc: Menus.MenuProc = {
viewer: Viewer = NARROW[parent];
which: INT;
sel: LIST OF ROPE ¬ popUpFormsFileNames;
blueButton: BOOL = mouseButton = blue;
IF popUpFormsList = NIL THEN RETURN;
which ¬ PopUpSelection.Request["Forms", popUpFormsList];
SELECT which FROM
<= 0 => RETURN;				-- no selection 
1 => { NewSenderProc[]; RETURN };
2 => { NewMsgFormProc[viewer]; RETURN };
3 => { PrevMsgProc[viewer, blueButton]; RETURN };
ENDCASE => which ¬ which - 3;

FOR i: INT IN [1..which) DO
sel ¬ sel.rest;
ENDLOOP;
SenderGetFormProc[viewer, sel.first];
};

SenderStoreProc: Menus.MenuProc = {
self: Viewer ¬ NARROW[parent];
fileName: Rope.ROPE = ViewerTools.GetSelectionContents[];
status: FileStatus;
exp: Rope.ROPE;
[status, exp] ¬ CheckForFile[fileName];
SELECT status FROM
local, notFound => {
TiogaMenuOps.Store[self, fileName];
IF mouseButton # blue THEN
{ IF ~self.newVersion THEN UnsetNewVersion[self] }
ELSE IF ~self.newVersion THEN ViewerOps.SetNewVersion[self];
};
ENDCASE => BadSaveOrStore[status, exp, fileName];
};

SenderSaveProc: Menus.MenuProc = {
self: Viewer ¬ NARROW[parent];
status: FileStatus;
exp: Rope.ROPE;
IF self.file = NIL THEN { SenderReport["\nCan't save - no file name\n"]; RETURN };

[status, exp] ¬ CheckForFile[self.name];
SELECT status FROM
local, notFound => {
[] ¬ ViewerOps.SaveViewer[ self ];
IF mouseButton # blue THEN
{ IF ~self.newVersion THEN UnsetNewVersion[self] }
ELSE IF ~self.newVersion THEN ViewerOps.SetNewVersion[self];
};
ENDCASE => BadSaveOrStore[status, exp, self.name];
};

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

LoadFile: PROC[self: Viewer, filename: ROPE, noName: BOOL ¬ FALSE] = {
status: FileStatus;
s, fName, nameToUse: ROPE;
EntryErrorReport: ENTRY PROC[exp: ROPE] = INLINE {
ENABLE UNWIND => NULL;
ErrorReport[exp];
};
[status, s, fName] ¬ CheckForFile[filename, FALSE];
IF status = notFound THEN {
[status, s, fName] ¬ CheckForFile[filename];		-- try .form extension
nameToUse ¬ fName;
}
ELSE nameToUse ¬ filename;
  
IF status = local OR status = remote THEN
{ self.file ¬ NIL; -- make sure that no one else thinks you're saving something
TiogaMenuOps.Load[ self, nameToUse ];
ViewerTools.EnableUserEdits[ self ];		-- in case remote file specified
IF noName THEN
{ self.name ¬ sendCaption;
ViewerOps.PaintViewer[self, caption];
self.file ¬ NIL;		-- don't want any file association
};
GrabFocus[self];
UnsetNewVersion[self];
}
ELSE EntryErrorReport[s];
};

CheckForFile: PROC[name: ROPE, addExt: BOOL ¬ TRUE]
	RETURNS[fileStatus: FileStatus ¬ local, explanation, fName: ROPE] = {

pathName: PFS.PATH  ¬ PFS.PathFromRope[name];
fullPath: PFS.PATH;
fullPath ¬ PFS.FileLookup[pathName, IF addExt THEN LIST[".form"] ELSE NIL ! PFS.Error => CONTINUE];
IF fullPath = NIL THEN {
explanation ¬ IO.PutFR1["%g not found", [rope[name]] ];
fileStatus ¬ notFound;
}
ELSE fName ¬ PFS.RopeFromPath[fullPath];
};

ErrorReport: INTERNAL PROC[exp: ROPE] = {
InternalReport[format: "\n%g\n", v1: [rope[exp]], blink: TRUE];
};

BadSaveOrStore: ENTRY PROC[status: FileStatus, exp, name: ROPE] = {
ENABLE UNWIND => NULL;
SELECT status FROM
notFound =>
InternalReport[format: "Can't store on remote file: \"%g\"\n", v1: [rope[name]], blink: TRUE];
illegalName, otherError => ErrorReport[exp];
ENDCASE => ERROR;
};

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
-- read the user profile line for message forms and add one menu entry for each

SetFormsList: PROC = {
OPEN Menus;
fLLast: LIST OF ROPE ¬ NIL;
popUpFormsFileNames ¬
UserProfile.ListOfTokens[key: "SendMailTool.MsgForms", default: NIL];
popUpFormsList ¬ NIL;

FOR fl: LIST OF ROPE ¬ popUpFormsFileNames, fl.rest UNTIL fl = NIL DO
form: ROPE ¬ fl.first;
shortName: ROPE;
fullPath: PFS.PATH;
IF form.Length[] = 0 THEN LOOP;		-- zero length name not allowed

shortName ¬ PFSNames.ComponentRope[PFSNames.ShortName[PFS.PathFromRope[form]]];
shortName ¬ shortName.Substr[0, shortName.Index[0, "."]];
IF fLLast = NIL THEN popUpFormsList ¬ fLLast ¬ LIST[shortName]
ELSE {
fLLast.rest ¬ LIST[shortName];
fLLast ¬ fLLast.rest;
};
ENDLOOP;

popUpFormsList ¬
CONS["NewSender", CONS["Default Form", CONS["Previous Msg", popUpFormsList]]];
};

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
--  Start code: create menus and register ourselves

DoInit: PROC = {
OPEN Menus;
pL: LIST OF MailSend.MailSendProcsRef ¬ MailSend.GetRegisteredSendProcsList[];
len: INT;
TRUSTED { len ¬ List.Length[LOOPHOLE[pL, List.LORA]] };
FOR procs: LIST OF MailSend.MailSendProcsRef ¬ MailSend.GetRegisteredSendProcsList[],
procs.rest UNTIL procs = NIL DO
tName: ROPE ¬ IF ( len = 1 ) THEN NIL ELSE Atom.GetPName[procs.first.which];
name: ROPE ¬ Rope.Concat[tName, "Send"];
AppendMenuEntry[sendMenu,
CreateEntry[name: name, proc: MessageSendProc, clientData: procs.first.which, fork: FALSE, guarded: procs.first.which = $gv]];
IF (procs.first.which = $xns) THEN
AppendMenuEntry[sendMenu,
CreateEntry[name: Rope.Concat[tName, "USend"], proc: MessageUSendProc, clientData: procs.first.which, fork: FALSE]];
ENDLOOP;

AppendMenuEntry[sendMenu, CreateEntry["Get", SenderGetFileProc]];
AppendMenuEntry[sendMenu,
CreateEntry[name: "Store", proc: SenderStoreProc, guarded: TRUE]];
AppendMenuEntry[sendMenu, CreateEntry["Save", SenderSaveProc]];
AppendMenuEntry[sendMenu, CreateEntry["Forms", SenderFormsProc]];
AppendMenuEntry[sendMenu, CreateEntry["CR/LF", ForceCRLFProc]];
AppendMenuEntry[sendMenu, CreateEntry["Split", SenderSplitProc]];
AppendMenuEntry[sendMenu, CreateEntry["Places", SenderPlacesProc]];
AppendMenuEntry[sendMenu, CreateEntry["Levels", SenderLevelsProc]];

AppendMenuEntry[sendingMenu, CreateEntry["StopSending!", AbortSendProc]];

AppendMenuEntry[confirmMenu, CreateEntry["Confirm", ConfirmSendProc]];
AppendMenuEntry[confirmMenu, CreateEntry["Deny", DenySendProc]];

AppendMenuEntry[replyToMenu, CreateEntry["Self", ReplyToSelfProc]];
AppendMenuEntry[replyToMenu, CreateEntry["All", ReplyToAllProc]];
AppendMenuEntry[replyToMenu, CreateEntry["Cancel", ReplyToCancelProc]];

Commander.Register["SendMail", SendMailCmd, "Mail sending tool"];
Commander.Register["SendMailTool", SendMailCmd, "Mail sending tool"];
SendMailInit[firstTime];
UserProfile.CallWhenProfileChanges[SendMailInit];

{
path: ROPE = "SendMailTool.icons";
senderIcon ¬ Icons.NewIconFromFile[path, 6];
IF senderIcon = unInit THEN senderIcon ¬ tool
ELSE {
edittingIcon ¬ Icons.NewIconFromFile[path, 9];
notSentIcon ¬ Icons.NewIconFromFile[path, 19];
};
};

IF UserProfile.Boolean["SendMailTool.GlobalSenderButton", FALSE] THEN
[] ¬ Buttons.Create[info: [name: "Sender"], proc: NewSenderClickProc];
};

initDir: ROPE ~ PFS.RopeFromPath[PFS.GetWDir[]];
DoInit[];

END.

SendMailControlImpl.mesa
Copyright Σ 1984, 1989, 1990, 1991, 1992, 1993 by Xerox Corporation.  All rights reserved.
Willie-Sue, February 2, 1990 5:44:01 pm PST
Willie-s, April 26, 1993 6:33 pm PDT
Theimer, April 30, 1990 10:39 pm PDT

Contents: Control module for SendMail
Last Edited by: Willie-Sue, January 17, 1984 10:20:02 am PST
Last Edited by: Donahue, October 7, 1983 9:42 am
************************************************************************
check for user name being set in defaultForm
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
be paranoid here
IF defaultForm.fields.rest.rest.first = NIL THEN
IF simpleUserNameList = NIL THEN SendMailInit[firstTime]; -- fixes up defaultForm
ViewerOps.PaintViewer[senderV, menu];	-- shouldn't be necessary
let's sidestep this issue for now
removes the named button from the sender menu, if such a button exists; no errors
make sure that there is no file pointed to so that you don't get something saved in UnSavedDocumentCache
should take senderInfo off of chain of senderInfo's, but why bother?

check if any comment nodes, and alert user if so
for now, we assume single character newline delimiter - beware crlf
assume cr and lf are the only values
now find the newest link in the chain to copy properties
Κ-Ψ•NewlineDelimiter

–
(cedarcode) style˜
codeš
Οb™Kšœ
Οe
œO™ZK™+K™$K™$K™Kš
œ%™%—K˜Kš
œ<™<Kš
œ0™0K˜š
Οk	˜	KšœŸœ˜Kšœ
Ÿœ˜KšœŸœ˜#Kšœ
Ÿœ˜(KšœŸœ˜*KšœŸœ˜!KšœŸœ
Ÿœ˜Kšœ	Ÿœ7˜EKšœŸœ˜'KšœŸœ€
˜‹
KšŸœ
˜KšŸœ
˜K˜	KšœŸœ˜KšœŸœ*˜7K˜KšœŸœ˜)KšœŸœ
˜Kšœ	Ÿœ˜%Kšœ	Ÿœ˜K˜K˜K˜Kšœ
Ÿœ"˜4Kšœ	ŸœU˜cKšœŸœ
˜Kšœ
ŸœH˜ZKšœ
Ÿœ™
˜¨
Kšœ	Ÿœ,˜:KšœŸœ
˜ 
KšœŸœ
˜KšœŸœT˜eKš
œ˜K˜—K˜šΟnœŸœ
Ÿ˜"š
Ÿ˜Kšœ%ŸœŸœ˜Ο—š
Ÿ˜Kš
œ˜—KšŸœ˜—K˜KšŸœ
Ÿœ˜)K˜Kš
Οc˜K˜KšŸœŸœŸœ
Ÿœ
˜KšŸœŸœŸœ
˜KšœŸœ˜$KšœŸœ˜0KšœŸœ˜(Kšœ"Ÿœ!˜FK˜KšœŸœŸœ
˜KšœŸœŸœ
˜KšœŸœ
ŸœŸœ
˜%K˜Kš	œŸœ
Ÿœ
ŸœŸœ
˜#Kš	œŸœ
Ÿœ
ŸœŸœ
˜(KšœŸ	œ
˜K˜KšœŸœŸœ‘˜9K˜$K˜&K˜%KšœŸœ
ŸœŸœ‘,˜KK˜Kšœ
ŸœŸœ
˜KšœŸœ
˜K˜Kš
œ,˜,Kšœ
Ÿœ˜.KšœŸœ˜-Kšœ
Ÿœ˜.K˜KšœŸœŸœŸœ	ŸœŸœ
Ÿœ	Ÿœ
Ÿœ˜OKšœŸœŸœ˜*KšœŸœŸœŸœ˜=KšœŸœ
ŸœŸœ
˜*K˜KšœŸœ6˜FK˜Kš
‘H™H˜Kš œ<Ÿœ˜N—˜š œŸœ
ŸœŸœ
ŸœŸœŸœŸœŸœ˜cKš
œ˜KšŸœ
Ÿœ˜.KšŸœŸœŸœ
˜'Kš
œ,™,K˜˜KšœŸœF˜Q—K˜KšŸœŸœ˜4KšœŸœ‘˜4Kš
œ˜——˜š 	œŸœ
Ÿœ
Ÿœ˜1KšŸœ
ŸœŸœ
˜KšŸœŸœ
Ÿœ
˜Kš
œ/˜/Kšœ,ŸœŸœ˜BKš
œ˜——K˜š
‘U™Uš œŸœ
ŸœŸœŸœŸœŸœŸœ
ŸœŸœ
˜‘
KšŸœŸœŸœ˜)Kš
œ˜Kš	œŸœŸœ
ŸœŸœ˜HK˜KKšŸœ˜"Kš
œ˜K˜—š œŸœ
Ÿœ˜6K™KšŸœŸœ
Ÿœ‘˜LKšŸœŸœ
Ÿœ
Ÿœ
˜(KšŸœŸœ
Ÿœ
Ÿœ
˜-KšŸœ Ÿœ
Ÿœ
Ÿœ
˜2Kš
Ÿœ&Ÿœ
Ÿœ
ŸœŸœ
Ÿœ‘™‚
KšŸœ˜K˜——˜š œŸœ
ŸœŸœ(ŸœŸœŸœŸœŸœ
˜†
KšŸœ˜#šŸœ
ŸœŸœŸœ
ŸœŸ˜AKšŸœ%Ÿœ
˜/—K˜Kš
œ˜K˜KšœŸœ
˜K˜šŸœŸ˜šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜@K˜šŸœ"ŸœŸœ
˜EKšŸœŸœŸœ˜Fš
Ÿ˜˜KšŸœŸœ
Ÿœ ˜:KšœŸœ
˜šŸœ2Ÿ˜8Kš
œ$˜$—šŸœŸœ‘#˜=KšœŸœ
Ÿœ2˜=šŸœŸœ
Ÿœ˜KšœŸœ˜$Kš
œ=˜=KšœŸœ
˜K˜—šŸœŸœŸœŸ˜5šœ+Ÿœ˜2Kšœ@Ÿœ˜G—KšŸœ˜!—Kš
œ˜—šŸœŸœ
ŸœŸœ
˜5KšŸœ˜!—Kš
œ%˜%KšœŸœ
˜KšŸœ˜	———KšŸœ
˜——K˜š
‘˜˜!Kš
œ˜š
œ˜Kš	œ	ŸœŸœ
ŸœŸœ˜.Kš
œ˜Kš
œ˜—Kšœ
Ÿœ˜—K˜šŸœŸœ
Ÿœ˜Kšœ@Ÿœ˜GKšœ7Ÿœ
˜<Kš
œ˜—KšœŸœ
˜Kšœ
Ÿœ(˜8KšŸœ>˜EKš
œ$˜$Kš
œ0˜0Kš
œ4˜4K˜šŸœŸœ
Ÿœ(ŸœŸœ
Ÿ˜HKš
œ;˜;KšŸœ
˜—K˜Kšœ
Ÿœ˜*K˜Kšœ~Ÿœ˜„
K˜KšœvŸœ˜|K˜KšœxŸœ˜~K˜Kš
ŸœŸœ
ŸœŸœŸœ˜WKšœ&‘™?KšœŸœ
˜KšŸœŸœŸœ%˜G—Kš
œ˜K˜—š œŸœ$Ÿœ˜?K™!K˜K˜——K˜Kš
‘X˜X˜š œ$˜0KšœŸœ?Ÿœ˜YKšœŸœ>Ÿœ˜WKšœŸœ?Ÿœ˜YKšœ*Ÿœ
˜.KšœŸœŸœ
˜Kš	œŸœ
Ÿœ
ŸœŸœ
˜"K˜K˜KšŸœŸœ
ŸœŸœ
ŸœŸœ˜RKšœŸœ
˜K˜PKšœLŸœ˜SKšœVŸœ˜]˜KšœBŸœ˜I—˜KšœCŸœ˜J—K˜šŸœŸœ
ŸœD˜aKšŸœ
Ÿœ
˜—K˜,šŸœŸœ
Ÿœ˜K˜2Kš	œŸœŸœŸœ
Ÿœ
˜>Kš
œ
˜
šŸœ˜K˜9K˜#Kš
œ˜——K˜KšœŸœ
˜KšŸœŸœ
ŸœF˜bK˜+šŸœŸœ
Ÿœ˜4KšŸœ!˜%—K˜KšœŸœ
˜KšŸœŸœ
ŸœH˜eK˜,šŸœŸœ
Ÿœ˜5KšŸœ#˜'—K˜K˜RKš
œ˜Kš
œ˜——˜š œŸœ
ŸœŸœ˜>KšŸœ
ŸœŸœ
˜KšœŸœ,˜KKšœ Ÿœ˜BK˜Kšœ%Ÿœ˜+Kš
œ˜——˜š œŸœ
Ÿœ
Ÿœ˜7KšŸœ
ŸœŸœ
˜KšœŸœ,˜KKš	ŸœŸœ
Ÿœ
Ÿœ‘˜1Kšœ$Ÿœ
˜)Kš
œ˜——˜š 	œŸœ
Ÿœ
Ÿœ(˜DKšŸœ
ŸœŸœ
˜KšœŸœ&˜EKš	ŸœŸœ
Ÿœ
Ÿœ‘˜1Kšœ+Ÿœ
˜0Kš
œ˜——K˜˜š œŸœ
Ÿœ
ŸœŸœŸœ	ŸœŸœ
Ÿœ	Ÿœ
Ÿœ˜ešŸœ
ŸœŸœ
˜˜KšŸœŸœ2˜L——K˜——˜š
 œŸœ
Ÿœ
ŸœŸœ˜7KšŸœ
ŸœŸœ
˜KšœŸœ
Ÿœ˜KšŸœŸœ
Ÿœ
Ÿœ
˜%šŸœŸœ
Ÿœ(ŸœŸœ
Ÿ˜JšŸœŸ˜šŸœŸ˜Kšœ*Ÿœ
˜1—š
Ÿ˜KšœŸœ˜——K˜	KšŸœ
˜—K˜——˜š
 
œŸœ
Ÿœ
ŸœŸœ˜GKšŸœ
ŸœŸœ
˜K˜8šŸœŸœ
Ÿ˜Kš
œ@˜@—šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜BK˜Kš
œ˜Kš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
˜$K˜?šŸœŸœ
Ÿœ˜Kš
œ@˜@Kš
œ.˜.K˜—KšŸœ
˜—Kš
œ˜K˜—š
 œŸœ
Ÿœ
ŸœŸœ˜GKšœ
ŸœŸœ˜KšŸœ
ŸœŸœ
˜š
 	œŸœŸœ
ŸœŸœ˜FKš
œ8˜8Kš
œ6˜6š
œC˜CKšœŸœŸœ˜ —KšŸœ
Ÿœ	Ÿœ&˜9K˜—K˜K˜K˜šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜BKš
œ˜KšœŸœ
˜Kš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
˜$K˜-KšœŸœ
˜"Kš
œ.˜.KšŸœ
˜—Kš
œ˜K˜—š
 œŸœ
Ÿœ
ŸœŸœ˜5K™QKšŸœ
ŸœŸœ
˜K˜7KšŸœŸœ
Ÿœ
Ÿœ
˜Kšœ>Ÿ	œ˜IšŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜BK˜Kš
œ˜Kš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
˜$K˜>šŸœŸœ
Ÿœ˜Kšœ>Ÿ	œ˜IKš
œ.˜.K˜—KšŸœ
˜—Kš
œ˜——K˜Kš
‘X˜XKš
‘˜˜š œŸœ
Ÿœ˜.KšŸœ
ŸœŸœ
˜Kš
œ˜Kš
œ˜——˜š œŸœ
ŸœŸœ˜>KšŸœ
ŸœŸœ
˜KšœŸœ+˜JK˜KšŸœ
Ÿœ
Ÿœ˜6Kš
œ˜K˜KšŸœ
Ÿœ
Ÿœ%Ÿœ
˜>šœ
Ÿœ˜šŸœŸœ
ŸœŸœŸœŸœ˜VšŸœ‘!˜(KšœŸœ
˜K˜Kš	œŸœ
Ÿœ
ŸœŸœ˜0KšœŸœ
Ÿœ
Ÿœ˜ šŸœ&ŸœŸœ
Ÿ˜:KšœŸœ
˜K˜KšŸœ
˜—K˜WKšŸœŸœ
Ÿœ
˜K˜šŸœŸœ
ŸœŸ˜K˜KšŸœ
˜—KšœŸœŸœŸœ˜6Kš
œ˜——šŸœ1Ÿ˜7Kš
œ#˜#—Kš
œ)˜)Kš
œ˜K˜—Kš
œ˜——˜š œ˜*Kš
œ˜K˜Kšœ Ÿœ
ŸœŸœ˜XKš
œ˜Kš
œ˜K˜—š 
œŸœ˜Kš
œ˜K˜Kšœ Ÿœ
ŸœŸœ˜XKš
œ˜Kš
œ˜——˜š 
œŸœ
Ÿœ˜-KšœŸœ+˜JK˜Kšœ$Ÿœ˜*Kš
œ˜Kš
œ˜——K˜Kš
‘X˜X˜š œ˜-KšœŸœ+˜JKš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜'KšŸœŸœ
ŸœŸœ
˜?Kš
œh™hKš
Ÿœ3Ÿœ
Ÿœ
Ÿœ
Ÿœ˜LKšŸœŸœ'˜CKšŸœ
Ÿœ˜
Kš
œ˜——˜š œŸœ
Ÿœ
Ÿœ2˜TKš	œŸœ
ŸœŸœŸœ˜>——˜š œŸœ
Ÿœ
Ÿœ%Ÿœ
Ÿœ
Ÿœ˜XKšœŸœ
ŸœŸœ3˜J——˜š œ˜+KšœŸœ+˜JKš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜'šŸœŸ˜šœLŸœ˜RKšŸœ
Ÿœ
˜—Kš
œ˜—Kšœ
ŸœŸœŸœ˜EKšŸœ
Ÿœ˜Kš
œ˜——˜š œ˜/KšŸœ˜KšœŸœ+˜JKš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜'Kšœ‘˜-KšŸœ
Ÿœ˜Kš
œ˜——˜š œŸœ
Ÿœ-˜HKšŸœ
ŸœŸœ
˜Kšœ
ŸœŸœ
˜KšŸœŸœ
Ÿœ‘˜+šŸœŸ˜š
œ?˜?KšŸœ*ŸœŸœ
˜L—Kš
œ˜—KšŸœŸœ
Ÿœ
˜K˜šŸœŸœ
Ÿ˜%Kš
œC˜C—K˜šŸœŸœ
Ÿ˜#Kš
œ?˜?—K˜šŸœŸœ
Ÿ˜"Kš
œ=˜=—K˜šŸœŸœ
Ÿ˜"Kš
œ=˜=—K˜šŸœŸœ
Ÿ˜#Kš
œG˜G—K˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜K˜Kš
œD™DK™KšŸœŸœ$˜@Kš
œ˜——˜š œŸœ
Ÿœ
Ÿœ˜5KšŸœ
ŸœŸœ
˜KšœŸœ+˜JKšŸœŸœ
Ÿœ
Ÿœ
˜ KšœŸœ
˜Kš
œ˜——˜š œŸœ
Ÿœ
Ÿœ˜8KšŸœ
ŸœŸœ
˜KšœŸœ+˜JKšŸœŸœ
Ÿœ
Ÿœ
˜ KšœŸœ
˜Kš
œ˜K˜—š œŸœ
Ÿœ
Ÿœ
Ÿœ
ŸœŸœŸœ˜gKšŸœ
ŸœŸœ
˜Kš
œ)˜)Kš
œ˜—K˜š œŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ˜eKšœŸœŸœ
˜KšœŸœ˜š œŸœ˜šŸœŸœ
Ÿœ˜Kšœ?Ÿœ"˜fKšœ(Ÿœ˜;KšœoŸœ˜uKš
œ˜—šŸœŸ˜
šœ;‘˜TKšŸœ
Ÿœ
Ÿœ˜1—Kš
œ˜—Kš
œ"˜"KšœŸœ
˜K˜—š
Ÿ˜šœŸœ
ŸœŸœ˜7KšœŸœ˜KšŸœŸœ
Ÿœ
˜(KšŸœ˜
—KšŸœŸœ
Ÿœ
˜KšŸœ
˜—Kš
œ˜——˜Kš
œŸœŸœ
ŸœŸœ
Ÿœ
Ÿœ˜KKšœŸœ˜KšœŸœŸœ˜J—˜š œŸœ˜1KšŸœ
ŸœŸœ
˜KšŸœŸœ
Ÿœ8˜QKšœŸœ
˜KšœŸœ
˜šŸœŸœ
ŸœŸ˜%KšŸœ#Ÿœ
Ÿœ
˜/KšœŸœ
˜KšŸœ
˜KšŸœ
˜—KšœŸœ
˜KšŸœ
Ÿœ˜Kš
œ˜——˜š
 œŸœ
Ÿœ
ŸœŸœ˜5šŸœŸœ
Ÿ˜š
œ˜Kš
œ7˜7KšœŸœ
˜Kš
œ"˜"KšœŸœ
˜KšœŸœ
˜—Kš
œ˜—KšŸœŸœ
Ÿœ˜'šŸœŸœ
ŸœŸ˜&KšŸœŸœ
Ÿœ
˜+KšŸœŸœ
Ÿœ
Ÿœ
˜*K˜KšŸœ
˜KšŸœ
˜—Kš
œ˜——˜š
 œŸœ
Ÿœ
ŸœŸœ˜7KšŸœ
ŸœŸœ
˜KšŸœŸœŸœ
˜'šŸœŸœ
ŸœŸ˜&KšŸœŸœ
Ÿœ
˜+KšœŸœ
˜KšŸœ
˜—šŸœŸœ
Ÿ˜šŸœŸœ
ŸœŸ˜&KšŸœŸœ
Ÿœ
Ÿœ
˜*K˜"KšŸœ
˜KšŸœ
˜——Kš
œ˜——˜š œŸœ˜&KšŸœ
ŸœŸœ
˜KšœŸœ	˜ KšœŸœ+˜JKšœŸœ
˜KšœŸœ
˜ KšŸ	œ˜Kš
œ˜——˜š œŸœ˜)KšŸœ
ŸœŸœ
˜KšœŸœ	˜ KšœŸœ+˜JKšœŸœ
˜KšœŸœ
˜ KšŸ	œ˜Kš
œ˜——˜š 
œŸœ˜'KšŸœ
ŸœŸœ
˜KšœŸœ	˜ KšœŸœ+˜JKš
œ%˜%KšœŸœ
˜Kš
œ˜——˜š œŸœ˜)KšŸœ
ŸœŸœ
˜KšœŸœ	˜ KšœŸœ+˜JK˜"KšœŸœ
˜ KšŸ	œ˜Kš
œ˜——˜š œŸœ˜(KšŸœ
ŸœŸœ
˜KšœŸœ	˜ KšœŸœ+˜JK˜!KšœŸœ
˜ KšŸ	œ˜Kš
œ˜——˜š œŸœ˜+KšŸœ
ŸœŸœ
˜KšœŸœ	˜ KšœŸœ+˜JK˜$KšœŸœ
˜ KšŸ	œ˜Kš
œ˜——˜š
 œŸœ
Ÿœ
ŸœŸœ˜UKšŸœ
ŸœŸœ
˜K˜%KšœŸœŸœŸœ˜>KšŸœŸœ
ŸœŸœ
˜=KšœŸœ
˜!KšŸœ˜#Kš
œ˜——˜š œŸœ
Ÿœ
ŸœŸœ
Ÿœ˜NKšŸœ
ŸœŸœ
˜šŸœŸœ˜Kš
œ+˜+KšŸœŸœ
Ÿœ'˜HKšŸœŸœ%Ÿœ
˜EKš
œ˜—KšŸœ˜Kš
œ˜——˜š
œ7˜7K˜—š œŸœ
Ÿœ#˜@KšŸœ
ŸœŸœ
˜šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜BKšœŸœ
˜KšŸœŸœ
Ÿœ
˜'KšŸœ
Ÿœ
Ÿœ
Ÿœ˜.šŸœ
Ÿœ˜˜
KšŸœ
Ÿœ
Ÿœ‘
˜8šŸœŸœ
ŸœŸ˜*KšŸœ˜KšŸœŸœ
Ÿœ
Ÿœ˜&KšŸœ
˜—Kš
œ/˜/KšŸœ‘˜)KšŸœ˜K˜—KšŸœ
˜—KšŸœ
Ÿœ‘˜*Kš
œ˜K˜—š œŸœ
Ÿœ
ŸœŸœŸœ˜HKš	œŸœ
ŸœŸœŸœ˜>——˜š
 œŸœ
ŸœŸœŸœ˜HK˜%K˜4KšœŸœŸœŸœ˜>KšŸœŸœ
ŸœŸœ
˜=Kš
œ!˜!KšœŸœ
˜!KšŸœ˜Kš
œ˜——˜š 
œŸœŸœ˜LK˜Kš
œ˜Kš
œ˜——˜š œŸœ˜*KšœŸœ	˜KšœŸœŸœ
˜%KšœŸœ+˜:Kš
œ#˜#KšŸœŸœ
Ÿœ˜*KšŸœŸœŸœ˜AKšŸœŸœ3Ÿœ˜YKš
œ˜——˜š œ˜$KšœŸœ	˜KšœŸœŸœ
˜%KšœŸœ+˜:Kš
œ#˜#KšŸœŸœ
Ÿœ˜*KšŸœŸœ3Ÿœ˜ZKš
œ˜K˜—š œ˜*KšœŸœ	˜KšœŸœŸœ
˜%KšœŸœ+˜:Kšœ
ŸœŸœ
˜Kš
œ#˜#Kš
œ0™0šŸœJ˜MšŸœŸœ
Ÿ˜KšŸœ(Ÿœ
Ÿœ
˜4KšŸœ
˜——šŸœ
Ÿœ˜KšŸœŸœ7˜TKšŸœ
˜K˜—KšŸœŸœ
Ÿœ˜*KšŸœŸœ3Ÿœ˜WKš
œ˜K˜—KšœŸœ˜šœŸœ˜K˜—š 
œ˜!KšœŸœ	˜K˜@K˜2K˜FKšœ8™CKšœ
Ÿœ5˜CK™$Kš	œŸœŸœŸœŸœ˜6šŸœŸ˜K˜*KšŸœŸœ
ŸœŸœ˜MKš
œ˜KšŸœ
˜—Kš
œ˜K˜-Kšœ)‘˜;K˜%K˜——˜š 	œŸœ:Ÿœ
Ÿœ˜cKšœŸœ)˜HKš
œd˜dšŸœŸœ˜#Kš
œ"˜"Kš
œ"˜"KšŸœ
˜K˜—KšŸœŸœ
Ÿœ˜*Kšœ2Ÿœ˜8K˜K˜—š
 œŸœ<Ÿœ
ŸœŸœ˜yKšŸœ˜KšœŸœ
˜
KšœŸœ+˜JKšœŸœ
˜K˜Kš
œ˜KšœŸœ
˜K˜šŸœŸœV˜kKšŸœb˜f—KšŸœ	Ÿœ˜)K˜K˜)KšœŸœŸœŸœ
˜9Kš
œ˜Kš
œ$˜$šŸœŸœ˜š œŸœ
Ÿœ˜Kš	œŸœ
ŸœŸœ&Ÿœ˜F—KšŸœŸœŸœŸœ˜NKš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜——˜š œ˜#KšœŸœ	˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ8™8KšŸœŸœŸœ
Ÿœ
˜BK˜Kšœ
Ÿœ)˜<Kšœ+Ÿœ˜BK˜K˜K˜5K˜#K˜1K˜3K˜-K˜%K˜3K˜-K˜%K˜!K˜-K˜+K˜'KšŸœ7˜>K˜˜2Kšœ@Ÿœ˜F—˜0Kšœ<Ÿœ˜B—˜/Kšœ?Ÿœ˜E—K˜Kš
œ˜——˜š 
œŸœ
Ÿœ˜0KšœŸœ
ŸœŸœ'˜>——˜š œŸœ
Ÿœ˜;K˜ Kš
œ˜Kš
œ˜š
Ÿ˜KšŸœŸœ
Ÿœ
˜ KšœŸœ)˜4šŸœŸœ
Ÿœ˜šŸœŸœ
Ÿ˜Kš
œ<˜<—KšŸœŸœ
Ÿœ8˜SKšŸœŸœ
Ÿœ6˜PKšœŸœ
˜KšœŸœ
˜KšœŸœ
˜Kš
œ˜—K˜KšŸœŸœ
Ÿœ!‘˜CK˜
KšŸœ
˜—Kš
‘3˜3šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜@KšŸœ Ÿœ
Ÿœ
˜.KšŸœ
˜—K˜KšœŸœ0˜;KšŸœŸœ
Ÿœ
Ÿœ
˜Kšœ
Ÿœ˜"Kš
œ˜——˜š œ˜"Kš
œL˜L——˜š œ˜"Kš
œL˜L——˜š œŸœ
ŸœŸœ˜?KšŸœ
ŸœŸœ
˜Kš
œ˜KšœŸœ
˜KšŸœŸœ
Ÿœ
˜%K˜K˜2šŸœŸœŸœ˜3K˜3KšœŸœ)˜HKšœ%Ÿœ˜+Kš
œ˜Kš
œ
˜
—KšŸœ˜Kš
œ˜——˜š œ˜%KšœŸœ	˜Kšœ
Ÿœ&˜4KšŸœŸœ
Ÿœ
˜%Kš
œ˜Kš
œ˜——˜š œ˜#KšœŸœ	˜ KšœŸœ
˜KšœŸœ
Ÿœ
Ÿœ˜(KšœŸœ˜&KšŸœŸœ
Ÿœ
Ÿœ
˜$K˜8šŸœŸ˜KšœŸœ‘œ
˜#KšœŸœ˜!KšœŸœ˜(Kšœ(Ÿœ˜1KšŸœ˜—K˜šŸœŸœ
ŸœŸ˜K˜KšŸœ
˜—Kš
œ%˜%Kš
œ˜K˜—š œ˜#KšœŸœ	˜KšœŸœ&˜9Kš
œ˜Kšœ
Ÿœ
˜K˜'šŸœŸ˜š
œ˜Kš
œ#˜#šŸœŸ˜KšœŸœŸœ˜2KšŸœ
ŸœŸœ˜<—Kš
œ˜—KšŸœ*˜1—Kš
œ˜——˜š œ˜"KšœŸœ	˜Kš
œ˜Kšœ
Ÿœ
˜KšŸœ
Ÿœ
Ÿœ2Ÿœ˜RK˜K˜(šŸœŸ˜š
œ˜K˜"šŸœŸ˜KšœŸœŸœ˜2KšŸœ
ŸœŸœ˜<—K˜—KšŸœ+˜2—Kš
œ˜——K˜Kš
‘H˜H˜š
 œŸœŸœ
ŸœŸœ˜FKš
œ˜KšœŸœ
˜š
 œŸœ
ŸœŸœŸœ˜2KšŸœ
ŸœŸœ
˜Kš
œ˜K˜—Kšœ,Ÿœ˜3šŸœŸœ˜Kšœ.‘˜DK˜K˜
KšŸœ˜—Kš
œ˜šŸœŸœŸ˜)šœŸœ‘<˜OKš
œ%˜%Kšœ&‘ ˜FšŸœŸ˜˜Kš
œ%˜%KšœŸœ‘"˜4—Kš
œ˜—Kš
œ˜Kš
œ˜—Kš
œ
˜
—KšŸœ˜Kš
œ˜——˜š
 œŸœŸœ
ŸœŸœ
˜3šœ
Ÿœ5Ÿœ˜FK˜—Kšœ
Ÿœ
ŸœŸœ˜-Kšœ
Ÿœ
Ÿœ
˜KšœŸœŸœŸœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ˜cšŸœŸœ
Ÿœ˜KšœŸœ&Ÿ
˜7K˜Kš
œ
˜
KšŸœ	Ÿœ˜(—Kš
œ˜——˜š œŸœ
ŸœŸœ˜)Kšœ9Ÿœ˜?Kš
œ˜——˜š œŸ
œ Ÿœ˜CKšŸœ
ŸœŸœ
˜šŸœŸ˜š
œ˜KšœXŸœ˜^—Kš
œ,˜,—KšŸœŸœ
˜Kš
œ˜K˜——Kš
‘H˜HKš
‘O˜O˜š œŸœ˜KšŸœ˜Kš	œŸœ
Ÿœ
ŸœŸœ
˜˜Kšœ@Ÿœ˜E—KšœŸœ
˜K˜š
ŸœŸœ
Ÿœ
Ÿœ ŸœŸœ
Ÿ˜EKšœŸœ˜KšœŸœ
˜Kšœ
Ÿœ
Ÿ˜KšŸœŸœ
Ÿœ‘˜@K˜Kšœ6Ÿœ˜OK˜9šŸœ
Ÿœ
ŸœŸœ˜>šŸœ˜KšœŸœ˜K˜K˜——KšŸœ
˜—K˜˜KšŸœŸœŸœ#˜N—Kš
œ˜——K˜Kš
‘H˜HKš
‘3˜3K˜š œŸœ˜KšŸœ˜KšœŸœ
ŸœC˜NKšœŸœ
˜	KšŸœŸœ
Ÿœ˜7šŸœŸœ
ŸœOŸœ	Ÿœ
Ÿ˜uKšœŸœŸœ
Ÿœ
Ÿœ
Ÿœ"˜LKšœŸœ˜(KšœnŸœ%˜˜
šŸœŸ˜"Kšœ†
Ÿœ˜Ž
—KšŸœ
˜—K˜Kš
œA˜AKšœUŸœ˜\Kš
œ?˜?Kš
œA˜AK˜?Kš
œA˜AKš
œC˜CKš
œC˜CK˜Kš
œI˜IK˜Kš
œF˜FKš
œ@˜@K˜Kš
œC˜CKš
œA˜AKš
œG˜G—˜Kš
œA˜AKš
œE˜EKš
œ˜Kš
œ1˜1K˜š
œ
˜
KšœŸœ˜"K˜,šŸœŸœ˜-šŸœ˜K˜.K˜.K˜——Kš
œ˜—K˜šŸœ8ŸœŸ˜EK˜F—Kš
œ˜K˜—Kšœ	ŸœŸœŸœ˜0K˜	K˜KšŸœ˜—…—•Ηψ