FinchToolImpl.mesa
Copyright Ó 1985, 1987, 1988, 1992 by Xerox Corporation. All rights reserved.
Last Edited by: Swinehart, June 4, 1992 10:36 pm PDT
Last Edited by: Pier, April 17, 1984 3:51:54 pm PST
Polle Zellweger (PTZ) July 31, 1990 10:44:14 pm PDT
DIRECTORY
BasicTime USING [ GMT, Now, OutOfRange, Period ],
Buttons USING [ ButtonProc, Create ],
Commander USING [ CommandProc, Handle, Register ],
CommanderOps USING [ NextArgument ],
Containers USING [ ChildXBound, ChildYBound, Container, Create ],
Convert USING [ IntFromRope, RopeFromTime, RopeFromTimeRFC822 ],
FinchSmarts USING [
AnswerCall, ConvDesc, CurrentConversations, CurrentRName, DisconnectCall, Feep, FetchAttribute, FinchIsRunning, IdentifyVisitor, Join, Poke, ReleaseVisitor, InitFinchSmarts, UninitFinchSmarts ],
FinchSynthesizer USING [ InitializeFinchSynthesizer, StopSpeech, TextToSpeech ],
FinchTool,
FS USING [ ComponentPositions, Error, ExpandName, StreamOpen ],
Icons USING [ IconFlavor, NewIconFromFile ],
IO,
Labels USING [Create],
List USING [Reverse],
MBQueue USING [ Create, CreateButton, CreateMenuEntry, Queue, QueueClientAction ],
Menus USING [AppendMenuEntry, CreateEntry, CreateMenu, FindEntry, Menu, MenuEntry, MenuProc, MouseButton, ReplaceMenuEntry ],
Nice USING [ View ],
Process USING [ Detach, Pause, MsecToTicks, SecondsToTicks, SetTimeout],
Rope USING [ ActionType, Cat, Concat, Equal, Fetch, Find, Flatten, Length, Map, MakeRope, MaxLen, Replace, ROPE, SkipTo, Substr ],
Rules USING [ Create ],
Synthesizer USING [ SynthSpecBody, SynthSpec ],
TEditScrolling USING [ AutoScroll ],
TextEdit USING [ MaxLen, ReplaceByRope ],
TextLooks USING [ RopeToLooks ],
TextNode USING [ Ref, Root ],
ThParty USING [ nullIx, PartyInfo ],
Thrush USING [ ActionReport, ConvEventBody, ConversationID, NB, notReallyInConv, nullConvID, Reason, StateInConv ],
TiogaButtons USING [ ChangeButtonLooks, CreateButton, CreateViewer, DeleteButton, FindTiogaButton, GetRope, SetStyleFromRope, TiogaButton, TiogaButtonProc, WrongViewerClass],
TiogaOps USING [ CallWithLocks, CancelSelection, GetRope, GetSelection, Location, Ref, SelectionError, SelectionGrain, SetSelection, StepForward ],
TypeScript USING [ Create ],
UserProfile USING [ Boolean, CallWhenProfileChanges, ProfileChangedProc, Token ],
VFonts USING [ Font, defaultFont ],
ViewerClasses USING [ Viewer, ViewerRec ],
ViewerEvents USING [ EventProc, RegisterEventProc, UnRegisterEventProc ],
ViewerIO USING [ CreateViewerStreams ],
ViewerLocks USING [ CallUnderWriteLock ],
ViewerOps USING [AddProp, ComputeColumn, DestroyViewer, FetchProp, PaintViewer, SetOpenHeight],
ViewerSpecs USING [ openTopY, openLeftWidth, openRightWidth ],
ViewerTools USING [GetSelectionContents, GetContents, MakeNewTextViewer, SetContents, SetSelection ],
VoiceUtils USING [ CurrentRName, Report, ReportFR, RegisterWhereToReport, WhereProc ]
;
FinchToolImpl: CEDAR MONITOR     
IMPORTS BasicTime, Buttons, Commander, CommanderOps, Containers, Convert, FinchSmarts, FinchSynthesizer, FinchTool, FS, Icons, IO, Labels, MBQueue, Menus, Rope, Rules, Process, TEditScrolling, TextEdit, TextLooks, TextNode, TiogaButtons, TiogaOps, TypeScript, UserProfile, VFonts, ViewerEvents, ViewerIO, ViewerLocks, ViewerOps, ViewerSpecs, ViewerTools, VoiceUtils
EXPORTS FinchTool = {
OPEN IO;
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
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[];
fadedIcon: Icons.IconFlavor ¬ tool;
fadingIcon: Icons.IconFlavor ¬ tool;
finchIcon: Icons.IconFlavor ¬ tool;
leftFinchIcon: Icons.IconFlavor ¬ tool;
rightFinchIcon: Icons.IconFlavor ¬ tool;
outgoingFinchIcon: Icons.IconFlavor ¬ tool;
outgoingConvIcon: Icons.IconFlavor ¬ tool;
incomingConvIcon: Icons.IconFlavor ¬ tool;
labelledFinchIcon: Icons.IconFlavor ¬ tool;
labelledLeftFinchIcon: Icons.IconFlavor ¬ tool;
labelledRightFinchIcon: Icons.IconFlavor ¬ tool;
finchMenu: Menus.Menu;
commentEntry, endCommentEntry: Menus.MenuEntry;
xFudge: INTEGER = 2;
entryHeight: INTEGER = 14;
defaultToolHeight: NAT ¬ ViewerSpecs.openTopY/5;
finchEnabledAtCheckpoint: BOOL ¬ FALSE;
deleteButtonEnabled: BOOL ¬ FALSE;
defaultCallLogFileName: Rope.ROPE ¬ "/tmp/PersistentCall.log";
Which: TYPE = { self, other, originator, moderator };
Placing and Controlling Calls
PhoneProc: Buttons.ButtonProc = { -- Place call to party identified by primary selection
[parent: REF ANY, clientData: REF ANY ← NIL, mouseButton: Menus.MouseButton ← red, shift: BOOL ← FALSE, control: BOOL ← FALSE]
calledPartyText: Rope.ROPE ¬ ViewerTools.GetSelectionContents[];
DoPhone[calledPartyText,
SELECT mouseButton FROM
red, yellow => FALSE, blue=> TRUE, ENDCASE=>ERROR];
};
CalledPartyProc: Buttons.ButtonProc = { -- Place call to Called Party field
[parent: REF ANY, clientData: REF ANY ← NIL, mouseButton: Menus.MouseButton ← red, shift: BOOL ← FALSE, control: BOOL ← FALSE]
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
[parent: REF ANY, clientData: REF ANY ← NIL, mouseButton: Menus.MouseButton ← red, shift: BOOL ← FALSE, control: BOOL ← FALSE]
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 = { -- CommandTool 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];
};
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[complain: FALSE, moreToCome: TRUE];
IF pauseNeededInMs#0 THEN Process.Pause[Process.MsecToTicks[pauseNeededInMs]];
-- Maybe a status check wait loop here ??
FinchTool.CallByDescription[description: callee, residence: wantResidence];
No Conversation ID needed here because assumed not active in any now.
};
RedialCmd: Commander.CommandProc = { -- CommandTool Redial command
ENABLE UNWIND => cmdHandle ¬ NIL;
cmdHandle ¬ cmd;
IF CheckActive[finchToolHandle] THEN
DoPhone[ViewerTools.GetContents[finchToolHandle.calledPartyText], FALSE];
cmdHandle ¬ NIL;
};
RedialOfficeCProc: PROC [data: REF] = { -- Redial from TiogaButton in conversation log
WITH data SELECT FROM
cDesc: FinchSmarts.ConvDesc => ShowRetriedCall[cDesc];
ENDCASE;
RedialIt[data: data];
};
RedialHomeCProc: PROC [data: REF] = { -- Redial from TiogaButton in conversation log
WITH data SELECT FROM
cDesc: ConvDesc => ShowRetriedCall[cDesc];
ENDCASE;
RedialIt[data: data, wantResidence: TRUE];
};
RedialIt: PROC [data: REF, wantResidence: BOOL¬FALSE] = {
activeCDesc: FinchSmarts.ConvDesc = GetSelectedDesc[];
IF activeCDesc#NIL AND activeCDesc.situation.self.state > $parsing THEN {
Report["Call already in progress"]; RETURN; };
WITH data SELECT FROM
cDesc: FinchSmarts.ConvDesc => {
IF cDesc.partyInfo=NIL OR cDesc.partyInfo.ixOriginator = ThParty.nullIx THEN
Report["Unknown caller/callee"]
ELSE IF CheckActive[finchToolHandle] THEN
DoPhone[SimplifyName[cDesc, $other], wantResidence];
};
descriptor: Rope.ROPE => {
dS: IO.STREAM ¬ IO.RIS[descriptor];
start: INT;
end: INT;
token: Rope.ROPE;
TabProc: IO.BreakProc~{RETURN[IF char='\011 THEN $sepr ELSE $other];};
token ¬ dS.GetTokenRope[TabProc!IO.EndOfStream => token¬NIL].token; -- date
token ¬ dS.GetTokenRope[TabProc!IO.EndOfStream => token¬NIL].token; -- time
token ¬ dS.GetTokenRope[TabProc!IO.EndOfStream => token¬NIL].token; -- status
token ¬ dS.GetTokenRope[TabProc!IO.EndOfStream => token¬NIL].token; -- elapsed time
token ¬ dS.GetTokenRope[TabProc!IO.EndOfStream => token¬NIL].token; -- source/dest
IF token=NIL THEN RETURN;
start ¬ token.Find["from outside line"];
IF start#-1 THEN RETURN;
IF (start ¬ token.Find["from "]) #-1 THEN start¬5
ELSE IF (start ¬ token.Find["to "]) #-1 THEN start¬3
ELSE IF (start ¬ token.Find["with: "]) #-1 THEN start¬6
ELSE RETURN;
end ¬ token.SkipTo[skip: "?\040\011", pos: start];
token ¬ token.Substr[start: start, len: end-start];
IF CheckActive[finchToolHandle] THEN DoPhone[token, wantResidence];
};
ENDCASE;
};
JoinCmd: Commander.CommandProc = {
[] ¬ FinchSmarts.Join[CommanderOps.NextArgument[cmd]];
};
AnswerCmd: Commander.CommandProc = { -- CommandTool Answer command
Refers to entries in the viewer finchToolHandle.conversations, not necessarily current one.
ENABLE UNWIND => cmdHandle ¬ NIL;
cDesc: ConvDesc = GetSelectedDesc[];
cmdHandle ¬ cmd;
AnswerIt[cDesc: cDesc];
cmdHandle ¬ NIL;
};
Answer: Menus.MenuProc = TRUSTED { -- Answer from Answer button in Finch Tool
Refers to entries in the viewer finchToolHandle.conversations, not necessarily current one.
cDesc: ConvDesc = GetSelectedDesc[];
AnswerIt[cDesc: cDesc];
};
AnswerCProc: PROC [data: REF] = { -- Answer from TiogaButton in conversation log
AnswerIt[cDesc: NARROW[data]]; };
AnswerIt: PROC [cDesc: ConvDesc¬NIL] = TRUSTED {
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];
};
HangUpCmd: Commander.CommandProc = { -- HangUp command
ENABLE UNWIND => cmdHandle ¬ NIL;
action: Menus.MouseButton ¬ $red;
IF CheckForMouseButtonSpec[cmd.commandLine, " middle", FALSE, TRUE].isMatch
THEN action ¬ $yellow;
IF CheckForMouseButtonSpec[cmd.commandLine, " right", FALSE, TRUE].isMatch
THEN action ¬ $blue;
cmdHandle ¬ cmd;
[] ¬ HangItUp[complain: TRUE, action: action];
cmdHandle ¬ NIL;
};
Hangup: PUBLIC Menus.MenuProc = { -- Hang up from Disconnect button in Finch Tool
[]¬HangItUp[complain: TRUE, action: mouseButton]; };
Refers to entries in the viewer finchToolHandle.conversations, not necessarily current one.
HangupQuietly: PUBLIC Menus.MenuProc = { []¬HangItUp[complain: FALSE, action: mouseButton]; };
Called to disconnect a call in progress without logging a message.
HangupCProc: PROC [data: REF] = { -- Hang up from TiogaButton in conversation log
[]¬HangItUp[complain: TRUE, cDesc: NARROW[data]]; };
ToggleActiveState: PROC [data: REF] = { -- Hang up from TiogaButton in conversation log
newState: Thrush.StateInConv;
cDesc: ConvDesc ¬ NARROW[data];
IF cDesc=NIL THEN { Report["No active or held conversation"]; RETURN; };
SELECT cDesc.situation.self.state FROM
$active => newState ¬ $inactive;
$inactive => newState ¬ $active;
ENDCASE => { Report["Conversation not active or held"]; RETURN; };
FinchSmarts.DisconnectCall[ -- Function now misnamed
convID: cDesc.situation.self.convID, newState: newState];
};
HangItUp: PROC[complain: BOOL¬TRUE, moreToCome: BOOL¬FALSE, cDesc: ConvDesc¬NIL, action: Menus.MouseButton¬$red] RETURNS [pauseNeededInMs: CARDINAL¬0] = TRUSTED {
state: Thrush.StateInConv;
isTrunk: BOOL;
previousSituation: Thrush.ConvEventBody¬[];
IF cDesc=NIL THEN cDesc ¬ GetSelectedDesc[];
state ¬ IF cDesc=NIL THEN idle ELSE cDesc.situation.self.state;
isTrunk ¬ IF cDesc#NIL THEN cDesc.partyInfo.conversationInfo.bilateralConv ELSE FALSE;
SELECT state FROM
$idle => {
IF complain THEN Report[" No conversation to leave"]; RETURN };
$inactive, -- flashing for a clear line; not needed
$reserved, $parsing => IF moreToCome THEN RETURN;
ENDCASE;
IF isTrunk THEN pauseNeededInMs ¬ IF cDesc.situation.self.state=active THEN 2000 ELSE 500;
IF action = $yellow THEN previousSituation ¬ cDesc.situation;
FinchSmarts.DisconnectCall[
convID: cDesc.situation.self.convID,
newState: SELECT action FROM $red => $idle, $yellow => $inactive, ENDCASE => $active];
IF action = $yellow THEN {
previousSituation.time ¬ cDesc.situation.time;
cDesc.previousSituation ¬ previousSituation;
};
};
ConversationMgmtProc: TiogaButtons.TiogaButtonProc = {
PROC [button: TiogaButton, clientData: REF ANY ← NIL,
mouseButton: ViewerClasses.MouseButton ← red, shift, control: BOOL ← FALSE]
Button-invoked operations when applied directly to conversation-viewer log entries.
IF deleteButtonEnabled AND control AND shift AND mouseButton=blue THEN {
Hack for controlling contents of conversation viewer.
TiogaButtons.DeleteButton[button]; RETURN;
};
IF clientData=NIL THEN clientData ¬ TiogaButtons.GetRope[button];
IF control THEN
MBQueue.QueueClientAction[q: finchQueue, proc: HangupCProc, data: clientData]
ELSE IF shift THEN
MBQueue.QueueClientAction[q: finchQueue, proc: AnswerCProc, data: clientData]
ELSE IF mouseButton=yellow THEN
MBQueue.QueueClientAction[q: finchQueue, proc: RedialOfficeCProc, data: clientData]
ELSE IF mouseButton=blue THEN
MBQueue.QueueClientAction[q: finchQueue, proc: RedialHomeCProc, data: clientData]
ELSE
MBQueue.QueueClientAction[q: finchQueue, proc: ToggleActiveState, data: clientData]
};
ParseCallee: PROC[fullCallee: ROPE, wantResidence: BOOL] RETURNS [callee: ROPE, fCallee: ROPE, residence: BOOL] = {
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.)
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[
target, prefix: ROPE, trueAlready: BOOL, ifMatch: BOOL]
RETURNS [remainingTarget: ROPE, isMatch: BOOL] = {
pLen: INT ¬ prefix.Length[];
remainingTarget ¬ target;
isMatch ¬ trueAlready;
IF target.Length[] >= pLen AND prefix.Equal[target.Substr[len: pLen]] THEN {
remainingTarget ¬ target.Substr[start: pLen];
isMatch ¬ ifMatch;
};
};
GetSelectedDesc: PUBLIC PROC[chosenButton: TiogaButtons.TiogaButton¬NIL, checkActive: BOOL¬TRUE] RETURNS [cDesc: ConvDesc¬NIL] = {
viewer: Viewer = IF finchToolHandle#NIL THEN finchToolHandle.conversations ELSE NIL;
selected: TiogaButtons.TiogaButton ¬ IF viewer=NIL THEN NIL
ELSE NARROW[ViewerOps.FetchProp[viewer, $selectedEntry]];
IF chosenButton#NIL AND selected#chosenButton THEN RETURN;
IF selected = NIL OR (checkActive AND ~CheckActive[finchToolHandle, TRUE]) THEN RETURN;
cDesc ¬ NARROW[selected.clientData];
};
MakeListener: Buttons.ButtonProc = {
[parent: REF ANY, clientData: REF ANY ← NIL, mouseButton: Menus.MouseButton ← red, shift: BOOL ← FALSE, control: BOOL ← FALSE]
Menus.ReplaceMenuEntry[finchToolHandle.outer.menu, endCommentEntry, commentEntry];
ViewerOps.PaintViewer[finchToolHandle.outer, menu];
Status["Listening only enabled"];
};
MakeCommentator: Buttons.ButtonProc = {
[parent: REF ANY, clientData: REF ANY ← NIL, mouseButton: Menus.MouseButton ← red, shift: BOOL ← FALSE, control: BOOL ← FALSE]
Menus.ReplaceMenuEntry[finchToolHandle.outer.menu, commentEntry, endCommentEntry];
ViewerOps.PaintViewer[finchToolHandle.outer, menu];
Status["Permission to comment granted"];
};
Speaking Text
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 = {
ENABLE UNWIND => cmdHandle ¬ NIL;
textToSpeak: Rope.ROPE ¬ cmd.commandLine.Substr[start: 1, len: cmd.commandLine.Length[]-2];
cmdHandle ¬ cmd;
IF CheckActive[finchToolHandle] AND textToSpeak.Length[]#0 THEN
[]¬SpeakTextWithFeedback[TRUE, textToSpeak];
cmdHandle ¬ NIL;
};
SpeakTextWithFeedback: PROC [
queueIt: BOOL, text: ROPE¬NIL, convID: Thrush.ConversationID¬Thrush.nullConvID]
RETURNS [newConvID: Thrush.ConversationID] ~ {
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.
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;
Report["Sorry, trouble with text to speech service (%g)", [atom[nb]]];
};
};
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.Concat[tiogaopstext, nodeEnd];
convID ¬ SpeakTextWithFeedback[queueIt, tiogaopstext, convID];
queueIt ¬ TRUE;
IF node=end.node THEN EXIT;
ENDLOOP;
};
StopSpeechProc: Buttons.ButtonProc = { StopSpeaking[]; };
StopSpeakingCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
cmdHandle ¬ cmd;
StopSpeaking[];
cmdHandle ¬ NIL;
};
StopSpeaking: PROC = {
nb: NB;
IF ~CheckActive[finchToolHandle, TRUE] THEN RETURN;
nb¬FinchSynthesizer.StopSpeech[].nb;
IF nb#$success THEN
Report["Sorry, trouble with text to speech service; could not Stop. (%g)", [atom[nb]]];
};
Other User Commands
FeepCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
textToFeep: Rope.ROPE ¬ FeepValue[cmd.commandLine.Substr[start: 1, len: cmd.commandLine.Length[]-2]];
cDesc: ConvDesc;
cmdHandle ¬ cmd;
cDesc ¬ 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] = {
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.
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 ];
a b c d e f g h i j k l m n o p q r s t u v w x y z
VisitCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
nb: NB;
visitor: Rope.ROPE ¬ cmd.commandLine.Substr[start: 1, len: cmd.commandLine.Length[]-2];
IF Rope.Length[visitor] = 0 THEN { -- collect the name now instead
IO.Put1[cmd.out, IO.rope["Visitor name: "]];
visitor ¬ IO.GetLineRope[cmd.in];
};
cmdHandle ¬ cmd;
IF CheckActive[finchToolHandle] THEN
nb ¬ FinchSmarts.IdentifyVisitor[visitor: visitor, password: "", complain: FALSE];
try first time w/o password
IF nb=$passwordNotValid THEN { -- password required, collect it
password: Rope.ROPE ¬ "";
IO.PutF1[cmd.out, "password: %l", IO.rope["h"]];
password ¬ IO.GetLineRope[cmd.in];
IO.PutF1[cmd.out, "%l", IO.rope["H"]];
[] ¬ FinchSmarts.IdentifyVisitor[visitor, password];
};
cmdHandle ¬ NIL;
};
UnvisitCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
visitor: Rope.ROPE ¬ cmd.commandLine.Substr[start: 1, len: cmd.commandLine.Length[]-2];
password: Rope.ROPE ¬ "";
IF Rope.Length[visitor] = 0 THEN {}; -- no name => self
No password for unvisiting, either.
cmdHandle ¬ cmd;
IF CheckActive[finchToolHandle] THEN
FinchSmarts.ReleaseVisitor[visitor, password];
cmdHandle ¬ NIL;
};
TDirCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
fileName: ROPE ¬ CommanderOps.NextArgument[cmd];
cP: FS.ComponentPositions;
IF fileName = NIL THEN RETURN[$Failed, "No Directory name Supplied"];
[fileName, cP] ¬ FS.ExpandName[fileName];
IF cP.ext.length=0 THEN
fileName ¬ fileName.Substr[len: cP.ext.start]
.Concat[".TelephoneDirectory"]
.Concat[fileName.Substr[start: cP.ver.start, len: cP.ver.length]];
cmdHandle ¬ cmd;
FinchTool.BuildDirectory[directoryFile: fileName, newOK: TRUE];
cmdHandle ¬ NIL;
};
Starting and Stopping
StartFinch: PUBLIC PROC[] = TRUSTED {
handle: FinchTool.Handle ¬ finchToolHandle;
enabled, connected: BOOL;
IF handle=NIL THEN {
MakeFinchTool[];
handle ¬ finchToolHandle;
IF handle=NIL THEN { Report["Can't create Finch viewer"]; RETURN; };
};
[enabled, connected] ¬ FinchSmarts.FinchIsRunning[];
SELECT TRUE FROM
connected => Report["Already running."];
enabled => { Report["Connecting . . ."]; FinchSmarts.Poke[]; };
ENDCASE => {
Report["Connecting . . ."];
FinchSmarts.InitFinchSmarts[serverInstance, $FinchTool, ReportSystemState, ReportConversationState, ReportRequestState];
FinchSynthesizer.InitializeFinchSynthesizer[];
--finchToolHandle.--finchEnabledAtCheckpoint ¬ FALSE;
};
};
FinchCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
cmdHandle ¬ cmd;
serverInstance ¬ CommanderOps.NextArgument[cmd];
StartFinch[];
cmdHandle ¬ NIL;
};
StopFinch: PUBLIC ENTRY PROC[disable: BOOL¬TRUE] = TRUSTED {
handle: FinchTool.Handle = finchToolHandle;
IF handle=NIL THEN RETURN;
handle.keepTwiddling ¬ FALSE;
NOTIFY handle.twiddleWait;
Process.SetTimeout[@handle.twiddleWait, 1];
WAIT handle.twiddleWait;
Report["Disconnecting . . ."];
FinchSmarts.UninitFinchSmarts[disable];
};
ButtonStopFinch: Buttons.ButtonProc = { StopFinch[]; };
UnfinchCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
cmdHandle ¬ cmd;
StopFinch[];
cmdHandle ¬ NIL;
};
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[];
IF finchToolHandle.callLog#NIL THEN finchToolHandle.callLog.Close[];
ViewerEvents.UnRegisterEventProc[proc: finchToolHandle.scrollEvent, event: open];
finchToolHandle ¬ NIL;
};
CheckActive: PUBLIC PROC[handle: FinchTool.Handle, mustAlreadyBeActive: BOOL¬FALSE, complain: BOOL¬TRUE] RETURNS[active: BOOL¬FALSE] = {
If not active, try to make it active, unless mustAlreadyBeActive. If complain is FALSE, don't complain when not active, if you have any control over it. Here "active" refers not to the state of a party in a conversation, but to the state of connectedness of Finch to the server.
enabled, connected: BOOL;
IF handle=NIL THEN RETURN; -- This is essentially a bug.
IF ~FinchSmarts.FinchIsRunning[].finchIsEnabled AND ~mustAlreadyBeActive
THEN StartFinch[];
[enabled, connected] ¬ FinchSmarts.FinchIsRunning[];
active ¬ IF mustAlreadyBeActive THEN connected ELSE enabled;
IF complain AND ~active AND mustAlreadyBeActive THEN Report["Sorry, Finch has lost contact with the telephone server"];
};
ReportSystemState: PROC[enabled, connected, voicePath: BOOL] = {
cDesc: ConvDesc ¬ GetSelectedDesc[checkActive: FALSE];
UpdateIconE[finchToolHandle];
IF finchToolHandle=NIL OR (connected=finchToolHandle.finchConnectedAtLastReport
AND enabled=finchToolHandle.finchEnabledAtLastReport) THEN RETURN;
finchToolHandle.finchConnectedAtLastReport¬connected;
finchToolHandle.finchEnabledAtLastReport¬enabled;
VoiceUtils.Report[where: $FinchOnly, remark: IF ~enabled THEN "Finch is not active." ELSE IO.PutFR1["Finch is active%g connected to the telephone server.", rope[IF connected THEN " and" ELSE ", but is not"]]];
IF ~connected AND cDesc # NIL THEN {
cDesc.situation.self.state ¬ $idle;
ReportConversationState[$success, cDesc, "Server connection broken; state of call unknown"];
};
};
didOurBest: BOOL¬FALSE;
defaultTime: CARDINAL ¬ 2500;
Try: PROC[p: PROC, msecsToWait: CARDINAL ¬ defaultTime] = TRUSTED {
didOurBest ¬ FALSE;
Process.Detach[FORK Try1[p]];
IF msecsToWait#0 THEN FOR i: NAT IN [0..100) DO
Process.Pause[Process.MsecToTicks[msecsToWait/100]];
IF didOurBest THEN EXIT;
ENDLOOP;
};
Try1: PROC[p: PROC] = {
p[];
didOurBest ¬ TRUE;
};
Conversation Management
joinReason: Thrush.Reason ¬ NIL; -- or $join; here to allow testing
ReportConversationState: ENTRY PROC[ nb: NB, cDesc: ConvDesc, remark: Rope.ROPE ] = {
ENABLE UNWIND => NULL;
s: IO.STREAM;
difficulty: BOOL¬FALSE;
state: Thrush.StateInConv;
SELECT nb FROM $success => NULL; ENDCASE => { Status[remark]; RETURN; };
Don't use conversation buttons for failure reports
IF cDesc = NIL THEN {Status["No state to report"]; RETURN;}; --Not much more can be done.
IF finchToolHandle=NIL THEN RETURN;
state ¬ cDesc.situation.self.state;
IF state=initiating THEN RETURN; -- wait until we know more about this conv
IF ~cDesc.originatorRecorded AND cDesc.numParties>1 AND cDesc.partyInfo#NIL THEN
SELECT cDesc.partyInfo.ixOriginator FROM
If we originated, called-party is already custom-tailored from local information. Else pick up calling party (incoming), or called-party (randomly-chosen if multiple).
cDesc.partyInfo.ixSelf => SetContents[finchToolHandle.calledPartyText, cDesc, $other];
ThParty.nullIx => NULL;
ENDCASE => SetContents[finchToolHandle.callingPartyText, cDesc, $originator];
UpdateIcon[finchToolHandle];
s ¬ IO.ROS[];
IF state=reserved OR state=parsing THEN s.PutRope[printLabel[state]]
ELSE {
IF cDesc.firstReport THEN {
TRUSTED {Process.Detach[ FORK DurationTimer[cDesc] ]}; -- increments every second
cDesc.firstReport ¬ FALSE;
};
s.PutF["%g\t%g\t%g\t", rope[CallDateAndTime[cDesc]], rope[CallStatus[cDesc]], rope[CallDuration[cDesc]]];
s.PutF1["%g", rope[CallerAndOrCallee[cDesc]]];
IF cDesc.numParties>1 AND cDesc.subject#NIL THEN s.Put[rope["\t"], rope[cDesc.subject]];
};
IF state = $failed THEN -- if failed, elaborate.
s.PutF1["%s", rope[
SELECT cDesc.situation.reason FROM
$busy => "", -- reported above in status field
$notFound => " -- no valid party found",
$error => " -- connection failed",
$noCircuits => " -- no circuits",
ENDCASE => " -- unexplained failure"
]
];
IF cDesc.situation.comment#NIL THEN s.PutF1[" (%s)", rope[cDesc.situation.comment]];
IF remark#NIL THEN s.PutF1[" [%s]", rope[remark]];
The following reinstated October 3, 1989 4:55:17 pm PDT; announcements don't work; see below.
IF finchToolHandle.backgrounding THEN SELECT state FROM
$notified => {
selectedDesc: ConvDesc ¬ GetSelectedDesc[checkActive: FALSE];
acceptNew: BOOL¬TRUE;
IF selectedDesc#NIL THEN SELECT selectedDesc.situation.self.state FROM
$idle, $inactive, $neverWas => NULL; -- OK to accept new
$active =>
IF ConvPriority[cDesc] > ConvPriority[selectedDesc] THEN
[] ¬ HangItUp[cDesc: selectedDesc, action: $yellow] -- Put active call on hold.
ELSE acceptNew ¬ FALSE;
ENDCASE => acceptNew ¬ FALSE;
FinchSmarts.DisconnectCall[
convID: cDesc.situation.self.convID,
newState: IF acceptNew THEN $ringing ELSE $idle,
reason: IF acceptNew THEN NIL ELSE $busy
];
Now report the original state; subsequent reports will cause our changes to be reflected.
};
$idle, $inactive => {
bestCDesc: ConvDesc ¬ NIL;
convs: LIST OF ConvDesc ¬ FinchSmarts.CurrentConversations[];
FOR convs1: LIST OF ConvDesc ¬ convs, convs1.rest WHILE convs1#NIL DO
Compute a best match: previous state must have been active, priority must be below foreground, but take the highest such, and among those, take the latest such to transition to held.
pSitBest: Thrush.ConvEventBody¬[];
pSit1: Thrush.ConvEventBody¬[];
cDesc1: ConvDesc ¬ convs1.first;
IF cDesc1#NIL THEN pSit1 ¬ cDesc1.previousSituation;
IF cDesc1 = cDesc
OR cDesc1.situation.self.state # $inactive
OR pSit1.self.state # $active
OR ConvPriority[cDesc1] >= 500
THEN LOOP;
-- don't make evergreen connections
IF bestCDesc = NIL
OR ConvPriority[cDesc1] > ConvPriority[bestCDesc]
OR (ConvPriority[cDesc1] = ConvPriority[bestCDesc]
AND BasicTime.Period[
from: pSitBest.time, to: pSit1.time] > 0)
THEN {
bestCDesc ¬ cDesc1;
pSitBest ¬ pSit1;
};
ENDLOOP;
IF bestCDesc#NIL THEN [] ¬ HangItUp[cDesc: bestCDesc, action: $blue]; -- reactivate some background call.
};
ENDCASE => NULL; -- no special action
Backgrounding completely disabled October 3, 1989 4:54:53 pm PDT; for further study.
SELECT state FROM
$notified => {
selectedDesc: ConvDesc ← GetSelectedDesc[checkActive: FALSE];
acceptNew: BOOL←TRUE;
newState: Thrush.StateInConv;
reason: Thrush.Reason;
IF selectedDesc # cDesc THEN { -- otherwise just another report; ignore it
IF doAnnounce AND Rope.Equal[cDesc.subject, "Announcement"] THEN
Announcement stuff currently vestigial; there are bugs -- PTZ 3/31/89
{ newState ← $active; reason ← joinReason; }
ELSE
{ newState ← $ringing; reason ← NIL; };
IF selectedDesc#NIL THEN SELECT selectedDesc.situation.self.state FROM
$idle, $inactive, $neverWas => NULL; -- OK to accept new
$active =>
IF finchToolHandle.backgrounding AND ConvPriority[cDesc] > ConvPriority[selectedDesc] THEN
[] ← HangItUp[cDesc: selectedDesc, action: $yellow] -- Put active call on hold.
ELSE acceptNew ← FALSE;
ENDCASE => acceptNew ← FALSE;
FinchSmarts.DisconnectCall[
convID: cDesc.situation.self.convID,
newState: IF acceptNew THEN newState ELSE $idle,
reason: IF acceptNew THEN reason ELSE $busy
];
};
Now report the original state; subsequent reports will cause our changes to be reflected.
};
$idle, $inactive =>
IF finchToolHandle.backgrounding THEN {
bestCDesc: ConvDesc ← NIL;
convs: LIST OF ConvDesc ← FinchSmarts.CurrentConversations[];
FOR convs1: LIST OF ConvDesc ← convs, convs1.rest WHILE convs1#NIL DO
Compute a best match: previous state must have been active, priority must be below foreground, but take the highest such, and among those, take the latest such to transition to held.
cDesc1: ConvDesc ← convs1.first;
IF cDesc1 = cDesc THEN LOOP; -- don't make evergreen connections
See above pSit reftab garbage code if you reactive this.
IF cDesc1.situation.self.state # $inactive OR cDesc1.previousSituation.self.state # $active OR ConvPriority[cDesc1] >= 500 THEN LOOP;
IF bestCDesc = NIL OR ConvPriority[cDesc1] > ConvPriority[bestCDesc] OR (ConvPriority[cDesc1] = ConvPriority[bestCDesc]AND BasicTime.Period[from: bestCDesc.previousSituation.time, to: cDesc1.previousSituation.time] > 0)
THEN bestCDesc ← cDesc1;
ENDLOOP;
IF bestCDesc#NIL THEN [] ← HangItUp[cDesc: bestCDesc, action: $blue]; -- reactivate some background call.
};
ENDCASE => NULL; -- no special action
UpdateConvLog[ cDesc: cDesc, logEntry: s.RopeFromROS[] ];
IF state <= Thrush.notReallyInConv THEN {
IF NOT cDesc.reportComplete THEN ShowIncompleteCall[cDesc]; -- only do this once
cDesc.reportComplete ¬ TRUE;
};
};
CallerAndOrCallee: PROC [cDesc: ConvDesc, showVisitor: BOOL¬TRUE]
RETURNS [who: ROPE¬""] = {
Use empty string rather than NIL ROPE to prevent Viewers from using Viewer name as a backup for a NIL label.
pInfo: ThParty.PartyInfo ¬ cDesc.partyInfo;
isMeeting: BOOL;
IF cDesc.numParties<2 OR pInfo=NIL THEN RETURN;
who ¬ IF ~(isMeeting ¬ pInfo.conversationInfo.convType = $meeting) THEN
SELECT pInfo.ixOriginator FROM
pInfo.ixSelf => Rope.Concat[ "to ", RepairIntelnet[DescribeParty[cDesc, TRUE]]],
ThParty.nullIx => Rope.Concat["to/from ", RepairIntelnet[DescribeParty[cDesc, TRUE]]],
ENDCASE =>
IF ~Rope.Equal[pInfo[pInfo.ixSelf].intendedName, pInfo[pInfo.ixSelf].name] THEN (
IF showVisitor THEN
Rope.Cat["to visitor: ", RepairIntelnet[DescribeParty[cDesc, TRUE, $self]],
" from ", RepairIntelnet[DescribeParty[cDesc, TRUE, $originator]]]
ELSE Rope.Concat["to visitor from ",
RepairIntelnet[DescribeParty[cDesc, TRUE, $originator]]]
)
ELSE Rope.Concat["from ", RepairIntelnet[DescribeParty[cDesc, TRUE, $originator]] ]
ELSE SELECT pInfo.ixModerator FROM
pInfo.ixSelf => "Transmitting meeting",
ENDCASE => Rope.Concat["with: ", RepairIntelnet[DescribeParty[cDesc, TRUE, $moderator]]];
IF isMeeting THEN who ¬ Rope.Concat[who, " (meeting)"]
ELSE IF cDesc.numParties > 2 THEN who ¬ Rope.Concat[who, " (conference)"];
};
CallStatus: PROC [cDesc: ConvDesc] RETURNS [status: ROPE] = {
state: Thrush.StateInConv ¬ cDesc.situation.self.state;
IF state <= Thrush.notReallyInConv THEN {
status ¬ SELECT TRUE FROM
state=$failed AND cDesc.situation.reason=$busy => "busy",
state#$idle => "failed",
cDesc.ultimateState>ringing => printLabel[$idle], -- state=idle
ENDCASE => "abandoned"; -- state=idle
}
ELSE status ¬ printLabel[state];
};
CallDuration: PROC [cDesc: ConvDesc] RETURNS [duration: ROPE] = {
s: IO.STREAM ¬ IO.ROS[];
s.PutF1["%r", int[MAX[0, BasicTime.Period[ cDesc.startTime, BasicTime.Now[] ]]] ];
duration ¬ s.RopeFromROS[];
};
ConvPriority: PROC[cDesc: ConvDesc] RETURNS [priority: INT] = {
pInfo: ThParty.PartyInfo;
priorityRope: ROPE;
IF cDesc=NIL THEN RETURN[500]; -- standard priority; don't take chances.
pInfo ¬ cDesc.partyInfo;
IF pInfo=NIL THEN RETURN[500];
priorityRope ¬
FinchSmarts.FetchAttribute[pInfo[pInfo.ixSelf].partyAttributes, $Priority, "500"].value;
priority ¬ Convert.IntFromRope[priorityRope];
};
ReportRequestState: PROC[cDesc: ConvDesc, actionReport: Thrush.ActionReport, actionRequest: REF] RETURNS[betterActionRequest: REF] = {
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. .
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 AND actionRequest # NIL THEN {
spoken: Rope.ROPE =
Rope.Substr[base: NARROW[actionRequest, Synthesizer.SynthSpec].textToSpeak, len: speakTextFeedbackLen];
Status["Finished speaking \"", spoken, "...\""];
};
ENDCASE;
};
Describe the other party.
DescribeParty: PROC[
cDesc: ConvDesc,
indicateUnauthenticated: BOOL¬FALSE,
which: Which ¬ $other]
RETURNS [otherParty: ROPE¬NIL] = {
ix: NAT¬ThParty.nullIx;
pInfo: ThParty.PartyInfo ¬ cDesc.partyInfo;
IF pInfo#NIL THEN ix ¬ SELECT which FROM
$self => pInfo.ixSelf, $other => pInfo.ixOther, $originator => pInfo.ixOriginator,
$moderator => pInfo.ixModerator, ENDCASE=>ix;
otherParty ¬ IF ix=ThParty.nullIx THEN "..unknown" ELSE pInfo[ix].intendedName;
IF indicateUnauthenticated AND (ix=ThParty.nullIx OR
pInfo[ix].type=$telephone) THEN otherParty ¬ otherParty.Concat["?"];
};
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.
SetContents: PROC[v: ViewerClasses.Viewer, cDesc: ConvDesc, which: Which] = {
ViewerTools.SetContents[v, SimplifyName[cDesc, which], TRUE];
cDesc.originatorRecorded ¬ TRUE;
};
SimplifyName: PROC [cDesc: ConvDesc, which: Which] RETURNS [name: ROPE] = {
i: INT;
name ¬ RepairIntelnet[DescribeParty[cDesc, FALSE, which]];
i ¬ name.Find["(", 0, FALSE];
IF name=NIL OR name.Length[]=0 THEN RETURN;
IF i>0 THEN name ¬ name.Substr[len: i-1];
};
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.
There may also be "#" codes embedded in the number, to serve as "enter" commands. Remove those, as well.
RepairIntelnet: PROC[num: ROPE] RETURNS[number: ROPE] = {
i: INT¬-1;
pause: BOOL¬FALSE;
M: Rope.ActionType={i¬i+1; pause ¬ c<'\040; RETURN[pause OR c='#]};
number ¬ num;
WHILE number.Map[0, number.Length[], M] DO
len: INT¬ IF pause THEN 2 ELSE 1;
repl: ROPE ¬ IF pause THEN "*" ELSE "";
number ¬ Rope.Replace[base: number, start: i, len: len, with: repl];
i¬-1;
ENDLOOP;
};
Viewer Construction and Management
Finch Viewer
lineHeight: INT ¬ 12;
tsHeight: INT ¬ 3*lineHeight;
convHeight: INT ¬ 5*lineHeight;
convStyle: ROPE ¬ "BeginStyle (Cedar) AttachStyle (basicConv) \"common defs for conversation log entries\" { default 160 bp restIndent clearTabStops 65 bp flushLeft tabStop 140 bp flushLeft tabStop 205 bp flushLeft tabStop 260 bp flushLeft tabStop 475 bp flushLeft tabStop } StyleRule EndStyle";
basicConvFormat: ROPE ¬ "basicConv";
MakeFinchTool: PROC = BEGIN
finchWidth: INTEGER;
dif, wH: INTEGER;
bt: Viewer;
h: FinchTool.Handle;
v: Viewer;
initialIconic: BOOL ¬ UserProfile.Boolean["Finch.InitialIconic", TRUE];
s: IO.STREAM;
initialButton: TiogaButtons.TiogaButton;
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 7.0",  -- name displayed in the caption
label: "",      -- label displayed in the icon
icon: fadedIcon,
iconic: initialIconic,  -- whether 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];
h.scrollEvent ¬ ViewerEvents.RegisterEventProc[
proc: ScrollConvsOnOpen, event: open, filter: v, before: FALSE];
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];
Check how much space is left (if any) in the control window for a typescript.
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 ¬ TiogaButtons.CreateViewer[
info: [wy: bt.wy + 2, ww: v.ww,
wh: convHeight, parent: v, border: FALSE] ];
TiogaButtons.SetStyleFromRope[h.conversations, convStyle];
Containers.ChildXBound[v, h.conversations];
Containers.ChildYBound[v, h.conversations];
s ¬ CallLogGenerate[];
IF s#NIL THEN WHILE TRUE DO
end: BOOL;
entry: Rope.ROPE;
[entry, end] ¬ CallLogRead[s];
IF end THEN EXIT;
IF entry=NIL THEN LOOP;
initialButton ¬ TiogaButtons.CreateButton[viewer: h.conversations, rope: entry, format: basicConvFormat, looks: NIL, proc: ConversationMgmtProc, clientData: NIL, fork: TRUE
! TiogaButtons.WrongViewerClass => EXIT];
ENDLOOP;
CallLogOpen[h];
IF initialButton#NIL THEN ViewerOps.AddProp[h.conversations, $lastButton, initialButton];
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[];
UserProfile.CallWhenProfileChanges[CollectUserProfileInfo];
END;
MakeMenus: PROC = {
Finch Tool Viewer
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, "Comment", MakeCommentator];
commentEntry ¬ Menus.FindEntry[finchMenu, "Comment"];
endCommentEntry ¬ Menus.CreateEntry["EndComment", MakeListener];
MakeOneMenu[finchMenu, "Drop Out", ButtonStopFinch];
Removed for now; use "Unfinch". Should be replaced by toggle that also serves
to indicate current enabled/connected state.
};
MakeFinchToolCmd: Commander.CommandProc = {
ENABLE UNWIND => cmdHandle ¬ NIL;
cmdHandle ¬ cmd;
MakeFinchTool[];
cmdHandle ¬ NIL;
};
Finch Icon
UpdateIconE: ENTRY PROC[handle: FinchTool.Handle] = {
UpdateIcon[handle]; };
UpdateIcon: INTERNAL PROC [handle: FinchTool.Handle] = {
Find the "most-active" cDesc
A nit: $inactive > $active, but must rank below all other real states.
CollatedState: PROC[state: Thrush.StateInConv] RETURNS [cs: NAT] = INLINE {
RETURN[IF state=$inactive THEN ORD[Thrush.StateInConv.failed]*2+1
ELSE ORD[state]*2]; };
state: Thrush.StateInConv ¬ $idle;
cs: NAT ¬ CollatedState[state];
cDesc: ConvDesc ¬ NIL;
conversations: LIST OF ConvDesc ¬ FinchSmarts.CurrentConversations[];
IF handle=NIL THEN RETURN;
FOR cDL: LIST OF ConvDesc ¬ conversations, cDL.rest WHILE cDL#NIL DO
cState: Thrush.StateInConv ¬ cDL.first.situation.self.state;
IF CollatedState[cState] >= cs THEN { cDesc ¬ cDL.first; state ¬ cState; };
ENDLOOP;
IF state=ringing THEN { -- start twiddling if haven't already
handle.outer.label ¬ CallerAndOrCallee[cDesc: cDesc, showVisitor: FALSE];
IF handle.keepTwiddling THEN RETURN;
handle.keepTwiddling ¬ TRUE;
TRUSTED {Process.Detach[ FORK TwiddleFinchIcon[handle, cDesc] ]}
}
ELSE {
IF handle.keepTwiddling THEN {
handle.keepTwiddling ¬ FALSE; NOTIFY handle.twiddleWait; };
PaintFinchIcon[handle, cDesc];
};
};
TwiddleFinchIcon: ENTRY PROC [handle: FinchTool.Handle, cDesc: ConvDesc] = {
ENABLE UNWIND => NULL;
MsPause: INTERNAL PROC [ms: INT] = TRUSTED {
Process.SetTimeout[@handle.twiddleWait, Process.MsecToTicks[ms]];
WAIT handle.twiddleWait;
};
pauseReps: INT ¬ handle.pauseTimeOn/
((handle.pauseTimeTilted+handle.pauseTimeDrawFactor)*2);
WHILE handle.keepTwiddling DO
whichTwid: Icons.IconFlavor ¬ labelledRightFinchIcon;
IF ~handle.outer.iconic THEN { MsPause[250]; LOOP; };
FOR i: INT IN [0..pauseReps) WHILE handle.keepTwiddling DO
whichTwid ¬ SELECT whichTwid FROM
labelledLeftFinchIcon=>labelledRightFinchIcon, ENDCASE=>labelledLeftFinchIcon;
PaintFinchIcon[handle, cDesc, whichTwid];
MsPause[handle.pauseTimeTilted];
ENDLOOP;
PaintFinchIcon[handle, cDesc, labelledFinchIcon];
MsPause[handle.pauseTimeOff];
ENDLOOP;
};
PaintFinchIcon: INTERNAL PROC [handle: FinchTool.Handle, cDesc: ConvDesc,
whichTwid: Icons.IconFlavor ¬ labelledFinchIcon] = {
newIcon, oldIcon: Icons.IconFlavor;
newLabel, oldLabel: ROPE;
state: Thrush.StateInConv ¬ $idle;
connected, voicePath: BOOL¬TRUE; -- obtain from system state report, somehow.
IF cDesc#NIL THEN {
state ¬ cDesc.situation.self.state; voicePath ¬ TRUE; };
newIcon ¬ oldIcon ¬ handle.outer.icon;
oldLabel ¬ handle.outer.label;
newLabel ¬ "";
[,connected, voicePath] ¬ FinchSmarts.FinchIsRunning[];
IF ~connected THEN newIcon ¬ fadedIcon
ELSE SELECT state FROM
$idle => newIcon ¬ IF voicePath THEN finchIcon ELSE fadingIcon;
$reserved, $parsing => {
newIcon ¬ outgoingFinchIcon;
newLabel ¬ printLabel[state];
};
$ringing => { newLabel ¬ oldLabel; newIcon ¬ whichTwid; };
ENDCASE => {
pInfo: ThParty.PartyInfo ¬ cDesc.partyInfo;
newIcon ¬ IF pInfo#NIL AND pInfo.ixOriginator#ThParty.nullIx AND pInfo.ixOriginator#pInfo.ixSelf THEN incomingConvIcon
ELSE outgoingConvIcon;
newLabel ¬ CallerAndOrCallee[cDesc: cDesc, showVisitor: FALSE];
};
handle.outer.icon ¬ newIcon; handle.outer.label ¬ newLabel;
IF handle.outer.iconic AND (oldIcon#newIcon OR ~oldLabel.Equal[newLabel]) THEN
ViewerOps.PaintViewer[viewer: handle.outer, hint: all];
};
Conversations subviewer
UpdateConvLog: INTERNAL PROC [cDesc: ConvDesc, logEntry: ROPE¬NIL] = {
state: Thrush.StateInConv = cDesc.situation.self.state;
button: TiogaButtons.TiogaButton ¬ NARROW[cDesc.clientData];
IF button = NIL THEN
button ¬ AddConvDesc[ cViewer: finchToolHandle.conversations, cDesc: cDesc, bRope: logEntry, bFormat: basicConvFormat ]
ELSE IF ~cDesc.reportComplete THEN
RelabelTiogaButton[ button: button, newRope: logEntry ];
SelectEntryInConversations[button, state >= $failed AND state#$notified];
};
AddConvDesc: INTERNAL PROC [cViewer: Viewer, cDesc: ConvDesc, bRope: ROPE¬NIL, bFormat: ROPE¬NIL, bLooks: ROPE¬NIL]
RETURNS [newButton: TiogaButtons.TiogaButton¬NIL] = {
lastButton: TiogaButtons.TiogaButton;
IF finchToolHandle=NIL THEN RETURN;
newButton ¬ NIL;
lastButton ¬ NARROW[ViewerOps.FetchProp[finchToolHandle.conversations, $lastButton]];
IF lastButton#NIL THEN {
lastDesc: ConvDesc = NARROW[lastButton.clientData];
ViewersOps.AddProp[newButton, $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.
IF lastDesc#NIL AND lastDesc.reportComplete
AND (lastDesc.ultimateState=$reserved OR lastDesc.ultimateState=$parsing
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.)
OR SuppressMultipleOutsideRingEntries[cDesc, lastDesc]
OR SuppressServiceEntries[cDesc, lastDesc] )
THEN {
newButton ¬ lastButton;
CallLogCancel[];
};
};
IF newButton#NIL THEN {
RelabelTiogaButton[button: newButton, newRope: bRope, newLooks: bLooks];
no way to specify new format for new rope!
newButton.clientData ¬ cDesc;
}
ELSE
newButton ¬ TiogaButtons.CreateButton[viewer: cViewer, rope: bRope, format: bFormat, looks: bLooks, proc: ConversationMgmtProc, clientData: cDesc, fork: TRUE
! TiogaButtons.WrongViewerClass => GOTO FinchViewerDestroyed];
cDesc.clientData ¬ newButton;
ViewerOps.AddProp[cViewer, $lastButton, newButton];
EXITS
FinchViewerDestroyed => RETURN[NIL]; -- never mind
};
SuppressMultipleOutsideRingEntries: INTERNAL PROC [currDesc, lastDesc: ConvDesc] RETURNS [BOOL]= {
RETURN[currDesc.situation.self.state=$notified AND lastDesc.ultimateState=$notified
AND currDesc.partyInfo[currDesc.partyInfo.ixOriginator].type=$trunk
AND lastDesc.partyInfo[lastDesc.partyInfo.ixOriginator].type=$trunk
AND BasicTime.Period[from: lastDesc.startTime, to: currDesc.startTime] <= 12];
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.
};
SuppressServiceEntries: INTERNAL PROC [currDesc, lastDesc: ConvDesc]
RETURNS [BOOL¬FALSE]= {
IF lastDesc.numParties>1 AND lastDesc.partyInfo#NIL AND lastDesc.partyInfo.ixOther#ThParty.nullIx AND lastDesc.partyInfo[lastDesc.partyInfo.ixOther].type=$service THEN
desc.numParties>1 does not imply desc.partyInfo#NIL in pathological cases
SELECT finchToolHandle.logServiceCalls FROM
none => RETURN[TRUE];
one => {
This implementation has a flaw: if the user made a service call followed by a "null" call (eg pick up receiver), lastButton will be the "null" call rather than the service call, so this call will be logged. But when the log entry is actually made, it will replace the "null" call, so two service calls will appear juxtaposed.
IF currDesc.numParties>1 AND currDesc.partyInfo#NIL AND currDesc.partyInfo.ixOther#ThParty.nullIx AND currDesc.partyInfo[currDesc.partyInfo.ixOther].type=$service THEN RETURN[TRUE];
};
-- all => -- ENDCASE;
};
SelectEntryInConversations: INTERNAL PROC[entryButton: TiogaButtons.TiogaButton, doSelect: BOOL¬TRUE] = {
viewer: Viewer = IF finchToolHandle#NIL THEN finchToolHandle.conversations ELSE NIL;
prevSelected: TiogaButtons.TiogaButton = IF viewer=NIL THEN NIL
ELSE NARROW[ViewerOps.FetchProp[viewer, $selectedEntry]];
IF entryButton = NIL THEN RETURN;
IF prevSelected # NIL AND NOT IsDestroyed[prevSelected, viewer] AND
((prevSelected=entryButton) # doSelect) THEN {
TiogaButtons.ChangeButtonLooks[button: prevSelected, removeLooks: "bs"];
ViewerOps.AddProp[viewer, $selectedEntry, NIL];
};
IF IsDestroyed[entryButton, viewer] THEN
{ Report["Conversation is no longer available."]; RETURN; };
IF NOT doSelect THEN RETURN;
TiogaButtons.ChangeButtonLooks[button: entryButton, addLooks: "bs"]; -- show it's selected
do it even if prevSelected = entryButton, because we may have relabeled the previous one inbetween, which will remove looks
ViewerOps.AddProp[viewer, $selectedEntry, entryButton];
ScrollConversations[entryButton, viewer];
};
ScrollConversations: PROC [button: TiogaButtons.TiogaButton, viewer: Viewer] = {
fViewer: Viewer;
start, end: TiogaOps.Location;
level: TiogaOps.SelectionGrain;
caretBefore, pendingDelete: BOOL;
[fViewer, start, end, level, caretBefore, pendingDelete] ¬ TiogaOps.GetSelection[feedback];
TiogaOps.SetSelection[viewer: viewer, start: button.startLoc, end: button.endLoc, which: feedback];
WaitForFeedback[viewer, start, end];
TEditScrolling.AutoScroll[viewer: viewer, tryToGlitch: TRUE, toEndOfDoc: FALSE, id: feedback];
IF fViewer#NIL THEN -- restore previous feedback selection
TiogaOps.SetSelection[fViewer, start, end, level, caretBefore, pendingDelete, feedback
! TiogaOps.SelectionError => {TiogaOps.CancelSelection[feedback]; CONTINUE} ]
ELSE -- there wasn't one
TiogaOps.CancelSelection[feedback];
};
ScrollConvsOnOpen: ViewerEvents.EventProc = {
PROC [viewer: Viewer, event: ViewerEvent, before: BOOL]
RETURNS [abort: BOOL ← FALSE]
button: TiogaButtons.TiogaButton;
cViewer: Viewer = IF finchToolHandle#NIL THEN finchToolHandle.conversations
ELSE NIL;
IF cViewer=NIL THEN RETURN;
button ¬ NARROW[ViewerOps.FetchProp[cViewer, $selectedEntry]];
IF button=NIL THEN button ¬ NARROW[ViewerOps.FetchProp[cViewer, $lastButton]];
IF button#NIL THEN TRUSTED {
FORK process to avoid deadlock with column lock held by ViewerEvents.
Process.Detach[FORK ScrollConversations[button, cViewer ! ABORTED => CONTINUE]];
};
};
feedbackPause: INT ¬ 200;
WaitForFeedback: PROC [viewer: Viewer, start, end: TiogaOps.Location] ~ {
fViewer: Viewer;
fstart, fend: TiogaOps.Location;
FOR i: INT IN [1..5] DO -- wait up to one second
[fViewer, fstart, fend] ¬ TiogaOps.GetSelection[feedback];
IF fViewer=viewer AND fstart=start AND fend=end THEN EXIT;
Process.Pause[Process.MsecToTicks[feedbackPause]];
ENDLOOP;
};
IsDestroyed: PROC [button: TiogaButtons.TiogaButton, viewer: Viewer] RETURNS [BOOL] = {
RETURN [TiogaButtons.FindTiogaButton[viewer, button.startLoc] = NIL];
};
ShowIncompleteCall: INTERNAL PROC [cDesc: ConvDesc] = {
button: TiogaButtons.TiogaButton ¬ NARROW[cDesc.clientData];
logEntry: Rope.ROPE ¬ TiogaButtons.GetRope[button];
IF Rope.Find[logEntry, "completed"] = -1 THEN
TiogaButtons.ChangeButtonLooks[button: button, addLooks: "i"];
CallLogRecord[logEntry];
};
ShowRetriedCall: ENTRY PROC [cDesc: ConvDesc] = {
button: TiogaButtons.TiogaButton ¬ NARROW[cDesc.clientData];
TiogaButtons.ChangeButtonLooks[button: button, removeLooks: "i"];
};
sample conversation log entry
date  time   status   duration from/to     subject (priority)
30 Dec 86 10:39:01 am abandoned 00:00:22 Dan Swinehart (4473) Finch (urgent)
statusField: INT ¬ 23; -- index of first char of status field in conversation log entry
CallDateAndTime: PROC [cDesc: ConvDesc] RETURNS [time: ROPE] = {
gmt: BasicTime.GMT ¬ cDesc.startTime;
date: ROPE¬Rope.Replace[base: Convert.RopeFromTimeRFC822[
gmt ! BasicTime.OutOfRange => GOTO TimeOutOfRange],
start: 9, with: "\t"]; -- eg, 1 Jul 87
IF Rope.Fetch[date, 1] = IO.SP THEN date ¬ Rope.Concat[" ", Rope.Substr[base: date, len: 8]];
time ¬ Convert.RopeFromTime[from: gmt, start: $hours, end: $seconds,
includeZone: FALSE]; -- eg, 12:00:00 am
IF Rope.Fetch[time, 1] = ': THEN time ¬ Rope.Concat[" ", time];
time ¬ Rope.Concat[date, time];
EXITS TimeOutOfRange => time ¬ "*****\t*****";
};
oneSecond: CONDITION;
DurationTimer: ENTRY PROC [cDesc: ConvDesc] = {
ENABLE UNWIND => NULL;
TRUSTED { Process.SetTimeout[@oneSecond, Process.SecondsToTicks[1]]; };
DO
WAIT oneSecond;
IF cDesc=NIL OR cDesc.clientData=NIL OR cDesc.reportComplete THEN RETURN;
{button: TiogaButtons.TiogaButton ¬ NARROW[cDesc.clientData];
durationField: INT ¬ Rope.Find[TiogaButtons.GetRope[button], "\t", statusField] + 1;
RelabelTiogaButton[button: button, newRope: CallDuration[cDesc],
start: durationField, len: 8, newLooks: "bs"];
};
ENDLOOP;
};
Directory
MakeDirectory: Menus.MenuProc = {
FinchTool.BuildDirectories[];
};
Viewer and Button Utilities
RelabelTiogaButton: INTERNAL PROC [button: TiogaButtons.TiogaButton,
newRope: ROPE¬NIL,
start: INT¬0, len: INT¬INT.LAST, newLooks: ROPE¬NIL] = {
Replaces the rope from [button.startLoc.where+start..button.startLoc.where+start+len] with newRope, using the specified new looks
node, rootNode: TextNode.Ref;
newLen: INT¬0;
LockedRelabel: PROC [root: TiogaOps.Ref] = {
[resultLen: newLen] ¬ TextEdit.ReplaceByRope[root: rootNode, dest: node,
rope: newRope, start: start, len: len, looks: TextLooks.RopeToLooks[newLooks]];
};
IF button#NIL THEN {
node ¬ button.startLoc.node;
rootNode ¬ TextNode.Root[node];
IF button.startLoc.where # -1 THEN { -- button < whole node, adjust params
start ¬ button.startLoc.where + MAX[LONG[0], start];
len ¬ MIN[button.endLoc.where - start, len];
};
TiogaOps.CallWithLocks[LockedRelabel, rootNode];
IF button.startLoc.where # -1 THEN { -- button < whole node, adjust endpoint
button.endLoc.where ¬ button.endLoc.where + (newLen-len);
};
};
};
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];
};
Creates a text viewer, next right on the same line as sib
sib must be a Viewer, not NIL
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] = {
Make an h-bit wide line after sib
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];
};
Sib is sibling to create TS after
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.ChildYBound[sib.parent, ts];
Containers.ChildXBound[sib.parent, ts];
};
Call Log Management
Manage a persistent log of calls. This should be recorded and maintained by the server, but a promise is a promise and time's a wastin'.
A brief reading will indicate that many things need to be improved before this is acceptable.
DCS, October 14, 1991 4:15:11 pm PDT
Five operations are currently supported:
CallLogOpen: Opens a stream on a persistent log of calls.
CallLogRecord: Records the final value of a call log entry into a log file, flushing after itself.
CallLogCancel: Records a characteristic sequence ("←<newline>") into the log, which will cause the previous entry to be ignored when the log is later replayed.
CallLogCancel: Returns a stream for reading the log.
CallLogRead[stream]: Returns a line from the log, or NIL for EOF;
CallLogOpen: PROC [h: FinchTool.Handle] ~ {
callLogFileName: Rope.ROPE ¬ UserProfile.Token[
key: "Finch.CallLogFileName" , default: defaultCallLogFileName];
h.callLog ¬ FS.StreamOpen[fileName: callLogFileName, accessOptions: $append];
};
CallLogRecord: PROC[entry: Rope.ROPE] ~ {
tempOpen: BOOL¬FALSE;
IF entry=NIL OR entry.Length[]=0 THEN RETURN;
finchToolHandle.callLog.Flush[!IO.EndOfStream => {
tempOpen ¬ TRUE; CallLogOpen[finchToolHandle]; CONTINUE; }];
finchToolHandle.callLog.PutRope[entry];
finchToolHandle.callLog.PutChar['\n];
finchToolHandle.callLog.Flush[];
IF tempOpen THEN finchToolHandle.callLog.Close[];
};
CallLogCancel: PROC ~ {
finchToolHandle.callLog.PutRope["←\n"];
finchToolHandle.callLog.Flush[];
};
CallLogGenerate: PROC RETURNS [s: IO.STREAM] ~ {
callLogFileName: Rope.ROPE ¬ UserProfile.Token[
key: "Finch.CallLogFileName" , default: defaultCallLogFileName];
s ¬ FS.StreamOpen[fileName: callLogFileName!
FS.Error => IF error.group=$user THEN {s¬NIL; CONTINUE; }];
};
CallLogRead: PROC[s: IO.STREAM] RETURNS [entry: Rope.ROPE, end: BOOL¬FALSE] ~ {
entry ¬ s.GetLineRope[!IO.EndOfStream => {end¬TRUE; entry ¬ NIL; CONTINUE; }];
IF NOT end THEN {
c: CHAR ¬ 'a;
c ¬ s.PeekChar[!IO.EndOfStream => CONTINUE];
IF c='← THEN {
[] ¬ s.GetLineRope[];
[entry, end] ¬ CallLogRead[s];
};
};
};
Reporting and Logging
Report: PUBLIC PROC[msg: ROPE, a1, a2, a3: IO.Value ¬ [null[]]] = {
VoiceUtils.ReportFR[where: $Finch, remark: msg, a1: a1, a2: a2, a3: a3];
};
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];
};
FinchOnlyWhereProc: VoiceUtils.WhereProc = {
RETURN[IF finchToolHandle=NIL THEN NIL ELSE finchToolHandle.tsOut];
};
ViewCmd: Commander.CommandProc = TRUSTED {
Nice.View[finchToolHandle, "FinchTool PD"];
};
CollectUserProfileInfo: UserProfile.ProfileChangedProc = {
logServiceCalls: ROPE ¬ UserProfile.Token["Finch.LogServiceCalls", "all"];
IF finchToolHandle=NIL THEN RETURN;
finchToolHandle.logServiceCalls ¬
SELECT TRUE FROM
Rope.Equal[s1: logServiceCalls, s2: "none", case: FALSE] => $none,
Rope.Equal[s1: logServiceCalls, s2: "one", case: FALSE] => $one,
ENDCASE => $all;
IF reason # $newUser OR
FinchSmarts.CurrentRName[].Equal[VoiceUtils.CurrentRName[], FALSE] OR
~FinchSmarts.FinchIsRunning[].finchIsEnabled THEN RETURN;
ViewerOps.DestroyViewer[finchToolHandle.outer]; -- Clean sweep!
StartFinch[]; -- Like now
};
doAnnounce: BOOL ¬ TRUE; -- belongs in finchToolHandle
AnnounceOnCmd: Commander.CommandProc = TRUSTED {
doAnnounce ¬ TRUE;
};
AnnounceOffCmd: Commander.CommandProc = TRUSTED {
doAnnounce ¬ FALSE;
};
Registration, Initialization
finchIcon ¬ Icons.NewIconFromFile["Finch.icons", 0!ANY=>CONTINUE];
leftFinchIcon ¬ Icons.NewIconFromFile["Finch.icons", 1!ANY=>CONTINUE];
rightFinchIcon ¬ Icons.NewIconFromFile["Finch.icons", 2!ANY=>CONTINUE];
labelledFinchIcon ¬ Icons.NewIconFromFile["Finch.icons", 3!ANY=>CONTINUE];
labelledLeftFinchIcon ¬ Icons.NewIconFromFile["Finch.icons", 4!ANY=>CONTINUE];
labelledRightFinchIcon ¬ Icons.NewIconFromFile["Finch.icons", 5!ANY=>CONTINUE];
outgoingFinchIcon ¬ Icons.NewIconFromFile["Finch.icons", 6!ANY=>CONTINUE];
outgoingConvIcon ¬ Icons.NewIconFromFile["Finch.icons", 9!ANY=>CONTINUE];
incomingConvIcon ¬ Icons.NewIconFromFile["Finch.icons", 10!ANY=>CONTINUE];
fadedIcon ¬ Icons.NewIconFromFile["Finch.icons", 26!ANY=>CONTINUE];
fadingIcon ¬ Icons.NewIconFromFile["Finch.icons", 13!ANY=>CONTINUE];
Register a command with the UserExec that will create an instance of this tool
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["Answer", AnswerCmd, "Answer current conversation"];
Commander.Register["HangUp", HangUpCmd, "Hang up current conversation"];
Commander.Register["SpeakText", SpeakTextCmd, "Utter the remainder of the command"];
Commander.Register["StopSpeech", StopSpeakingCmd, "Stop speaking"];
Commander.Register["Feep", FeepCmd, "Issue touch-tones"];
Commander.Register["Visit", VisitCmd, "Identify an office visitor (by RName)"];
Commander.Register["Unvisit", UnvisitCmd, "Cancel visiting for specified visitor (by RName) or self"];
Commander.Register["TDir", TDirCmd, "Create telephone directory for named file"];
Commander.Register["Join", JoinCmd, "Join an ongoing conversation by name"];
VoiceUtils.RegisterWhereToReport[proc: FinchWhereProc, where: $System];
VoiceUtils.RegisterWhereToReport[proc: FinchWhereProc, where: $Finch];
VoiceUtils.RegisterWhereToReport[proc: FinchOnlyWhereProc, where: $FinchOnly];
printLabel[$active] ¬ "active";
printLabel[$idle] ¬ "completed";
printLabel[$inactive] ¬ "on hold";
printLabel[$ringing] ¬ "ringing";
printLabel[$notified] ¬ " ";
printLabel[$initiating] ¬ " ";
printLabel[$ringback] ¬ "ringing";
printLabel[$reserved] ¬ "Telephone is off hook";
printLabel[$parsing] ¬ "Call is being dialed";
Commander.Register["AnnounceOn", AnnounceOnCmd,
"Allow announcement calls."];
Commander.Register["AnnounceOff", AnnounceOffCmd,
"Disallow announcement calls."];
Debugging nonsense
Commander.Register["VuFinchTool", ViewCmd,
"Program Management variables for FinchTool"];
}.
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.
Polle Zellweger (PTZ) February 9, 1987 6:27:46 pm PST
changes to: FeepMap, VisitCmd, Commander, Commander
Polle Zellweger (PTZ) February 19, 1987 10:29:47 pm PST
changes to: VisitCmd, DIRECTORY
Polle Zellweger (PTZ) February 20, 1987 6:19:47 pm PST
changes to: VisitCmd
Polle Zellweger (PTZ) February 23, 1987 2:15:31 pm PST
changes to: StartFinch
Polle Zellweger (PTZ) February 25, 1987 5:08:58 pm PST
changes to: UnvisitCmd
Polle Zellweger (PTZ) February 26, 1987 11:30:32 am PST
changes to: Commander, VoiceUtils, DIRECTORY
Polle Zellweger (PTZ) February 27, 1987 2:35:40 pm PST
changes to: DIRECTORY, VisitCmd
Polle Zellweger (PTZ) July 27, 1987 11:24:07 pm PDT
Better party identification in ReportConversationState.
changes to: ReportConversationState, OtherParty, SetContents, DIRECTORY, serverInstance, us, unknown, PaintFinchIcon
Polle Zellweger (PTZ) July 28, 1987 8:34:12 pm PDT
Replace buttons with TiogaButtons in conversation log; no new functionality.
changes to: DIRECTORY, FinchToolImpl, PhoneProc, GetSelectedDesc, AddConvDesc, ConversationMgmtProc, HangupCProc, AnswerCProc, RedialOfficeCProc, RedialHomeCProc, Hangup, HangItUp, ReportConversationState, convStyle, basicConvFormat, MakeFinchTool, MakeMenus, RelabelTiogaButton, LockedRelabel (local of RelabelTiogaButton), SetOpenHeight, finchMenu, SelectEntryInConversations, IsDestroyed
Polle Zellweger (PTZ) July 30, 1987 3:00:51 pm PDT
Add ability to Redial from TiogaButtons in conversation log.
changes to: RedialOfficeCProc, RedialHomeCProc, RedialIt, Answer, AnswerCProc, AnswerIt, HangupCProc, HangItUp, ConversationMgmtProc, SetContents, SimplifyName
Polle Zellweger (PTZ) July 31, 1987 11:36:39 pm PDT
Changed format of conversation log entries; added process to increment call duration field while active.
changes to: FinchToolImpl, PhoneHomeCmd, RedialIt, UnfinchOnDestroy, CheckActive, ReportConversationState, RepairIntelnet, RelabelTiogaButton, LockedRelabel (local of RelabelTiogaButton), VoiceUtils, printLabel, IsDestroyed, CallDateAndTime, DurationTimer, DIRECTORY, CallStatus, CallDuration, ReportRequestState, convStyle, printLabel, printLabel, printLabel, printLabel, printLabel, SelectEntryInConversations, ReportConversationState, SimplifyName
Polle Zellweger (PTZ) August 3, 1987 6:52:36 pm PDT
Bug fixes re conv log reports; new icons (larger labels)
changes to: ReportConversationState, CallStatus, AddConvDesc, RelabelTiogaButton, LockedRelabel (local of RelabelTiogaButton), DurationTimer, PaintFinchIcon, labelledFinchIcon, labelledLeftFinchIcon, labelledRightFinchIcon, outgoingConvIcon, incomingConvIcon
Polle Zellweger (PTZ) August 4, 1987 4:44:02 pm PDT
More bug fixes re conv log reports
changes to: ReportConversationState, CallerAndOrCallee, CallStatus, PaintFinchIcon
Polle Zellweger (PTZ) August 7, 1987 3:37:15 pm PDT
Improve reporting of names; change monitor structure to fix race condition between conv log entries and duration timer; fix icon mgmt for notified calls
changes to: ReportConversationState, CallerAndOrCallee, PaintFinchIcon, AddConvDesc, SelectEntryInConversations, DurationTimer, RelabelTiogaButton, oneSecond, PaintFinchIcon, TwiddleFinchIcon
Polle Zellweger (PTZ) August 11, 1987 2:41:54 pm PDT
Inhibit redialing from conv log buttons if any call is in progress (like Directory buttons); add outgoingFinchIcon for reserved or parsing states; partition ReportConversationState so that it fits in one screen.
changes to: RedialIt, ReportConversationState, CallerAndOrCallee, MakeFinchTool, PaintFinchIcon, DurationTimer
new: outgoingFinchIcon, UpdateIcon, UpdateConvLog
Polle Zellweger (PTZ) August 13, 1987 3:59:35 pm PDT
Fix bug in reporting of Intelnet numbers in conv log; add logServiceCalls UserProfile option to allow user to control logging of service calls.
changes to: DIRECTORY, ReportConversationState, ReportRequestState, RepairIntelnet, MakeFinchTool, UpdateIcon, CheckUserLogOptions, UpdateConvLog, ViewCmd, CollectUserProfileInfo, UserProfile, VoiceUtils, Commander, initialization
Polle Zellweger (PTZ) August 14, 1987 5:36:19 pm PDT
changes to: CheckUserLogOptions, CollectUserProfileInfo, ReportConversationState, MakeFinchTool, AddConvDesc, SuppressServiceEntries, SuppressMultipleOutsideRingEntries, SelectEntryInConversations
Polle Zellweger (PTZ) August 17, 1987 11:19:54 am PDT
changes to: PaintFinchIcon
Polle Zellweger (PTZ) September 14, 1987 10:07:17 pm PDT
DCS changes in the meantime: totally grey icon for disconnected Finch; grey handset icon for disconnected Lark.
PTZ changes: fix bug in setting italic looks on conv log entries when another call is in progress; add feature to remove italic looks when conv log entry is used to retry call.
changes to: RedialOfficeCProc, RedialHomeCProc, ReportConversationState, UpdateConvLog, SelectEntryInConversations, ShowRetriedCall, RelabelTiogaButton
Polle Zellweger (PTZ) September 14, 1987 10:31:18 pm PDT
changes to: SelectEntryInConversations
Polle Zellweger (PTZ) September 16, 1987 12:04:15 pm PDT
Change STOP! command to StopSpeech.
changes to: Commander
Polle Zellweger (PTZ) September 18, 1987 2:47:44 pm PDT
Fix bug in icon painting: icon & label fields not set if Finch not iconic.
changes to: PaintFinchIcon
Polle Zellweger (PTZ) October 29, 1987 2:32:37 pm PST
Catch BasicTimeImpl.OutOfRange in case Thrush sends a bogus convDesc; also make sure conversation logging can handle bogus convDescs & missing Finch viewer.
changes to: CallDateAndTime, DIRECTORY, SelectEntryInConversations
Swinehart, February 16, 1988 11:11:24 pm PST
Change to use new PartyInfo indexing scheme. Generally improves things.
changes to: finchEnabledAtCheckpoint, Which, RedialIt, ReportConversationState, CallerAndOrCallee, DescribeParty, SetContents, SimplifyName, PaintFinchIcon, SuppressMultipleOutsideRingEntries, SuppressServiceEntries
Polle Zellweger (PTZ) February 28, 1988 12:07:39 pm PST
Add Comment|EndComment toggle menu button for meeting commentator.
changes to: DIRECTORY, listenEntry, commentEntry, MakeListener, MakeCommentator, MakeMenus
Swinehart, December 1988
Improve interaction between working directories and TDir command.
Polle Zellweger (PTZ) January 13, 1989 6:04:19 pm PST
Fix AddressFault in ReportRequestState if request=NIL; scroll conv log to view current conv (requested by Pavel); add Answer command (requested by Pier); catch TiogaButtons error if user destroys Finch viewer as a call is coming in.
changes to: DIRECTORY, FinchToolImpl, AnswerCmd, ReportRequestState, MakeFinchTool, AddConvDesc, SelectEntryInConversations, ScrollConversations, ScrollConvsOnOpen, initialization
Polle Zellweger (PTZ) March 25, 1989 2:34:54 pm PST
Answer automatically if subject=Announcement and no higher-priority call is active.
changes to: ReportConversationState
Polle Zellweger (PTZ) March 29, 1989 11:13:43 pm PST
Creature comforts for above, but without changing interfaces.
changes to: ReportConversationState, doAnnounce, AnnounceOnCmd, AnnounceOffCmd
Polle Zellweger (PTZ) June 9, 1989 4:33:53 pm PDT
Trying to fix Finch conversation lockups. Change to use TeditScrolling.AutoScroll
changes to: DIRECTORY, ScrollConversations
Polle Zellweger (PTZ) June 13, 1989 11:40:41 am PDT
Also wait for feedback selection to be made.
changes to: DIRECTORY, ScrollConversations, feedbackPause, WaitForFeedback
Polle Zellweger (PTZ) June 26, 1989 10:49:16 am PDT
FORK process from ScrollConvsOnOpen, so column lock held by Viewers will be released. Also remove scroll event registration on UnFinch.
changes to: UnfinchOnDestroy, MakeFinchTool, ScrollConversations, ScrollConvsOnOpen, ScrollConvsOnOpen
Swinehart, September 8, 1990 5:46:38 pm PDT
Added previousSituation field to FinchSmarts; remove hack.
Swinehart, May 22, 1992 5:04:41 pm PDT
Add Polle Zellweger's fix to SuppressServiceEntries -- more tests to avoid NIL-faults and the like.