Annotation of uae/src/keybuf.c, revision 1.1.1.4

1.1.1.3   root        1:  /*
1.1       root        2:   * UAE - The Un*x Amiga Emulator
1.1.1.3   root        3:   *
1.1       root        4:   * Keyboard buffer. Not really needed for X, but for SVGAlib and possibly
                      5:   * Mac and DOS ports.
1.1.1.3   root        6:   *
                      7:   * Note: it's possible to have two threads in UAE, one reading keystrokes
                      8:   * and the other one writing them. Despite this, no synchronization effort
                      9:   * is needed. This code should be perfectly thread safe. At least if you
                     10:   * assume that integer store instructions are atomic.
                     11:   *
                     12:   * Copyright 1995, 1997 Bernd Schmidt
1.1       root       13:   */
                     14: 
                     15: #include "sysconfig.h"
                     16: #include "sysdeps.h"
                     17: #include <assert.h>
                     18: 
                     19: #include "config.h"
                     20: #include "options.h"
                     21: #include "keybuf.h"
                     22: #include "keyboard.h"
1.1.1.3   root       23: #include "joystick.h"
1.1       root       24: 
1.1.1.3   root       25: static int fakestate[3][5] = { { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } };
1.1       root       26: 
1.1.1.3   root       27: static int *fs_np;
                     28: static int *fs_ck;
                     29: static int *fs_se;
                     30: 
                     31: void getjoystate(int nr, unsigned int *st, int *button)
1.1       root       32: {
1.1.1.3   root       33:     int *fake = 0;
                     34: 
1.1.1.4 ! root       35:     if (JSEM_ISJOY0 (nr, &currprefs))
1.1.1.3   root       36:        nr = 0;
1.1.1.4 ! root       37:     else if (JSEM_ISJOY1 (nr, &currprefs))
1.1.1.3   root       38:        nr = 1;
1.1.1.4 ! root       39:     else if (JSEM_ISMOUSE (nr, &currprefs)) {
1.1.1.3   root       40:        *st = 0;
                     41:        *button = 0;
                     42:        return;
                     43:     } else
                     44:        fake = fakestate[nr];
                     45: 
                     46:     if (fake) {
                     47:        int top = fake[0];
                     48:        int bot = fake[3];
                     49:        if (fake[1]) top = !top;
                     50:        if (fake[2]) bot = !bot;
                     51:        *st = bot | (fake[2] << 1) | (top << 8) | (fake[1] << 9);
                     52:        *button = fake[4];
1.1       root       53:     } else
1.1.1.3   root       54:        read_joystick (nr, st, button);
1.1       root       55: }
                     56: 
                     57: /* Not static so the DOS code can mess with them */
                     58: int kpb_first, kpb_last;
                     59: 
1.1.1.2   root       60: int keybuf[256];
1.1       root       61: 
                     62: int keys_available (void)
                     63: {
1.1.1.3   root       64:     int val;
                     65:     val = kpb_first != kpb_last;
                     66:     return val;
1.1       root       67: }
                     68: 
                     69: int get_next_key (void)
                     70: {
                     71:     int key;
                     72:     assert (kpb_first != kpb_last);
1.1.1.3   root       73: 
1.1       root       74:     key = keybuf[kpb_last];
1.1.1.3   root       75:     if (++kpb_last == 256)
1.1       root       76:        kpb_last = 0;
1.1.1.3   root       77:     return key;
1.1       root       78: }
                     79: 
                     80: void record_key (int kc)
                     81: {
                     82:     int kpb_next = kpb_first + 1;
                     83: 
                     84:     if (kpb_next == 256)
                     85:        kpb_next = 0;
                     86:     if (kpb_next == kpb_last) {
1.1.1.3   root       87:        write_log ("Keyboard buffer overrun. Congratulations.\n");
1.1       root       88:        return;
                     89:     }
1.1.1.3   root       90:     if (fs_np != 0) {
                     91:        switch (kc >> 1) {
                     92:         case AK_NP8: fs_np[0] = !(kc & 1); return;
                     93:         case AK_NP4: fs_np[1] = !(kc & 1); return;
                     94:         case AK_NP6: fs_np[2] = !(kc & 1); return;
                     95:         case AK_NP2: fs_np[3] = !(kc & 1); return;
                     96:         case AK_NP0: case AK_NP5: fs_np[4] = !(kc & 1); return;
                     97:        }
                     98:     }
                     99:     if (fs_ck != 0) {
1.1       root      100:        switch (kc >> 1) {
1.1.1.3   root      101:         case AK_UP: fs_ck[0] = !(kc & 1); return;
                    102:         case AK_LF: fs_ck[1] = !(kc & 1); return;
                    103:         case AK_RT: fs_ck[2] = !(kc & 1); return;
                    104:         case AK_DN: fs_ck[3] = !(kc & 1); return;
                    105:         case AK_RCTRL: fs_ck[4] = !(kc & 1); return;
1.1       root      106:        }
                    107:     }
1.1.1.3   root      108:     if (fs_se != 0) {
                    109:        switch (kc >> 1) {
                    110:         case AK_T: fs_se[0] = !(kc & 1); return;
                    111:         case AK_F: fs_se[1] = !(kc & 1); return;
                    112:         case AK_H: fs_se[2] = !(kc & 1); return;
                    113:         case AK_B: fs_se[3] = !(kc & 1); return;
                    114:         case AK_LALT: fs_se[4] = !(kc & 1); return;
                    115:        }
                    116:     }
1.1.1.4 ! root      117:     if ((kc >> 1) == AK_RCTRL) {
        !           118:        kc ^= AK_RCTRL << 1;
        !           119:        kc ^= AK_CTRL << 1;
        !           120:     }
1.1       root      121:     keybuf[kpb_first] = kc;
                    122:     kpb_first = kpb_next;
                    123: }
                    124: 
1.1.1.3   root      125: void joystick_setting_changed (void)
                    126: {
                    127:     fs_np = fs_ck = fs_se = 0;
                    128: 
1.1.1.4 ! root      129:     if (JSEM_ISNUMPAD (0, &currprefs))
1.1.1.3   root      130:        fs_np = fakestate[0];
1.1.1.4 ! root      131:     else if (JSEM_ISNUMPAD (1, &currprefs))
1.1.1.3   root      132:        fs_np = fakestate[1];
                    133: 
1.1.1.4 ! root      134:     if (JSEM_ISCURSOR (0, &currprefs))
1.1.1.3   root      135:        fs_ck = fakestate[0];
1.1.1.4 ! root      136:     else if (JSEM_ISCURSOR (1, &currprefs))
1.1.1.3   root      137:        fs_ck = fakestate[1];
                    138: 
1.1.1.4 ! root      139:     if (JSEM_ISSOMEWHEREELSE (0, &currprefs))
1.1.1.3   root      140:        fs_se = fakestate[0];
1.1.1.4 ! root      141:     else if (JSEM_ISSOMEWHEREELSE (1, &currprefs))
1.1.1.3   root      142:        fs_se = fakestate[1];
                    143: 
                    144: }
                    145: 
1.1       root      146: void keybuf_init (void)
                    147: {
                    148:     kpb_first = kpb_last = 0;
1.1.1.3   root      149:     joystick_setting_changed ();
1.1       root      150: }

unix.superglobalmegacorp.com

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.