-- ppkint.mesa
--  keyboard interrupt routines for silicon (pretty picture) program
-- last edited by McCreight, December 16, 1982  12:00 PM

DIRECTORY
  ProcessDefs,
  FrameDefs,
  ppddefs,
ppdddefs,
  ppdefs,
  multiGraphicsDefs,
  InlineDefs,
  SystemDefs;
ppkint: MONITOR
  IMPORTS ProcessDefs, FrameDefs, InlineDefs, multiGraphicsDefs, ppdddefs,ppdefs, ppddefs
  EXPORTS ppddefs,ppdefs =
  BEGIN OPEN InlineDefs, ppdddefs,ppdefs, ppddefs, multiGraphicsDefs;

  curx, cury: PUBLIC INTEGER;
  localx, localy: INTEGER;
  gridCol, gridBW: PUBLIC CARDINAL;
  savedCx, savedCy: INTEGER;

  tickCnt: CARDINAL _ 0;
  tickLimit: CARDINAL = 14;

  lev: ProcessDefs.InterruptLevel = 11;
  Keywakeup: CONDITION;
  aKey: CONDITION;

  kb: ARRAY [0..3] OF POINTER TO CARDINAL = [
    LOOPHOLE[177034B], LOOPHOLE[177035B], LOOPHOLE[177036B], LOOPHOLE[177037B]];
  oldkb, akb, akmb, kbd: ARRAY [0..3] OF CARDINAL;
  kbm: ARRAY [0..3] OF CARDINAL = [177777B, 177777B, 153676B, 177564B];

  MouseX: POINTER TO INTEGER = LOOPHOLE[424B];
  MouseY: POINTER TO INTEGER = LOOPHOLE[425B];
  curse: POINTER TO ARRAY [0..15] OF CARDINAL = LOOPHOLE[431B];
  CursX: POINTER TO INTEGER = LOOPHOLE[426B];
  CursY: POINTER TO INTEGER = LOOPHOLE[427B];

  mButs: POINTER TO CARDINAL = LOOPHOLE[177030B];
  amb, mb, oldmb: CARDINAL _ 0;
  mbmask: CARDINAL = 7;
  mbArray1: ARRAY [0..7] OF CARDINAL = [0, 1, 2, 2, 4, 4, 4, 4];
  --none,yel,blue,yb,red,yr,br,ybr
  mbArray2: ARRAY [0..4] OF CARDINAL = [0, 2, 3, 3, 1];

  kesMax: CARDINAL = 127;
  takek, kesi: CARDINAL;
  kes: ARRAY [0..kesMax] OF keyEvent;

  -- THE KEYS !:  BS,<bl-top>,xx,xx, LF,<bl-mid>,DEL,xx,
  -- \,],^,<bl-bot>,  /,',RET,<sh-rt>,  P,COMMA,;,=,  -,L,.,[,
  -- K,O,<sh-lft>,SPC,  0,X,Z,LOCK,  V,I,B,M,  U,9,J,N,
  -- D,A,C,8,  7,S,CTRL,H,  E,Q,F,Y,
  -- 6,W,TAB,G,  4,2,ESC,T,  5,3,1,R

  kCode: PACKED ARRAY [0..63] OF [0..255] = [
    62B, 56B, 0, 0, 61B, 66B, 63B, 0, 54B, 55B, 57B, 67B, 51B, 52B, 60B, 0, 31B, 46B,
    44B, 45B, 47B, 25B, 50B, 53B, 24B, 30B, 0, 64B, 0B, 41B, 43B, 0, 37B, 22B,
    13B, 26B, 36B, 11B, 23B, 27B, 15B, 12B, 14B, 10B, 7B, 34B, 0, 21B, 16B, 32B,
    17B, 42B, 6B, 40B, 0, 20B, 4B, 2B, 65B, 35B, 5B, 3B, 1B, 33B];

  bwCursPnt: POINTER TO ARRAY [0..15] OF CARDINAL;
  cursorOnBW: PUBLIC BOOLEAN;

  initkbd: PUBLIC PROCEDURE [
    bp: POINTER TO ARRAY [0..15] OF CARDINAL, cp: POINTER TO Bitmap] =
    BEGIN
    i: CARDINAL;
    gridCol _ 8;
    gridBW _ 1;
    bwCursPnt _ bp;
    initCcurse[cp.nLines, cp];
    curx _ cury _ localx _ localy _ 200;
    drawColorCurs[200, 200];
    savedCx _ savedCy _ 200;
    cursorOnBW _ FALSE;
    FOR i IN [0..3] DO oldkb[i] _ 0; ENDLOOP;
    oldmb _ 0;
    FrameDefs.MakeCodeResident[FrameDefs.GlobalFrame[keybreak]];
    FrameDefs.MakeCodeResident[FrameDefs.GlobalFrame[doTemps]];
    FrameDefs.MakeCodeResident[FrameDefs.GlobalFrame[reDrawRect]];
    FrameDefs.MakeCodeResident[FrameDefs.GlobalFrame[SetupColorAreaBLT]];
    FrameDefs.MakeCodeResident[FrameDefs.GlobalFrame[cannonRect]];
    FrameDefs.MakeCodeResident[FrameDefs.GlobalFrame[deScaledCursor]];
    ProcessDefs.DisableTimeout[@Keywakeup];
    ProcessDefs.CV[lev] _ @Keywakeup;
    ProcessDefs.DIW^ _ BITOR[ProcessDefs.DIW^, BITSHIFT[1, lev]];
    ProcessDefs.Detach[FORK keybreak[]];
    END;
  keybreak: ENTRY PROCEDURE =
    BEGIN
    bitthing, i, b: CARDINAL;
    ke: keyEvent;
    ctrl: [0..255];
    c, n: [0..127];
    lockState, oldLockState: BOOLEAN _ FALSE;
    takek _ kesi _ 0;
    MouseX^ _ MouseY^ _ 0;
    ProcessDefs.SetPriority[ProcessDefs.DefaultPriority + 1];
    DO
      WAIT Keywakeup;

      lockState _ BITAND[kb[3]^, 200B] = 0;

      n _ 4;
      FOR i IN [0..3] DO
        kbd[i] _ BITNOT[kb[i]^];
        akmb[i] _ BITAND[kbd[i], kbm[i]];
        akb[i] _ BITAND[akmb[i], BITNOT[oldkb[i]]];
        IF akb[i] # 0 THEN n _ i;
        oldkb[i] _ BITAND[oldkb[i], kbd[i]];
        ENDLOOP;
      mb _ BITNOT[mButs^];
      mb _ BITAND[mb, mbmask];
      amb _ BITXOR[mb, oldmb];
      IF MouseX^ # 0 OR MouseY^ # 0 THEN
        BEGIN
        localx _ localx + MouseX^;
        localy _ localy + MouseY^;
        IF localx < 0 THEN localx _ 0;
        IF localx > colWidth + 606 THEN localx _ colWidth + 606;
        IF localy < 0 THEN localy _ 0;
        IF localy > 808 THEN localy _ 808;
        MouseX^ _ MouseY^ _ 0;
        IF localx <= colWidth THEN
          BEGIN
          IF cursorOnBW THEN localy _ (localy*3)/5;
          IF localy > colHeight THEN localy _ colHeight;
          curx _ localx - (localx MOD gridCol);
          cury _ localy - (localy MOD gridCol);
          IF curx # savedCx OR cury # savedCy THEN
            BEGIN drawColorCurs[curx, cury]; savedCx _ curx; savedCy _ cury; END;
          IF cursorOnBW THEN
            BEGIN
            FOR i IN [0..15] DO curse^[i] _ 0; ENDLOOP;
            cursorOnBW _ FALSE;
            END;
          END
        ELSE
          BEGIN
          IF NOT cursorOnBW THEN localy _ (localy*5)/3;
          IF localy > 808 THEN localy _ 808;
          IF localy < bwBottom THEN
            BEGIN
            curx _ localx - ((localx-colWidth) MOD gridBW);
            cury _ localy - (localy MOD gridBW);
            IF curx < colWidth THEN curx _ colWidth;
            END
          ELSE BEGIN curx _ localx; cury _ localy; END;
          IF NOT cursorOnBW THEN
            BEGIN
            undrawColorCurs[];
            FOR i IN [0..15] DO curse^[i] _ bwCursPnt^[i]; ENDLOOP;
            cursorOnBW _ TRUE;
            END;
          CursX^ _ curx - colWidth;
          CursY^ _ cury;
          END;
        END;
      ke.mx _ curx;
      ke.my _ cury;
      ctrl _ 0;
      IF BITAND[100B, kbd[2]] # 0 OR BITAND[10B, kbd[3]] # 0 THEN
        ctrl _ ctrl + 16;  --shift
      IF BITAND[4000B, kbd[2]] # 0 THEN ctrl _ ctrl + 4;  -- CTRL
      IF BITAND[20000B, kbd[2]] # 0 THEN ctrl _ ctrl + 8;  -- TAB
      ke.ctl _ ctrl;
      IF amb # 0 THEN
        BEGIN
        bitthing _ mbArray1[amb];
        oldmb _ BITXOR[oldmb, bitthing];
        IF BITAND[mb, bitthing] = 0 THEN  --if button up
          BEGIN
          ke.k _ 71B + mbArray2[bitthing];
          kesi _ kesi + 1;
          IF kesi > kesMax THEN kesi _ 0;
          kes[kesi] _ ke;
          BROADCAST aKey;
          END
        ELSE
          BEGIN
          ke.ctl _ BITOR[ctrl, mbArray2[bitthing]];
          ke.k _ 77B;
          FOR i IN [0..3] DO
            IF akmb[i] # 0 THEN
              BEGIN
              b _ akmb[i];
              c _ i;
              UNTIL BITAND[b, 1] # 0 DO c _ c + 4; b _ BITSHIFT[b, -1]; ENDLOOP;
              ke.k _ kCode[c];
              EXIT;
              END;
            ENDLOOP;
          kesi _ kesi + 1;
          IF kesi > kesMax THEN kesi _ 0;
          kes[kesi] _ ke;
          BROADCAST aKey;
          ke.ctl _ ctrl;
          END;
        END;
      IF n # 4 THEN
        BEGIN
        FOR i IN [0..3] DO
          IF akb[i] # 0 THEN
            BEGIN
            bitthing _ b _ akb[i];
            c _ i;
            UNTIL BITAND[b, 1] # 0 DO c _ c + 4; b _ BITSHIFT[b, -1]; ENDLOOP;
            ke.k _ kCode[c];
            EXIT;
            END;
          ENDLOOP;
        oldkb[n] _ BITOR[oldkb[n], bitthing];
        kesi _ kesi + 1;
        IF kesi > kesMax THEN kesi _ 0;
        kes[kesi] _ ke;
        BROADCAST aKey;
        END;
      tickCnt _ tickCnt + 1;
      IF tickCnt > tickLimit THEN
        BEGIN tickCnt _ 0; IF NOT cursorOnBW THEN doTemps[]; END;
      ENDLOOP;
    END;
  getKchr: PUBLIC ENTRY PROCEDURE RETURNS [ke: keyEvent] =
    BEGIN
    UNTIL takek # kesi DO WAIT aKey; ENDLOOP;
    takek _ takek + 1;
    IF takek > kesMax THEN takek _ 0;
    ke _ kes[takek];
    RETURN;
    END;
  anyKavail: PUBLIC ENTRY PROCEDURE RETURNS [BOOLEAN] =
    BEGIN RETURN[takek # kesi]; END;


  END.