DIRECTORY
Commander USING [CommandProc, Register],
DefaultRemoteNames USING [Get],
FS USING [ComponentPositions, Error, OpenFile, Close, ExpandName, Open],
GVSend USING [Abort],
Icons USING [IconFlavor, NewIconFromFile],
InputFocus USING [GetInputFocus],
Menus USING [AppendMenuEntry, CopyEntry, CreateEntry, CreateMenu,
		FindEntry, Menu, MenuEntry,
		MenuProc, MouseButton, ReplaceMenuEntry, targetNotFound],
IO,
PopUpSelection USING [Request],
Process USING [Detach],
Rope,
TEditSplit USING[ Split ],
TiogaMenuOps USING[ tiogaMenu, Empty, Load, Store ],
TiogaOps USING [ Ref, Location, CancelSelection, GetSelection, IsComment, NextPlaceholder, StepForward, ViewerDoc ],
TypeScript USING [Create],
ViewerEvents USING [EventProc, EventRegistration, RegisterEventProc, UnRegisterEventProc],
ViewerOps USING [AddProp, BlinkIcon, ComputeColumn, CreateViewer, DestroyViewer,
		FetchProp, MoveBelowViewer, OpenIcon, PaintViewer, SetMenu, SetNewVersion],
ViewerIO USING [CreateViewerStreams, GetViewerFromStream],
ViewerTools USING [EnableUserEdits, GetSelectionContents, InhibitUserEdits,
		SelPos, SelPosRec, SetSelection, SetTiogaContents, TiogaContents, TiogaContentsRec],
ViewerClasses USING [Viewer],
ViewerMenus USING [ Save ],
UserCredentials USING [Get],
UserProfile USING [Boolean, CallWhenProfileChanges, ProfileChangedProc,
  		ListOfTokens, Token],
WalnutSendInternal,
WalnutSendOps,
WalnutSendOpsExtras USING [];

WalnutSendControlImpl: CEDAR MONITOR
IMPORTS
Commander, DefaultRemoteNames, IO, PopUpSelection, Process, Rope, FS,
GVSend,
Icons, InputFocus, Menus,
TEditSplit, TiogaMenuOps, TiogaOps, TypeScript,
ViewerEvents, ViewerIO, ViewerMenus, ViewerOps, ViewerTools,
UserCredentials, UserProfile,
WalnutSendInternal, WalnutSendOps
EXPORTS
WalnutSendInternal, WalnutSendOps, WalnutSendOpsExtras
SHARES Menus =

BEGIN OPEN WalnutSendOps, WalnutSendInternal;

-- Global types & variables

ROPE: TYPE = Rope.ROPE;
Viewer: TYPE = ViewerClasses.Viewer;
TiogaContents: TYPE = ViewerTools.TiogaContents;
viewerStart: ViewerTools.SelPos = NEW[ViewerTools.SelPosRec _ [0, 0]];

userRName: PUBLIC ROPE _ NIL;				-- user name with regsitry
simpleUserName: PUBLIC ROPE _ NIL;		-- user name without registry
replyToSelf: PUBLIC BOOL _ FALSE;
alwaysOpenSender: BOOL _ FALSE;

sendCaption: PUBLIC ROPE _ "Walnut Sender";

destroyAfterSend: BOOL _ FALSE;
senderList: LIST OF SenderInfo _ NIL;

sendMenu: PUBLIC Menus.Menu _ Menus.CreateMenu[];
formsMenu: PUBLIC Menus.Menu;
sendingMenu: PUBLIC Menus.Menu _ Menus.CreateMenu[];
blankMenu: PUBLIC Menus.Menu _ Menus.CreateMenu[];
confirmMenu: PUBLIC Menus.Menu _ Menus.CreateMenu[];
replyToMenu: PUBLIC Menus.Menu _ Menus.CreateMenu[];

popUpFormsList: LIST OF ROPE _ NIL;
popUpFormsFileNames: LIST OF ROPE _ NIL;
sendingSynch: CONDITION;
needToAuthenticate: PUBLIC BOOL _ TRUE;

iconicSender: BOOL _ TRUE;		-- make iconic initially only
senderIcon: Icons.IconFlavor _ tool;
edittingIcon: Icons.IconFlavor _ tool;

reporter: IO.STREAM _ NIL;
senderTS: Viewer _ NIL;

labelFont: PUBLIC ROPE  _ NIL; -- font to use for printing of header labels

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

standardDefaultText: ViewerTools.TiogaContents =
NEW[ ViewerTools.TiogaContentsRec _
    		  [contents: "\nSubject: \001Topic\002\nTo: \001Recipients\002\nCc: \001Copies To\002\n\n\001Message\002\n",
    		  formatting: "\000\000\000\006\000\000\235\312\000<\000\000\002\230\000J\232\002\320bs\007\234\t\230\020J\232\002\235\002\234\016\230\020J\232\002\235\002\234\n\230\017J\230\000J\230\t\227\000\205\227\000\000\000\000\000>\000\000\000\200\000\000"] ];

standardAnswerText: ViewerTools.TiogaContents =
NEW[ ViewerTools.TiogaContentsRec _
    		  [contents: "\nSubject: \001Topic\002\nIn-reply-to: \001Message\002\nTo: \001Recipients\002\nCc: \001Copies To\002\n\n\001Message\002\n\000",
    		  formatting: "\000\000\000\006\000\000\235\312\000I\000\000\002\230\000J\232\002\320bs\007\234\t\230\020J\232\002\235\013\234\013\230\026J\232\002\235\002\234\016\230\020J\232\002\235\002\234\n\230\017J\230\000J\232\001\234\t\230\t\227\000\205\227\000\000\000\000\000V\000\000\000\245\000\000"] ];

standardForwardText: ViewerTools.TiogaContents =
NEW[ ViewerTools.TiogaContentsRec _
    		  [contents: "\nSubject: \001Topic\002\nTo: \001Recipients\002\nCc: \001Copies To\002\n\n\001CoveringMessage\002\n\n--------------------------------------\nForwardedMessage\n--------------------------------------\n\n\001ClosingComment\002\n",
    		  formatting: "\000\000\000\006\000\000\235\312\000W\000\000\002\230\000J\232\002\320bs\007\234\t\230\020J\232\002\235\002\234\016\230\020J\232\002\235\002\234\n\230\017J\230\000J\230\021J\230\000\002\232\001\234&\230&J\230\020\227J\232\001\234&\230&J\230\000J\230\020\227\000\205\227\000\000\000\000\000\270\000\000\001\025\000\000"] ];

defaultForm: WalnutSendOps.Form =
NEW[ WalnutSendOps.FormRec _ [ formText: defaultText,
    									 fields: LIST[ NIL, NIL, simpleUserName] ] ];

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, localNotFound, remoteNotFound, otherError};

-- ************************************************************************
--  Sending messages is independent of CedarDB

WalnutSendMail: Commander.CommandProc = { WalnutSendProc[fromExec: TRUE]};

WalnutSendProc: PUBLIC PROC[fromExec: BOOL] =
BEGIN
senderInfo: SenderInfo;
IF fromExec THEN fromExec _ ~alwaysOpenSender;
IF ~fromExec THEN iconicSender _ FALSE;
senderInfo _ BuildSender[paint: TRUE, iconic: iconicSender, form: defaultForm];

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

GrabFocus: PUBLIC ENTRY PROC[senderV: Viewer] =
BEGIN ENABLE UNWIND => NULL;
IF senderV.iconic THEN RETURN;
ViewerTools.SetSelection[senderV, viewerStart];
[] _ TiogaOps.NextPlaceholder[gotoend: FALSE];
END;

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
BuildSendViewer: PUBLIC PROC[paint, iconic: BOOL, form: WalnutSendOps.Form _ NIL,
										  who: Viewer _ NIL] RETURNS[v: Viewer] =
{ newForm: WalnutSendOps.Form = IF form # NIL THEN form ELSE defaultForm;
RETURN[BuildSender[paint, iconic, newForm, who].senderV] };

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

senderV: Viewer;

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
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, $WalnutSendOpsForm];
IF ra # NIL THEN {
form: WalnutSendOps.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;
ViewerOps.SetMenu[senderV, sendMenu];
senderInfo _ NEW[SenderInfoObject _ [senderV: senderV]];
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];
END;

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
DoUserNameAndRegistry: PROC = {
uN: ROPE = UserCredentials.Get[].name;
pos: INT;
IF (pos _ Rope.SkipTo[s: uN, skip: "."]) = Rope.Length[uN]
THEN {
simpleUserName _ uN;
defaultRegistry _ DefaultRemoteNames.Get[].registry;
userRName _ Rope.Cat[uN, ".", defaultRegistry];
}
ELSE {
simpleUserName _ Rope.Substr[uN, 0, pos];
defaultRegistry _ Rope.Substr[uN, pos+1];
userRName _ uN;
};
};

ChangeUserRName: PUBLIC PROC[newUserRName: ROPE] = {
userRName _ newUserRName;
simpleUserName _ newUserRName.Substr[0, newUserRName.Find["."]];
};

WalnutSendInit: UserProfile.ProfileChangedProc = {
defaultFormFile: ROPE = UserProfile.Token[key: "WalnutSend.DefaultForm", default: NIL];
answerFormFile: ROPE = UserProfile.Token[key: "WalnutSend.AnswerForm", default: NIL];
forwardFormFile: ROPE = UserProfile.Token[key: "WalnutSend.ForwardForm", default: NIL];
formContents: ViewerTools.TiogaContents _ NIL;

DoUserNameAndRegistry[];
needToAuthenticate _ TRUE;
replyToSelf _ UserProfile.Boolean[key: "WalnutSend.ReplyToSelf", default: FALSE];
destroyAfterSend _ UserProfile.Boolean[key: "WalnutSend.DestroyAfterSend", default: FALSE];
alwaysOpenSender _
UserProfile.Boolean[key: "WalnutSend.AlwaysOpenSender", default: FALSE];

IF defaultFormFile # NIL THEN formContents _ GetSendForm[defaultFormFile];
IF formContents # NIL THEN
{ defaultText _ defaultForm.formText _ formContents; defaultForm.fields _ NIL }
ELSE
{ defaultText _ defaultForm.formText _ standardDefaultText;
defaultForm.fields _ LIST[NIL, NIL, simpleUserName]};

formContents _ NIL;
IF answerFormFile # NIL THEN formContents _ GetSendForm[answerFormFile];
IF formContents # NIL THEN answerText _ formContents
ELSE answerText _ standardAnswerText;

formContents _ NIL;
IF forwardFormFile # NIL THEN formContents _ GetSendForm[forwardFormFile];
IF formContents # NIL THEN forwardText _ formContents
ELSE forwardText _ standardForwardText;

labelFont _ UserProfile.Token[key: "WalnutSend.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] =
BEGIN 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;
END;

RemoveFromSendMenu: PUBLIC ENTRY PROC[name: ROPE] =
BEGIN
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;
END;

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

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

PrevMsgProc: ENTRY PROC[viewer: Viewer]  =
BEGIN ENABLE UNWIND => NULL;
senderInfo: SenderInfo _ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
IF viewer.link#NIL THEN InternalDestroySplits[viewer];
ClearFileAssoc[viewer];
IF senderInfo.prevMsg = NIL THEN InsertForm[senderInfo, defaultForm, TRUE]
 ELSE {
IF TiogaOps.GetSelection[feedback].viewer = viewer THEN
TiogaOps.CancelSelection[feedback];
ViewerTools.SetTiogaContents[viewer, senderInfo.prevMsg];
UnsetNewVersion[viewer];
}
END;

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

NewMsgForm: INTERNAL PROC[viewer: Viewer] =
BEGIN
senderInfo: SenderInfo _ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
InsertForm[senderInfo, defaultForm, TRUE];
ClearFileAssoc[viewer];
END;

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

DestroySendViewer: ViewerEvents.EventProc =
BEGIN
senderInfo: SenderInfo _ NARROW[ViewerOps.FetchProp[viewer, $SenderInfo]];
IF senderInfo = NIL THEN RETURN[FALSE];
IF senderInfo.senderV # NIL THEN senderInfo.senderV.file _ NIL;
-- make sure that there is no file pointed to so that you don't get something saved in UnSavedDocumentCache
IF ViewerOps.FetchProp[viewer, $DestroySenderProc] = NIL THEN RETURN[FALSE];
TRUSTED {Process.Detach[FORK CheckForDestroy[viewer, senderInfo]]};
RETURN[TRUE];
END;

EntryInsertForm: PUBLIC ENTRY PROC[senderInfo: SenderInfo, form: WalnutSendOps.Form] =
BEGIN ENABLE UNWIND => NULL;
InsertForm[senderInfo, form, TRUE];
END;

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

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

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

CheckForDestroy: ENTRY PROC[senderV: Viewer, senderInfo: SenderInfo] =
BEGIN 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]]};
END;

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

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

SenderReport: PUBLIC ENTRY PROC[msg: ROPE, blink: BOOL _ FALSE] =
BEGIN ENABLE UNWIND => NULL;
InternalReport[msg, blink];
END;

InternalReport: INTERNAL PROC[msg: ROPE, blink: BOOL _ FALSE] =
BEGIN
IF reporter = NIL THEN
{ senderTS _ TypeScript.Create[
	info: [name: "WalnutSend", 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.PutRope[msg];
END;

DestroyReporter: ViewerEvents.EventProc =
BEGIN
IF senderEvent # NIL THEN ViewerEvents.UnRegisterEventProc[senderEvent, destroy];
senderEvent _ NIL;
senderTS _ NIL;
reporter _ NIL;
RETURN[FALSE];
END;

RegisterReporter: PUBLIC ENTRY PROC[strm: IO.STREAM] =
BEGIN ENABLE UNWIND => NULL;
IF senderTS # NIL THEN
{ reporter.Close[];
ViewerEvents.UnRegisterEventProc[senderEvent, destroy];
senderEvent _ NIL;
ViewerOps.DestroyViewer[senderTS];
senderTS _ NIL;
};
reporter _ strm;
END;

UnregisterReporter: PUBLIC ENTRY PROC[strm: IO.STREAM] =
BEGIN ENABLE UNWIND => NULL;
IF reporter = strm THEN reporter _ NIL;
END;

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

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

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

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

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

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

----------------------------
ReplyToResponse: PUBLIC ENTRY PROC[senderInfo: SenderInfo] RETURNS [HowToReplyTo] =
BEGIN 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] 
  END;

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

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

SendingConfirm: INTERNAL PROC[senderInfo: SenderInfo] RETURNS [BOOL] =
BEGIN
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];
END;

ChangeMenu: PROC[v: Viewer, menu: Menus.Menu] RETURNS [oldM: Menus.Menu] =
BEGIN
oldM _ v.menu;
ViewerOps.SetMenu[v, menu];
END;

MessageSendProc: PUBLIC Menus.MenuProc =
BEGIN
self: Viewer _ NARROW[parent];
iHadFocus: BOOL _ InputFocus.GetInputFocus[].owner = self;
ViewerTools.InhibitUserEdits[self];
IF self.link#NIL THEN DestroySplits[self];
TRUSTED {Process.Detach[FORK SendProc[self, mouseButton, iHadFocus]]};
END;

MessageSendCheckedProc: PUBLIC Menus.MenuProc =
BEGIN
self: Viewer _ NARROW[parent];
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]] };
RETURN;
};
IF self.link#NIL THEN DestroySplits[self];
TRUSTED {Process.Detach[FORK SendProc[self, mouseButton, iHadFocus]]};
END;

CheckProc: PROC[self: Viewer, mouseButton: Menus.MouseButton, iHadFocus: BOOL] = {
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];
};

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

sendOK _ WalnutSendOps.Send[v: viewer, doClose: mouseButton=blue];
IF ~sendOK THEN SenderNewVersion[viewer];

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

SenderSplitProc: Menus.MenuProc =
BEGIN
self: Viewer = NARROW[parent];
newV: Viewer;
nsI, senderInfo: SenderInfo;
TEditSplit.Split[self];
-- now find the newest link in the chain to copy properties
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 _ senderInfo^]];

nsI.senderV _ newV;
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
END;

DestroySplits: ENTRY PROC[keepThisOne: Viewer] =
BEGIN ENABLE UNWIND => NULL;
InternalDestroySplits[keepThisOne];
END;

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] =
BEGIN 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 {InternalReport["\n", TRUE]; InternalReport[exp]; InternalReport["\n"]};
END;

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

SenderFormsProc: Menus.MenuProc = {
viewer: Viewer = NARROW[parent];
which: INT;
sel: LIST OF ROPE _ popUpFormsFileNames;
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]; RETURN };
ENDCASE => which _ which - 3;

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

SenderStoreProc: Menus.MenuProc =
BEGIN
self: Viewer _ NARROW[parent];
fileName: Rope.ROPE = ViewerTools.GetSelectionContents[];
status: FileStatus;
exp: Rope.ROPE;
[status, exp] _ CheckForFile[fileName];
SELECT status FROM
local, localNotFound => {
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];
END;

SenderSaveProc: Menus.MenuProc =
BEGIN
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, localNotFound => {
ViewerMenus.Save[ 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];
END;

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

LoadFile: PROC[self: Viewer, filename: ROPE, noName: BOOL _ FALSE] =
BEGIN
status: FileStatus;
s, fName, nameToUse: ROPE;

[status, s, fName] _ CheckForFile[filename, FALSE];
IF status = localNotFound OR status = remoteNotFound 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 ErrorReport[s];
END;

CheckForFile: PROC[name: ROPE, addExt: BOOL _ TRUE]
	RETURNS[fileStatus: FileStatus, explanation, fName: ROPE] =
BEGIN
of: FS.OpenFile;
cp: FS.ComponentPositions;
explanation _ NIL;
fName _ name;
BEGIN ENABLE FS.Error =>
{ IF error.group = user THEN
{ SELECT error.code FROM
$illegalName => fileStatus _ illegalName;
$unknownFile =>
fileStatus _ IF fileStatus = local THEN localNotFound ELSE remoteNotFound;
ENDCASE => fileStatus _ otherError}
ELSE fileStatus _ otherError;
explanation _ error.explanation;
CONTINUE
};

cp _ FS.ExpandName[name, NIL].cp;
IF explanation # NIL THEN RETURN;

fName _ IF cp.ext.length = 0 AND addExt THEN name.Concat[".form"] ELSE name;
IF cp.server.length = 0 THEN fileStatus _ local ELSE fileStatus _ remote;
of _ FS.Open[fName];
IF of # NIL THEN FS.Close[of];
END;
END;

ErrorReport: ENTRY PROC[exp: ROPE] =
{ ENABLE UNWIND => NULL;
InternalReport["\n", TRUE];
InternalReport[exp];
InternalReport["\n"];
};

BadSaveOrStore: PROC[status: FileStatus, exp, name: ROPE] =
BEGIN
SELECT status FROM
remote, remoteNotFound =>
ErrorReport[Rope.Cat["Can't store on remote file: \"", name, "\""]];
illegalName, otherError => ErrorReport[exp];
ENDCASE => ERROR;
END;

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

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

FOR fl: LIST OF ROPE _ popUpFormsFileNames, fl.rest UNTIL fl = NIL DO
form: ROPE _ fl.first;
shortName, fullName: ROPE;
cp: FS.ComponentPositions;

[fullName, cp, ] _ FS.ExpandName[form, NIL];
-- if the file is a remote one, then strip off the leading server/directory info
shortName _ fullName.Substr[cp.base.start, cp.base.length];
-- add ".form" if one does not exist
IF cp.ext.length = 0 THEN form _ form.Concat[".form"];

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]]];
END;

-- * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
--  Start code: create menus

BEGIN
OPEN Menus;

AppendMenuEntry[sendMenu,
		CreateEntry[name: "Send", proc: MessageSendProc, fork: FALSE]];
AppendMenuEntry[sendMenu,
		CreateEntry[name: "SendChecked", proc: MessageSendCheckedProc, fork: FALSE]];
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["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]];
END;

----------------------------
--  start code; make menu and register ourselves

Commander.Register["WalnutSend", WalnutSendMail, "Mail sending tool"];
UserProfile.CallWhenProfileChanges[WalnutSendInit];
DoUserNameAndRegistry[];

BEGIN
path: ROPE = "Walnut.icons";
senderIcon _ Icons.NewIconFromFile[path, 6 ! FS.Error => GOTO notFound];
edittingIcon _ Icons.NewIconFromFile[path, 9];
EXITS
notFound => NULL;
END;

END.

nWalnutSendControlImpl.mesa
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Willie-Sue, September 17, 1986 10:46:06 am PDT

Contents: Control module for WalnutSend
Last Edited by: Willie-Sue, January 17, 1984 10:20:02 am PST
Last Edited by: Donahue, October 7, 1983 9:42 am
ViewerOps.PaintViewer[senderV, menu];		-- shouldn't be necessary
removes the named button from the sender menu, if such a button exists; no errors
ViewerOps.PaintViewer[viewer, menu];		-- shouldn't be necessary
should take senderInfo off of chain of senderInfo's, byt why bother?

check if any comment nodes, and alert user if so
�Ê(|˜š
Ïb™Jšœ
Ïm
œ1™<Icode™.—J™Jš
œ'™'J˜Jš
œ<™<Jš
œ0™0J˜š
Ïk	˜	Jšœ
Ÿœ˜(JšœŸœ˜JšŸœ
Ÿœ@˜HJšœŸœ	˜JšœŸœ˜*JšœŸœ˜!šœŸœ6˜AJš
œ˜Jš
œ;˜;—JšŸœ
˜JšœŸœ˜JšœŸœ
˜Jš
œ˜JšœŸœ
˜Jšœ
Ÿœ"˜4Jšœ	Ÿœf˜tJšœŸœ
˜Jšœ
ŸœH˜Zšœ
ŸœA˜PJš
œM˜M—Jšœ	Ÿœ,˜:šœŸœ:˜KJš
œV˜V—JšœŸœ
˜JšœŸœ
˜JšœŸœ˜JšœŸœP˜aJš
œ˜Jš
œ˜JšœŸœ˜—J˜šœŸœ
Ÿ˜$š
Ÿ˜JšœŸœ!Ÿœ
˜EJš
œ˜Jš
œ˜Jš
œ/˜/Jš
œ<˜<Jš
œ˜Jš
œ!˜!—š
Ÿ˜Jš
œ6˜6—JšŸœ˜—J˜JšŸœ
Ÿœ#˜-J˜Jš
Ïc˜J˜JšŸœŸœŸœ
˜JšœŸœ˜$JšœŸœ˜0Jšœ"Ÿœ!˜FJ˜JšœŸœ
ŸœŸœ ˜;JšœŸœ
ŸœŸœ ˜AJšœ
Ÿœ
ŸœŸœ
˜!JšœŸœŸœ
˜J˜Jšœ
Ÿœ
Ÿœ˜+J˜JšœŸœŸœ
˜JšœŸœ
ŸœŸœ
˜%J˜Jšœ
Ÿœ!˜1JšœŸœ˜Jšœ
Ÿœ!˜4JšœŸœ!˜2Jšœ
Ÿœ!˜4Jšœ
Ÿœ!˜4J˜Jš	œŸœ
Ÿœ
ŸœŸœ
˜#Jš	œŸœ
Ÿœ
ŸœŸœ
˜(JšœŸ	œ
˜JšœŸœ
ŸœŸœ
˜'J˜JšœŸœŸœ ˜9Jš
œ$˜$Jš
œ&˜&J˜Jšœ
Ÿœ
ŸœŸœ
˜JšœŸœ
˜J˜JšœŸœ
ŸœŸœ ,˜KJ˜Jš
œ,˜,Jšœ
Ÿœ˜.JšœŸœ˜-Jšœ
Ÿœ˜.J˜š
œ0˜0JšŸœ•˜˜—J˜š
œ/˜/JšŸœæ˜é—J˜š
œ0˜0JšŸœñ˜ô—J˜š
œ!˜!JšŸœIŸœŸœŸœ˜p—J˜JšœŸœŸœŸœ	ŸœŸœ
Ÿœ	Ÿœ
Ÿœ˜OJšœŸœŸœ˜*JšœŸœŸœŸœ˜=JšœŸœ
ŸœŸœ
˜*J˜JšœŸœK˜[J˜Jš
 K˜KJš
 .˜.J˜JšÏnœ5Ÿœ˜JJ˜š¡œŸœ
ŸœŸœ˜-š
Ÿ˜Jš
œ˜JšŸœ
Ÿœ˜.JšŸœŸœŸœ
˜'Jšœ Ÿœ+˜OJ˜JšŸœŸœ˜4JšœŸœ ˜4—JšŸœ
˜—J˜š¡	œŸœ
Ÿœ˜/šŸœ
Ÿœ
ŸœŸœ
˜JšŸœŸœ
Ÿœ
˜Jš
œ/˜/Jšœ'Ÿœ˜.—JšŸœ
˜—J˜Jš
 X˜Xš¡œŸœ
ŸœŸœŸœŸœŸœ
˜…
š	œ ŸœŸœ
ŸœŸœ
˜IJšŸœ5˜;——J˜š¡œŸœ
ŸœŸœ*ŸœŸœŸœŸœ˜™
šŸœ
Ÿœ
Ÿœ˜šŸœŸœ
ŸœŸ˜0JšŸœ%Ÿœ
˜/—J˜Jš
œ˜J˜šŸœŸ˜šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜@Jš
œ˜šŸœ"ŸœŸœ
˜EJšŸœ˜!š
Ÿ˜š
œ˜JšŸœŸœ
Ÿœ ˜:JšœŸœ
˜šŸœ2Ÿ˜8Jš
œ$˜$—šŸœŸœ #˜=JšœŸœ
Ÿœ4˜?šŸœŸœ
Ÿœ˜JšœŸœ˜&Jš
œ=˜=JšœŸœ
˜J˜—šŸœŸœŸœŸ˜5šœ+Ÿœ˜2Jšœ@Ÿœ˜G—JšŸœ˜!—Jš
œ˜—šŸœŸœ
ŸœŸœ
˜5JšŸœ˜!—Jš
œ%˜%JšœŸœ
˜JšŸœ˜	————JšŸœ
˜—J˜š
 ˜š
œ!˜!Jš
œ˜š
œ˜Jš	œ	ŸœŸœ
ŸœŸœ˜.Jš
œ˜Jš
œ˜—Jšœ
Ÿœ˜—J˜šŸœŸœ
Ÿ˜šœAŸœ˜HJšœ7Ÿœ˜?——JšœŸœ
˜Jš
œ%˜%Jšœ
Ÿœ(˜8Jš
œ4˜4J˜šŸœŸœ
Ÿœ(ŸœŸœ
Ÿ˜HJš
œ;˜;JšŸœ
˜—J˜Jšœ
Ÿœ˜*J˜Jšœ€
Ÿœ˜†
J˜JšœyŸœ˜J˜Jšœ{Ÿœ˜�
J˜Jš
ŸœŸœ
ŸœŸœŸœ ˜ZJšœ' ™@JšœŸœ
˜JšŸœŸœŸœ%˜G——JšŸœ
˜—J˜Jš
 X˜Xš¡œŸœ˜JšœŸœ˜&JšœŸœ
˜	šŸœ8˜:šŸœ˜Jš
œ˜Jš
œ4˜4Jš
œ/˜/Jš
œ
˜
—šŸœ˜Jš
œ)˜)Jš
œ)˜)Jš
œ˜Jš
œ˜——J˜—J˜š¡œŸœ
ŸœŸœ˜4Jš
œ˜Jš
œ@˜@J˜—J˜š¡œ$˜2JšœŸœ=Ÿœ˜WJšœŸœ<Ÿœ˜UJšœŸœ=Ÿœ˜WJšœ*Ÿœ
˜.J˜Jš
œ˜JšœŸœ
˜JšœJŸœ˜QJšœTŸœ˜[š
œ˜JšœAŸœ˜I—JšŸœŸœ
Ÿœ-˜JšŸœŸœ
Ÿ˜JšœJŸœ˜OJš
Ÿ˜š
œ;˜;JšœŸœ
ŸœŸœ˜5——J˜JšœŸœ
˜JšŸœŸœ
Ÿœ,˜HšŸœŸœ
Ÿœ˜4JšŸœ!˜%—J˜JšœŸœ
˜JšŸœŸœ
Ÿœ-˜JšŸœŸœ
Ÿœ˜5JšŸœ#˜'—J˜Jš
œP˜PJš
œ˜Jš
œ˜—J˜š¡œŸœ
ŸœŸœ˜>JšŸœ
ŸœŸœ
˜JšœŸœ,˜KJšœ Ÿœ˜BJš
œ˜Jšœ%Ÿœ˜+Jš
œ˜—J˜š¡œŸœ
Ÿœ
Ÿœ˜7JšŸœ
ŸœŸœ
˜JšœŸœ,˜KJš	ŸœŸœ
Ÿœ
Ÿœ ˜1Jšœ$Ÿœ
˜)Jš
œ˜—J˜š¡	œŸœ
Ÿœ
Ÿœ(˜DJšŸœ
ŸœŸœ
˜JšœŸœ&˜EJš	ŸœŸœ
Ÿœ
Ÿœ ˜1Jšœ+Ÿœ
˜0Jš
œ˜—J˜J˜š¡œŸœ
Ÿœ
ŸœŸœŸœ	ŸœŸœ
Ÿœ	Ÿœ
Ÿœ˜ešŸœ
ŸœŸœ
˜š
œ˜JšŸœŸœ2˜L——J˜—J˜š
¡œŸœ
Ÿœ
ŸœŸœ˜7JšŸœ
ŸœŸœ
˜JšœŸœ
Ÿœ˜JšŸœŸœ
Ÿœ
Ÿœ
˜%šŸœŸœ
Ÿœ(ŸœŸœ
Ÿ˜JšŸœŸ˜šŸœŸ˜Jšœ*Ÿœ
˜1—š
Ÿ˜JšœŸœ˜——J˜	JšŸœ
˜—J˜—J˜š¡
œŸœŸœ˜EšŸœ
Ÿœ
ŸœŸœ
˜J˜8šŸœŸœ
Ÿ˜Jš
œ@˜@—šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜BJ˜Jš
œ˜Jš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
˜$Jš
œ?˜?šŸœŸœ
Ÿœ˜Jš
œ@˜@Jš
œ.˜.J˜—JšŸœ
˜——JšŸœ
˜—J˜š
¡œŸœ
Ÿœ
ŸœŸœ˜3J™Qš
Ÿ˜J˜7JšŸœŸœ
Ÿœ
Ÿœ
˜Jšœ>Ÿ	œ˜I—šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜BJ˜Jš
œ˜Jš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
˜$Jš
œ>˜>šŸœŸœ
Ÿœ˜Jšœ>Ÿ	œ˜IJš
œ.˜.J˜—JšŸœ
˜—JšŸœ
˜—J˜Jš
 X˜XJš
 ˜J˜š¡œŸœ
Ÿœ˜.JšŸœ
ŸœŸœ
˜Jš
œ˜Jš
œ˜—J˜š¡œŸœ
Ÿœ˜*šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ+˜JJšŸœ
Ÿœ
Ÿœ˜6Jš
œ˜JšŸœŸœ
Ÿœ%Ÿœ
˜Jšœ
Ÿœ˜šŸœ1Ÿ˜7Jš
œ#˜#—Jš
œ9˜9Jšœ& ™?Jš
œ˜Jš
œ
˜
——JšŸœ
˜—J˜š¡
œŸœ˜Jšœ.Ÿœ
ŸœŸœ˜fJš
œ˜Jš
œ˜—J˜š¡
œŸ
œ˜+š
Ÿ˜JšœŸœ+˜JJšœ$Ÿœ˜*Jš
œ˜—JšŸœ
˜—J˜Jš
 X˜XJ˜š¡œ˜+š
Ÿ˜JšœŸœ+˜JJš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜'JšŸœŸœ
ŸœŸœ
˜?—š
 k˜kJš
Ÿœ3Ÿœ
Ÿœ
Ÿœ
Ÿœ˜LJšŸœŸœ'˜CJšŸœ
Ÿœ˜
—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
Ÿœ4˜VšŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ˜#—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
Ÿœ%Ÿœ
Ÿœ
Ÿœ˜XšŸœ
Ÿœ
ŸœŸœ
˜Jš
œ/˜/—JšŸœ
˜—J˜š¡œ˜)š
Ÿ˜JšœŸœ+˜JJš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜'šŸœŸ˜šœ=Ÿœ˜CJšŸœ
Ÿœ
˜—Jš
œ˜—Jšœ
ŸœŸœŸœ˜EJšŸœ
Ÿœ˜—JšŸœ
˜—J˜š¡œ˜-šŸœ
Ÿœ˜JšœŸœ+˜JJš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜'Jšœ ˜-JšŸœ
Ÿœ˜—JšŸœ
˜—J˜š¡œŸœ
Ÿœ+˜FšŸœ
Ÿœ
ŸœŸœ
˜Jšœ
ŸœŸœ
˜JšŸœŸœ
Ÿœ ˜+šŸœŸ˜š
œ?˜?JšŸœ*ŸœŸœ
˜L—Jš
œ˜—JšŸœŸœ
Ÿœ
˜J˜šŸœŸœ
Ÿ˜%Jš
œC˜C—J˜šŸœŸœ
Ÿ˜#Jš
œ?˜?—J˜šŸœŸœ
Ÿ˜"Jš
œ=˜=—J˜šŸœŸœ
Ÿ˜"Jš
œ=˜=—J˜šŸœŸœ
Ÿ˜#Jš
œG˜G—J˜JšœŸœ
˜JšœŸœ
˜JšœŸœ
˜JšœŸœ
˜JšœŸœ
˜J˜Jš
œD™DJ™JšŸœŸœ$˜@—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
Ÿœ˜3šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ+˜JJšŸœŸœ
Ÿœ
Ÿœ
˜ JšœŸœ
˜—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
Ÿœ˜6šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ+˜JJšŸœŸœ
Ÿœ
Ÿœ
˜ JšœŸœ
˜—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
ŸœŸœ	ŸœŸœ˜AšŸœ
Ÿœ
ŸœŸœ
˜Jš
œ˜—JšŸœ
˜—J˜š¡œŸœ
ŸœŸœ	ŸœŸœ˜?š
Ÿ˜šŸœŸœ
Ÿ˜š
œ˜Jšœ$Ÿœ"˜KJšœ(Ÿœ˜;š
œ-˜-JšœBŸœ˜H——Jš
œ˜—šŸœŸ˜
šœ; ˜TJšŸœ
Ÿœ
Ÿœ˜1—Jš
œ˜—Jš
œ˜—JšŸœ
˜—J˜š¡œ˜)š
Ÿ˜JšŸœŸœ
Ÿœ8˜QJšœŸœ
˜JšœŸœ
˜JšœŸœ
˜JšŸœ
Ÿœ˜—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
ŸœŸœ
Ÿœ˜6šŸœ
Ÿœ
ŸœŸœ
˜šŸœŸœ
Ÿ˜š
œ˜Jš
œ7˜7JšœŸœ
˜Jš
œ"˜"JšœŸœ
˜—Jš
œ˜—Jš
œ˜—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
ŸœŸœ
Ÿœ˜8šŸœ
Ÿœ
ŸœŸœ
˜JšŸœŸœŸœ
˜'—JšŸœ
˜—J˜š¡œŸœ˜$šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ	˜ JšœŸœ+˜JJšœŸœ
˜JšœŸœ
˜ JšŸ	œ˜—JšŸœ
˜—J˜š¡œŸœ˜'šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ	˜ JšœŸœ+˜JJšœŸœ
˜JšœŸœ
˜ JšŸ	œ˜—JšŸœ
˜—J˜š¡
œŸœ˜%šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ	˜ JšœŸœ+˜JJš
œ%˜%JšœŸœ
˜—JšŸœ
˜—J˜š¡œŸœ˜'šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ	˜ JšœŸœ+˜JJš
œ"˜"JšœŸœ
˜ JšŸ	œ˜—JšŸœ
˜—J˜š¡œŸœ˜&šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ	˜ JšœŸœ+˜JJš
œ!˜!JšœŸœ
˜ JšŸ	œ˜—JšŸœ
˜—J˜š¡œŸœ˜)šŸœ
Ÿœ
ŸœŸœ
˜JšœŸœ	˜ JšœŸœ+˜JJš
œ$˜$JšœŸœ
˜ JšŸ	œ˜—JšŸœ
˜—J˜Jš
 ˜š
¡œŸœ
Ÿœ
ŸœŸœ˜SšŸœ
Ÿœ
ŸœŸœ
˜Jš
œ%˜%JšœŸœŸœŸœ˜>JšŸœŸœ
ŸœŸœ
˜=JšœŸœ
˜!JšŸœ Ÿœ
˜*——J˜š¡œŸœ
Ÿœ
ŸœŸœ
Ÿœ˜LšŸœ
Ÿœ
ŸœŸœ
˜šŸœŸ˜š
œ-˜-JšŸœŸœ
Ÿœ%˜FJšŸœŸœ%Ÿœ
˜E—Jš
œ˜—JšŸœ˜—JšŸœ
˜—J˜š¡œŸœ
Ÿœ
ŸœŸœŸœ˜HJš	œŸœ
ŸœŸœŸœ˜>—J˜š
¡œŸœ
ŸœŸœŸœ˜Fš
Ÿ˜Jš
œ%˜%Jš
œ4˜4JšœŸœŸœŸœ˜>JšŸœŸœ
ŸœŸœ
˜=Jš
œ!˜!JšœŸœ
˜!JšŸœ˜—JšŸœ
˜—J˜š¡
œŸœŸœ˜Jš
Ÿ˜Jš
œ˜Jš
œ˜—JšŸœ
˜—J˜š¡œŸœ˜(š
Ÿ˜JšœŸœ	˜JšœŸœ+˜:Jš
œ#˜#JšŸœŸœ
Ÿœ˜*JšŸœŸœ*˜F—JšŸœ
˜—J˜š¡œŸœ˜/š
Ÿ˜JšœŸœ	˜JšœŸœ+˜:Jšœ
ŸœŸœ
˜Jš
œ#˜#Jš
œ0™0šŸœJ˜MšŸœŸœ
Ÿ˜JšŸœ(Ÿœ
Ÿœ
˜4—JšŸœ
˜—šŸœ
Ÿœ˜JšŸœŸœ,˜HJšŸœ
˜J˜—JšŸœŸœ
Ÿœ˜*JšŸœŸœ*˜F—JšŸœ
˜—J˜š¡	œŸœ:Ÿœ˜RJšœŸœ)˜HJš
œd˜dšŸœŸœ˜#Jš
œ"˜"Jš
œ"˜"JšŸœ
˜J˜—JšŸœŸœ
Ÿœ˜*Jš
œ'˜'J˜—J˜š¡œŸœ<Ÿœ˜QšŸœ
Ÿœ˜JšœŸœ
˜
JšœŸœ+˜JJšœŸœ
˜Jš
œ˜Jš
œ˜JšœŸœ
˜J˜Jš
œB˜BJšŸœ	Ÿœ˜)J˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ$˜$šŸœŸ˜šœ¡œŸœ
Ÿœ˜šŸœ
Ÿœ
ŸœŸœ
˜Jšœ$Ÿœ˜+—JšŸœ
˜JšŸœŸœŸœŸœ˜NJš
œ˜Jš
œ˜—Jš
œ˜——JšŸœ
˜—J˜š¡œ˜!š
Ÿ˜JšœŸœ	˜Jš
œ
˜
Jš
œ˜Jš
œ˜—š
 ;˜;JšŸœŸœŸœ
Ÿœ
˜BJ˜Jšœ
Ÿœ)˜<Jšœ+Ÿœ"˜PJ˜Jš
œ˜š
œ2˜2Jšœ@Ÿœ˜F—š
œ0˜0Jšœ<Ÿœ˜B—š
œ/˜/Jšœ?Ÿœ˜E—Jš
œ˜—JšŸœ
˜—J˜š¡
œŸœ
Ÿœ˜0šŸœ
Ÿœ
ŸœŸœ
˜Jš
œ#˜#—JšŸœ
˜—J˜š¡œŸœ
Ÿœ˜;Jš
œ ˜ Jš
œ˜Jš
œ˜š
Ÿ˜JšŸœŸœ
Ÿœ
˜ JšœŸœ)˜4šŸœŸœ
Ÿ˜šœŸœŸœ
Ÿ˜Jš
œ<˜<JšŸœŸœ
Ÿœ8˜SJšŸœŸœ
Ÿœ6˜PJšœŸœ
˜JšœŸœ
˜JšœŸœ
˜—Jš
œ˜—Jš
œ˜JšŸœŸœ
Ÿœ! ˜CJš
œ
˜
—JšŸœ
˜Jš
 3˜3šŸœŸœ
Ÿœ"ŸœŸœ
Ÿ˜@JšŸœ Ÿœ
Ÿœ
˜.—JšŸœ
˜J˜JšœŸœ0˜;JšŸœŸœ
Ÿœ
Ÿœ
˜Jšœ
Ÿœ˜"Jš
œ˜—J˜š¡œ˜"Jš
œL˜L—J˜š¡œ˜"Jš
œL˜L—J˜š¡œŸœ
ŸœŸœ˜=šŸœ
Ÿœ
ŸœŸœ
˜Jš
œ˜JšœŸœ
˜JšŸœŸœ
Ÿœ
˜%J˜Jš
œ2˜2šŸœŸœŸ˜1š
œ5˜5JšœŸœ)˜HJšœ%Ÿœ˜+Jš
œ˜—Jš
œ
˜
—JšŸœŸœ.˜M—JšŸœ
˜—J˜š¡œ˜#š
Ÿ˜JšœŸœ	˜Jšœ
Ÿœ&˜4JšŸœŸœ
Ÿœ
˜%Jš
œ˜—JšŸœ
˜—J˜š¡œ˜#JšœŸœ	˜ JšœŸœ
˜JšœŸœ
Ÿœ
Ÿœ˜(JšŸœŸœ
Ÿœ
Ÿœ
˜$Jš
œ8˜8šŸœŸ˜JšœŸœ œ
˜#JšœŸœ˜!JšœŸœ˜(JšœŸœ˜%JšŸœ˜—J˜šŸœŸœ
ŸœŸ˜J˜JšŸœ
˜—Jš
œ%˜%Jš
œ˜—J˜š¡œ˜!š
Ÿ˜JšœŸœ	˜JšœŸœ&˜9Jš
œ˜Jšœ
Ÿœ
˜Jš
œ'˜'šŸœŸ˜š
œ˜Jš
œ#˜#šŸœŸ˜JšœŸœŸœ˜2JšŸœ
ŸœŸœ˜<—Jš
œ˜——JšŸœ*˜1—JšŸœ
˜—J˜š¡œ˜ š
Ÿ˜JšœŸœ	˜Jš
œ˜Jšœ
Ÿœ
˜JšŸœ
Ÿœ
Ÿœ1Ÿœ˜PJ˜Jš
œ(˜(šŸœŸ˜š
œ˜Jš
œ˜šŸœŸ˜JšœŸœŸœ˜2JšŸœ
ŸœŸœ˜<—J˜——JšŸœ+˜2—JšŸœ
˜—J˜Jš
 H˜HJ˜š
¡œŸœŸœ
ŸœŸœ˜Dš
Ÿ˜Jš
œ˜JšœŸœ
˜J˜Jšœ,Ÿœ˜3šŸœŸœŸœ˜;Jšœ. ˜DJš
œ˜J˜
JšŸœ˜—Jš
œ˜šŸœŸœŸ˜)šœŸœ <˜OJš
œ%˜%Jšœ&  ˜FšŸœŸ˜š
œ˜Jš
œ%˜%JšœŸœ "˜4—Jš
œ˜—Jš
œ˜Jš
œ˜—Jš
œ
˜
—JšŸœ˜—JšŸœ
˜—J˜š
¡œŸœŸœ
ŸœŸœ
˜3Jšœ
Ÿœ-Ÿœ˜<š
Ÿ˜JšœŸœ
˜JšœŸœ˜JšœŸœ
˜Jš
œ
˜
šŸœ
Ÿœ
Ÿœ	˜šœŸœŸ˜šœŸœŸ˜Jš
œ)˜)š
œ˜Jšœ
ŸœŸœŸœ˜J—JšŸœ˜#—JšŸœ˜Jš
œ ˜ Jš
Ÿ˜—Jš
œ˜—J˜JšœŸœŸœ˜!JšŸœŸœ
Ÿœ
Ÿœ
˜!J˜Jš	œŸœŸœŸœŸœ˜LJšŸœŸœŸœ˜IJšœŸœ
˜JšŸœŸœ
Ÿœ
Ÿœ˜JšŸœ
˜—JšŸœ
˜—J˜š¡œŸœ
ŸœŸœ˜$šœŸœ
ŸœŸœ
˜JšœŸœ˜Jš
œ˜Jš
œ˜—Jš
œ˜—J˜š¡œŸœ Ÿœ˜;š
Ÿ˜šŸœŸ˜š
œ˜Jš
œD˜D—Jš
œ,˜,—JšŸœŸœ
˜—JšŸœ
˜J˜—Jš
 H˜HJš
 O˜OJ˜š¡œŸœ˜šŸœ
Ÿœ˜Jš	œŸœ
Ÿœ
ŸœŸœ
˜š
œ˜Jšœ>Ÿœ˜C—JšœŸœ
˜J˜š
ŸœŸœ
Ÿœ
Ÿœ ŸœŸœ
Ÿ˜EJšœŸœ˜JšœŸœ
˜JšœŸœ˜J˜JšœŸœŸœ˜,—š
 P˜PJš
œ;˜;—š
 $˜$JšŸœŸœ˜6J˜šŸœ
Ÿœ
ŸœŸœ˜>šŸœ˜JšœŸœ˜Jš
œ˜J˜———JšŸœ
˜—š
œ˜JšŸœŸœŸœ#˜N—JšŸœ
˜—J˜Jš
 H˜HJš
 ˜J˜š
Ÿ˜JšŸœ˜J˜JšœSŸœ˜[JšœaŸœ˜iJš
œA˜AJšœWŸœ˜^Jš
œ?˜?Jš
œA˜AJš
œA˜AJš
œC˜CJš
œC˜CJ˜Jš
œI˜IJ˜Jš
œF˜FJš
œ@˜@J˜Jš
œC˜CJš
œA˜AJš
œG˜G—JšŸœ
˜J˜Jš
 ˜Jš
 0˜0J˜Jš
œF˜FJš
œ3˜3˜J˜š
Ÿ˜JšœŸœ˜Jšœ-Ÿœ
Ÿœ˜HJš
œ.˜.š
Ÿ˜JšœŸœ
˜——JšŸœ
˜—J˜JšŸœ˜—…—ƒh®R