DIRECTORY
BasicTime USING [ GMT, Now, Period ],
Booting USING [ CheckpointProc, RollbackProc, RegisterProcs ],
Buttons USING [ButtonProc, Create, ReLabel, SetDisplayStyle ],
Commander USING [CommandProc, Handle, Register],
CommandTool USING [ArgN],
Containers USING [ ChildXBound, ChildYBound, Container, Create ],
FinchSmarts USING [
AnswerCall, ConvDesc, DisconnectCall, Feep, InitFinchSmarts, RegisterForReports, UninitFinchSmarts ],
FinchSynthesizer USING [ InitializeFinchSynthesizer, StopSpeech, TextToSpeech ],
FinchTool,
Icons USING [ IconFlavor, NewIconFromFile ],
IO,
Labels USING [Create],
MBQueue USING [ Create, CreateButton, CreateMenuEntry, Queue ],
Menus USING [AppendMenuEntry, CreateMenu, Menu, MenuProc ],
Nice USING [ View ],
Process USING [ Detach, Pause, MsecToTicks, SetTimeout],
Rope USING [ ActionType, Cat, Concat, Equal, Fetch, Find, Flatten, Length, Map, MakeRope, MaxLen, Replace, ROPE, Substr ],
Rules USING [ Create ],
Synthesizer USING [ SynthSpecBody, SynthSpec ],
Thrush USING [ ActionReport, ConversationID, NB, notReallyInConv, nullConvID, Reason, StateInConv ],
TiogaOps USING [ GetRope, GetSelection, Location, Ref, StepForward ],
TypeScript USING [ Create ], 
UserProfile USING [ Token ],
VFonts USING [ Font, defaultFont ],
ViewerClasses USING [ Viewer, ViewerClassRec, ViewerRec ],
ViewerEvents USING [ EventProc, RegisterEventProc ],
ViewerIO USING [ CreateViewerStreams ],
ViewerLocks USING [ CallUnderWriteLock ],
ViewerOps USING [AddProp, ComputeColumn, CreateViewer, DestroyViewer, FetchProp, PaintViewer, SetOpenHeight],
ViewerSpecs USING [ openTopY, openLeftWidth, openRightWidth ],
ViewerTools USING [GetSelectionContents, GetContents, MakeNewTextViewer, SetContents, SetSelection ],
VoiceUtils USING [ CurrentRName, Report, RegisterWhereToReport, WhereProc ]
;

FinchToolImpl: CEDAR MONITOR					       
IMPORTS BasicTime, Booting, Buttons, Commander, CommandTool, Containers, FinchSmarts, FinchSynthesizer, FinchTool, Icons, IO, Labels, MBQueue, Menus, Nice, Rope, Rules, Process, TiogaOps, TypeScript, UserProfile, VFonts, ViewerEvents, ViewerIO, ViewerLocks, ViewerOps, ViewerSpecs, ViewerTools, VoiceUtils
EXPORTS FinchTool = {
OPEN IO;

ConvDesc: TYPE = FinchSmarts.ConvDesc;
NB: TYPE = Thrush.NB;
Reason: TYPE = Thrush.Reason;
ROPE: TYPE = Rope.ROPE;
Viewer: TYPE = ViewerClasses.Viewer;

finchToolHandle: PUBLIC FinchTool.Handle;
cmdHandle: Commander.Handle_NIL;
serverInstance: Rope.ROPE  _ NIL;

printLabel: ARRAY Thrush.StateInConv OF Rope.ROPE_ALL["does not make sense"];
finchQueue: PUBLIC MBQueue.Queue _ MBQueue.Create[];
finchIcon: Icons.IconFlavor _ tool;
leftFinchIcon: Icons.IconFlavor _ tool;
rightFinchIcon: Icons.IconFlavor _ tool;
conversationIcon: Icons.IconFlavor _ tool;

labelledFinchIcon: Icons.IconFlavor _ tool;
labelledLeftFinchIcon: Icons.IconFlavor _ tool;
labelledRightFinchIcon: Icons.IconFlavor _ tool;
labelledConversationIcon: Icons.IconFlavor _ tool;

finchMenu: Menus.Menu;
finchConvMenu: Menus.Menu;

xFudge: INTEGER = 2;
entryHeight: INTEGER = 14;
defaultToolHeight: NAT _ ViewerSpecs.openTopY/5;

PhoneProc: Buttons.ButtonProc = { -- Place call to party identified by primary selection
calledPartyText: Rope.ROPE _ ViewerTools.GetSelectionContents[];
DoPhone[ViewerTools.GetSelectionContents[],
SELECT mouseButton FROM
red, yellow => FALSE, blue=> TRUE, ENDCASE=>ERROR];
};

CalledPartyProc: Buttons.ButtonProc = { -- Place call to Called Party field
calledPartyText: Rope.ROPE_ViewerTools.GetContents[finchToolHandle.calledPartyText];
SELECT mouseButton FROM
red => ViewerTools.SetSelection[finchToolHandle.calledPartyText, NIL];
yellow => DoPhone[calledPartyText, FALSE];
blue => DoPhone[calledPartyText, TRUE];
ENDCASE => ERROR;
};

CallingPartyProc: Buttons.ButtonProc = { -- Place call to Calling Party field
callingPartyText: Rope.ROPE_ViewerTools.GetContents[finchToolHandle.callingPartyText];
SELECT mouseButton FROM
red => ViewerTools.SetSelection[finchToolHandle.callingPartyText, NIL];
yellow => DoPhone[callingPartyText, FALSE];
blue => DoPhone[callingPartyText, TRUE];
ENDCASE => ERROR;
};

PhoneCmd: Commander.CommandProc = { -- Commander Phone command
ENABLE UNWIND => cmdHandle _ NIL;
calledPartyText: Rope.ROPE _ cmd.commandLine.Substr[start: 1, len: cmd.commandLine.Length[]-2];
cmdHandle _ cmd;
DoPhone[calledPartyText];
cmdHandle _ NIL;
};

PhoneHomeCmd: Commander.CommandProc = { -- Phone home (ET) command
cmd.commandLine _ " home\n";
[result, msg] _ PhoneCmd[cmd];
};

RedialCmd: Commander.CommandProc = { -- Redial command
IF ~CheckActive[finchToolHandle] THEN RETURN;
DoPhone[ViewerTools.GetContents[finchToolHandle.calledPartyText], FALSE];
};

DoPhone: PROC[calledPartyText: Rope.ROPE, wantResidence: BOOL_FALSE] = {
callee, newCalledPartyText: Rope.ROPE;
pauseNeededInMs: CARDINAL;
IF ~CheckActive[finchToolHandle] OR calledPartyText = NIL OR calledPartyText.Length[]=0
THEN RETURN;
[callee, newCalledPartyText, wantResidence] _ ParseCallee[calledPartyText, wantResidence];
Status["Placing call to ", newCalledPartyText];
IF newCalledPartyText#ViewerTools.GetContents[finchToolHandle.calledPartyText] THEN
ViewerTools.SetContents[finchToolHandle.calledPartyText, newCalledPartyText];
pauseNeededInMs _ HangItUp[FALSE, TRUE];
IF pauseNeededInMs#0 THEN Process.Pause[Process.MsecToTicks[pauseNeededInMs]];
-- Maybe a status check wait loop here ??
FinchTool.CallByDescription[description: callee, residence: wantResidence];
};

Answer: Menus.MenuProc = TRUSTED {
cDesc: ConvDesc = GetSelectedDesc[];
IF cDesc = NIL OR (SELECT cDesc.situation.self.state FROM
$notified, $ringing =>FALSE, ENDCASE=>TRUE) THEN {
Report[" No conversation to join"]; RETURN; };
FinchSmarts.AnswerCall[convID: cDesc.situation.self.convID];
};

ConversationMgmtProc: Buttons.ButtonProc = {
viewer: Viewer = NARROW[parent];
cDesc: ConvDesc = GetSelectedDesc[viewer];
IF ~CheckActive[finchToolHandle] OR cDesc=NIL THEN RETURN;
IF control THEN Hangup[parent: viewer.parent, mouseButton: mouseButton]
ELSE IF mouseButton#red THEN Answer[parent: viewer.parent, mouseButton: mouseButton];
};

Hangup: PUBLIC Menus.MenuProc = { []_HangItUp[TRUE]; };

HangUpCmd: Commander.CommandProc = {
IF ~CheckActive[finchToolHandle] THEN RETURN;
[] _ HangItUp[TRUE];
};

HangupQuietly: PUBLIC Menus.MenuProc = { []_HangItUp[FALSE]; };
HangItUp: PROC[complain: BOOL, moreToCome: BOOL_FALSE] RETURNS [pauseNeededInMs: CARDINAL_0] = TRUSTED {
cDesc: ConvDesc = GetSelectedDesc[];
state: Thrush.StateInConv _ IF cDesc=NIL THEN idle ELSE cDesc.situation.self.state;
isTrunk: BOOL_FALSE;
IF cDesc#NIL THEN FOR i: NAT IN [1..cDesc.numParties) DO
IF cDesc.partyInfo[i].type=$trunk THEN isTrunk_TRUE; ENDLOOP;
SELECT state FROM
idle => {
IF complain THEN Report[" No conversation to leave"]; RETURN };
reserved, parsing => IF moreToCome THEN RETURN;
ENDCASE;
IF isTrunk THEN pauseNeededInMs _ IF cDesc.situation.self.state=active THEN 2000 ELSE 500;
FinchSmarts.DisconnectCall[convID: cDesc.situation.self.convID];
};

ParseCallee: PROC[fullCallee: ROPE, wantResidence: BOOL] RETURNS [callee: ROPE, fCallee: ROPE, residence: BOOL] = {
endCallee: INT;
[callee, residence] _
CheckForMouseButtonSpec[fullCallee, "left ", wantResidence, wantResidence];
[callee, residence] _ CheckForMouseButtonSpec[callee, "middle ", residence, residence];
[callee, residence] _ CheckForMouseButtonSpec[callee, "right ", residence, TRUE];
IF callee.Equal["home", FALSE] THEN {
callee _ VoiceUtils.CurrentRName[];
residence _ TRUE;
};
IF (endCallee_callee.Find[" at home", 0, FALSE]) >= 0 THEN {
callee _ callee.Substr[len: endCallee];
residence _ TRUE;
};
fCallee _ callee;
IF wantResidence THEN fCallee _ fCallee.Concat[" at home"];
};

CheckForMouseButtonSpec: PROC[
fullCallee, pattern: ROPE, wantedRes: BOOL, ifMatch: BOOL]
RETURNS [fCallee: ROPE, wantResidence: BOOL] = {
pLen: INT _ pattern.Length[];
fCallee _ fullCallee;
wantResidence _ wantedRes;
IF fullCallee.Length[] >= pLen AND pattern.Equal[fullCallee.Substr[len: pLen]] THEN {
fCallee _ fullCallee.Substr[start: pLen];
wantResidence _ ifMatch;
};
};
GetSelectedDesc: PUBLIC PROC[chosenButton: Viewer_NIL] RETURNS [cDesc: ConvDesc_NIL] = {
viewer: Viewer = finchToolHandle.conversations;
selected: Viewer _ IF viewer=NIL THEN NIL
ELSE NARROW[ViewerOps.FetchProp[viewer, $selectedEntry]];
IF chosenButton#NIL AND selected#chosenButton THEN RETURN;
IF ~CheckActive[finchToolHandle] OR selected = NIL THEN RETURN;
cDesc _ NARROW[ViewerOps.FetchProp[selected, $convDesc]];
};
speakTextFeedbackLen: INT _ 40;
dectalkParaSep: Rope.ROPE _ " \033P;z.+\033\\";

SpeakSelectedProc: Buttons.ButtonProc = { 
queueIt: BOOL_TRUE;
IF ~CheckActive[finchToolHandle] THEN RETURN;
SELECT mouseButton FROM
red => NULL;
yellow =>  RETURN;
blue => queueIt _ FALSE;
ENDCASE => NULL;
SpeakTextNodesFromSelection[queueIt];
};

SpeakTextCmd: Commander.CommandProc = {
textToSpeak: Rope.ROPE _ cmd.commandLine.Substr[start: 1, len: cmd.commandLine.Length[]-2];
IF ~CheckActive[finchToolHandle] OR textToSpeak.Length[]=0 THEN RETURN;
[]_SpeakTextWithFeedback[TRUE, textToSpeak];
};

SpeakTextWithFeedback: PROC [
queueIt: BOOL, text: ROPE_NIL, convID: Thrush.ConversationID_Thrush.nullConvID]
RETURNS [newConvID: Thrush.ConversationID] ~ {
nb: NB;
Status[
IF ~queueIt THEN "Flushing text. " ELSE NIL,
"Speaking text: \"", 
text.Substr[len: speakTextFeedbackLen],
IF text.Length[] > speakTextFeedbackLen THEN "...\"" ELSE "\""
];
[nb, newConvID] _ FinchSynthesizer.TextToSpeech[convID: convID,
 synthSpec: NEW[Synthesizer.SynthSpecBody_[textToSpeak: text]], queueIt: queueIt];
IF nb#$success THEN newConvID _ Thrush.nullConvID;
};

SpeakTextNodesFromSelection:PROC[queueIt: BOOL, nodeEnd: Rope.ROPE_dectalkParaSep] ~ {
start, end: TiogaOps.Location;
[start: start, end: end] _ TiogaOps.GetSelection[];
FOR node: TiogaOps.Ref _ start.node, TiogaOps.StepForward[node] DO
convID: Thrush.ConversationID _ Thrush.nullConvID;
tiogaopstext: Rope.ROPE _ TiogaOps.GetRope[node];
tiogaopstext _ SELECT TRUE FROM
node = start.node => Rope.Substr[
base: tiogaopstext,
start: start.where,
len: IF node=end.node THEN end.where-start.where+1 ELSE Rope.MaxLen
],
node = end.node => Rope.Substr[base: tiogaopstext, len: end.where+1],
ENDCASE => tiogaopstext;
IF node#end.node THEN tiogaopstext _ Rope.Cat[tiogaopstext, nodeEnd];
convID _ SpeakTextWithFeedback[queueIt, tiogaopstext, convID];
queueIt _ TRUE;
IF node=end.node THEN EXIT;
ENDLOOP;
};


StopSpeechProc: Buttons.ButtonProc = { StopSpeaking[]; };
StopSpeakingCmd: Commander.CommandProc = { StopSpeaking[]; };
StopSpeaking: PROC = {
IF ~CheckActive[finchToolHandle] THEN RETURN;
[]_FinchSynthesizer.StopSpeech[];
};
FeepCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle _ NIL;
textToFeep: Rope.ROPE _ FeepValue[cmd.commandLine.Substr[start: 1, len: cmd.commandLine.Length[]-2]];
cmdHandle _ cmd;
IF CheckActive[finchToolHandle] THEN {
cDesc: ConvDesc = GetSelectedDesc[];
IF cDesc#NIL THEN FinchSmarts.Feep[cDesc.situation.self.convID, textToFeep]
ELSE Report["Sorry, was not able to `feep'."];
};
cmdHandle _ NIL;
};

FeepValue: PUBLIC PROC[text: ROPE] RETURNS [feepText: ROPE] = {
FeepFetch: PROC[data: REF, index: INT] RETURNS [c: CHAR] = {
c_NARROW[data, ROPE].Fetch[index];
c _ SELECT c FROM
IN ['A..'Z] => FeepMap[c+('a-'A)],
IN ['a..'z] => FeepMap[c],
ENDCASE => c;
};
IF text=NIL OR text.Length[]=0 THEN RETURN[text];
RETURN[Rope.Flatten[Rope.MakeRope[base: text, size: text.Length[], fetch: FeepFetch]]];
};

FeepMap: PACKED ARRAY CHAR['a..'z] OF CHAR = [
'2, '2, '2, '3, '3, '3, '4, '4, '4, '5, '5, '5, '6, '6, '6, '7, '7, '7, '7, '8, '8, '8, '9, '9, '9, '9 ];


StartFinch: PUBLIC PROC[] = TRUSTED {
handle: FinchTool.Handle _ finchToolHandle;
IF handle=NIL THEN {
MakeFinchTool[];
handle _ finchToolHandle;
IF handle=NIL THEN RETURN; -- complain?--
};
Report["Connecting . . ."];
FinchSmarts.RegisterForReports[ReportSystemState, ReportConversationState, ReportRequestState, FALSE]; -- Can go last.
FinchSmarts.InitFinchSmarts[serverInstance];
FinchSynthesizer.InitializeFinchSynthesizer[];
Report[IF handle.finchActive THEN "Finch is connected" ELSE "Could not connect",
" to telephone server"];
finchToolHandle.finchActiveAtCheckpoint _ FALSE;
};

FinchCmd: Commander.CommandProc = { 
serverInstance _ CommandTool.ArgN[cmd,1];
StartFinch[];
};

ReFinchOnRollback: Booting.RollbackProc = {
IF finchToolHandle=NIL OR ~finchToolHandle.finchActiveAtCheckpoint THEN RETURN;
finchToolHandle.finchActiveAtCheckpoint _ FALSE;
Try[StartFinch];
};

StopFinch: PUBLIC PROC[] = TRUSTED {
handle: FinchTool.Handle = finchToolHandle;
IF handle=NIL THEN RETURN;
Report["Disconnecting . . ."];
FinchSmarts.UninitFinchSmarts[];
Report[IF handle.finchActive THEN "Could not disconnect" ELSE "Finch is disconnected",
" from telephone server"];
};

ButtonStopFinch: Buttons.ButtonProc =  { StopFinch[]; };

UnfinchOnDestroy: ViewerEvents.EventProc = {
IF finchToolHandle=NIL THEN RETURN;
StopFinch[];
IF finchToolHandle.conversations#NIL THEN {
finchToolHandle.conversations.inhibitDestroy _ FALSE;
ViewerOps.DestroyViewer[finchToolHandle.conversations];
};
FinchTool.DestroyDirectories[];
IF finchToolHandle.tsIn#NIL THEN finchToolHandle.tsIn.Close[];
IF finchToolHandle.tsOut#NIL THEN finchToolHandle.tsOut.Close[];
finchToolHandle _ NIL;
};

UnFinchOnCheckpointOrBoot: Booting.CheckpointProc = {
IF finchToolHandle=NIL THEN RETURN;
finchToolHandle.finchActiveAtCheckpoint _
finchToolHandle.finchActiveAtCheckpoint OR finchToolHandle.finchActive;
IF finchToolHandle.finchActive THEN Try[StopFinch];
};

CheckActive: PUBLIC PROC[handle: FinchTool.Handle] RETURNS[active: BOOL_FALSE] = TRUSTED {
IF handle#NIL AND handle.finchActive THEN RETURN[TRUE];
StartFinch[];
RETURN[handle.finchActive];
};

UnfinchCmd: Commander.CommandProc = { StopFinch[]; };

ReportSystemState: PROC[on: BOOL] = {
IF finchToolHandle=NIL THEN RETURN;
finchToolHandle.finchActive _ on;
IF finchToolHandle.finchWasActive=finchToolHandle.finchActive THEN RETURN;
finchToolHandle.finchWasActive_finchToolHandle.finchActive;
ViewerOps.PaintViewer[finchToolHandle.outer, menu];
};

didOurBest: BOOL_FALSE;
maxTime: CARDINAL _ 2500;

Try: PROC[p: PROC] = TRUSTED {
didOurBest _ FALSE;
Process.Detach[FORK Try1[p]];
FOR i: NAT IN [0..100) DO
Process.Pause[Process.MsecToTicks[maxTime/100]];
IF didOurBest THEN EXIT;
ENDLOOP;
};

Try1: PROC[p: PROC] = {
p[];
didOurBest _ TRUE;
};

ReportConversationState: PROC[ nb: NB, cDesc: ConvDesc, remark: Rope.ROPE ] = {
s: IO.STREAM;
p: PROCESS;
difficulty: BOOL_FALSE;
button: Viewer;
state: Thrush.StateInConv;
SELECT nb FROM $success => NULL; ENDCASE => { Status[remark]; RETURN; };
IF cDesc = NIL THEN {Status["No State to report"]; RETURN;}; --Not much more can be done.
button _ NARROW[cDesc.clientData];
IF button = NIL THEN button _ AddConvDesc[finchToolHandle.conversations, cDesc];
s _ IO.ROS[];
state_cDesc.situation.self.state;
IF ~cDesc.originatorRecorded AND cDesc.numParties>1 THEN
SELECT cDesc.whoOriginated FROM
us => SetContents[finchToolHandle.calledPartyText, cDesc]; -- Set called-party field
them => SetContents[finchToolHandle.callingPartyText, cDesc]; --Set calling-party field
-- unknown => -- ENDCASE;
IF state=ringing THEN { -- start twiddling if haven't already
IF ~finchToolHandle.keepTwiddling THEN {
finchToolHandle.keepTwiddling _ TRUE;  
TRUSTED {Process.Detach[p _ FORK TwiddleFinchIcon[finchToolHandle]]}
};
}
ELSE -- stop twiddling if haven't already
IF finchToolHandle.keepTwiddling THEN
PaintFinchIcon[finchToolHandle, cDesc, state=idle];
IF (state#reserved AND state#parsing) THEN {
s.PutRope["Call "];
IF cDesc.numParties>1 THEN
s.PutF[" %s %s",
rope[SELECT cDesc.whoOriginated FROM
$us => "to", $them=>"from", ENDCASE=>"to/from"],
rope[RepairIntelnet[OtherParty[cDesc, TRUE]]]
];
s.PutF[" at %t", time[cDesc.startTime] ];
IF ~finchToolHandle.keepTwiddling THEN
PaintFinchIcon[finchToolHandle, cDesc, state=idle];
};
IF state <= Thrush.notReallyInConv THEN {
s.PutF["%s%s, duration = %r",
rope[IF state#$idle THEN " was not successful"
ELSE IF cDesc.ultimateState>ringing THEN printLabel[$idle] ELSE " was abandoned"],
rope[IF state#$failed THEN ""
ELSE SELECT cDesc.situation.reason FROM
$busy => " -- busy",
$notFound => " -- no valid party found",
$error => " -- connection failed",
$noCircuits => " -- no circuits",
ENDCASE => " for some reason"
],
int[BasicTime.Period[cDesc.startTime, BasicTime.Now[]]]
];
}
ELSE s.PutRope[printLabel[state]];
IF cDesc.situation.comment#NIL THEN s.PutF[" (%s)", rope[cDesc.situation.comment]];
IF remark#NIL THEN s.PutF[" [%s]", rope[remark]];
IF ~cDesc.reportComplete THEN Buttons.ReLabel[ button: button, paint: TRUE,
newName: s.RopeFromROS[] ];
IF state <= Thrush.notReallyInConv THEN cDesc.reportComplete_TRUE;
SelectEntryInConversations[button, state >= $failed AND state#$notified];
};

ReportRequestState: PROC[cDesc: ConvDesc, actionReport: Thrush.ActionReport, actionRequest: REF] RETURNS[betterActionRequest: REF] = {
betterActionRequest _ actionRequest;
SELECT actionReport.actionClass FROM
$recording =>
Status[SELECT actionReport.actionType FROM
$started => "Please begin Speaking",
$finished => "Thank you",
$flushed => "Voice transmission stopped",
ENDCASE => NIL
];
$playback =>
IF actionReport.actionType = $flushed THEN Status["Voice transmission stopped"];
$synthesizer =>
IF actionReport.actionType = $finished THEN {
spoken: Rope.ROPE =
Rope.Substr[base: NARROW[actionRequest, Synthesizer.SynthSpec].textToSpeak, len: speakTextFeedbackLen];
Status["Finished speaking \"", spoken, "...\""];
};
ENDCASE;
};
OtherParty: PROC[cDesc: ConvDesc, indicateUnauthenticated: BOOL_FALSE] RETURNS [otherParty: ROPE_NIL] = {
IF cDesc.numParties<2 THEN RETURN;
otherParty _ cDesc.partyInfo[1].name;
IF indicateUnauthenticated AND cDesc.partyInfo[1].type=$telephone THEN otherParty _ otherParty.Concat["?"];
};
SetContents: PROC[v: ViewerClasses.Viewer, cDesc: ConvDesc] = {
contents: ROPE _ RepairIntelnet[OtherParty[cDesc, FALSE]];
i: INT_contents.Find["(", 0, FALSE];
IF contents=NIL OR contents.Length[]=0 THEN RETURN;
IF i>0 THEN contents _ contents.Substr[len: i-1];
ViewerTools.SetContents[v, contents, TRUE];
cDesc.originatorRecorded _ TRUE;
};

RepairIntelnet: PROC[num: ROPE] RETURNS[number: ROPE] = {
i: INT_-1;
M: Rope.ActionType={i_i+1; RETURN[c<'\040]};
number _ num;
IF number.Map[0, number.Length[], M] THEN {
number _ Rope.Replace[number, i, 2, "*"]; -- replace first pause with "*"
i_-1;
IF number.Map[0, number.Length[], M] THEN
number _ Rope.Replace[number, i, 5, ""]; -- replace second pause and authentication with "*"
};
};

PaintFinchIcon: ENTRY PROC [handle: FinchTool.Handle, cDesc: ConvDesc, useFinchIcon: BOOL] = {
ENABLE UNWIND => NULL;
oldIcon: Icons.IconFlavor _ handle.outer.icon;
handle.keepTwiddling _ FALSE;
NOTIFY handle.twiddleWait;
IF useFinchIcon THEN {
handle.outer.icon _ finchIcon;
handle.outer.label _ NIL;
}
ELSE {
handle.outer.icon _ labelledConversationIcon;
handle.outer.label _ SELECT cDesc.whoOriginated FROM
$us => Rope.Concat["to ",   -- this doesn't work right for "listen to this!`' mode
ViewerTools.GetContents[handle.calledPartyText]
],
$them => Rope.Concat["from ", ViewerTools.GetContents[handle.callingPartyText]],
ENDCASE => Rope.Concat["to/from ", RepairIntelnet[OtherParty[cDesc, FALSE]]];
};
IF finchToolHandle.outer.iconic AND oldIcon#handle.outer.icon THEN
ViewerOps.PaintViewer[viewer: handle.outer, hint: all];
};

TwiddleFinchIcon: ENTRY PROC [handle: FinchTool.Handle] = {
ENABLE UNWIND => NULL;
MsPause: INTERNAL PROC [ms: INT] = TRUSTED { 
Process.SetTimeout[@handle.twiddleWait, Process.MsecToTicks[ms]];
WAIT handle.twiddleWait;
};
NewIcon: INTERNAL PROC [icon: Icons.IconFlavor, ms: INT] RETURNS [keepGoing: BOOL] = { 
IF ms # 0 THEN {
handle.outer.icon _ icon;
IF handle.outer.iconic THEN
ViewerOps.PaintViewer[viewer: handle.outer, hint: all];
MsPause[ms];
};
RETURN [handle.keepTwiddling];
};

pauseReps: INT _ handle.pauseTimeOn/
((handle.pauseTimeTilted + handle.pauseTimeMiddle+handle.pauseTimeDrawFactor)*2);
handle.outer.label _ ViewerTools.GetContents[handle.callingPartyText];
WHILE handle.keepTwiddling DO
IF ~handle.outer.iconic THEN 
MsPause[250]
ELSE {
FOR i: INT IN [0..pauseReps) DO
IF ~NewIcon[labelledRightFinchIcon, handle.pauseTimeTilted] THEN RETURN;
IF ~NewIcon[labelledFinchIcon, handle.pauseTimeMiddle] THEN RETURN;
IF ~NewIcon[labelledLeftFinchIcon, handle.pauseTimeTilted] THEN RETURN;
IF ~NewIcon[labelledFinchIcon, handle.pauseTimeMiddle] THEN RETURN;
ENDLOOP;
IF ~NewIcon[labelledFinchIcon, handle.pauseTimeOff] THEN RETURN;
};
ENDLOOP;
};


lineHeight: INT _ 12;
tsHeight: INT _ 3*lineHeight;
convHeight: INT _ 5*lineHeight;

MakeFinchTool: PROC = BEGIN
finchWidth: INTEGER;
dif, wH: INTEGER;
bt: Viewer;
h: FinchTool.Handle;
v: Viewer;
IF finchToolHandle#NIL THEN {
ViewerOps.PaintViewer[finchToolHandle.outer, all]; RETURN; };
finchToolHandle _ NEW[FinchTool.FinchToolRec];
h _ finchToolHandle;
h.finchToolHeight _ defaultToolHeight;
MakeMenus[];
finchToolHandle.outer _ Containers.Create[[-- outer container
name: "Finch",	-- name displayed in the caption
icon: finchIcon,
iconic: FALSE,			-- so tool will not be iconic (small) when first created
column: left,				-- initially in the left column
menu: finchMenu,-- displaying our menu command
openHeight: h.finchToolHeight,	-- See Walnut
scrollable: FALSE ]];		-- inhibit user from scrolling contents
v _ h.outer;
finchWidth _ IF v.column=right THEN ViewerSpecs.openRightWidth ELSE ViewerSpecs.openLeftWidth;
[]_ViewerEvents.RegisterEventProc[
proc: UnfinchOnDestroy, event: destroy, filter: v, before: TRUE];
bt _ FirstButton[q: finchQueue, name: "Called Party:", proc: CalledPartyProc, parent: v];
h.calledPartyText _ NextRightTextViewer[sib: bt, w: finchWidth/2-bt.ww];
bt _ AnotherButton[q: finchQueue, name: "Calling Party:", proc: CallingPartyProc, sib: h.calledPartyText, newLine: FALSE];
h.callingPartyText _ NextRightTextViewer[sib: bt, w: finchWidth];
Containers.ChildXBound[h.outer, h.callingPartyText];
bt _ MakeRuler[sib: bt, h: 2];
wH _ v.ch;
IF (dif _ (wH-bt.cy)) < tsHeight+convHeight THEN {
SetOpenHeight[v, wH + (tsHeight+convHeight-dif)];
IF ~v.iconic THEN ViewerOps.ComputeColumn[v.column];
};
h.typescript _ MakeTypescript[sib: bt];
[h.tsIn, h.tsOut] _ ViewerIO.CreateViewerStreams[NIL, h.typescript];
bt _ MakeRuler[sib: h.typescript, h: 2];
h.conversations _ ViewerOps.CreateViewer[
flavor: $Container, paint: TRUE,
info: [wy: bt.wy + 2, ww: v.ww,
wh: convHeight, parent: v, border: FALSE] ];
Containers.ChildXBound[h.outer, h.conversations];
Containers.ChildYBound[h.outer, h.conversations];
ViewerOps.PaintViewer[v, all];				-- reflect above change
IF Rope.Equal[s1: "TRUE", case: FALSE,
s2: UserProfile.Token[key: "Finch.InitialDirectoriesLeft", default: "FALSE"]]
  OR Rope.Equal[s1: "TRUE", case: FALSE,
s2: UserProfile.Token[key: "Finch.InitialDirectoriesRight", default: "FALSE"]] THEN
FinchTool.BuildDirectories[];
END;

MakeMenus: PROC = {
MakeOneMenu: PROC[menu: Menus.Menu, name: ROPE, proc: Menus.MenuProc] = {
Menus.AppendMenuEntry[	
menu: menu,
entry: MBQueue.CreateMenuEntry[finchQueue, name, proc, finchToolHandle]
];
};
finchMenu _ Menus.CreateMenu[];
MakeOneMenu[finchMenu, "Phone", PhoneProc];
MakeOneMenu[finchMenu, "Answer", Answer];
MakeOneMenu[finchMenu, "Disconnect", Hangup];
MakeOneMenu[finchMenu, "SpeakText", SpeakSelectedProc];
MakeOneMenu[finchMenu, "StopSpeech", StopSpeechProc];
MakeOneMenu[finchMenu, "Directory", MakeDirectory];
MakeOneMenu[finchMenu, "Drop Out", ButtonStopFinch];

finchConvMenu _ Menus.CreateMenu[];
MakeOneMenu[finchConvMenu, "Answer", Answer];
MakeOneMenu[finchConvMenu, "Disconnect", Hangup];
};

MakeFinchToolCmd: Commander.CommandProc = { MakeFinchTool[]; };

AddConvDesc: PROC[cViewer: Viewer, cDesc: ConvDesc] RETURNS [newV: Viewer_NIL] = {
lastButton: Viewer =
NARROW[ViewerOps.FetchProp[finchToolHandle.conversations, $lastButton]];
BuildLine: PROC = {
IF lastButton = NIL THEN
newV _ FirstButton[
q: finchQueue, name: NIL, proc: ConversationMgmtProc, width: 1024, parent: cViewer]
ELSE newV _ AnotherButton[
q: finchQueue, name: NIL, proc: ConversationMgmtProc, width: 1024, sib: lastButton, newLine: TRUE];
};
IF lastButton#NIL THEN {
lastDesc: ConvDesc = NARROW[ViewerOps.FetchProp[lastButton, $convDesc]];
IF lastDesc#NIL AND lastDesc.reportComplete AND
(lastDesc.ultimateState=$reserved OR lastDesc.ultimateState=$parsing OR
  (lastDesc.ultimateState=$notified AND cDesc.situation.self.state=$notified AND
cDesc.partyInfo[1].type=$trunk AND lastDesc.partyInfo[1].type=$trunk AND
BasicTime.Period[from: lastDesc.startTime, to: cDesc.startTime] <= 10)  )
THEN newV _ lastButton;

};
IF newV=NIL THEN
IF cViewer.parent.iconic THEN BuildLine[] 
ELSE ViewerLocks.CallUnderWriteLock[BuildLine, cViewer];
cDesc.clientData _ newV;
ViewerOps.AddProp[newV, $convDesc, cDesc];
ViewerOps.AddProp[cViewer, $lastButton, newV];
};

SelectEntryInConversations: PROC[entryButton: Viewer, doSelect: BOOL_TRUE] = {
prevSelected: Viewer =
NARROW[ViewerOps.FetchProp[entryButton.parent, $selectedEntry]];
IF prevSelected # NIL AND ~prevSelected.destroyed AND
((prevSelected=entryButton) # doSelect) THEN {
Buttons.SetDisplayStyle[prevSelected, $BlackOnWhite];
ViewerOps.PaintViewer[prevSelected, all];
ViewerOps.AddProp[entryButton.parent, $selectedEntry, NIL];
};
IF entryButton.destroyed THEN { Report["Conversation is no longer available."];RETURN; }
ELSE IF ~doSelect OR prevSelected = entryButton THEN RETURN;
Buttons.SetDisplayStyle[entryButton, $BlackOnGrey];	-- show it is selected
ViewerOps.PaintViewer[entryButton, all];
ViewerOps.AddProp[entryButton.parent, $selectedEntry, entryButton];
}; 

MakeDirectory: Menus.MenuProc = {
FinchTool.BuildDirectories[];
}; 

SetOpenHeight: PROC[viewer: ViewerClasses.Viewer, clientHeight: INTEGER] = {
LockedSetHeight: PROC = {ViewerOps.SetOpenHeight[viewer, clientHeight]};
ViewerLocks.CallUnderWriteLock[LockedSetHeight, viewer];
};

FirstLabel: PROC[name: ROPE, parent: Viewer] RETURNS [nV: Viewer] = {
IF ~FinchTool.CheckAborted[parent] THEN RETURN;
nV_ Labels.Create[
info: [name: name, parent: parent, wh: entryHeight, wy: 1,
wx: IF parent.scrollable THEN 0 ELSE xFudge, border: FALSE]];
};

ImmediateButton: PUBLIC PROC[name: ROPE, proc: Buttons.ButtonProc, border: BOOL,
sib: Viewer_NIL, parent: Viewer_NIL, fork: BOOL_ TRUE, guarded: BOOL_ FALSE, newLine: BOOL_ FALSE]
RETURNS[Viewer] = {
info: ViewerClasses.ViewerRec;
wy: INTEGER _ 1;
sibWh: INTEGER _ 0;
IF parent=NIL THEN IF sib#NIL THEN parent _ sib.parent ELSE ERROR;
IF sib#NIL THEN { wy _ sib.wy; sibWh _ sib.wh; };
info _ [name: name, wy: wy, wh: entryHeight, parent: parent, border: border];
IF (~newLine) AND sib=NIL THEN ERROR;
IF newLine THEN { -- first button on new line
info.wy_ info.wy + sibWh + (IF border THEN 1 ELSE 0);	-- extra bit
info.wx_ IF parent.scrollable THEN 0 ELSE xFudge;
}
ELSE -- next button right on same line as previous 
info.wx_ sib.wx+sib.ww+xFudge;
RETURN[Buttons.Create[info: info, proc: proc, fork: fork, guarded: guarded]];
};

QueuedButton: PUBLIC PROC[name: ROPE, proc: Buttons.ButtonProc, border: BOOL,
sib: Viewer, guarded: BOOL_ FALSE, newLine: BOOL_ FALSE]
RETURNS[Viewer] = {
info: ViewerClasses.ViewerRec_ [name: name, wy: sib.wy, wh: entryHeight,
parent: sib.parent, border: border];
IF newLine THEN   -- first button on new line
{ info.wy_ sib.wy + sib.wh + (IF border THEN 1 ELSE 0);	-- extra bit
info.wx_ IF sib.parent.scrollable THEN 0 ELSE xFudge;
}
ELSE -- next button right on same line as previous 
info.wx_ sib.wx+sib.ww+xFudge;
RETURN[MBQueue.CreateButton[q: finchQueue, info: info, proc: proc, guarded: guarded]];
};

--  sib is a viewer to the left or above the button to be made
AnotherButton: PUBLIC PROC[
q: MBQueue.Queue, name: ROPE, proc: Buttons.ButtonProc, sib: Viewer,
data: REF ANY_ NIL, border: BOOL_ FALSE, width: INTEGER_ 0,
guarded: BOOL_ FALSE, font: VFonts.Font _ VFonts.defaultFont, newLine: BOOL_ FALSE]
RETURNS [nV: Viewer] = {
  info: ViewerClasses.ViewerRec_ [name: name, wy: sib.wy, ww: width, wh: entryHeight,
  parent: sib.parent, border: border];
IF ~CheckAborted[sib] THEN RETURN;
IF newLine THEN { -- first button on new line
info.wy_ sib.wy + sib.wh + (IF border THEN 1 ELSE 0);	-- extra bit
info.wx_ IF sib.parent.scrollable THEN 0 ELSE xFudge;
}
ELSE -- next button right on same line as previous
info.wx_ sib.wx+sib.ww+xFudge;
RETURN[MBQueue.CreateButton[
q: q, info: info, proc: proc, clientData: data, font: font, guarded: guarded]]
};

FirstButton: PUBLIC PROC[
q: MBQueue.Queue, name: ROPE, proc: Buttons.ButtonProc,
parent: Viewer, data: REF ANY_ NIL, border: BOOL_ FALSE, width: INTEGER_ 0,
guarded: BOOL_ FALSE, font: VFonts.Font _ VFonts.defaultFont]
RETURNS [nV: Viewer] = {
info: ViewerClasses.ViewerRec_
[name: name, parent: parent, wh: entryHeight, wy: 1, ww: width,
wx:  IF parent.scrollable THEN 0 ELSE xFudge, border: border];
IF ~CheckAborted[parent] THEN RETURN;
nV_ MBQueue.CreateButton[
q: q, info: info, proc: proc, clientData: data, font: font, guarded: guarded];
};

CheckAborted: PUBLIC PROC[sib: Viewer] RETURNS[ok: BOOL] = {
IF sib = NIL THEN RETURN[TRUE];
IF sib.destroyed THEN RETURN[FALSE];
RETURN[TRUE];
};

NextRightTextViewer: PUBLIC PROC[sib: Viewer, w: INTEGER] RETURNS [nV: Viewer] = {
IF ~FinchTool.CheckAborted[sib] THEN RETURN;
nV_ ViewerTools.MakeNewTextViewer[
info: [parent: sib.parent, wx: sib.wx+sib.ww+xFudge, wy: sib.wy,
ww: w, wh: entryHeight, border: FALSE]];
};

MakeRuler: PROC[sib: Viewer, h: INTEGER_ 1] RETURNS [r: Viewer] = {
  IF ~FinchTool.CheckAborted[sib] THEN RETURN;
  r_ Rules.Create[
     info: [parent: sib.parent, wy: sib.wy+sib.wh+1, ww: sib.parent.ww, wh: h]];
  Containers.ChildXBound[sib.parent, r];
  };

MakeTypescript: PROC[sib: Viewer] RETURNS [ts: Viewer] = {
y: INTEGER_ sib.wy+sib.wh+xFudge;
IF ~CheckAborted[sib] THEN RETURN;
ts_ TypeScript.Create[
info: [parent: sib.parent, ww: sib.cw, wy: y, wh: tsHeight, border: FALSE] ];
Containers.ChildXBound[sib.parent, ts];
};

Report: PUBLIC PROC[msg1, msg2, msg3, msg4: ROPE_NIL] = {
VoiceUtils.Report[where: $Finch, remark: 
IO.PutFR["%s%s%s%s",
rope[msg1], rope[msg2], rope[msg3], rope[msg4]]];
};

ReportRope: PUBLIC PROC[msg1: ROPE] = {
IF msg1#NIL THEN VoiceUtils.Report[where: $Finch, remark: msg1];
};

Status: PUBLIC PROC[msg1, msg2, msg3, msg4: ROPE_NIL] = {
what: ROPE = Rope.Cat[msg1, msg2, msg3, msg4];
ReportRope[what];
};

FinchWhereProc: VoiceUtils.WhereProc = {
RETURN[IF cmdHandle#NIL THEN cmdHandle.out ELSE IF finchToolHandle=NIL THEN NIL
ELSE finchToolHandle.tsOut];
};
FinchWhereCmdProc: VoiceUtils.WhereProc = {
RETURN[NIL];
};

ViewCmd: Commander.CommandProc = TRUSTED {
Nice.View[finchToolHandle, "FinchTool PD"];
};


finchIcon _ Icons.NewIconFromFile["Finch.Icons", 0!ANY=>CONTINUE];
leftFinchIcon _ Icons.NewIconFromFile["Finch.Icons", 4!ANY=>CONTINUE];
rightFinchIcon _ Icons.NewIconFromFile["Finch.Icons", 3!ANY=>CONTINUE];
labelledFinchIcon _ Icons.NewIconFromFile["Finch.Icons", 11!ANY=>CONTINUE];
labelledLeftFinchIcon _ Icons.NewIconFromFile["Finch.Icons", 12!ANY=>CONTINUE];
labelledRightFinchIcon _ Icons.NewIconFromFile["Finch.Icons", 10!ANY=>CONTINUE];
conversationIcon _ Icons.NewIconFromFile["Finch.Icons", 5!ANY=>CONTINUE];
labelledConversationIcon _ Icons.NewIconFromFile["Finch.Icons", 14!ANY=>CONTINUE];

Commander.Register[key: "FinchTool", proc: MakeFinchToolCmd,
doc: "Create a Finch viewers tool" ];
Commander.Register["Finch", FinchCmd, "Start Finch (connect to server)"];
Commander.Register["Unfinch", UnfinchCmd, "Stop Finch (disconnect server)"];
-- initialize text for print form of connect state
Commander.Register["Phone", PhoneCmd, "Place telephone call to specified party"];
Commander.Register["ET", PhoneHomeCmd, "Phonnne hommmmmmme"];
Commander.Register["Redial", RedialCmd, "Hang up and try current call again"];
Commander.Register["HangUp", HangUpCmd, "Hang up current conversation"];
Commander.Register["SpeakText", SpeakTextCmd, "Utter the remainder of the command"];
Commander.Register["STOP!", StopSpeakingCmd, "Stop speaking"];
Commander.Register["Feep", FeepCmd, "Issue touch-tones"];
VoiceUtils.RegisterWhereToReport[proc: FinchWhereProc, where: $Finch];
VoiceUtils.RegisterWhereToReport[proc: FinchWhereCmdProc, where: $FinchCmd];
printLabel[$active] _ " is in progress";
printLabel[$idle] _ " is completed";
printLabel[$ringing] _ " is ringing";
printLabel[$notified] _ NIL;
printLabel[$initiating] _ NIL;
printLabel[$ringback] _ " is ringing";
printLabel[$reserved] _ " Telephone set is off hook";
printLabel[$parsing] _ " Call is being dialed";
TRUSTED { Booting.RegisterProcs[c: UnFinchOnCheckpointOrBoot, r: ReFinchOnRollback, b: UnFinchOnCheckpointOrBoot]; };
Commander.Register["VuFinchTool", ViewCmd,
"Program Management variables for FinchTool"];
}.
!RFinchToolImpl.mesa 
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last Edited by: Swinehart, November 3, 1986 7:44:21 am PST
Last Edited by: Pier, April 17, 1984 3:51:54 pm PST
Polle Zellweger (PTZ) October 27, 1985 10:10:45 pm PST
List USING [Reverse],
Current assumption, subject to change as we develop the notion of multiple calls: Only one call is allowed, by Lark, to reach interesting states (>=failed, +notified).  We can select any call that does go beyond an interesting state, to indicate the "current" call; all actions that deal with ongoing call will refer to that one.  We will not, for the moment, allow any manual selection of conversation-log entries.  When there isn't an entry, it's OK to place calls without hanging up first.  So Lark and FinchTool/Directory know about the one-call philosophy; FinchSmarts does not, at present.

Current assumption:  all descriptions, including called/calling party fields and conversation logs, describe only the first other party; in a conference, they'll ignore late arrivals.

Types and Typeoids

Placing and Controlling Calls

[parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]
[parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]
[parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]
No Conversation ID needed here because assumed not active in any now.
Called whenever the user clicks the answer button
Refers to entries in the viewer finchToolHandle.conversations, not necessarily current one.
Button-invoked operations when applied directly to conversation-viewer log entries.
SelectEntryInConversations[viewer]; -- no manual control over selection!
Called whenever the user clicks the hangup button
Refers to entries in the viewer finchToolHandle.conversations, not necessarily current one.
Called to disconnect a call in progress without logging a message.

Parses single party-specification: phone number (leading character is not a letter), or named recipient.  Names can be RNames or other text sequences that can be looked up in one's private (TDir-style) telephone directory.  "XXX at home" is a request to call a residence rather than office number.  "home" is equivalent to "<logged-in user> at home".  "left XXX" and "middle XXX" are equivalent to "XXX".  "right XXX" is the same as "XXX at home".  This is to accommodate the strange Command Tool. "XXX at <number>" says you want to call the specified number, and the recipient is XXX (not implemented yet.)


Speaking Text

We let FinchSynthesizer invent the actionID's, we don't track reports, but we do return the conversationID, so that subsequent adjacent requests can be reliably queued under the same conversation.

Other User Commands

Convert an arbitrary rope into characters found on a DTMF touchpad.  '*, '#, and digits and all punctuation (often used to format phone numbers) map to themselves. Letters (either case) map to their standard telephone-dial locations.  Also, 'Q->'7 and 'Z->'9.  One can put a leading '. or something in front of an address to force higher levels to interpret it as a "number" instead of a name.
Now people can dial .FAX or .HELP or 9(800)TheCard, or 9Fastell.
Starting and Stopping
If not active, try to make it active.
Conversation Management

Don't use conversation buttons for failure reports
If we originated, called-party is already set better than we can get this way (home or office, nicknames, and so on.)  Else pick up calling party (incoming), or called-party (outgoing).  originatorRecorded is set TRUE whenever one of these fields is set.
Don't want to step on twiddling if state=ringing.  This call covers hanging up from non-ringing state or placing outgoing call.
If idle, elaborate.
We might receive reports about IntervalSpec requests or voice synthesizer requests.  The actionRequest will be REF that we supplied in the original request 
subject to change.  We may also have to add parameters (first, last) to this report. .

Describe the other party.

Other party descriptions can be of the form "xxx.pa (nnnn)", which confuses Phone commands.  Number in parens and lack-of-authentication question mark should be eliminated from number field being set here.
Other party description can contain Intelnet pause characters and authentication code.
Intelnet pause characters are all characters < '\040, followed by "P".  For the present, we assume that there's a P following the pause in one of these; other values are possible, but we don't expect them in phone numbers.
Should be repaired (pause => "*" and auth-code removed) wherever the user sees it.
IF cDesc.bluejayConnection THEN "Recording service"
ELSE IF cDesc.proseConnection THEN "Text-to-Speech service"
ELSE
Assumes that the ordinary Finch icon is unlabelled.
Viewer Construction and Management

Finch Viewer
Check how much space is left (if any) in the control window for a typescript.
Finch Tool Viewer
Conversation Viewer
Conversations Viewer

ViewersOps.AddProp[newV, $convDesc, NIL];

Above could be used to forget about any conversation but the latest one.  Once we're dealing with multiple converations, that won't be good enough.  Perhaps a better place to do that is where we detect them going idle.
At present, this occurs only when one had dial-tone or was dialing and hung up.  Otherwise, busy calls would be lost and we some day hope to be able to use the information about busy calls in redialing. STCWN (Subject to change without notice.)
Incoming back door calls are retried once per ring if rejected because the called telephone is busy.  Combine them in the log.  
This is a hack.

Directory
Viewer and Button Utilities

Creates a text viewer, next right on the same line as sib
 sib must be a Viewer, not NIL
 Make an h-bit wide line after sib
Sib is sibling to create TS after
Containers.ChildYBound[sib.parent, ts];
Reporting and Logging

Registration, Initialization
Register a command with the UserExec that will create an instance of this tool
Debugging nonsense
Swinehart, August 7, 1985 8:56:34 am PDT
Merge PTZ TextSpeech stuff
changes to: DIRECTORY, MakeMenus, SpeakSelectedProc
Polle Zellweger (PTZ) August 19, 1985 5:00:46 pm PDT
Handle Prose flushing.
changes to: MakeMenus, ReportConversationState, StopSpeechProc
Polle Zellweger (PTZ) August 19, 1985 5:54:32 pm PDT
changes to: DIRECTORY, FinchToolImpl, ReportConversationState, StopSpeechProc
Polle Zellweger (PTZ) September 3, 1985 5:57:21 pm PDT
Curtail intermediate Prose reports if ~finchToolHandle.debug; allow user to specify SpeakText queueIt via red|blue button; some cosmetic feedback changes.
changes to: ReportConversationState, SpeakSelectedProc, speakTextFeedbackLen, SpeakTextWithFeedback, StopSpeechProc
Swinehart, September 6, 1985 10:03:45 am PDT
Don't OPEN FinchTool.bcd, eliminate (status line, extra Phone button).
Eliminate dual-menu, demote Drop-Out.  Merge Phone, Redial.
PhoneSelection becomes CommandTool feature, with user profile help.
Add names->feepNum features (can dial 9(800)TheCard)
Add feep command (for talking to your bank or whatever).
Add HangUp, SpeakText, StopSpeaking commands.
Pick up incoming call idents, outgoing calls originated at telset, in called-party fields.
Automatically connect to Server when command is issued; don't delete conversation viewer when disconnecting any more. Reorganize order of procedures.
Polle Zellweger (PTZ) October 4, 1985 6:58:47 pm PDT
Add labelled icons, used to display caller when Finch tool etc is closed.
changes to: labelledFinchIcon, labelledLeftFinchIcon, labelledRightFinchIcon, labelledConversationIcon, TwiddleFinchIcon, (module initialization)
Polle Zellweger (PTZ) October 16, 1985 4:38:58 pm PDT
Change Finch telephone icon to labelled conversation icon while conversation in progress.  Added monitor to protect icon twiddling and restoring.
changes to: FinchToolImpl, ConversationHandle, ReportConversationState, PaintFinchIcon, TwiddleFinchIcon, NewIcon, MsPause
Polle Zellweger (PTZ) October 18, 1985 4:08:31 pm PDT
Add ability to recognize node boundaries in selection for text-to-speech.
changes to: SpeakTextWithFeedback, RopeWithNodesFromSelection (new)
Swinehart, October 27, 1986 5:12:27 pm PST
Synthesis had been removed from development versions of Finch.  Put it back in, now using the service facilities provided by the FinchSynthesizer interface.

Κ&T˜–

"Cedar" styleš
œ™Icode–

"Cedar" stylešœ
Οm
œ1™<Jš
œ:™:J™3Kš
œ6™6—J˜š
Οk	˜	J˜%J˜>Jšœžœ1˜>Jšœ
žœ!˜0Jšœžœ˜Jšœžœ1˜Ašœžœ˜Jš
œe˜e—Jšœžœ:˜PJš
œ
˜
Jšœžœ!˜,J˜Jšœžœ
˜Jšœžœ™Jšœžœ2˜?Jšœžœ0˜;Jšœžœ
˜Jšœžœ+˜8Jšœžœažœ˜zJšœžœ˜Jšœžœ˜/Jšœžœ!žœ5˜dJšœ	žœ7˜EJšœžœ
˜Jšœžœ˜J˜#Jšœžœ'˜:Jšœ
žœ"˜4Jšœ	žœ˜'Jšœžœ˜)Jšœ
žœ^˜mJ˜>JšœžœT˜eJš
œK˜KJš
œ
˜
J˜—šœž˜(Jšžœsžœ΅
˜±Jšžœ˜Jšžœ˜J˜—Idefault™ΣL™L™·
L™™J™Jšœ
žœ˜&Jšžœžœ
žœ
˜Jšœžœ˜Jšžœžœžœ
˜J˜$J˜Jšœžœ˜)Jšœžœ
˜ Jšœžœžœ
˜!J˜Jš	œžœžœžœ
žœ˜MJšœžœ"˜4J˜#J˜'J˜(J˜*J˜Jš
œ+˜+Jš
œ/˜/Jš
œ0˜0Jš
œ2˜2J˜J˜J˜J˜Jšœžœ˜Jšœ
žœ˜Jšœžœ˜0J˜—™J™•StartOfExpansion‚
 -- [parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]šΟn	œΟc6˜XJš
Πck~™~Jšœžœ&˜@š
œ+˜+šžœ
ž˜Jš	œžœ	žœžœžœ˜3——J˜J˜—–‚
 -- [parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]šŸœ #˜KJš
‘~™~Jšœžœ:˜Tšžœ
ž˜JšœAžœ˜FJšœ#žœ˜*Jšœ!žœ˜'Jšžœžœ
˜—Jš
œ˜J˜—–‚
 -- [parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]šŸœ $˜MJš
‘~™~Jšœžœ;˜Všžœ
ž˜JšœBžœ˜GJšœ$žœ˜+Jšœ"žœ˜(Jšžœžœ
˜—Jš
œ˜J˜—šŸœ ˜>Jšžœ
žœžœ
˜!JšœžœE˜_J˜J˜Jšœžœ
˜J˜J˜—šŸœ ˜BJš
œ˜Jš
œ˜J˜J˜—šŸ	œ ˜6Jšžœžœ
žœ
˜-JšœBžœ˜IJ˜J˜—š
Ÿœžœžœžœ
žœ˜HJšœ!žœ
˜&Jšœžœ
˜šžœžœžœ
žœ˜WJšžœ
žœ
˜—Jš
œZ˜ZJš
œ/˜/šžœMž˜SJš
œM˜M—Jšœžœ˜(šžœžœ5˜NJš
 )˜)—š
œK˜KJ™E—J˜J˜—šŸœžœ˜"Jš
œ1™1Jš
œ[™[Jš
œ$˜$š	žœ	žœ
žœžœž˜9š	œžœžœžœžœ˜2Jšœ$žœ˜.——Jš
œ<˜<Jš
œ˜J˜—šŸœ˜,J™SJšœžœ	˜ Jš
œ*˜*J™HJš
žœžœžœ
žœ
žœ
˜:Jšžœ	žœ8˜GJšžœ
žœžœ9˜UJš
œ˜J˜—šŸœžœ žœ˜7Jš
œ1™1Jš
œ[™[—J˜šŸ	œ˜$Jšžœžœ
žœ
˜-Jšœžœ˜J˜J˜—šŸ
œžœ žœ˜?Jš
œB™BJ™—šŸœžœžœžœ
žœžœžœžœ˜hJ˜$Jš	œžœžœ
žœžœ˜SJšœ	žœ
žœ
˜š
žœžœ
žœ
žœžœ
žœž˜8Jšžœ žœ	žœžœ
˜=—šžœž˜š
œ	˜	Jšžœ
žœ&žœ˜?—Jšœžœžœ
žœ
˜/Jšžœ
˜—Jš
žœ	žœžœ#žœžœ˜ZJš
œ@˜@Jš
œ˜J˜—šŸœžœ
žœžœžœ
žœžœ
žœ˜sJ™ίJšœžœ
˜š
œ˜Jš
œK˜K—Jš
œW˜WJšœKžœ˜Qšžœžœž˜%Jš
œ#˜#Jšœžœ
˜J˜—šžœ'žœžœ˜<Jš
œ'˜'Jšœžœ
˜J˜—J˜Jšžœžœ&˜;J˜J˜—šŸœžœ
˜Jšœžœ
žœžœ
˜:Jšžœžœžœ˜0Jšœžœ˜J˜Jš
œ˜šžœžœ-žœ˜UJ˜)J˜J˜—J˜—J™šŸœžœ
žœžœžœžœ˜XJš
œ/˜/šœžœžœ
žœ
ž˜)Jšžœ
žœ.˜9—Jš
žœžœ
žœžœ
žœ
˜:Jš
žœžœžœ
žœ
žœ
˜?Jšœžœ+˜9Jš
œ˜—J™—™
J™Jšœžœ˜Jšœžœ˜/J˜šŸœ˜*Jšœ	žœ
žœ
˜Jšžœžœ
žœ
˜-šžœ
ž˜Kšœžœ
˜Jšœžœ
˜Jšœžœ
˜Kšžœžœ
˜—K˜%Jš
œ˜J˜—šŸœ˜'JšœžœE˜[Jšžœžœžœ
žœ
˜GJšœžœ˜,J˜J˜—šŸœžœ˜Kšœ	žœžœ
žœ2˜OKšžœ'˜.K™Δ
Kšœžœ
˜š
œ˜Kšžœ
žœžœ
žœ
˜,Kš
œ˜Kš
œ'˜'Kšžœ&žœ	žœ˜>Kš
œ˜—š
œ?˜?JšœžœC˜R—Jšžœ
žœ˜2Kš
œ˜K˜—šŸœ
žœ	žœžœ˜VJš
œ˜Kš
œ3˜3šžœ=ž˜BK˜2Kšœžœ˜1šœžœ
žœ
ž˜š
œ!˜!Kš
œ˜Kš
œ˜Kšœžœžœžœ˜CKš
œ˜—Kšœžœ3˜E—Kšžœ˜Kšžœžœ0˜EK˜>Kšœ
žœ
˜Kšžœžœ
žœ
˜Kšžœ
˜—K˜K˜—J˜JšŸœ+˜9JšŸœ.˜=šŸœžœ˜Jšžœžœ
žœ
˜-Jš
œ!˜!J˜J™——™J™šŸœ˜"Jšžœ
žœžœ
˜!JšœžœP˜eJ˜šžœžœ˜&J˜$Jšžœžœ
žœ:˜KJšžœ*˜.J˜—Jšœžœ
˜J˜J˜—š
Ÿ	œžœžœžœžœ˜?J™‰J™@šŸ	œžœžœ	žœžœžœ˜<Jšœžœžœ˜"šœžœž˜Jšžœ ˜"Jšžœ˜Jšžœ˜
—Jš
œ˜—J–. -- [data: REF ANY, index: INT] RETURNS [CHAR]š
žœžœ
žœžœ
žœ˜1JšžœQ˜WJ˜J˜—šœ	žœ
žœ
žœ	žœ
žœ˜.J˜iJ˜——™J˜šŸ
œžœžœ˜%Jš
œ+˜+šžœžœ
žœ˜J˜J˜Jš	žœžœ
žœ
žœ ˜)Jš
œ˜—Jš
œ˜Jšœ_žœ ˜vJš
œ,˜,J˜.šœžœžœžœ˜PJš
œ˜—Jšœ*žœ
˜0Jš
œ˜—J˜šŸœ˜$J˜)Jš
œ
˜
Jš
œ˜J˜—šŸœ˜+Jš
žœžœ
žœ*žœ
žœ
˜OJšœ*žœ
˜0Jš
œ˜J˜J˜—šŸ	œžœžœ˜$Jš
œ+˜+Jšžœžœ
žœ
žœ
˜Jš
œ˜Jš
œ ˜ šœžœžœžœ˜VJš
œ˜—J˜—J˜JšŸœ)˜8J˜šŸœ˜,Jšžœžœ
žœ
žœ
˜#Jš
œ˜šžœžœ
žœ˜+Jšœ/žœ
˜5Jš
œ7˜7J˜—J˜Jšžœžœ
žœ˜>Jšžœžœ
žœ˜@Jšœžœ
˜Jš
œ˜J˜—šŸœ˜5Jšžœžœ
žœ
ž˜#š
œ)˜)Jšœ(žœ˜G—Jšžœžœ˜3J˜J˜—šŸœžœ
žœžœ	žœ
žœžœ˜ZJ™%Jšžœžœ
žœžœ
žœ
žœ˜7J˜
Jšžœ˜J˜J˜—šŸ
œ+˜5J˜—šŸœžœžœ˜%Jšžœžœ
žœ
žœ
˜#J˜!Jšžœ<žœ
žœ
˜JJš
œ;˜;Jš
œ3˜3J˜J˜—Jšœžœ
žœ
˜Jšœ	žœ˜J˜šŸœžœžœžœ˜Jšœ
žœ
˜Jšœžœ
˜šžœžœ
žœ
ž˜J˜0Jšžœžœ
žœ
˜Jšžœ
˜—J˜J˜—šŸœžœžœ˜J˜Jšœ
žœ
˜J˜—J˜—™J™šŸœžœžœ žœ˜OJšœžœ
žœ
˜
Jšœžœ
˜Jšœžœ
žœ
˜J˜J˜š
žœžœ
žœ
žœžœ˜HJš
œ2™2—Jš	žœ	žœ
žœ žœ ˜YJšœžœ˜"Jšžœ
žœ
žœ;˜PJšœžœ
žœ˜
J˜!šžœžœž˜8šžœž˜JšœΥ
žœ%™ώ
Jšœ; ˜TJš
œW˜WJš 
œ œ
žœ
˜——–[]šžœžœ %˜=šžœžœ˜(Jšœ žœ˜'Kšžœžœ$˜DK˜—K˜
—šžœ
 $˜)šžœž˜%Jš
œ3˜3——šžœžœžœ˜,Jš
œ˜šžœž˜š
œ˜šœžœž˜$Jšœžœ
˜0—Jšœ&žœ˜-J˜——Jš
œ)˜)šžœž˜&K™Jš
œ3˜3—J˜—J™šžœ!žœ˜)˜šœžœ
žœ˜.Jšžœ
žœžœžœ˜R—šœžœžœ˜šžœ
žœž˜'J˜J˜(J˜"J˜!Jšžœ˜Jš
œ˜——J˜7J˜—J˜
—Jšžœ˜"Jšžœžœ
žœ0˜SJšžœžœ
žœ˜1šžœžœ)žœ
˜KJš
œ˜—Jšžœ!žœžœ
˜BJšœ4žœ˜IJš
œ˜—J˜š
ŸœžœDžœžœžœ˜†
Jšœožœ*Οt
œU’
œ
™τ
J˜$šžœž˜$š
œ
˜
šœžœž˜*J˜$J˜J˜)Jšžœž˜Jš
œ˜——š
œ˜Jšžœ$žœ&˜P—˜šžœ%žœ˜-šœ
žœ˜JšœžœO˜g—J˜0J˜——Jšžœ
˜—J˜J™—J™šŸ
œžœ+žœ
žœžœžœ
žœ˜iJšžœžœ
žœ
˜"Jš
œ%˜%Jšžœžœ$žœ%˜kJ˜—J™J™Ν
šŸœžœ.˜?Jšœ
žœ$žœ˜:Jšœžœžœ˜$Jš
žœ
žœ
žœžœ
žœ
˜3Jšžœžœ&˜1Jšœ%žœ˜+Jšœžœ
˜ J˜J˜—™VJ™ή
J™R—š
Ÿœžœžœžœ	žœ˜9Jšœžœ˜
JšŸ
œžœ˜,Jš
œ
˜
šžœ#žœ˜+Jšœ* ˜IJ˜šžœ#ž˜)Jšœ) 3˜\—J˜—J˜J˜—šŸœžœ
žœ;žœ˜^Kšžœ
žœžœ
˜Kš
œ.˜.Kšœžœ
˜Jšžœ˜šžœžœ˜Jš
œ˜Jšœžœ
˜J˜
—šžœ˜Kš
œ-˜-šœžœž˜4šœ 6˜RKšžœžœ™3Kšžœžœ™;Kš
ž™Kš
œ/˜/Kš
œ˜—Jš
œP˜PJšžœ=žœ˜M—J˜—šžœžœž˜BJš
œ7˜7—K˜K˜—šŸœž
œ˜;Jšžœ
žœžœ
˜š
Ÿœžœ
žœžœžœ˜-Jš
œA˜AJšžœ˜Jš
œ˜—šŸœžœ
žœžœžœ
žœ˜Wšžœžœ˜Jš
œ˜šžœž˜Jš
œ7˜7—Jš
œ˜J˜—Kšžœ˜Jš
œ˜J˜—šœžœ˜$Jš
œQ˜Q—š
œF˜FJ™3—šžœž˜šžœž˜Jš
œ˜—šžœ
˜šžœžœ
žœž˜Jšžœ:žœ
žœ
˜HJšžœ5žœ
žœ
˜CJšžœ9žœ
žœ
˜GJšžœ5žœ
žœ
˜CJšžœ
˜—Jšžœ2žœ
žœ
˜@J˜—Jšžœ
˜—J˜—J˜—™"J™™J˜Jšœžœ˜Jšœ
žœ˜Jšœžœ˜J˜šŸ
œžœž˜Jšœžœ
˜Jšœ	žœ
˜J˜Jš
œ˜J˜
šžœžœ
žœ˜Jšœ3žœ˜=—Jšœžœ˜.J˜J˜&J˜šœ+Πac˜=Jšœ  ˜/J˜Jšœžœ 8˜IJšœ ˜0Jšœ ˜.Jšœ 
˜,Jšœžœž
œ '˜>—J˜Jšœ
žœžœžœ˜^š
œ"˜"Jšœ;žœ˜A—Jš
œY˜YJ˜HJšœsžœ˜zJ˜AJ˜4J˜Jš
œM™MJ˜
šžœ*žœ˜2Jš
œ1˜1Jšžœžœ#˜4J˜—J˜'Jšœ1žœ˜DJ˜(š
œ)˜)Jšœžœ
˜ š
œ˜Jšœ#žœ˜,——Jš
œ1˜1Jš
œ1˜1Jšœ" ˜9šžœžœ
˜&Jš
œM˜M—šžœžœ
˜(šœOž˜SJ˜——Jšžœ
˜—J˜šŸ	œžœ˜™šŸœžœžœ˜Iš
œ˜Jš
œ˜Jš
œG˜GJš
œ˜—J˜—Jš
œ˜Jš
œ+˜+Jš
œ)˜)Jš
œ-˜-Jš
œ7˜7Jš
œ5˜5Jš
œ3˜3Jš
œ4˜4J˜—™Jš
œ#˜#Jš
œ-˜-Jš
œ1˜1—Jš
œ˜J˜—JšΟbœ/˜?—J˜™J™šŸœžœ#žœžœ˜Rš
œ˜JšžœB˜H—šŸ	œžœ˜šžœžœ
ž˜š
œ˜Jšœžœ;˜S——šžœ˜JšœžœEžœ˜c—J˜—šžœžœ
žœ˜Jšœžœ-˜Hšœ$žœ™)Jš
œά
™ά
—šžœ
žœ
žœž˜/šœ"žœ!ž˜GJ™τ
—šœ$žœ&ž˜Pšœžœ#ž˜Hš
œI˜IJšœ€
’
œ’
™‘
———šžœ˜J˜——J˜—šžœžœ
ž˜Jšžœžœ
˜*Jšžœ4˜8—Jš
œ˜Jš
œ*˜*Jš
œ.˜.J˜J˜—šŸœžœ žœ
žœ˜Nš
œ˜Jšžœ:˜@—šžœžœ
žœž˜5Jšœ(žœ˜.J˜5J˜)Jšœ6žœ˜;J˜—Jšžœžœ2žœ˜XJš
žœ
žœžœžœ
žœ
˜<Jšœ4 ˜JJš
œ(˜(Jš
œC˜CJ˜——J™J™	˜š€
œ˜!J˜Jš
œ˜J˜——™J™šŸ
œžœ-žœ˜LJšŸœžœ3˜HJš
œ8˜8Jš
œ˜—J˜šŸ
œžœžœžœ˜EJšžœ!žœ
žœ
˜/š
œ˜Jš
œ:˜:Jš	œžœžœžœžœ˜=—J˜—J˜š
Ÿœžœ
žœžœ$žœ
˜PJšœžœžœžœžœžœžœžœžœ
˜bšžœ˜Jš
œ˜Jšœžœ˜Jšœžœ˜Jšžœžœ
žœ
žœžœ
žœžœ
žœ
˜BJšžœžœ
žœ"˜1Jš
œM˜MJš
žœžœžœ
žœ
žœ
˜%šžœžœ ˜-Jšœžœžœžœ ˜BJšœ	žœžœžœ˜1Jš
œ
˜
—šžœ
 .˜3Jš
œ˜——JšžœG˜MJš
œ˜—J˜š
Ÿœžœ
žœžœ$žœ
˜MJš	œžœžœžœžœ
˜8šžœ˜Jš
œH˜HJš
œ$˜$Jšžœ	žœ ˜-Jšœžœžœžœ ˜DJšœ	žœžœžœ˜5Jš
œ
˜
—šžœ
 .˜3Jš
œ˜—JšžœP˜VJš
œ˜—J˜Jš
 >˜>šŸ
œžœ
˜Jšœžœ(˜DJš
œžœ
žœžœ
žœžœ	žœ˜;Jš	œ	žœžœ3žœžœ
˜SJšžœ˜—Jš
œU˜Uš
œ&˜&Jšžœžœ
žœ
˜"šžœ	žœ ˜-Jšœžœžœžœ ˜BJšœ	žœžœžœ˜5Jš
œ
˜
—šžœ
 -˜2Jš
œ˜—šžœ˜Jš
œN˜N—Jš
œ˜—J˜šŸœžœ
˜Jšœžœ˜7Jš
œžœ
žœžœ
žœžœ	žœ˜KJšœ	žœžœ)˜=Jšžœ˜š
œ˜Jš
œ?˜?Jšœžœžœžœ˜>—Jšžœžœ
žœ
˜%š
œ˜Jš
œN˜N—Jš
œ˜J˜—š
Ÿœžœ
žœžœžœ˜<Jš
žœžœ
žœ
žœ
žœ˜Jšžœžœ
žœ
žœ˜$Jšžœ
žœ˜
Jšž
œ
˜J˜—Jš
 9™9Jš
 ™š
Ÿœžœ
žœžœžœ˜RJšžœžœ
žœ
˜,š
œ"˜"Jš
œ@˜@Jšœ žœ˜(—Jš
œ˜—J˜JšŸ	œžœžœžœ˜CJšœ  ™"Jšœžœžœ
žœ
˜.Jš
œ˜Jš
œP˜PJš
œ(˜(Jšœž
œ
˜J˜Jš
 !™!šŸœžœžœ˜:Jšœžœ˜!Jšžœžœ
žœ
˜"š
œ˜JšœDžœ˜M—Jš
œ'™'Jš
œ'˜'Jš
œ˜—J˜——™™š
Ÿœžœ
žœžœ
žœ˜9J˜)šžœ˜Jš
œ1˜1—Jš
œ˜—J˜šŸ
œžœ
žœžœ˜'Jšžœžœ
žœ0˜@Jš
œ˜—J˜š
Ÿœžœ
žœžœ
žœ˜9Jšœžœ$˜.J˜J˜—J˜šŸœ˜(šžœ
žœžœ
žœžœ
žœžœ
žœ
ž˜OJšžœ˜—Jš
œ˜—šŸœ˜+Jšžœ
žœ˜Jš
œ˜J˜—šŸœžœ˜*Jš
œ+˜+Jš
œ˜J˜———™J˜Jšœ3žœžœ˜BJšœ7žœžœ˜FJšœ8žœžœ˜GJšœ<žœžœ˜KJšœ@žœžœ˜OJšœAžœžœ˜PJšœ:žœžœ˜IJšœCžœžœ˜RJš
 N™NJ˜š
œ<˜<Jš
œ%˜%—Jš
œI˜IJš
œL˜LJ˜2J˜QJ˜=J˜NJ˜HJ˜TJ˜>J˜9J˜FJ˜LJ˜(Jš
œ$˜$Jš
œ%˜%Jšœžœ
˜Jšœžœ
˜Jš
œ&˜&J˜5J˜/Jšžœn˜uJ™š
œ*˜*Jš
œ.˜.——Jš
œ˜™(K™KšœΟr'™3—š
œ4™4Kš
œ™Kšœ₯2™>—š
œ4™4Kšœ₯A™M—š
œ6™6Kš
œš
™š
Kšœ₯g™s—™,Kš
œF™FKš
œ;™;K™CK™4K™8K™-K™ZK™•
—™4K™IKšœ₯…
™‘
—™5K™‘
Kšœ₯n™z—š
œ5™5K™IKšœ₯1œ™C—™*K™œ
—K™—…—€ΗΎ