-- ChatImpl.mesa
-- Stolen from Laurel Chat.mesa
-- Larry Stewart, April 6, 1983 6:43 pm
-- Warren Teitelman, November 3, 1982 5:53 pm
-- Last Edited by: Maxwell, January 25, 1983 3:09 pm

DIRECTORY
	Ascii USING [LF],
	Commander USING [CommandProc, Register],
	 ConvertUnsafe USING [AppendRope],
	 FileIO USING [Open, OpenFailed],
	 Inline USING [BITAND],
	 IO,
	 List USING [Length, Remove],
	 Menus USING [AppendMenuEntry, CreateEntry, FindEntry, MenuEntry, MenuProc, ReplaceMenuEntry],
	 PupDefs USING [PupAddress, PupPackageMake, PupPackageDestroy],
	 PupStream USING [GetPupAddress, PupByteStreamCreate, PupNameTrouble, SecondsToTocks, StreamClosing],
	 PupTypes USING [telnetSoc],
	 Rope USING [Cat, Fetch, Find, Length, ROPE, Substr],
	 Runtime USING [BoundsFault, GetBcdTime],
	 Stream USING [CompletionCode, GetBlock, Handle, InputOptions, PutByte, PutChar, SendNow, SetInputOptions, SetSST, SubSequenceType, TimeOut],
	 TiogaOps USING [GetCaret, GetRope, Location],
	 TIPUser USING [InstantiateNewTIPTable, RegisterTIPPredicate, TIPPredicate, TIPTable],
	 TypeScript USING [ChangeLooks, Create, InsertCharAtFrontOfBuffer, TS],
	 UECP USING [Argv, Parse],
	 UserCredentials USING [GetUserCredentials],
	 ViewerClasses,
	 ViewerEvents USING [EventProc, EventRegistration, RegisterEventProc, UnRegisterEventProc],
	 ViewerIO USING [CreateViewerStreams],
	 ViewerOps USING [AddProp, DestroyViewer, FetchProp, PaintViewer],
	 ViewerTools USING [GetSelectedViewer, GetSelectionContents, SetSelection];

ChatImpl: CEDAR MONITOR LOCKS h.LOCK USING h: Handle
IMPORTS Commander, ConvertUnsafe, FileIO, Inline, IO, List, Menus, PupDefs, PupStream,
	Rope, Runtime, Stream, TiogaOps, TIPUser,
	TypeScript, UECP, UserCredentials,
	ViewerEvents, ViewerIO, ViewerOps, ViewerTools
SHARES Menus, ViewerClasses =
BEGIN

Handle: TYPE = REF ChatInstanceRecord;
State: TYPE = {idle, starting, running, closing, destroy};

DisconnectChar: CHAR = 220C;
AbortChar: CHAR = 221C;
ConnectChar: CHAR = 222C;
LoginChar: CHAR = 223C;
RemoteCloseChar: CHAR = 224C;
setLineWidth: Stream.SubSequenceType = 2;
setPageLength: Stream.SubSequenceType = 3;
timingMark: Stream.SubSequenceType = 5;
timingMarkReply: Stream.SubSequenceType = 6;

ChatInstanceRecord: TYPE = MONITORED RECORD [
	ts: TypeScript.TS,	-- the primary typescript
	state: State _ idle,
	lorc: CHAR _ 'c,
	logFileName: Rope.ROPE,
	logStream: IO.STREAM,
	keyFile: Rope.ROPE,
	argv: UECP.Argv,
	pleaseStop: BOOL _ FALSE,
	uToSStopped: BOOL _ FALSE,
	sToUStopped: BOOL _ FALSE,
	inDestroy: BOOL _ FALSE,
	serverToUserProcess: PROCESS,
	userToServerProcess: PROCESS,
	serverName: Rope.ROPE _ "Ivy",
	useOldHost: BOOL _ FALSE,
	keyStream: IO.STREAM,
	destroyOnClose: BOOL _ FALSE,
	setSelection: BOOL _ FALSE,
	in: IO.STREAM,
	origOut: IO.STREAM,
	out: IO.STREAM,
	tipTable: TIPUser.TIPTable,
	serverStream: Stream.Handle _ NIL,
	oldSplit: Menus.MenuEntry _ NIL
	];

logFileNumber: INT _ 0;
chatInstanceList: LIST OF REF ANY _ NIL;
destroyEvent: ViewerEvents.EventRegistration _ NIL;
closeEvent: ViewerEvents.EventRegistration _ NIL;

-- This procedure is FORKed by the UserToServer process at the time a
-- connection is opened.  It is JOINED whenever the connection is closed.
-- It also goes away if the Chat viewer is destroyed.

ServerToUser: PROC [h: Handle] = TRUSTED {{
	buffer: STRING _ [400];
	why: Stream.CompletionCode;
	mySST: Stream.SubSequenceType;
	DO
		ENABLE {
			ABORTED => GOTO Cleanup;
			PupStream.StreamClosing => {
				IF NOT h.pleaseStop THEN TypeScript.InsertCharAtFrontOfBuffer[ts: h.ts, char: RemoteCloseChar];
				GOTO Cleanup;
				};
			IO.Error => GOTO Cleanup;
			};
		buffer.length _ 0;
		[buffer.length, why, mySST] _ Stream.GetBlock[h.serverStream, [@buffer.text, 0, buffer.maxlength] ! Stream.TimeOut => {
			IF h.pleaseStop OR h.state # running THEN GOTO Cleanup
			ELSE RESUME;
			}];
		IF h.pleaseStop OR h.state # running THEN GOTO Cleanup;
		IF h.out.UserAbort[] THEN ERROR;
		FOR i: NAT IN [0.. buffer.length) DO
			IF buffer[i]#Ascii.LF THEN h.out.PutChar[Inline.BITAND[buffer[i], 177B]];
			ENDLOOP;
		IF why = sstChange AND mySST = timingMark
			THEN Stream.SetSST[h.serverStream, timingMarkReply];
		ENDLOOP;
	EXITS
	Cleanup => h.sToUStopped _ TRUE;
	};
	};

InitialNegotiations: PROC [h: Handle] = TRUSTED {
	Stream.SetSST[h.serverStream, setLineWidth]; 
	Stream.PutByte[h.serverStream, 0];
	--Stream.SetSST[h.serverStream, setPageLength]; 
	--Stream.PutByte[h.serverStream, 255];	kludge to minimize BELLS from Juniper
	IF h.lorc='l OR h.lorc='x THEN {
		name, password: Rope.ROPE;
		[name: name, password: password] _ UserCredentials.GetUserCredentials[];
		SendStringToServer[h, "Login "];
		SendStringToServer[h, name];
		IF h.lorc='l AND Rope.Find[s1: name, s2: "."] = -1 THEN {
			SendStringToServer[h, ".PA"];
			};
		SendStringToServer[h, " "];
		SendStringToServer[h, password];
		SendStringToServer[h, " \n"];
		};
	};

	SendStringToServer: PROC[h: Handle, s: Rope.ROPE] = TRUSTED {
		FOR i: INT IN [0 .. s.Length[]) DO
			Stream.PutChar[h.serverStream, s.Fetch[i]];
			ENDLOOP;
		Stream.SendNow[h.serverStream];
		};

	FinishStringWithErrorMsg: PROC [h: Handle, errorMsg: STRING] = {
		IF errorMsg # NIL THEN h.out.PutF[":	%s.\n", IO.string[errorMsg]]
		ELSE h.out.PutF[".\n"];
		};

-- UserAbort is active because Chat.TIP is not activated until h.state = running (due to
-- the TIP predicate), so control-DEL sets UserAbort.
-- However, while in this routine, UserAbort is used only to stop taking characters from
-- the keyStream, not to close the connection.  If the user types control-DEL here, she
-- will have to type it again to really close the connection.

	FromKeys: PROC [h: Handle] = TRUSTED {
		count: NAT _ 0;
		{
		WHILE h.keyStream # NIL AND ~h.keyStream.EndOf[] DO
			IF h.in.UserAbort[] OR h.pleaseStop OR h.state # starting THEN GOTO CloseKeyStream;
			Stream.PutChar[h.serverStream, h.keyStream.GetChar[]];
			count _ count + 1;
			IF count >= 50 THEN {
				Stream.SendNow[h.serverStream];
				count _ 0;
				};
			ENDLOOP;
		GOTO CloseKeyStream;
		EXITS
		CloseKeyStream => {
			IF h.in.UserAbort[] THEN h.in.ResetUserAbort[];
			IF h.keyStream # NIL THEN{
				h.keyStream.Close[];
				h.keyStream _ NIL;
				};
			IF count # 0 THEN Stream.SendNow[h.serverStream];
			};
		};
		};
	
	StartUp: PROC [h: Handle] = {{
		ENABLE UNWIND => h.state _ idle;
		h.state _ starting;
		IF NOT h.useOldHost OR h.serverName.Length[] = 0 THEN h.serverName _ FindHostName[h];
		h.useOldHost _ FALSE;
		h.pleaseStop _ FALSE;
		h.sToUStopped _ FALSE;
		h.uToSStopped _ FALSE;
		IF h.setSelection THEN ViewerTools.SetSelection[h.ts, NIL];
		h.setSelection _ FALSE;
		h.in.ResetUserAbort[];
		h.out.PutF["\nViewers Chat of %t.\n", IO.time[Runtime.GetBcdTime[]]];
		IF h.logStream # NIL THEN h.out.PutF["Log file: %g\n", IO.rope[h.logFileName]]
		ELSE h.out.PutF["No log file.\n"];
		OpenConnection[h];
		IF h.serverStream = NIL THEN {
			h.state _ idle;
			RETURN;
			};
		SetName[h, Rope.Cat["Chat ", h.serverName]];
		InitialNegotiations[h];
		FromKeys[h];
		h.state _ running;
		h.serverToUserProcess _ FORK ServerToUser[h];
		};
		};
	
	FindHostName: PROC [h: Handle] RETURNS [host: Rope.ROPE] = {
		caret: TiogaOps.Location;
		r: Rope.ROPE;
		i: INT;
		r _ ViewerTools.GetSelectionContents[];
		IF r.Length[] > 1 THEN RETURN[r];
		caret _ TiogaOps.GetCaret[];
		r _ TiogaOps.GetRope[caret.node];
		i _ caret.where;
		WHILE i > 0 DO
			char: CHARACTER = Rope.Fetch[r, i - 1];
			IF -- char # '* AND  -- NOT ChatTokenProc[char] = other THEN EXIT;
			i _ i -1;
			ENDLOOP;
		host _ Rope.Substr[base: r, start: i, len: caret.where - i];
		};
	
	-- This procedure includes '+ in order to handle Pup names of the form
	-- dls+100004
	ChatTokenProc: IO.BreakProc -- [char: CHAR] RETURNS [IO.CharClass] --  = TRUSTED {
		IF IO.TokenProc[char] = other THEN RETURN [other];
		IF char = '+ THEN RETURN [other];
		RETURN [sepr];
		};
	
	OpenConnection: PROC [h: Handle] = TRUSTED {
		connect: STRING _ [64];
		addr: PupDefs.PupAddress;
		PupDefs.PupPackageMake[];
		{
		connect.length _ 0;
		h.out.ResetUserAbort[];
		ConvertUnsafe.AppendRope[to: connect, from: h.serverName ! Runtime.BoundsFault => {
			h.out.PutF[" ... name too long!"];
			GOTO Return;
			} ];
		h.out.PutF["Opening connection to %g ... ", IO.rope[h.serverName]];
		
		addr.socket _ PupTypes.telnetSoc; -- default value
		
		PupStream.GetPupAddress
			[@addr, connect
				! PupStream.PupNameTrouble => {
					h.out.ResetUserAbort[];
					h.out.PutF["PUP name error"];
					FinishStringWithErrorMsg[h, e];
					GOTO Return;
					}];
		h.serverStream _ PupStream.PupByteStreamCreate
			[addr, PupStream.SecondsToTocks[1]
				! PupStream.StreamClosing => {
					h.out.ResetUserAbort[];
					h.out.PutF["Can't connect"];
					FinishStringWithErrorMsg[h, text];
					GOTO Return;
					}];
		Stream.SetInputOptions[h.serverStream, Stream.InputOptions[TRUE,FALSE,FALSE,FALSE,FALSE]];
		h.out.PutF["open.\n"];
		EXITS
		Return => NULL;
		};
		};

	CloseConnection: PROC [h: Handle, print: BOOL] = TRUSTED {
		h.pleaseStop _ TRUE;
		IF h.serverStream # NIL THEN {
			IF print THEN h.out.PutF["\nClosing connection to %s", IO.rope[h.serverName] ! IO.Error => CONTINUE];
			h.serverStream.delete[h.serverStream];
			h.serverStream _ NIL;	-- could cause pointer faults!
			IF print THEN h.out.PutF[" ... Closed\n" ! IO.Error => CONTINUE];
			PupDefs.PupPackageDestroy[];
			};
		IF h.keyStream # NIL THEN {
			h.keyStream.Close[];
			h.keyStream _ NIL;
			};
		IF h.state = running THEN JOIN h.serverToUserProcess;
		IF h.logStream # NIL THEN h.logStream.Flush[];
		h.state _ idle;
		SetName[h, "Chat"];
		};

SetName: PROC [h: Handle, r: Rope.ROPE] = {
	InternalSetName: PROC [v: ViewerClasses.Viewer] = {
		v.name _ r;
		ViewerOps.PaintViewer[viewer: v, hint: caption];
		};
	EnumerateSplits[h.ts, InternalSetName ! ANY => CONTINUE]; 
	};

ChatMain: Commander.CommandProc = TRUSTED {
	h: Handle _ NEW[ChatInstanceRecord _ []];
	chatTipTable: TIPUser.TIPTable _ TIPUser.InstantiateNewTIPTable["Chat.TIP"];
	execOut: IO.STREAM _ cmd.out;
	switchChar: CHAR;
	i: NAT _ 2;

	h.argv _ UECP.Parse[cmd.commandLine];
	h.lorc _ 'l;	-- default GV login
	WHILE i < h.argv.argc DO
		IF h.argv[i].Length[] > 1 THEN
			SELECT h.argv[i].Fetch[0] FROM
				'- => {
					switchChar _ h.argv[i].Fetch[1];
					SELECT switchChar FROM
						'd => h.destroyOnClose _ TRUE;
						'k => {
							IF i+1 < h.argv.argc THEN {
								h.keyStream _ IO.RIS[h.argv[i+1]];
								i _ i + 1;
								};
							};
						ENDCASE => h.lorc _ switchChar;
					};
				'> => h.logFileName _ Rope.Substr[base: h.argv[i], start: 1];
				'< => h.keyFile _ Rope.Substr[base: h.argv[i], start: 1];
				ENDCASE => execOut.PutF["chat: unknown command: %s.\n", IO.rope[h.argv[i]]];
		i _ i + 1;
		ENDLOOP;
	IF h.logFileName.Length[] = 0 THEN {
		h.logFileName _ IO.PutFR["Chat%d.log", IO.int[logFileNumber]];
		logFileNumber _ logFileNumber + 1;
		};

	IF h.keyFile.Length[] > 0 THEN h.keyStream _ FileIO.Open[fileName: h.keyFile ! FileIO.OpenFailed => {
		execOut.PutF["Chat:"];
		IO.PutSignal[execOut];
		execOut.PutF[", %s\n", IO.rope[h.keyFile]];
		CONTINUE;
		}];
	-- iconic unless command line not empty
	h.ts _ TypeScript.Create[info: [name: "Chat", iconic: h.argv.argc <= 1 OR h.lorc = 'i], paint: TRUE];
	TypeScript.ChangeLooks[h.ts, 'f];
	h.ts.file _ h.logFileName;
	h.ts.icon _ typescript;
	-- create log file
	h.logStream _ FileIO.Open[fileName: h.logFileName, accessOptions: overwrite, raw: TRUE ! FileIO.OpenFailed => {
		execOut.PutF["Chat:"];
		IO.PutSignal[execOut];
		execOut.PutF[", %s\n", IO.rope[h.logFileName]];
		CONTINUE;
		}];

	-- plug in Chat TIP table.
	chatTipTable.link _ h.ts.tipTable;
	chatTipTable.opaque _ FALSE;
	h.tipTable _ h.ts.tipTable _ chatTipTable;
	[in: h.in, out: h.origOut] _ ViewerIO.CreateViewerStreams[name: "Chat.log", viewer: h.ts, editedStream: FALSE];
	h.out _ h.origOut;
	IF h.logStream # NIL THEN h.out _ IO.CreateDribbleStream[stream: h.origOut, dribbleTo: h.logStream, flushEveryNChars: 256];
	[] _ IO.SetEcho[h.in, NIL];
	IF h.argv.argc > 1 THEN {
		h.serverName _ h.argv[1];
		h.useOldHost _ TRUE;
		-- IF -i then we are just initializing the host name, else really connect
		IF h.lorc = 'i THEN h.lorc _ 'c
		ELSE TypeScript.InsertCharAtFrontOfBuffer[ts: h.ts, char: IF h.lorc = 'c THEN ConnectChar ELSE LoginChar];
		};
	IF List.Length[chatInstanceList] = 0 THEN {
		-- closeEvent _ ViewerEvents.RegisterEventProc[proc: MyClose, event: close];
		destroyEvent _ ViewerEvents.RegisterEventProc[proc: MyDestroy, event: destroy]
		};
	chatInstanceList _ CONS[h, chatInstanceList];
	Menus.AppendMenuEntry[menu: h.ts.menu, entry: Menus.CreateEntry[name: "Disconnect", proc: MyDisconnect, clientData: h, fork: TRUE, documentation: "Close Ethernet connection"]];
	Menus.AppendMenuEntry[menu: h.ts.menu, entry: Menus.CreateEntry[name: "Login", proc: MyLogin, clientData: h, documentation: "Open Ethernet Connection to selected host and send Login sequence"]];
	Menus.AppendMenuEntry[menu: h.ts.menu, entry: Menus.CreateEntry[name: "Connect", proc: MyConnect, clientData: h, documentation: "Open Ethernet Connection to selected host"]];
	Menus.AppendMenuEntry[menu: h.ts.menu, entry: Menus.CreateEntry[name: "BreakKey", proc: MyBreakKey, clientData: h, documentation: "Transmit Ascii.NULL (DLS interprets as RS-232 Line Break)"]];
	Menus.AppendMenuEntry[menu: h.ts.menu, entry: Menus.CreateEntry[name: "FlushLog", proc: MyFlushLog, clientData: h, documentation: "Flush log file to disk."]];

	h.oldSplit _ Menus.FindEntry[menu: h.ts.menu, entryName: "Split"];
	Menus.ReplaceMenuEntry[menu: h.ts.menu, oldEntry: h.oldSplit, newEntry: Menus.CreateEntry[name: "Split", proc: MySplit, fork: TRUE, clientData: h, documentation: "Split window"]];
	ViewerOps.AddProp[h.ts, $ChatToolData, h];
	ViewerOps.PaintViewer[viewer: h.ts, hint: all];
	h.userToServerProcess _ FORK UserToServer[h];
	};

	UserToServer: PROC [h: Handle] = TRUSTED {{
		char: CHAR;
		count: NAT _ 0;
		DO ENABLE {
				ABORTED => ERROR;  -- ever happen?
				IO.UserAborted => {
					h.out.ResetUserAbort[];
					h.out.PutF["\nUserAbort!\n"];
					CONTINUE;
					};
				IO.Error => {
					-- last viewer destroyed !
					-- Close connection and exit
					CloseConnection[h, FALSE];
					GOTO Die;
					};
				PupStream.StreamClosing =>  {
					IF h.serverStream # NIL THEN {
						h.out.PutF["\nConnection being closed by %s", IO.rope[h.serverName]];
						FinishStringWithErrorMsg[h, text];
						CloseConnection[h, FALSE];
						IF h.destroyOnClose THEN {
							ViewerOps.DestroyViewer[h.ts];
							GOTO Die;
							};
						};
					CONTINUE;
					};
				};
			char _ h.in.GetChar[];
			IF h.inDestroy THEN {
				CloseConnection[h, FALSE];
				GOTO Die;
				};
			SELECT char FROM
				AbortChar => {
					IF h.state = running THEN CloseConnection[h, TRUE];
					h.out.ResetUserAbort[];
					};
				DisconnectChar => {
					IF h.state = running THEN CloseConnection[h, TRUE];
					};
				RemoteCloseChar => {
					ERROR PupStream.StreamClosing[why: remoteClose, text: NIL];
					};
				ConnectChar => {
					IF h.state = idle THEN {
						h.lorc _ 'c;
						StartUp[h];
						count _ 0;
						};
					};
				LoginChar => {
					IF h.state = idle THEN {
						h.lorc _ 'l;
						StartUp[h];
						count _ 0;
						};
					};
				ENDCASE => {
					SELECT h.state FROM
						running => {
							Stream.PutChar[h.serverStream, char]; 
							IF count >= 50 OR NOT h.in.CharsAvail[] THEN {
								Stream.SendNow[h.serverStream];
								count _ 0;
								}
							ELSE count _ count + 1;
							};
						ENDCASE => h.out.PutChar[char];
					};
			ENDLOOP;
		EXITS
		Die => {
			IF h.logStream # NIL THEN h.logStream.Close[];
			};
		};
		};
	
	-- This EventProc exits only to keep h.ts pointing to a valid copy of the typescript
	-- viewer.  It is only needed for the use of TypeScript.InsertCharAtFrontOfBuffer.
	
	MyDestroy: ViewerEvents.EventProc = {
		h: Handle _ NARROW[ViewerOps.FetchProp[viewer, $ChatToolData]];
		IF h = NIL THEN RETURN;
		IF NumSplit[viewer] = 1 THEN {	-- last one
			h.inDestroy _ TRUE;
			-- next line is a crock to avoid signal in TypeScripts, see McGregor
			-- Process.Pause[Process.SecondsToTicks[2]];
			-- h.out.Close[];	breaks viewers destroy!!
			chatInstanceList _ List.Remove[h, chatInstanceList];
			IF List.Length[chatInstanceList] = 0 THEN {
				ViewerEvents.UnRegisterEventProc[proc: destroyEvent, event: destroy];
				-- ViewerEvents.UnRegisterEventProc[proc: closeEvent, event: close];
				};
			}
		ELSE IF NumSplit[viewer] > 1 THEN {
			IF viewer = h.ts THEN {
				 Another: PROC [v: ViewerClasses.Viewer] = {
					 IF v # viewer THEN h.ts _ v;
					 };
				 EnumerateSplits[viewer, Another];
				 };
			};
		};
		
	MyClose: ViewerEvents.EventProc = {
		h: Handle _ NARROW[ViewerOps.FetchProp[viewer, $ChatToolData]];
		IF h = NIL THEN RETURN;
		TypeScript.InsertCharAtFrontOfBuffer[ts: h.ts, char: DisconnectChar];
		};
		
	MyConnect: Menus.MenuProc = {
		viewer: TypeScript.TS _ NARROW[parent];
		h: Handle _ NARROW[clientData];
		h.ts _ viewer;	-- "primary" copy
		h.useOldHost _  mouseButton # red;
		TypeScript.InsertCharAtFrontOfBuffer[ts: h.ts, char: ConnectChar];
		};
	 
	MyLogin: Menus.MenuProc = {
		viewer: TypeScript.TS _ NARROW[parent];
		h: Handle _ NARROW[clientData];
		h.ts _ viewer;	-- "primary" copy
		h.useOldHost _  mouseButton # red;
		TypeScript.InsertCharAtFrontOfBuffer[ts: h.ts, char: LoginChar];
		};
		
	MyDisconnect: Menus.MenuProc = {
		h: Handle _ NARROW[clientData];
		TypeScript.InsertCharAtFrontOfBuffer[ts: h.ts, char: DisconnectChar];
		};

	MyBreakKey: Menus.MenuProc = TRUSTED {
		h: Handle _ NARROW[clientData];
		IF h.state # running THEN RETURN;
		IF h.serverStream # NIL THEN {
			Stream.PutChar[h.serverStream, '\000];
			Stream.SendNow[h.serverStream];
			};
		};

	MyFlushLog: Menus.MenuProc = {
		h: Handle _ NARROW[clientData];
		IF h.logStream # NIL THEN h.logStream.Flush[];
		};
	
MySplit: Menus.MenuProc = {
		h: Handle _ NARROW[clientData];
		CheckChatProperties: PROC [v: ViewerClasses.Viewer] = {
			IF ViewerOps.FetchProp[v, $ChatToolData] = NIL THEN ViewerOps.AddProp[v, $ChatToolData, h];
			v.tipTable _ h.tipTable;
			};
		h.oldSplit.proc[parent: parent, clientData: h.oldSplit.clientData, mouseButton: mouseButton, shift: shift, control: control];
		EnumerateSplits[NARROW[parent, ViewerClasses.Viewer], CheckChatProperties];
		};
  
ConnectionOpen: TIPUser.TIPPredicate --PROC RETURNS [BOOLEAN]-- = {
	h: Handle;
	viewer: ViewerClasses.Viewer _ ViewerTools.GetSelectedViewer[];
	IF viewer=NIL THEN RETURN [FALSE]; -- no primary selection
	h _ NARROW[ViewerOps.FetchProp[viewer, $ChatToolData]];
	IF h=NIL THEN RETURN [FALSE]; -- not a chat tool
	RETURN [h.state = running]; -- connection open?
	};
  
EnumerateSplits: PROC [v: ViewerClasses.Viewer, p: PROC [v: ViewerClasses.Viewer]] = {
	v2: ViewerClasses.Viewer _ v;
	IF v = NIL THEN RETURN;
	DO
		p[v2];
		IF v2.link = NIL OR v2.link = v THEN RETURN;
		v2 _ v2.link;
		ENDLOOP;
	};

NumSplit: PROC [v: ViewerClasses.Viewer] RETURNS [count: INT _ 0] = {
	Counter: PROC [v2: ViewerClasses.Viewer] = {
		count _ count + 1;
		};
	EnumerateSplits[v, Counter]; 
	};
	
Init: PROC = {
	Commander.Register[key: "Chat", proc: ChatMain, doc: "Pup User Telnet, see Chat.doc"];
	TIPUser.RegisterTIPPredicate[$ConnectionOpen, ConnectionOpen];
	};
	
-- main program for chat

Init[];

END.

March 31, 1982 9:27 pm, Stewart, copied from Laurel Chat
April 1, 1982 4:06 pm, Stewart, own viewer class & TIP table
April 4, 1982 5:18 pm, Stewart, Menu
April 6, 1982 10:27 pm, Stewart, command line stuff
18-Apr-82 17:42:24, Use TypeScript again
June 6, 1982 4:44 pm, Stewart, fix Menu instantiation to add Split
June 6, 1982 8:08 pm, Stewart, using own Split code until viewers copies PropList
September 21, 1982 4:26 pm, Stewart, Cedar 3.4
January 23, 1983 10:18 pm, Stewart, Cedar 3.5, major rework
January 24, 1983 5:49 pm, Stewart, Cedar 3.6




��j�J�StartOfExpansion* -- [c: CHAR] RETURNS [IO.BreakAction] -- �
��	��	J�
���
���
���N&N�