![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to keymap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous / src|
Return to keymap.c CVS log | Up to [Previous NeXT emulator] / previous / src |
1.1 root 1: /*
2: Hatari - keymap.c
3:
4: This file is distributed under the GNU Public License, version 2 or at
5: your option any later version. Read the file gpl.txt for details.
6:
7: Here we process a key press and the remapping of the scancodes.
8: */
9: const char Keymap_fileid[] = "Hatari keymap.c : " __DATE__ " " __TIME__;
10:
11: #include <ctype.h>
12: #include "main.h"
13: #include "keymap.h"
14: #include "configuration.h"
15: #include "file.h"
16: #include "shortcut.h"
17: #include "str.h"
18: #include "screen.h"
19: #include "debugui.h"
20: #include "log.h"
1.1.1.2 root 21: #include "ioMem.h"
22: #include "m68000.h"
1.1.1.3 ! root 23: #include "dma.h"
! 24: #include "sysReg.h"
1.1.1.2 root 25:
26: #include "SDL.h"
27:
28:
1.1.1.3 ! root 29: #define IO_SEG_MASK 0x1FFFF
! 30:
1.1.1.2 root 31: /*
32:
33: Byte at address 0x0200e00a contains modifier key values:
34:
35: x--- ---- valid
36: -x-- ---- alt_right
37: --x- ---- alt_left
38: ---x ---- command_right
39: ---- x--- command_left
40: ---- -x-- shift_right
41: ---- --x- shift_left
42: ---- ---x control
43:
44:
45: Byte at address 0x0200e00b contains key values:
46:
47: x--- ---- key up (1) or down (0)
48: -xxx xxxx key_code
49:
50: */
51:
52:
53: void Keymap_Init(void) {
54: if(ConfigureParams.Keyboard.bDisableKeyRepeat)
55: SDL_EnableKeyRepeat(0, 0);
56: else
57: SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
58: }
59:
60: Uint8 nextkeycode;
61: Uint8 modkeys;
62: Uint8 ralt;
63: Uint8 lalt;
64: Uint8 rcom;
65: Uint8 lcom;
66: Uint8 rshift;
67: Uint8 lshift;
68: Uint8 ctrl;
69:
1.1.1.3 ! root 70: /*--------------------------- Monitor, move to different place --------------------------*/
! 71: #define LOG_MON_LEVEL LOG_DEBUG
1.1.1.2 root 72:
1.1.1.3 ! root 73: /* Monitor Register 0 */
! 74: #define DMAOUT_ENABLE 0x80
! 75: #define DMAOUT_DAV 0x40
! 76: #define DMAOUT_OVR 0x20
! 77: #define DMAIN_ENABLE 0x08
! 78: #define DMAIN_DAV 0x04
! 79: #define DMAIN_OVR 0x02
! 80:
! 81: /* Monitor Register 1 */
! 82: #define KM_INT 0x80
! 83: #define KM_DAV 0x40
! 84: #define KM_OVR 0x20
! 85: #define KM_CLR_NMI 0x10
! 86: #define CONTROL_INT 0x08
! 87: #define CONTROL_DAV 0x04
! 88: #define CONTROL_OVR 0x02
! 89:
! 90: /* Monitor Register 2 */
! 91: #define DTX_PEND 0x80
! 92: #define DTX 0x40
! 93: #define CTX_PEND 0x20
! 94: #define CTX 0x10
! 95: #define RTX_PEND 0x08
! 96: #define RTX 0x04
! 97: #define RESET 0x02
! 98: #define TXLOOP 0x01
! 99:
! 100: /* Monitor Register 3 */
! 101:
! 102:
! 103: struct {
! 104: Uint8 status_dma;
! 105: Uint8 status_kbdmouse;
! 106: Uint8 status_x;
! 107: Uint8 command;
! 108: } monitor_csr;
! 109:
! 110: void Monitor_CSR_Read(void) {
! 111: Uint8 reg = IoAccessCurrentAddress&0x3;
! 112: Uint8 val;
! 113:
! 114: switch (reg) {
! 115: case 0:
! 116: Log_Printf(LOG_MON_LEVEL, "Monitor: DMA CSR read at $%08x PC=$%08x\n", IoAccessCurrentAddress, m68k_getpc());
! 117: val = monitor_csr.status_dma; //DMAOUT_ENABLE|DMAOUT_OVR; // 0xA0;
! 118: break;
! 119:
! 120: case 1:
! 121: //Log_Printf(LOG_MON_LEVEL, "Monitor: Keyboard status read at $%08x PC=$%08x\n", IoAccessCurrentAddress, m68k_getpc());
! 122: val = monitor_csr.status_kbdmouse|0xF0; //KM_INT|KM_DAV|KM_OVR|KM_CLR_NMI; // 0xF0;
! 123: break;
! 124:
! 125: case 2:
! 126: Log_Printf(LOG_MON_LEVEL, "Monitor: X status read at $%08x PC=$%08x\n", IoAccessCurrentAddress, m68k_getpc());
! 127: val = monitor_csr.status_x; //CTX|RESET|TXLOOP // 0x13;
! 128: break;
! 129:
! 130: case 3:
! 131: Log_Printf(LOG_MON_LEVEL, "Monitor: Command read at $%08x PC=$%08x\n", IoAccessCurrentAddress, m68k_getpc());
! 132: val = monitor_csr.command;
! 133: break;
! 134: }
! 135: IoMem[IoAccessCurrentAddress&IO_SEG_MASK] = val;
1.1.1.2 root 136: }
137:
1.1.1.3 ! root 138: void Monitor_CSR_Write(void) {
! 139: Uint8 reg = IoAccessCurrentAddress&0x3;
! 140: Uint8 val = IoMem[IoAccessCurrentAddress&IO_SEG_MASK];
! 141: Uint8 sound[32768];
! 142: Uint32 length;
! 143:
! 144: switch (reg) {
! 145: case 0:
! 146: Log_Printf(LOG_MON_LEVEL, "Monitor: DMA CSR write at $%08x, val = %02x, PC=$%08x\n",
! 147: IoAccessCurrentAddress, val, m68k_getpc());
! 148: monitor_csr.status_dma = val;
! 149: if (monitor_csr.status_dma&DMAOUT_ENABLE) {
! 150: dma_memory_read(sound, &length, CHANNEL_SOUNDOUT);
! 151: monitor_csr.status_dma |= DMAOUT_ENABLE;
! 152: }
! 153: break;
! 154:
! 155: case 1:
! 156: Log_Printf(LOG_MON_LEVEL, "Monitor: Keyboard status write at $%08x, val = %02x, PC=$%08x\n",
! 157: IoAccessCurrentAddress, val, m68k_getpc());
! 158: monitor_csr.status_kbdmouse = val;
! 159: break;
! 160:
! 161: case 2:
! 162: Log_Printf(LOG_MON_LEVEL, "Monitor: X status write at $%08x, val = %02x, PC=$%08x\n",
! 163: IoAccessCurrentAddress, val, m68k_getpc());
! 164: monitor_csr.status_x = val;
! 165: break;
! 166:
! 167: case 3:
! 168: Log_Printf(LOG_MON_LEVEL, "Monitor: Command write at $%08x, val = %02x, PC=$%08x\n",
! 169: IoAccessCurrentAddress, val, m68k_getpc());
! 170: monitor_csr.command = val;
! 171: switch (monitor_csr.command) {
! 172: case 0xc4:
! 173: set_interrupt(INT_SND_OUT_DMA, SET_INT);
! 174: monitor_csr.status_dma = 0x00;
! 175: break;
! 176:
! 177: default:
! 178: break;
! 179: }
! 180: break;
! 181: }
1.1.1.2 root 182: }
183:
1.1.1.3 ! root 184: /*------------------------------ End of monitor code -------------------------------*/
1.1.1.2 root 185:
186: void Keycode_Read(void) {
1.1.1.3 ! root 187: //Log_Printf(LOG_WARN, "Keycode read at $%08x PC=$%08x\n", IoAccessCurrentAddress, m68k_getpc());
! 188: //IoMem[0xe002]=0x93;
! 189: monitor_csr.status_kbdmouse = DTX_PEND | CTX | RESET | TXLOOP;
1.1.1.2 root 190: IoMem[0xe008]=0x10;
191:
192: IoMem[0xe00a]=modkeys; // Set modifier Keys
193: IoMem[0xe00b]=nextkeycode; // Press virtual Key
194: nextkeycode=nextkeycode | 0x80; // Automatically release virtual Key
195: }
196:
197:
198: void KeyTranslator(SDL_keysym *sdlkey) { // Translate SDL Keys to NeXT Keycodes
199: Log_Printf(LOG_WARN, "Key pressed: %s\n", SDL_GetKeyName(sdlkey->sym));
200:
201: int symkey = sdlkey->sym;
202: int modkey = sdlkey->mod;
203: if (ShortCut_CheckKeys(modkey, symkey, 1)) // Check if we pressed a shortcut
204: ShortCut_ActKey();
205: else
206:
207: switch (sdlkey->sym) {
208:
209: case SDLK_RIGHTBRACKET: nextkeycode = 0x04;
210: break;
211: case SDLK_LEFTBRACKET: nextkeycode = 0x05;
212: break;
213: case SDLK_i: nextkeycode = 0x06;
214: break;
215: case SDLK_o: nextkeycode = 0x07;
216: break;
217: case SDLK_p: nextkeycode = 0x08;
218: break;
219: case SDLK_LEFT: nextkeycode = 0x09;
220: break;
221: case SDLK_KP0: nextkeycode = 0x0B;
222: break;
223: case SDLK_KP_PERIOD: nextkeycode = 0x0C;
224: break;
225: case SDLK_KP_ENTER: nextkeycode = 0x0D;
226: break;
227: case SDLK_DOWN: nextkeycode = 0x0F;
228: break;
229: case SDLK_RIGHT: nextkeycode = 0x10;
230: break;
231: case SDLK_KP1: nextkeycode = 0x11;
232: break;
233: case SDLK_KP4: nextkeycode = 0x12;
234: break;
235: case SDLK_KP6: nextkeycode = 0x13;
236: break;
237: case SDLK_KP3: nextkeycode = 0x14;
238: break;
239: case SDLK_KP_PLUS: nextkeycode = 0x15;
240: break;
241: case SDLK_UP: nextkeycode = 0x16;
242: break;
243: case SDLK_KP2: nextkeycode = 0x17;
244: break;
245: case SDLK_KP5: nextkeycode = 0x18;
246: break;
247: case SDLK_BACKSPACE: nextkeycode = 0x1B;
248: break;
249: case SDLK_EQUALS: nextkeycode = 0x1C;
250: break;
251: case SDLK_MINUS: nextkeycode = 0x1D;
252: break;
253: case SDLK_8: nextkeycode = 0x1E;
254: break;
255: case SDLK_9: nextkeycode = 0x1F;
256: break;
257: case SDLK_0: nextkeycode = 0x20;
258: break;
259: case SDLK_KP7: nextkeycode = 0x21;
260: break;
261: case SDLK_KP8: nextkeycode = 0x22;
262: break;
263: case SDLK_KP9: nextkeycode = 0x23;
264: break;
265: case SDLK_KP_MINUS: nextkeycode = 0x24;
266: break;
267: case SDLK_KP_MULTIPLY: nextkeycode = 0x25;
268: break;
269: case SDLK_BACKQUOTE: nextkeycode = 0x26;
270: break;
271: case SDLK_KP_EQUALS: nextkeycode = 0x27;
272: break;
273: case SDLK_KP_DIVIDE: nextkeycode = 0x28;
274: break;
275: case SDLK_RETURN: nextkeycode = 0x2A;
276: break;
277: case SDLK_BACKSLASH: nextkeycode = 0x2B;
278: break;
279: case SDLK_SEMICOLON: nextkeycode = 0x2C;
280: break;
281: case SDLK_l: nextkeycode = 0x2D;
282: break;
283: case SDLK_COMMA: nextkeycode = 0x2E;
284: break;
285: case SDLK_PERIOD: nextkeycode = 0x2F;
286: break;
287: case SDLK_SLASH: nextkeycode = 0x30;
288: break;
289: case SDLK_z: nextkeycode = 0x31;
290: break;
291: case SDLK_x: nextkeycode = 0x32;
292: break;
293: case SDLK_c: nextkeycode = 0x33;
294: break;
295: case SDLK_v: nextkeycode = 0x34;
296: break;
297: case SDLK_b: nextkeycode = 0x35;
298: break;
299: case SDLK_m: nextkeycode = 0x36;
300: break;
301: case SDLK_n: nextkeycode = 0x37;
302: break;
303: case SDLK_SPACE: nextkeycode = 0x38;
304: break;
305: case SDLK_a: nextkeycode = 0x39;
306: break;
307: case SDLK_s: nextkeycode = 0x3A;
308: break;
309: case SDLK_d: nextkeycode = 0x3B;
310: break;
311: case SDLK_f: nextkeycode = 0x3C;
312: break;
313: case SDLK_g: nextkeycode = 0x3D;
314: break;
315: case SDLK_k: nextkeycode = 0x3E;
316: break;
317: case SDLK_j: nextkeycode = 0x3F;
318: break;
319: case SDLK_h: nextkeycode = 0x40;
320: break;
321: case SDLK_TAB: nextkeycode = 0x41;
322: break;
323: case SDLK_q: nextkeycode = 0x42;
324: break;
325: case SDLK_w: nextkeycode = 0x43;
326: break;
327: case SDLK_e: nextkeycode = 0x44;
328: break;
329: case SDLK_r: nextkeycode = 0x45;
330: break;
331: case SDLK_u: nextkeycode = 0x46;
332: break;
333: case SDLK_y: nextkeycode = 0x47;
334: break;
335: case SDLK_t: nextkeycode = 0x48;
336: break;
337: case SDLK_ESCAPE: nextkeycode = 0x49;
338: break;
339: case SDLK_1: nextkeycode = 0x4A;
340: break;
341: case SDLK_2: nextkeycode = 0x4B;
342: break;
343: case SDLK_3: nextkeycode = 0x4C;
344: break;
345: case SDLK_4: nextkeycode = 0x4D;
346: break;
347: case SDLK_7: nextkeycode = 0x4E;
348: break;
349: case SDLK_6: nextkeycode = 0x4F;
350: break;
351: case SDLK_5: nextkeycode = 0x50;
352: break;
353:
354: /* Modifier Keys */
355: case SDLK_RMETA: ctrl = 0x01;
356: break;
357: case SDLK_LMETA: ctrl = 0x01;
358: break;
359: case SDLK_LSHIFT: lshift = 0x02;
360: break;
361: case SDLK_RSHIFT: rshift = 0x04;
362: break;
363: case SDLK_LCTRL: lcom = 0x08;
364: break;
365: case SDLK_RCTRL: rcom = 0x10;
366: break;
367: case SDLK_LALT: lalt = 0x20;
368: break;
369: case SDLK_RALT: ralt = 0x40;
370: break;
371: case SDLK_CAPSLOCK: lshift = 0x02, rshift = 0x04;
372: break;
373:
374: /* Special keys not yet emulated:
375: SOUND_UP_KEY 0x1A
376: SOUND_DOWN_KEY 0x02
377: BRIGHTNESS_UP_KEY 0x19
378: BRIGHTNESS_DOWN_KEY 0x01
379: POWER_KEY 0x58
380: */
381:
382: default: break;
383: }
384: modkeys = 0x80 | ralt | lalt | rcom | lcom | rshift | lshift | ctrl;
385: Log_Printf(LOG_WARN, "Modkeys: $%02x\n", modkeys);
386: }
387:
388:
389: void KeyRelease(SDL_keysym *sdlkey) { //release modifier Keys
390: int symkey = sdlkey->sym;
391: int modkey = sdlkey->mod;
392: if (ShortCut_CheckKeys(modkey, symkey, 0))
393: return;
394:
395: switch (sdlkey->sym) {
396:
397: case SDLK_RMETA: ctrl = 0x00;
398: break;
399: case SDLK_LMETA: ctrl = 0x00;
400: break;
401: case SDLK_LSHIFT: lshift = 0x00;
402: break;
403: case SDLK_RSHIFT: rshift = 0x00;
404: break;
405: case SDLK_LCTRL: lcom = 0x00;
406: break;
407: case SDLK_RCTRL: rcom = 0x00;
408: break;
409: case SDLK_LALT: lalt = 0x00;
410: break;
411: case SDLK_RALT: ralt = 0x00;
412: break;
413: case SDLK_CAPSLOCK: lshift = 0x00, rshift = 0x00;
414: break;
415: default: break;
416: }
417: modkeys = 0x80 | ralt | lalt | rcom | lcom | rshift | lshift | ctrl;
418: Log_Printf(LOG_WARN, "Modkeys: $%02x\n", modkeys);
419: }
1.1 root 420:
421:
422:
423: /*-----------------------------------------------------------------------*/
424: /**
425: * User press key down
426: */
427: void Keymap_KeyDown(SDL_keysym *sdlkey)
428: {
429: bool bPreviousKeyState;
430: char STScanCode;
431: int symkey = sdlkey->sym;
432: int modkey = sdlkey->mod;
433:
434: /*fprintf(stderr, "keydown: sym=%i scan=%i mod=$%x\n",symkey, sdlkey->scancode, modkey);*/
435:
436: if (ShortCut_CheckKeys(modkey, symkey, 1))
437: return;
438:
439: }
440:
441:
442: /*-----------------------------------------------------------------------*/
443: /**
444: * User released key
445: */
446: void Keymap_KeyUp(SDL_keysym *sdlkey)
447: {
448: char STScanCode;
449: int symkey = sdlkey->sym;
450: int modkey = sdlkey->mod;
451:
452: /*fprintf(stderr, "keyup: sym=%i scan=%i mod=$%x\n",symkey, sdlkey->scancode, modkey);*/
453:
454: /* Ignore short-cut keys here */
455:
456: if (ShortCut_CheckKeys(modkey, symkey, 0))
457: return;
458:
459:
460: }
461:
462: /*-----------------------------------------------------------------------*/
463: /**
464: * Simulate press or release of a key corresponding to given character
465: */
466: void Keymap_SimulateCharacter(char asckey, bool press)
467: {
468: SDL_keysym sdlkey;
469:
470: sdlkey.mod = KMOD_NONE;
471: sdlkey.scancode = 0;
472: if (isupper(asckey)) {
473: if (press) {
474: sdlkey.sym = SDLK_LSHIFT;
475: Keymap_KeyDown(&sdlkey);
476: }
477: sdlkey.sym = tolower(asckey);
478: sdlkey.mod = KMOD_LSHIFT;
479: } else {
480: sdlkey.sym = asckey;
481: }
482: if (press) {
483: Keymap_KeyDown(&sdlkey);
484: } else {
485: Keymap_KeyUp(&sdlkey);
486: if (isupper(asckey)) {
487: sdlkey.sym = SDLK_LSHIFT;
488: Keymap_KeyUp(&sdlkey);
489: }
490: }
491: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.