Return to keybuf.c CVS log

Up to [UNIX Amiga Emulator] / uae / src

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

1.1       root        1:  /* 
                      2:   * UAE - The Un*x Amiga Emulator
                      3:   * 
                      4:   * Keyboard buffer. Not really needed for X, but for SVGAlib and possibly
                      5:   * Mac and DOS ports.
                      6:   * 
                      7:   * (c) 1995 Bernd Schmidt
                      8:   */
                      9: 
                     10: #include "sysconfig.h"
                     11: #include "sysdeps.h"
                     12: #include <assert.h>
                     13: 
                     14: #include "config.h"
                     15: #include "options.h"
                     16: #include "keybuf.h"
                     17: #include "keyboard.h"
                     18: #include "os.h"
                     19: 
                     20: /* This is cryptic, but hey, it works! */
                     21: int fakestate[5] = { 0, 0, 0, 0, 0 };
                     22: 
                     23: void getjoystate(UWORD *st, int *button)
                     24: {
                     25:     if (fake_joystick) {
                     26:        int top = fakestate[0];
                     27:        int bot = fakestate[3];
                     28:        if (fakestate[1]) top = !top;
                     29:        if (fakestate[2]) bot = !bot;
                     30:        *st = bot | (fakestate[2] << 1) | (top << 8) | (fakestate[1] << 9);
                     31:        *button = fakestate[4];
                     32:     } else
                     33:        read_joystick(st, button);
                     34: }
                     35: 
                     36: /* Not static so the DOS code can mess with them */
                     37: int kpb_first, kpb_last;
                     38: 
1.1.1.2 ! root       39: int keybuf[256];
1.1       root       40: 
                     41: int keys_available (void)
                     42: {
                     43:     return kpb_first != kpb_last;
                     44: }
                     45: 
                     46: int get_next_key (void)
                     47: {
                     48:     int key;
                     49:     
                     50:     assert (kpb_first != kpb_last);
                     51:     
                     52:     key = keybuf[kpb_last];
                     53:     if (++kpb_last == 256) 
                     54:        kpb_last = 0;
                     55:     return key;    
                     56: }
                     57: 
                     58: void record_key (int kc)
                     59: {
                     60:     int kpb_next = kpb_first + 1;
                     61: 
                     62:     if (kpb_next == 256)
                     63:        kpb_next = 0;
                     64:     if (kpb_next == kpb_last) {
                     65:        fprintf(stderr, "Keyboard buffer overrun. Congratulations.\n");
                     66:        return;
                     67:     }
                     68:     if (fake_joystick) {
                     69:        switch (kc >> 1) {
                     70:         case AK_NP8: fakestate[0] = !(kc & 1); return;
                     71:         case AK_NP4: fakestate[1] = !(kc & 1); return;
                     72:         case AK_NP6: fakestate[2] = !(kc & 1); return;
                     73:         case AK_NP2: fakestate[3] = !(kc & 1); return;
                     74:         case AK_NP0: case AK_NP5: fakestate[4] = !(kc & 1); return;
                     75:        }
                     76:     }
                     77:     keybuf[kpb_first] = kc;
                     78:     kpb_first = kpb_next;
                     79: }
                     80: 
                     81: void keybuf_init (void)
                     82: {
                     83:     kpb_first = kpb_last = 0;
                     84: }

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