Return to rawkeys.c CVS log

Up to [UNIX Amiga Emulator] / uae / src

Annotation of uae/src/rawkeys.c, revision 1.1

1.1     ! root        1:  /*
        !             2:   * UAE - The Un*x Amiga Emulator
        !             3:   *
        !             4:   * Support for mapping SDL raw keycodes
        !             5:   *
        !             6:   * Copyright 2004 Richard Drummond
        !             7:   */
        !             8: 
        !             9: #include "sysconfig.h"
        !            10: #include "sysdeps.h"
        !            11: 
        !            12: #include "options.h"
        !            13: #include "inputdevice.h"
        !            14: #include "keyboard.h"
        !            15: 
        !            16: #include "hotkeys.h"
        !            17: #include "keymap/keymap.h"
        !            18: #include "keymap/keymap_all.h"
        !            19: #include "sdlgfx.h"
        !            20: 
        !            21: #include <SDL.h>
        !            22: 
        !            23: /*
        !            24:  * This stuff is hacked together for now to get
        !            25:  * raw keyboard support working and tested.
        !            26:  *
        !            27:  * A cleaner implementation will be coming . . .
        !            28:  */
        !            29: struct sdl_raw_keymap
        !            30: {
        !            31:     int                          sdl_gfx_driver;
        !            32:     const char                  *name;
        !            33:     const struct uaekey_hostmap *keymap;
        !            34:          struct uae_hotkeyseq  *hotkeys;
        !            35:     const int                   *modtable;
        !            36: };
        !            37: 
        !            38: static struct uae_input_device_kbr_default *keyboard = 0;
        !            39: static const int *modkeytable;
        !            40: 
        !            41: /*
        !            42:  * Table used to pick keymapping based on SDL gfx driver
        !            43:  */
        !            44: static const struct sdl_raw_keymap keymaps[] = {
        !            45: #if (defined __i386__ || defined __x86_64__ || defined __powerpc__ || defined __ppc__) && defined __linux__
        !            46:     { SDLGFX_DRIVER_X11,     "x11pc",  x11pc_keymap,  x11pc_hotkeys,  0},
        !            47:     { SDLGFX_DRIVER_DGA,     "x11pc",  x11pc_keymap,  x11pc_hotkeys,  0},
        !            48: #endif
        !            49: #if (defined __powerpc__ || defined __ppc__) && defined __APPLE__
        !            50:     { SDLGFX_DRIVER_QUARTZ,  "quartz", quartz_keymap, quartz_hotkeys, quartz_modkeytable},
        !            51: #endif
        !            52: #ifdef __BEOS__
        !            53:     { SDLGFX_DRIVER_BWINDOW, "beos",   beos_keymap,   beos_hotkeys,   0},
        !            54: #endif
        !            55: #ifdef TARGET_AMIGAOS
        !            56: # ifdef __amigaos4__
        !            57:     { SDLGFX_DRIVER_AMIGAOS4, "amiga", amiga_keymap,  amiga_hotkeys,  0},
        !            58: # else
        !            59:     { SDLGFX_DRIVER_CYBERGFX, "amiga", amiga_keymap,  amiga_hotkeys,  0},
        !            60: # endif
        !            61: #endif
        !            62:     { 0, 0, 0, 0, 0 }
        !            63: };
        !            64: 
        !            65: struct uae_input_device_kbr_default *get_default_raw_keymap (int type)
        !            66: {
        !            67:     const struct sdl_raw_keymap *k = &keymaps[0];
        !            68: 
        !            69:     if (!keyboard) {
        !            70:        free (keyboard);
        !            71:        keyboard = 0;
        !            72:     }
        !            73: 
        !            74:     while (k->sdl_gfx_driver != type && k->sdl_gfx_driver != 0)
        !            75:        k++;
        !            76: 
        !            77:     if (k->keymap) {
        !            78:        write_log ("Found %s raw keyboard mapping\n", k->name);
        !            79:        modkeytable = k->modtable;
        !            80:        keyboard = uaekey_make_default_kbr (k->keymap);
        !            81:     }
        !            82: 
        !            83:     return keyboard;
        !            84: }
        !            85: 
        !            86: struct uae_hotkeyseq *get_default_raw_hotkeys (void)
        !            87: {
        !            88:     const struct sdl_raw_keymap *k = &keymaps[0];
        !            89: 
        !            90:     while (k->sdl_gfx_driver != get_sdlgfx_type())
        !            91:        k++;
        !            92: 
        !            93:     return k->hotkeys;
        !            94: }
        !            95: 
        !            96: 
        !            97: /*
        !            98:  * Map SDL modifier key to raw key code
        !            99:  *
        !           100:  * This is required on platforms where the modifiers keys aren't
        !           101:  * reported with a raw key code - but SDL_GetModState() works, e.g.,
        !           102:  * on OS X.
        !           103:  */
        !           104: int modifier_hack (int *scancode, int *pressed)
        !           105: {
        !           106:     int result = 1;
        !           107: 
        !           108:     static int old_modifiers = 0;
        !           109:     int modifiers = SDL_GetModState ();
        !           110: 
        !           111:     if (modkeytable && modifiers != old_modifiers) {
        !           112:        if ((modifiers & KMOD_LSHIFT) != (old_modifiers & KMOD_LSHIFT)) {
        !           113:             *scancode = modkeytable[UAEMODKEY_LSHIFT];
        !           114:             *pressed  = modifiers & KMOD_LSHIFT;
        !           115:        } else if ((modifiers & KMOD_RSHIFT) != (old_modifiers & KMOD_RSHIFT)) {
        !           116:             *scancode = modkeytable[UAEMODKEY_RSHIFT];
        !           117:             *pressed  = modifiers & KMOD_RSHIFT;
        !           118:        } else if ((modifiers & KMOD_LCTRL) != (old_modifiers & KMOD_LCTRL)) {
        !           119:             *scancode = modkeytable[UAEMODKEY_LCTRL];
        !           120:             *pressed  = modifiers & KMOD_LCTRL;
        !           121:        } else if ((modifiers & KMOD_RCTRL) != (old_modifiers & KMOD_RCTRL)) {
        !           122:             *scancode = modkeytable[UAEMODKEY_RCTRL];
        !           123:             *pressed  = modifiers & KMOD_RCTRL;
        !           124:        } else if ((modifiers & KMOD_LALT) != (old_modifiers & KMOD_LALT)) {
        !           125:             *scancode = modkeytable[UAEMODKEY_LALT];
        !           126:             *pressed  = modifiers & KMOD_LALT;
        !           127:        } else if ((modifiers & KMOD_RALT) != (old_modifiers & KMOD_RALT)) {
        !           128:             *scancode = modkeytable[UAEMODKEY_RALT];
        !           129:             *pressed  = modifiers & KMOD_RALT;
        !           130:        } else if ((modifiers & KMOD_LMETA) != (old_modifiers & KMOD_LMETA)) {
        !           131:             *scancode = modkeytable[UAEMODKEY_LSUPER];
        !           132:             *pressed  = modifiers & KMOD_LMETA;
        !           133:        } else if ((modifiers & KMOD_RMETA) != (old_modifiers & KMOD_RMETA)) {
        !           134:             *scancode = modkeytable[UAEMODKEY_RSUPER];
        !           135:             *pressed  = modifiers & KMOD_RMETA;
        !           136:        } else if ((modifiers & KMOD_CAPS) != (old_modifiers & KMOD_CAPS)) {
        !           137:             *scancode = modkeytable[UAEMODKEY_CAPSLOCK];
        !           138:             *pressed  = modifiers & KMOD_CAPS;
        !           139:        } else
        !           140:             result = 0;
        !           141:        old_modifiers = modifiers;
        !           142:     } else
        !           143:        result = 0;
        !           144: 
        !           145:     return result;
        !           146: }

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