Return to keybuf.c CVS log

Up to [UNIX Amiga Emulator] / uae / src

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

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: 
        !            35:     if (JSEM_ISJOY0 (nr, currprefs.fake_joystick))
        !            36:        nr = 0;
        !            37:     else if (JSEM_ISJOY1 (nr, currprefs.fake_joystick))
        !            38:        nr = 1;
        !            39:     else if (JSEM_ISMOUSE (nr, currprefs.fake_joystick)) {
        !            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:     }
        !           117:     if (kc == AK_RCTRL)
        !           118:        kc = AK_CTRL;
1.1       root      119:     keybuf[kpb_first] = kc;
                    120:     kpb_first = kpb_next;
                    121: }
                    122: 
1.1.1.3 ! root      123: void joystick_setting_changed (void)
        !           124: {
        !           125:     fs_np = fs_ck = fs_se = 0;
        !           126: 
        !           127:     if (JSEM_ISNUMPAD (0, currprefs.fake_joystick))
        !           128:        fs_np = fakestate[0];
        !           129:     else if (JSEM_ISNUMPAD (1, currprefs.fake_joystick))
        !           130:        fs_np = fakestate[1];
        !           131: 
        !           132:     if (JSEM_ISCURSOR (0, currprefs.fake_joystick))
        !           133:        fs_ck = fakestate[0];
        !           134:     else if (JSEM_ISCURSOR (1, currprefs.fake_joystick))
        !           135:        fs_ck = fakestate[1];
        !           136: 
        !           137:     if (JSEM_ISSOMEWHEREELSE (0, currprefs.fake_joystick))
        !           138:        fs_se = fakestate[0];
        !           139:     else if (JSEM_ISSOMEWHEREELSE (1, currprefs.fake_joystick))
        !           140:        fs_se = fakestate[1];
        !           141: 
        !           142: }
        !           143: 
1.1       root      144: void keybuf_init (void)
                    145: {
                    146:     kpb_first = kpb_last = 0;
1.1.1.3 ! root      147:     joystick_setting_changed ();
1.1       root      148: }

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