source/src/qt/gui/qt_input.cpp

   1 /*
   2  *      Skelton for retropc emulator
   3  *
   4  *      Author : Takeda.Toshiya
   5  *      Date   : 2006.08.18 -
   6  *      Converted to QT by (C) 2015 K.Ohta
   7  *         History:
   8  *            Jan 12, 2015 (maybe) : Initial
   9  *      [ Qt input -> Keyboard]
  10 */
  11
  12 #include <Qt>
  13 #include <QKeyEvent>
  14 //#include "emu.h"
  15 //#include "vm/vm.h"
  16 #include "config.h"
  17 #include "fileio.h"
  18
  19 #include "qt_input.h"
  20 #include "qt_gldraw.h"
  21 #include "qt_main.h"
  22 //#include "menuclasses.h"
  23 #include "agar_logger.h"
  24 #include "menu_flags.h"
  25
  26 #ifndef Ulong
  27 #define Ulong unsigned long
  28 #endif
  29
  30 #define KEY_KEEP_FRAMES 3
  31
  32 //extern USING_FLAGS *using_flags;
  33
  34 #if defined(Q_OS_WIN) || defined(Q_OS_CYGWIN)
  35 const struct NativeScanCode convTable_QTScan106[] = {
  36         // Line 0
  37         {VK_ESCAPE,  0x01},
  38         {VK_F1,  0x3b},
  39         {VK_F2,  0x3c},
  40         {VK_F3,  0x3d},
  41         {VK_F4,  0x3e},
  42         {VK_F5,  0x3f},
  43         {VK_F6,  0x40},
  44         {VK_F7,  0x41},
  45         {VK_F8,  0x42},
  46         {VK_F9,  0x43},
  47         {VK_F10, 0x44},
  48         {VK_F11, 0x57},
  49         {VK_F12, 0x58},
  50         // Power, Sleep, Wake is not implemented, they are'nt safety.
  51         // Line 1
  52         {VK_KANJI, 0x29}, // Hankaku/Zenkaku
  53         {'1', 0x02},
  54         {'2', 0x03},
  55         {'3', 0x04},
  56         {'4', 0x05},
  57         {'5', 0x06},
  58         {'6', 0x07},
  59         {'7', 0x08},
  60         {'8', 0x09},
  61         {'9', 0x0a},
  62         {'0', 0x0b},
  63         {VK_OEM_MINUS, 0x0c}, // - =
  64         {VK_OEM_7, 0x0d}, // ^~
  65         {VK_OEM_5, 0x7d}, // \|
  66         {VK_BACK, 0x0e}, // Backspace
  67         // Line 2
  68         {VK_TAB, 0x0f},
  69         {'Q', 0x10},
  70         {'W', 0x11},
  71         {'E', 0x12},
  72         {'R', 0x13},
  73         {'T', 0x14},
  74         {'Y', 0x15},
  75         {'U', 0x16},
  76         {'I', 0x17},
  77         {'O', 0x18},
  78         {'P', 0x19},
  79         {VK_OEM_3, 0x1a}, // @
  80         {VK_OEM_4, 0x1b}, // [
  81         {VK_RETURN, 0x1c}, // Enter (Full key)
  82         // Line 3
  83         {VK_OEM_ATTN, 0x3a}, // CAPS Lock
  84         {'A', 0x1e},
  85         {'S', 0x1f},
  86         {'D', 0x20},
  87         {'F', 0x21},
  88         {'G', 0x22},
  89         {'H', 0x23},
  90         {'J', 0x24},
  91         {'K', 0x25},
  92         {'L', 0x26},
  93         {VK_OEM_PLUS, 0x27}, // ;
  94         {VK_OEM_1, 0x28}, // :
  95         {VK_OEM_6, 0x2b}, // ]
  96         // Line 3
  97         {VK_LSHIFT, 0x2a}, // LShift
  98         {'Z', 0x2c},
  99         {'X', 0x2d},
 100         {'C', 0x2e},
 101         {'V', 0x2f},
 102         {'B', 0x30},
 103         {'N', 0x31},
 104         {'M', 0x32},
 105         {VK_OEM_COMMA, 0x33}, // ,
 106         {VK_OEM_PERIOD, 0x34}, // .
 107         {VK_OEM_2, 0x35}, // /(Slash)
 108         {VK_OEM_102, 0x73}, //\_
 109         {VK_RSHIFT, 0x36},
 110         // Line 4
 111         {VK_LCONTROL, 0x1d},
 112         {VK_LWIN, 0x015b},
 113         {VK_LMENU, 0x38},
 114         {VK_NONCONVERT, 0x68}, // Muhenkan
 115         {VK_SPACE, 0x39},
 116         {VK_CONVERT, 0x66}, // Henkan
 117         {VK_OEM_COPY, 0x70}, // Katakana_Hiragana
 118         {VK_RMENU, 0x0138},
 119         {VK_RWIN,  0x015c},
 120         {VK_APPS, 0x015d},
 121         {VK_RCONTROL, 0x011d},
 122         // Cursors
 123         {VK_UP, 0x0148},
 124         {VK_DOWN, 0x0150},
 125         {VK_LEFT, 0x014b},
 126         {VK_RIGHT,0x014d},
 127         //
 128         //     {VK_PRINT, },
 129         {VK_SCROLL, 0x46},
 130         {VK_PAUSE, 0x45},
 131         {VK_INSERT, 0x0152},
 132         {VK_HOME, 0x0147},
 133         {VK_NEXT, 0x0149},
 134         {VK_DELETE, 0x0153},
 135         {VK_END, 0x014f},
 136         {VK_PRIOR, 0x0151},
 137         // TenKey
 138         {VK_NUMPAD0, 0x52},
 139         {VK_NUMPAD1, 0x4f},
 140         {VK_NUMPAD2, 0x50},
 141         {VK_NUMPAD3, 0x51},
 142         {VK_NUMPAD4, 0x4b},
 143         {VK_NUMPAD5, 0x4c},
 144         {VK_NUMPAD6, 0x4d},
 145         {VK_NUMPAD7, 0x47},
 146         {VK_NUMPAD8, 0x48},
 147         {VK_NUMPAD9, 0x49},
 148         //
 149         {VK_DECIMAL, 0x53}, // NumLock
 150         {VK_DIVIDE, 0x0135},
 151         {VK_MULTIPLY, 0x37},
 152         {VK_SUBTRACT, 0x4a},
 153         {VK_ADD, 0x4e},
 154         {VK_RETURN, 0x011c},  // Enter(ten Key)
 155         {0xffffffff, 0xffffffff}
 156 };
 157 #endif
 158
 159 uint32_t GLDrawClass::get106Scancode2VK(uint32_t data)
 160 {
 161         uint32_t val = 0;
 162         uint32_t vk;
 163         int i = 0;
 164         vk = key_table->get_vk_from_scan(data);
 165         if(config.swap_kanji_pause) {
 166                 if(vk == VK_KANJI) {
 167                         vk = VK_PAUSE;
 168                 } else if(vk == VK_PAUSE) {
 169                         vk = VK_KANJI;
 170                 }
 171         }
 172         if(!using_flags->is_notify_key_down_lr_shift()) {
 173                 if((vk == VK_LSHIFT) || (vk == VK_RSHIFT)) vk = VK_SHIFT;
 174                 if((vk == VK_LMENU) || (vk == VK_RMENU)) vk = VK_MENU;
 175         }
 176         if((vk == VK_LCONTROL) || (vk == VK_RCONTROL)) vk = VK_CONTROL;
 177         return vk;
 178 }
 179
 180 void GLDrawClass::initKeyCode(void)
 181 {
 182         int i;
 183         key_table = new CSP_KeyTables(this, default_key_table_106_QtScan);
 184
 185         {
 186                 // Replace only ScanCode
 187                 FILEIO *fio = new FILEIO();
 188                 std::string app_path2;
 189                 // Read scan table.
 190                 app_path2 = cpp_confdir + "scancode.cfg";
 191                 if(fio->Fopen(app_path2.c_str(), FILEIO_READ_ASCII)) {
 192                         char buf[512];
 193                         memset(buf, 0x00, sizeof(buf));
 194                         while(fio->Fgets(buf, 512) != NULL) {
 195                                 QString nstr;
 196                                 QStringList nlist;
 197                                 bool ok1, ok2;
 198                                 nstr = QString::fromUtf8(buf);
 199                                 nlist = nstr.split(",", QString::SkipEmptyParts);
 200                                 if(nlist.count() < 2) continue;
 201                                 uint32_t vk   = nlist.at(0).toULong(&ok1, 16);
 202                                 uint32_t scan = nlist.at(1).toULong(&ok2, 16);
 203                                 if((vk == 0) || (vk > 255)) continue;
 204                                 if(ok1 && ok2) {
 205                                         key_table->do_set_scan_code(vk, scan);
 206                                 }
 207                         }
 208                         fio->Fclose();
 209                 }
 210                 delete fio;
 211         }
 212 }
 213
 214 void GLDrawClass::releaseKeyCode(void)
 215 {
 216         // Replace only ScanCode
 217         int i;
 218         FILEIO *fio = new FILEIO();
 219         std::string app_path2;
 220         uint32_t scan;
 221         // Read scan table.
 222
 223         app_path2 = cpp_confdir + "scancode.cfg";
 224         if(fio->Fopen(app_path2.c_str(), FILEIO_WRITE_ASCII)) {
 225                 for(i = 0; i < 256; i++) {
 226                         scan = key_table->get_scan_from_vk((uint32_t)i);
 227                         if(scan >= 0xffffffff)  continue;
 228                         fio->Fprintf("%02x,%08x\n", i, scan);
 229                 }
 230                 fio->Fclose();
 231         }
 232         if(key_table != NULL) {
 233                 delete key_table;
 234                 key_table = NULL;
 235         }
 236 }
 237
 238 void GLDrawClass::keyReleaseEvent(QKeyEvent *event)
 239 {
 240         int key = event->key();
 241         uint32_t mod = event->modifiers();
 242         uint32_t scan;
 243         uint32_t vk;
 244         if(event->isAutoRepeat()) return;
 245         scan = event->nativeScanCode();
 246         vk = get106Scancode2VK(scan);
 247 #if defined(Q_OS_WIN) || defined(Q_OS_CYGWIN)
 248         if(using_flags->is_notify_key_down_lr_shift()) {
 249                 if(vk == VK_SHIFT) {
 250                         if((GetAsyncKeyState(VK_LSHIFT) & 0x8000) == 0) vk = VK_LSHIFT;
 251                         if((GetAsyncKeyState(VK_RSHIFT) & 0x8000) == 0) vk = VK_RSHIFT;
 252                 }
 253                 if(vk == VK_MENU) {
 254                         if(GetAsyncKeyState(VK_LMENU) & 0x8000) vk = VK_LMENU;
 255                         if(GetAsyncKeyState(VK_RMENU) & 0x8000) vk = VK_RMENU;
 256                 }
 257         }
 258 #endif
 259         //printf("Key: UP: VK=%d SCAN=%04x MOD=%08x\n", vk, scan, mod);
 260         emit sig_key_up(vk, mod);
 261 }
 262
 263 void GLDrawClass::keyPressEvent(QKeyEvent *event)
 264 {
 265         int key = event->key();
 266         uint32_t mod = event->modifiers();;
 267         uint32_t scan;
 268         uint32_t vk;
 269
 270         if(event->isAutoRepeat()) return;
 271         scan = event->nativeScanCode();
 272         vk = get106Scancode2VK(scan);
 273
 274         if(using_flags->is_use_mouse()) {
 275                 if(vk == VK_APPS) { // Special key : capture/uncapture mouse.
 276                         emit sig_toggle_mouse();
 277                         return;
 278                 }
 279         }
 280 #if defined(Q_OS_WIN) || defined(Q_OS_CYGWIN)
 281         if(using_flags->is_notify_key_down_lr_shift()) {
 282                 if(vk == VK_SHIFT) {
 283                         if(GetAsyncKeyState(VK_LSHIFT) & 0x8000) vk = VK_LSHIFT;
 284                         if(GetAsyncKeyState(VK_RSHIFT) & 0x8000) vk = VK_RSHIFT;
 285                 }
 286                 if(vk == VK_MENU) {
 287                         if(GetAsyncKeyState(VK_LMENU) & 0x8000) vk = VK_LMENU;
 288                         if(GetAsyncKeyState(VK_RMENU) & 0x8000) vk = VK_RMENU;
 289                 }
 290         }
 291 #endif
 292
 293         //printf("Key: DOWN: VK=%d SCAN=%04x MOD=%08x\n", vk, scan, mod);
 294         emit sig_key_down(vk, mod, false);
 295 }
 296
 297
 298 QStringList *GLDrawClass::getKeyNames(void)
 299 {
 300         if(key_table) {
 301                 return key_table->get_scan_name_list();
 302         }
 303         return NULL;
 304 }
 305
 306 QStringList *GLDrawClass::getVKNames(void)
 307 {
 308         if(key_table) {
 309                 return key_table->get_vk_name_list();
 310         }
 311         return NULL;
 312 }
 313
 314 keydef_table_t *GLDrawClass::get_key_table(int index)
 315 {
 316         if(key_table) {
 317                 return key_table->get_using_key_table(index);
 318         }
 319         return NULL;
 320 }
 321
 322 keydef_table_t *GLDrawClass::get_key_tables(void)
 323 {
 324         if(key_table) {
 325                 return key_table->get_using_key_table(0);
 326         }
 327         return NULL;
 328 }
 329
 330 int GLDrawClass::get_key_table_size(void)
 331 {
 332         if(key_table) {
 333                 return key_table->get_key_table_size();
 334         }
 335         return 0;
 336 }
 337
 338
 339 void GLDrawClass::do_update_keyboard_scan_code(uint32_t vk, uint32_t scan)
 340 {
 341         if(key_table) {
 342                 key_table->do_set_scan_code(vk, scan);
 343         }
 344 }
 345
 346 uint32_t GLDrawClass::get_vk_from_index(int index)
 347 {
 348         if(key_table) {
 349                 return key_table->get_vk_from_index(index);
 350         }
 351         return 0;
 352 }
 353
 354 uint32_t GLDrawClass::get_scan_from_index(int index)
 355 {
 356         if(key_table) {
 357                 return key_table->get_scan_from_index(index);
 358         }
 359         return 0;
 360 }
 361
 362 const char *GLDrawClass::get_key_vk_name(int index)
 363 {
 364         if(key_table) {
 365                 return key_table->get_vk_name(index);
 366         }
 367         return NULL;
 368 }
 369
 370 const keydef_table_t *GLDrawClass::get_default_key_table()
 371 {
 372         if(key_table) {
 373                 return (const keydef_table_t *)key_table->get_default_key_table();
 374         }
 375         return NULL;
 376 }