-- Keyboard.Mesa  Edited by Sandman on May 22, 1980  3:24 PM
-- Copyright  Xerox Corporation 1979, 1980

DIRECTORY
  AltoDisplay USING [Coordinate],
  InlineDefs USING [BITAND, BITSHIFT, BITXOR],
  KeyDefs USING [KeyArray, KeyBits, KeyItem, updown],
  KeyPrivate USING [Xmax, Ymax],
  StreamDefs USING [KeyboardHandle, KeyBufChars, StreamHandle];

Keyboard: MONITOR LOCKS monitor
  IMPORTS InlineDefs EXPORTS KeyDefs, KeyPrivate, StreamDefs SHARES StreamDefs =
  BEGIN OPEN KeyDefs, StreamDefs;

  monitor: PUBLIC MONITORLOCK;
  wakeup: PUBLIC CONDITION;
  charactersAvailable: PUBLIC CONDITION;

  -- variables set by KeyStreams

  ks: PUBLIC KeyboardHandle;

  userAbort, halt, trackCursor: PUBLIC BOOLEAN;

  KeyTable: PUBLIC POINTER TO ARRAY [0..80) OF KeyItem;

  -- The Keyboard part:
  -- fixed addresses for keyboard and mouse

  keys: PUBLIC POINTER TO KeyArray;

  mouse: PUBLIC POINTER TO AltoDisplay.Coordinate;
  cursor: PUBLIC POINTER TO AltoDisplay.Coordinate;

  oldState, newState: PUBLIC POINTER TO KeyArray;

  ProcessKeyboard: PUBLIC ENTRY PROCEDURE =
    BEGIN OPEN InlineDefs;
    bitcount, start: [0..15];
    char: [0..377B];
    entry: KeyItem;
    i: [0..SIZE[KeyArray]);
    newin: CARDINAL;
    StateWord: WORD;
    stroke: POINTER TO KeyBits = LOOPHOLE[newState];
    DO
      WAIT wakeup[ ! ABORTED => CONTINUE];
      IF halt THEN EXIT; -- first update the cursor
      IF trackCursor THEN
	BEGIN
	mouse.x _ cursor.x _ MAX[MIN[KeyPrivate.Xmax, mouse.x], 0];
	mouse.y _ cursor.y _ MAX[MIN[KeyPrivate.Ymax, mouse.y], 0];
	END;
      newState^ _ keys^;
      -- The following code checks for down transitions in the keyboard state
      -- and enters characters in the current keystream buffer
      FOR i IN [0..SIZE[KeyArray]) DO
	IF (StateWord _ BITXOR[oldState[i], newState[i]]) # 0 THEN
	  BEGIN -- found one or more transitions
	  start _ 0;
	  DO
	    FOR bitcount IN [start..15] DO
	      IF LOOPHOLE[StateWord, INTEGER] < 0 THEN EXIT;
	      StateWord _ BITSHIFT[StateWord, 1];
	      ENDLOOP;
	    entry _ KeyTable[i*16 + bitcount];
	    IF (char _ entry.NormalCode) # 0 AND BITAND[
	      oldState[i], BITSHIFT[100000B, -bitcount]] # 0 THEN
	      BEGIN
	      SELECT updown[down] FROM
		stroke.Ctrl =>
		  IF char = 177B THEN BEGIN userAbort _ TRUE; GOTO skip END
		  ELSE char _ BITAND[char, 37B];
		stroke.LeftShift, stroke.RightShift => char _ entry.ShiftCode;
		stroke.Lock => IF entry.Letter THEN char _ entry.ShiftCode;
		ENDCASE;
	      IF (newin _ ks.in + 1) = KeyBufChars THEN newin _ 0;
	      IF newin # ks.out THEN
		BEGIN
		ks.buffer[ks.in] _ LOOPHOLE[char];
		ks.in _ newin;
		BROADCAST charactersAvailable;
		END;
	      EXITS skip => NULL;
	      END;
	    IF (StateWord _ BITSHIFT[StateWord, 1]) = 0 THEN EXIT;
	    start _ bitcount + 1;
	    ENDLOOP;
	  END;
	ENDLOOP;
      oldState^ _ newState^;
      ENDLOOP;
    END;

  ReadChar: PUBLIC ENTRY PROCEDURE [stream: StreamHandle]
    RETURNS [char: UNSPECIFIED] =
    BEGIN
    char _ 0;
    WITH s: stream SELECT FROM
      Keyboard =>
	DO
	  -- until character typed
	  IF s.out # s.in THEN
	    BEGIN
	    char _ s.buffer[s.out];
	    s.out _ IF s.out = KeyBufChars - 1 THEN 0 ELSE s.out + 1;
	    RETURN
	    END;
	  WAIT charactersAvailable[ ! UNWIND => NULL];
	  ENDLOOP;
      ENDCASE;
    RETURN;
    END;

  InputBufferEmpty: PUBLIC ENTRY PROCEDURE [stream: StreamHandle]
    RETURNS [empty: BOOLEAN] =
    BEGIN
    empty _ TRUE;
    WITH s: stream SELECT FROM
      Keyboard => IF s.in # s.out THEN empty _ FALSE;
      ENDCASE;
    RETURN
    END;


  END.