![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to keybuf.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae / src|
Return to keybuf.c CVS log | Up to [UNIX Amiga Emulator] / uae / src |
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.8 ! root 23: #include "inputdevice.h"
1.1.1.5 root 24: #include "custom.h"
1.1.1.8 ! root 25: #include "savestate.h"
1.1 root 26:
1.1.1.8 ! root 27: static int fakestate[2][7] = { {0},{0} };
1.1 root 28:
1.1.1.8 ! root 29: static int *fs_np, *fs_ck, *fs_se, *fs_xa1, *fs_xa2;
1.1 root 30:
31: /* Not static so the DOS code can mess with them */
32: int kpb_first, kpb_last;
33:
1.1.1.8 ! root 34: static int keybuf[256];
1.1 root 35:
36: int keys_available (void)
37: {
1.1.1.3 root 38: int val;
39: val = kpb_first != kpb_last;
40: return val;
1.1 root 41: }
42:
43: int get_next_key (void)
44: {
45: int key;
46: assert (kpb_first != kpb_last);
1.1.1.3 root 47:
1.1 root 48: key = keybuf[kpb_last];
1.1.1.3 root 49: if (++kpb_last == 256)
1.1 root 50: kpb_last = 0;
1.1.1.3 root 51: return key;
1.1 root 52: }
53:
1.1.1.8 ! root 54: static void do_fake (int nr)
! 55: {
! 56: int *fake = fakestate[nr];
! 57:
! 58: nr = compatibility_device[nr];
! 59: setjoystickstate (nr, 0, fake[1] ? -100 : (fake[2] ? 100 : 0), 100);
! 60: setjoystickstate (nr, 1, fake[0] ? -100 : (fake[3] ? 100 : 0), 100);
! 61: setjoybuttonstate (nr, 0, fake[4]);
! 62: setjoybuttonstate (nr, 1, fake[5]);
! 63: setjoybuttonstate (nr, 2, fake[6]);
! 64: }
! 65:
1.1 root 66: void record_key (int kc)
67: {
1.1.1.8 ! root 68: int fs = 0;
1.1 root 69: int kpb_next = kpb_first + 1;
1.1.1.8 ! root 70: int k = kc >> 1;
! 71: int b = !(kc & 1);
1.1 root 72:
1.1.1.8 ! root 73: //write_log ("got kc %02.2X\n", ((kc << 7) | (kc >> 1)) & 0xff);
1.1 root 74: if (kpb_next == 256)
75: kpb_next = 0;
76: if (kpb_next == kpb_last) {
1.1.1.3 root 77: write_log ("Keyboard buffer overrun. Congratulations.\n");
1.1 root 78: return;
79: }
1.1.1.8 ! root 80:
1.1.1.3 root 81: if (fs_np != 0) {
1.1.1.8 ! root 82: switch (k) {
! 83: case AK_NP8: fs = 1; fs_np[0] = b; break;
! 84: case AK_NP4: fs = 1; fs_np[1] = b; break;
! 85: case AK_NP6: fs = 1; fs_np[2] = b; break;
! 86: case AK_NP2: fs = 1; fs_np[3] = b; break;
! 87: case AK_NP0: case AK_NP5: fs = 1; fs_np[4] = b; break;
! 88: case AK_NPDEL: case AK_NPDIV: case AK_ENT: fs = 1; fs_np[5] = b; break;
1.1.1.3 root 89: }
90: }
91: if (fs_ck != 0) {
1.1.1.8 ! root 92: switch (k) {
! 93: case AK_UP: fs = 1; fs_ck[0] = b; break;
! 94: case AK_LF: fs = 1; fs_ck[1] = b; break;
! 95: case AK_RT: fs = 1; fs_ck[2] = b; break;
! 96: case AK_DN: fs = 1; fs_ck[3] = b; break;
! 97: case AK_RCTRL: case AK_RALT: fs = 1; fs_ck[4] = b; break;
! 98: case AK_RSH: fs = 1; fs_ck[5] = b; break;
1.1 root 99: }
100: }
1.1.1.3 root 101: if (fs_se != 0) {
1.1.1.8 ! root 102: switch (k) {
! 103: case AK_T: fs = 1; fs_se[0] = b; break;
! 104: case AK_F: fs = 1; fs_se[1] = b; break;
! 105: case AK_H: fs = 1; fs_se[2] = b; break;
! 106: case AK_B: fs = 1; fs_se[3] = b; break;
! 107: case AK_LALT: fs = 1; fs_se[4] = b; break;
! 108: case AK_LSH: fs = 1; fs_se[5] = b; break;
! 109: }
! 110: }
! 111: if (fs_xa1 != 0) {
! 112: switch (k) {
! 113: case AK_NP8: fs = 1; fs_xa1[0] = b; break;
! 114: case AK_NP4: fs = 1; fs_xa1[1] = b; break;
! 115: case AK_NP6: fs = 1; fs_xa1[2] = b; break;
! 116: case AK_NP2: case AK_NP5: fs = 1; fs_xa1[3] = b; break;
! 117: case AK_CTRL: fs = 1; fs_xa1[4] = b; break;
! 118: case AK_LALT: fs = 1; fs_xa1[5] = b; break;
! 119: case AK_SPC: fs = 1; fs_xa1[6] = b; break;
1.1.1.3 root 120: }
121: }
1.1.1.8 ! root 122: if (fs_xa2 != 0) {
! 123: switch (k) {
! 124: case AK_R: fs = 1; fs_xa2[0] = b; break;
! 125: case AK_D: fs = 1; fs_xa2[1] = b; break;
! 126: case AK_G: fs = 1; fs_xa2[2] = b; break;
! 127: case AK_F: fs = 1; fs_xa2[3] = b; break;
! 128: case AK_A: fs = 1; fs_xa2[4] = b; break;
! 129: case AK_S: fs = 1; fs_xa2[5] = b; break;
! 130: case AK_Q: fs = 1; fs_xa2[6] = b; break;
! 131: }
! 132: }
! 133:
! 134: if (fs && currprefs.input_selected_setting == 0) {
! 135: if (JSEM_ISANYKBD (0, &currprefs))
! 136: do_fake (0);
! 137: if (JSEM_ISANYKBD (1, &currprefs))
! 138: do_fake (1);
! 139: return;
! 140: } else {
! 141: if ((kc >> 1) == AK_RCTRL) {
! 142: kc ^= AK_RCTRL << 1;
! 143: kc ^= AK_CTRL << 1;
! 144: }
! 145: if (fs_xa1 || fs_xa2) {
! 146: int k2 = k;
! 147: if (k == AK_1)
! 148: k2 = AK_F1;
! 149: if (k == AK_2)
! 150: k2 = AK_F2;
! 151: if (k == AK_3)
! 152: k2 = AK_LALT;
! 153: if (k == AK_4)
! 154: k2 = AK_RALT;
! 155: if (k == AK_6)
! 156: k2 = AK_DN;
! 157: if (k == AK_LBRACKET || k == AK_LSH)
! 158: k2 = AK_SPC;
! 159: if (k == AK_RBRACKET)
! 160: k2 = AK_RET;
! 161: if (k == AK_C)
! 162: k2 = AK_1;
! 163: if (k == AK_5)
! 164: k2 = AK_2;
! 165: if (k == AK_Z)
! 166: k2 = AK_3;
! 167: if (k == AK_X)
! 168: k2 = AK_4;
! 169: if (k != k2)
! 170: kc = (k2 << 1) | (b ? 0 : 1);
! 171: }
1.1.1.4 root 172: }
1.1.1.8 ! root 173:
1.1 root 174: keybuf[kpb_first] = kc;
175: kpb_first = kpb_next;
176: }
177:
1.1.1.3 root 178: void joystick_setting_changed (void)
179: {
1.1.1.8 ! root 180: fs_np = fs_ck = fs_se = fs_xa1 = fs_xa2 = 0;
1.1.1.3 root 181:
1.1.1.4 root 182: if (JSEM_ISNUMPAD (0, &currprefs))
1.1.1.3 root 183: fs_np = fakestate[0];
1.1.1.4 root 184: else if (JSEM_ISNUMPAD (1, &currprefs))
1.1.1.3 root 185: fs_np = fakestate[1];
186:
1.1.1.4 root 187: if (JSEM_ISCURSOR (0, &currprefs))
1.1.1.3 root 188: fs_ck = fakestate[0];
1.1.1.4 root 189: else if (JSEM_ISCURSOR (1, &currprefs))
1.1.1.3 root 190: fs_ck = fakestate[1];
191:
1.1.1.4 root 192: if (JSEM_ISSOMEWHEREELSE (0, &currprefs))
1.1.1.3 root 193: fs_se = fakestate[0];
1.1.1.4 root 194: else if (JSEM_ISSOMEWHEREELSE (1, &currprefs))
1.1.1.3 root 195: fs_se = fakestate[1];
196:
1.1.1.8 ! root 197: if (JSEM_ISXARCADE1 (0, &currprefs))
! 198: fs_xa1 = fakestate[0];
! 199: else if (JSEM_ISXARCADE1 (1, &currprefs))
! 200: fs_xa1 = fakestate[1];
! 201:
! 202: if (JSEM_ISXARCADE2 (0, &currprefs))
! 203: fs_xa2 = fakestate[0];
! 204: else if (JSEM_ISXARCADE2 (1, &currprefs))
! 205: fs_xa2 = fakestate[1];
! 206:
! 207: }
1.1.1.3 root 208:
1.1 root 209: void keybuf_init (void)
210: {
211: kpb_first = kpb_last = 0;
1.1.1.8 ! root 212: inputdevice_updateconfig (&currprefs);
! 213: }
! 214:
! 215:
! 216: uae_u8 *save_keyboard (int *len)
! 217: {
! 218: uae_u8 *dst, *t;
! 219: dst = t = malloc (8);
! 220: save_u32 (getcapslockstate() ? 1 : 0);
! 221: save_u32 (0);
! 222: *len = 8;
! 223: return t;
! 224: }
! 225:
! 226: uae_u8 *restore_keyboard (uae_u8 *src)
! 227: {
! 228: setcapslockstate (restore_u32 ());
! 229: restore_u32 ();
! 230: return src;
1.1 root 231: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.