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