From: sungmin ha Date: Thu, 28 Aug 2014 02:03:53 +0000 (+0900) Subject: keyboard: modified keyboard operation X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=e9efd1c27181560bb9430d3d1c213cdf567caf7a;p=sdk%2Femulator%2Fqemu.git keyboard: modified keyboard operation for ubuntu and windows support Change-Id: Iae7147b7e747b959a40bc9e33edc09dbcd20e8ee Signed-off-by: sungmin ha --- diff --git a/tizen/src/skin/maruskin_keymap.h b/tizen/src/skin/maruskin_keymap.h index a58d9fc064..77beb6393b 100644 --- a/tizen/src/skin/maruskin_keymap.h +++ b/tizen/src/skin/maruskin_keymap.h @@ -85,11 +85,9 @@ enum JAVA_KEYCODE { JAVA_KEY_DELETE = 127 }; - #define KEY_MAX 0777 #define KEY_F0 0410 -#define QT_KEY_F0 66 #ifdef KEY_F #undef KEY_F @@ -103,123 +101,8 @@ enum JAVA_KEYCODE { #define KEY_BTAB 0541 -#define QT_KEY_F(n) (QT_KEY_F0 + (n)) -#define QT_KEY_UP 111 -#define QT_KEY_DOWN 116 -#define QT_KEY_LEFT 113 -#define QT_KEY_RIGHT 114 - #define SHIFT 0 -/* for Qt skin */ -static const int qtkey2scancode[KEY_MAX] = { - [0 ... (KEY_MAX - 1)] = -1, - - [9] = 1, /* Escape */ - [10] = 2, /* Number 1 ~ 0 */ - [11] = 3, - [12] = 4, - [13] = 5, - [14] = 6, - [15] = 7, - [16] = 8, - [17] = 9, - [18] = 10, - [19] = 11, - [20] = 12, /* - */ - [21] = 13, /* = */ - [22] = 14, /* Backspace */ - - [23] = 15, /* Tab */ - [24] = 16, /* q ~ p */ - [25] = 17, - [26] = 18, - [27] = 19, - [28] = 20, - [29] = 21, - [30] = 22, - [31] = 23, - [32] = 24, - [33] = 25, - [34] = 26, /* [ */ - [35] = 27, /* ] */ - [36] = 28, /* Enter */ - [104] = 28, /* Return */ - - [37] = 29, /* Ctrl */ - [64] = 56, /* Alt */ - [38] = 30, /* a ~ l */ - [39] = 31, - [40] = 32, - [41] = 33, - [42] = 34, - [43] = 35, - [44] = 36, - [45] = 37, - [46] = 38, - [47] = 39, /* ; */ - [48] = 40, /* Single quote */ - [49] = 41, /* ` */ - [50] = 42, /* Left Shift */ - [51] = 43, /* Backslash */ - - [52] = 44, /* z ~ m */ - [53] = 45, - [54] = 46, - [55] = 47, - [56] = 48, - [57] = 49, - [58] = 50, - [59] = 51, /* , */ - [60] = 52, /* . */ - [61] = 53, /* / */ - [62] = 42, /* Right Shift */ - - [106] = 53, /* Keypad / */ - [63] = 55, /* Keypad * */ - [82] = 74, /* Keypad - */ - [86] = 78, /* Keypad + */ - [90] = 82, /* Keypad 0 */ - [87] = 79, /* Keypad 1 */ - [88] = 80, /* Keypad 2 */ - [89] = 81, /* Keypad 3 */ - [83] = 75, /* Keypad 4 */ - [84] = 76, /* Keypad 5 */ - [85] = 77, /* Keypad 6 */ - [79] = 71, /* Keypad 7 */ - [80] = 72, /* Keypad 8 */ - [81] = 73, /* Keypad 9 */ - [91] = 83, /* Keypad . */ - [65] = 57, /* Space */ - - [QT_KEY_F(1)] = 59, /* Function Key 1 */ - [QT_KEY_F(2)] = 60, /* Function Key 2 */ - [QT_KEY_F(3)] = 61, /* Function Key 3 */ - [QT_KEY_F(4)] = 62, /* Function Key 4 */ - [QT_KEY_F(5)] = 63, /* Function Key 5 */ - [QT_KEY_F(6)] = 64, /* Function Key 6 */ - [QT_KEY_F(7)] = 65, /* Function Key 7 */ - [QT_KEY_F(8)] = 66, /* Function Key 8 */ - [QT_KEY_F(9)] = 67, /* Function Key 9 */ - [QT_KEY_F(10)] = 68, /* Function Key 10 */ - [QT_KEY_F(11)] = 87, /* Function Key 11 */ - [QT_KEY_F(12)] = 88, /* Function Key 12 */ - - [QT_KEY_UP] = 72, /* Up Arrow */ - [QT_KEY_LEFT] = 75, /* Left Arrow */ - [QT_KEY_RIGHT] = 77, /* Right Arrow */ - [QT_KEY_DOWN] = 80, /* Down Arrow */ - - [112] = 73, /* PgUp */ - [117] = 81, /* PgDn */ - [110] = 71, /* Home */ - [115] = 79, /* End */ - [118] = 82, /* Insert */ - [119] = 83, /* Delete */ - - [127] = 198, /* Pause/Break */ -}; - /* for Java skin*/ static const int vkkey2scancode[KEY_MAX] = { [0 ... (KEY_MAX - 1)] = -1, diff --git a/tizen/src/skin/maruskin_operation.c b/tizen/src/skin/maruskin_operation.c index 7a0c1d8e9e..e4bb30a079 100644 --- a/tizen/src/skin/maruskin_operation.c +++ b/tizen/src/skin/maruskin_operation.c @@ -185,14 +185,12 @@ void do_mouse_event(int button_type, int event_type, } void do_qt_keyboard_key_event(int event_type, int keycode) { - int scancode = qtkey2scancode[keycode]; - if (KEY_PRESSED == event_type) { - TRACE("key pressed: %d\n", scancode); - virtio_keyboard_event(scancode); + TRACE("key pressed: %d\n", keycode); + virtio_keyboard_event(keycode); } else if (KEY_RELEASED == event_type) { - TRACE("key released: %d\n", scancode); - virtio_keyboard_event(scancode | 0x80); + TRACE("key released: %d\n", keycode); + virtio_keyboard_event(keycode | 0x80); } } diff --git a/tizen/src/ui/Makefile.objs b/tizen/src/ui/Makefile.objs index 44775becbf..9389303f1d 100644 --- a/tizen/src/ui/Makefile.objs +++ b/tizen/src/ui/Makefile.objs @@ -16,6 +16,7 @@ obj-$(CONFIG_QT) += skinbezelitem.o obj-$(CONFIG_QT) += skincontrollerview.o obj-$(CONFIG_QT) += skinkeyitem.o obj-$(CONFIG_QT) += skinform.o +obj-$(CONFIG_QT) += keyboardhelper.o obj-$(CONFIG_QT) += skinview.o obj-$(CONFIG_QT) += uiinformation.o obj-$(CONFIG_QT) += uistate.o diff --git a/tizen/src/ui/keyboardhelper.cpp b/tizen/src/ui/keyboardhelper.cpp new file mode 100644 index 0000000000..37ac16e6be --- /dev/null +++ b/tizen/src/ui/keyboardhelper.cpp @@ -0,0 +1,464 @@ +/* + * Qt keyboard helper + * + * Copyright (C) 2014 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Sungmin Ha + * Sangho Park + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +#include +#include + +#include "keyboardhelper.h" + +extern "C" { +#include "emul_state.h" +#include "skin/maruskin_operation.h" + +void virtio_keyboard_event(int keycode); +} + +KeyboardHelper::KeyboardHelper() +{ + createKeyMap(); + createKeypadMap(); + + this->numLockState = false; + this->capsLockState = false; +} + +void KeyboardHelper::createKeypadMap() +{ + keypadMap.insert(48, Qt::Key_Insert); + keypadMap.insert(49, Qt::Key_End); + keypadMap.insert(50, Qt::Key_Down); + keypadMap.insert(51, Qt::Key_PageDown); + keypadMap.insert(52, Qt::Key_Left); + keypadMap.insert(53, Qt::Key_Clear); + keypadMap.insert(54, Qt::Key_Right); + keypadMap.insert(55, Qt::Key_Home); + keypadMap.insert(56, Qt::Key_Up); + keypadMap.insert(57, Qt::Key_PageUp); + keypadMap.insert(46, Qt::Key_Delete); + keypadMap.insert(42, 106); /* * */ + keypadMap.insert(45, 109); /* - */ + + keypadMap.insert(Qt::Key_Insert, 48); + keypadMap.insert(Qt::Key_End, 49); + keypadMap.insert(Qt::Key_Down, 50); + keypadMap.insert(Qt::Key_PageDown, 51); + keypadMap.insert(Qt::Key_Left, 52); + keypadMap.insert(Qt::Key_Clear, 53); + keypadMap.insert(Qt::Key_Right, 54); + keypadMap.insert(Qt::Key_Home, 55); + keypadMap.insert(Qt::Key_Up, 56); + keypadMap.insert(Qt::Key_PageUp, 57); + keypadMap.insert(Qt::Key_Delete, 46); +} + +void KeyboardHelper::createKeyMap() +{ + /* characters */ + /* q ~ p */ + keyMap.insert(81, 16); + keyMap.insert(87, 17); + keyMap.insert(69, 18); + keyMap.insert(82, 19); + keyMap.insert(84, 20); + keyMap.insert(89, 21); + keyMap.insert(85, 22); + keyMap.insert(73, 23); + keyMap.insert(79, 24); + keyMap.insert(80, 25); + + /* a ~ l */ + keyMap.insert(65, 30); + keyMap.insert(83, 31); + keyMap.insert(68, 32); + keyMap.insert(70, 33); + keyMap.insert(71, 34); + keyMap.insert(72, 35); + keyMap.insert(74, 36); + keyMap.insert(75, 37); + keyMap.insert(76, 38); + + /* z ~ m */ + keyMap.insert(90, 44); + keyMap.insert(88, 45); + keyMap.insert(67, 46); + keyMap.insert(86, 47); + keyMap.insert(66, 48); + keyMap.insert(78, 49); + keyMap.insert(77, 50); + + /* signs */ + keyMap.insert(32, 57); /* space */ + keyMap.insert(44, 51); /* , */ + keyMap.insert(46, 52); /* . */ + keyMap.insert(59, 39); /* ; */ + keyMap.insert(47, 53); /* / */ + keyMap.insert(42, 55); /* * */ + keyMap.insert(106, 55); /* * */ + keyMap.insert(45, 12); /* - */ + keyMap.insert(109, 74); /* - */ + keyMap.insert(61, 13); /* = */ + keyMap.insert(91, 26); /* [ */ + keyMap.insert(93, 27); /* ] */ + keyMap.insert(92, 43); /* \ */ + keyMap.insert(43, 78); /* + */ + keyMap.insert(39, 40); /* Single quote */ + keyMap.insert(96, 41); /* ` */ + + /* special keys */ + keyMap.insert(Qt::Key_Return, 28); /* return */ + keyMap.insert(Qt::Key_Enter, 28); /* enter */ + keyMap.insert(Qt::Key_Escape, 1); /* escape */ + keyMap.insert(Qt::Key_Tab, 15); /* tab */ + keyMap.insert(Qt::Key_Backtab, 15); /* shift tab */ + keyMap.insert(Qt::Key_Backspace, 14); /* backspace */ + keyMap.insert(Qt::Key_Pause, 198); /* pause/break */ + keyMap.insert(Qt::Key_PageUp, 73); /* PgUp */ + keyMap.insert(Qt::Key_PageDown, 81); /* PgDn */ + keyMap.insert(Qt::Key_Home, 71); /* Home */ + keyMap.insert(Qt::Key_End, 79); /* End */ + keyMap.insert(Qt::Key_Insert, 82); /* Insert */ + keyMap.insert(Qt::Key_Delete, 83); /* delete */ + + /* arrow keys */ + keyMap.insert(Qt::Key_Up, 72); /* up arrow */ + keyMap.insert(Qt::Key_Down, 80); /* down arrow */ + keyMap.insert(Qt::Key_Left, 75); /* left arrow */ + keyMap.insert(Qt::Key_Right, 77); /* right arrow */ + + /* modifiers */ + keyMap.insert(Qt::Key_Shift, 42); /* shift */ + keyMap.insert(Qt::Key_Control, 29); /* ctrl */ + keyMap.insert(Qt::Key_Alt, 56); /* alt */ + + /* numbers */ + keyMap.insert(48, 11); /* 0 */ + keyMap.insert(49, 2); /* 1 */ + keyMap.insert(50, 3); /* 2 */ + keyMap.insert(51, 4); /* 3 */ + keyMap.insert(52, 5); /* 4 */ + keyMap.insert(53, 6); /* 5 */ + keyMap.insert(54, 7); /* 6 */ + keyMap.insert(55, 8); /* 7 */ + keyMap.insert(56, 9); /* 8 */ + keyMap.insert(57, 10); /* 9 */ + + /* shift + numbers */ + keyMap.insert(126, 41); /* ~ */ + keyMap.insert(33, 2); /* ! */ + keyMap.insert(64, 3); /* @ */ + keyMap.insert(35, 4); /* # */ + keyMap.insert(36, 5); /* $ */ + keyMap.insert(37, 6); /* % */ + keyMap.insert(94, 7); /* ^ */ + keyMap.insert(38, 8); /* & */ + keyMap.insert(40, 10); /* ( */ + keyMap.insert(41, 11); /* ) */ + + /* shift + signs */ + keyMap.insert(95, 12); /* _ */ + keyMap.insert(124, 43); /* | */ + keyMap.insert(123, 26); /* { */ + keyMap.insert(125, 27); /* } */ + keyMap.insert(58, 39); /* : */ + keyMap.insert(34, 40); /* " */ + keyMap.insert(60, 51); /* < */ + keyMap.insert(62, 52); /* > */ + keyMap.insert(63, 53); /* ? */ + + /* function keys */ + keyMap.insert(Qt::Key_F1, 59); /* f1 */ + keyMap.insert(Qt::Key_F2, 60); /* f2 */ + keyMap.insert(Qt::Key_F3, 61); /* f3 */ + keyMap.insert(Qt::Key_F4, 62); /* f4 */ + keyMap.insert(Qt::Key_F5, 63); /* f5 */ + keyMap.insert(Qt::Key_F6, 64); /* f6 */ + keyMap.insert(Qt::Key_F7, 65); /* f7 */ + keyMap.insert(Qt::Key_F8, 66); /* f8 */ + keyMap.insert(Qt::Key_F9, 67); /* f9 */ + keyMap.insert(Qt::Key_F10, 68); /* f10 */ + keyMap.insert(Qt::Key_F11, 87); /* f11 */ + keyMap.insert(Qt::Key_F12, 88); /* f12 */ +} + +void KeyboardHelper::autoKeyRelease(void) +{ + while (!this->keyCodeList.isEmpty()) { + qDebug() << "auto release scancode: " << this->keyCodeList.last(); + do_qt_keyboard_key_event(KEY_RELEASED, this->keyCodeList.last()); + this->keyCodeList.removeLast(); + } + +#if 0 + clear_finger_slot(false); + qDebug() << "disable multi-touch"; +#endif +} + +int KeyboardHelper::keyCodeOperation(QKeyEvent *event, int keyCode) +{ + /* keypad and specialKey translation */ + if (!this->numLockState && (event->modifiers() == (Qt::KeypadModifier | Qt::ShiftModifier))) { + QMap::iterator keypadIter = this->keypadMap.find(keyCode); + while (keypadIter != this->keypadMap.end()) { + if (keypadIter.key() == keyCode) { + keyCode = keypadIter.value(); + break; + } + } + } + + if (this->isSpecialKey(keyCode)) { + virtio_keyboard_event(224); + } + + QMap::iterator keyMapIter = this->keyMap.find(keyCode); + while (keyMapIter != this->keyMap.end()) { + if (keyMapIter.key() == keyCode) { + break; + } + } + + if (keyMapIter == this->keyMap.end()) { + qDebug() << "unsupported keycode pressed: " << keyCode; + return -1; + } + + return keyMapIter.value(); +} + +bool KeyboardHelper::isSpecialKey(int keyCode) +{ + switch(keyCode) { + case Qt::Key_PageDown: + case Qt::Key_PageUp: + case Qt::Key_Home: + case Qt::Key_End: + case Qt::Key_Insert: + case Qt::Key_Delete: + case Qt::Key_Up: + case Qt::Key_Down: + case Qt::Key_Left: + case Qt::Key_Right: + return true; + default: + break; + } + + return false; +} + +void KeyboardHelper::keyPressed(QKeyEvent *event) +{ + int keyCode = event->key(); + qDebug() << "key pressed :" << event->key() << event->text() << event->nativeScanCode() << event->modifiers() << event->nativeModifiers(); + +#if 0 + /* TODO: multi-touch */ + if (get_emul_max_touch_point() > 1) { + /* multi-touch checking */ + if (event->modifiers() == (Qt::ShiftModifier|Qt::ControlModifier)) { + get_emul_multi_touch_state()->multitouch_enable = 2; + /* add a finger before start the multi-touch processing + if already exist the pressed touch in display */ + qDebug() << "enable multi-touch = mode 2"; + } else if (event->modifiers() == Qt::ShiftModifier || + event->modifiers() == Qt::ControlModifier) { + get_emul_multi_touch_state()->multitouch_enable = 1; + qDebug() << "enable multi-touch = mode 1"; + } + } +#endif + + /* NumLock or CapsLock key */ + if (keyCode == Qt::Key_NumLock) { +#ifdef CONFIG_WIN32 + if (event->nativeModifiers() == 0x1000200) { + this->numLockState = ON; + } else if (event->nativeModifiers() == 0x1000000) { + this->numLockState = OFF; + } +#else + if (event->nativeModifiers() == 0) { + this->numLockState = ON; + } else if (event->nativeModifiers() == 16) { + this->numLockState = OFF; + } +#endif + qDebug() << "num_lock state: " << this->numLockState << "pressed"; + return; + } else if (keyCode == Qt::Key_CapsLock) { +#ifdef CONFIG_WIN32 + if (event->nativeModifiers() == 256) { + this->capsLockState = ON; + } else if (event->nativeModifiers() == 0) { + this->capsLockState = OFF; + } +#else + if (event->nativeModifiers() == 18) { + this->capsLockState = ON; + } else if (event->nativeModifiers() == 16) { + this->capsLockState = OFF; + } +#endif + qDebug() << "caps_lock state: " << this->capsLockState << "pressed"; + return; + } + + /* host numlock check for sync */ + if ((event->modifiers() & Qt::KeypadModifier)) { + if (this->isSpecialKey(keyCode) || keyCode == Qt::Key_Clear) { + if (!(event->modifiers() & Qt::ShiftModifier)) { + this->numLockState = OFF; + } else { + this->numLockState = ON; + } + } else { + if (!(event->modifiers() & Qt::ShiftModifier || keyCode == 42 || keyCode == 43 || keyCode == 45 || keyCode == 47)) { /* (42 = *, 43 = +, 45 = -, 47 = /) on keypad */ + this->numLockState = ON; + } else { + this->numLockState = OFF; + } + } + } + if (event->key() >= 65 && event->key() <= 90) { +#ifdef CONFIG_WIN32 + if (event->nativeModifiers() & 256) { +#else + if (event->nativeModifiers() & 0x02) { +#endif + this->capsLockState = ON; + } else { + this->capsLockState = OFF; + } + } + + if (get_emul_caps_lock_state() != this->capsLockState) { + virtio_keyboard_event(58); + virtio_keyboard_event(58 | 0x80); + set_emul_caps_lock_state(get_emul_caps_lock_state() ^ 1); + qDebug() << "qemu CapsLock state was synchronized with host key value (" << + get_emul_caps_lock_state() << ")"; + } + if (get_emul_num_lock_state() != this->numLockState) { + virtio_keyboard_event(69); + virtio_keyboard_event(69 | 0x80); + set_emul_num_lock_state(get_emul_num_lock_state() ^ 1); + qDebug() << "qemu NumLock state was synchronized with host key value (" << + get_emul_num_lock_state() << ")"; + } + + int ret = this->keyCodeOperation(event, keyCode); + if (ret != -1) { + /* for auto release */ + this->keyCodeList.append(ret); + do_qt_keyboard_key_event(KEY_PRESSED, ret); + } +} + +void KeyboardHelper::keyReleased(QKeyEvent *event) +{ + int keyCode = event->key(); + qDebug() << "key released :" << event->key() << event->text() << event->nativeScanCode() << event->modifiers() << event->nativeModifiers(); + +#if 0 + /* TODO: multi-touch */ + if (event->key() == Qt::Key_Shift && event->modifiers() == Qt::ControlModifier) { + get_emul_multi_touch_state()->multitouch_enable = 1; + qDebug() << "enabled multi-touch = mode 1"; + } else if (event->key() == Qt::Key_Shift || event->key() == Qt::Key_Control) { + clear_finger_slot(false); + qDebug() << "disable multi-touch"; + } +#endif + + if (keyCode == Qt::Key_NumLock) { + qDebug() << "num_lock state: " << this->numLockState << "released"; + return; + } else if (keyCode == Qt::Key_CapsLock) { + qDebug() << "caps_lock state: " << this->capsLockState << "released"; + return; + } + +#ifdef CONFIG_LINUX + /* for keypad keycode translation */ + if (this->numLockState && event->modifiers() == Qt::KeypadModifier) { + if (this->isSpecialKey(keyCode) || keyCode == Qt::Key_Clear) { + switch(keyCode) { + case Qt::Key_Delete: + keyCode = 46; /* . */ + break; + case Qt::Key_Insert: + keyCode = 48; /* 0 */ + break; + case Qt::Key_End: + keyCode = 49; /* 1 */ + break; + case Qt::Key_Down: + keyCode = 50; /* 2 */ + break; + case Qt::Key_PageDown: + keyCode = 51; /* 3 */ + break; + case Qt::Key_Left: + keyCode = 52; /* 4 */ + break; + case Qt::Key_Clear: + keyCode = 53; /* 5 */ + break; + case Qt::Key_Right: + keyCode = 54; /* 6 */ + break; + case Qt::Key_Home: + keyCode = 55; /* 7 */ + break; + case Qt::Key_Up: + keyCode = 56; /* 8 */ + break; + case Qt::Key_PageUp: + keyCode = 57; /* 9 */ + break; + default: + break; + } + } + } +#endif + + int ret = this->keyCodeOperation(event, keyCode); + if (ret != -1) { + do_qt_keyboard_key_event(KEY_RELEASED, ret); + /* remove keycode from list */ + this->keyCodeList.removeOne(ret); + } +} + +KeyboardHelper::~KeyboardHelper() +{ + qDebug("destroy keyboard helper"); +} diff --git a/tizen/src/ui/keyboardhelper.h b/tizen/src/ui/keyboardhelper.h new file mode 100644 index 0000000000..7eef329712 --- /dev/null +++ b/tizen/src/ui/keyboardhelper.h @@ -0,0 +1,64 @@ +/* + * Qt keyboard helper + * + * Copyright (C) 2014 Samsung Electronics Co., Ltd. All rights reserved. + * + * Contact: + * Sungmin Ha + * Sangho Park + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, + * MA 02110-1301, USA. + * + * Contributors: + * - S-Core Co., Ltd + * + */ + +#ifndef KEYBOARDHELPER_H +#define KEYBOARDHELPER_H + +#include + +enum KbdLedState { + OFF, + ON +}; + +class KeyboardHelper +{ +public: + KeyboardHelper(); + ~KeyboardHelper(); + + void keyPressed(QKeyEvent *event); + void keyReleased(QKeyEvent *event); + void autoKeyRelease(void); + bool isSpecialKey(int keyCode); + int keyCodeOperation(QKeyEvent *event, int keyCode); + +protected: + QList keyCodeList; + QMap keyMap; + QMap keypadMap; + bool numLockState; + bool capsLockState; + +private: + void createKeyMap(); + void createKeypadMap(); +}; + +#endif // KEYBOARDHELPER_H diff --git a/tizen/src/ui/skinview.cpp b/tizen/src/ui/skinview.cpp index d743d4dcf3..6637d58ed5 100644 --- a/tizen/src/ui/skinview.cpp +++ b/tizen/src/ui/skinview.cpp @@ -46,6 +46,8 @@ SkinView::SkinView(QGraphicsScene *scene, QWidget *parent) : grabPos = QPoint(-1, -1); createItems(); + + kbd = new KeyboardHelper(); } void SkinView::createItems() @@ -139,132 +141,20 @@ void SkinView::mouseMoveEvent(QMouseEvent *event) QGraphicsView::mouseMoveEvent(event); } -void SkinView::autoKeyRelease(void) -{ - while (!this->keyCodeList.isEmpty()) { - qDebug() << "auto release scancode: " << this->keyCodeList.last(); - do_qt_keyboard_key_event(KEY_RELEASED, this->keyCodeList.last()); - this->keyCodeList.removeLast(); - } - -#if 0 - clear_finger_slot(false); - qDebug() << "disable multi-touch"; -#endif -} - void SkinView::focusOutEvent(QFocusEvent *event) { qDebug() << "focus out!"; - this->autoKeyRelease(); -} - -bool SkinView::isSpecialKey(QKeyEvent *event) -{ - if (event->modifiers() == Qt::NoModifier) { - switch(event->key()) { - case Qt::Key_PageDown: - case Qt::Key_PageUp: - case Qt::Key_Home: - case Qt::Key_End: - case Qt::Key_Insert: - case Qt::Key_Delete: - return true; - default: - break; - } - } - - return false; + this->kbd->autoKeyRelease(); } void SkinView::keyPressEvent(QKeyEvent *event) { - qDebug() << "key pressed :" << event->key() << event->text() << event->nativeScanCode() << event->modifiers(); - -#if 0 - /* TODO: multi-touch */ - if (get_emul_max_touch_point() > 1) { - /* multi-touch checking */ - if (event->modifiers() == (Qt::ShiftModifier|Qt::ControlModifier)) { - get_emul_multi_touch_state()->multitouch_enable = 2; - /* add a finger before start the multi-touch processing - if already exist the pressed touch in display */ - qDebug() << "enable multi-touch = mode 2"; - } else if (event->modifiers() == Qt::ShiftModifier || - event->modifiers() == Qt::ControlModifier) { - get_emul_multi_touch_state()->multitouch_enable = 1; - qDebug() << "enable multi-touch = mode 1"; - } - } -#endif - - if (event->key() == Qt::Key_NumLock) { - set_emul_num_lock_state(get_emul_num_lock_state() ^ 1); //toggle - return; - } else if (event->key() == Qt::Key_CapsLock) { - set_emul_caps_lock_state(get_emul_caps_lock_state() ^ 1); //toggle - return; - } - - int caps_lock = -1; - int num_lock = -1; - - caps_lock = get_host_lock_key_state(HOST_CAPSLOCK_KEY); - num_lock = get_host_lock_key_state(HOST_NUMLOCK_KEY); - - if (caps_lock != -1 && get_emul_caps_lock_state() != caps_lock) { - virtio_keyboard_event(58); - virtio_keyboard_event(58 | 0x80); - set_emul_caps_lock_state(get_emul_caps_lock_state() ^ 1); - qDebug() << "qemu CapsLock state was synchronized with host key value (" << - get_emul_caps_lock_state() << ")"; - } - if (num_lock != -1 && get_emul_num_lock_state() != num_lock) { - virtio_keyboard_event(69); - virtio_keyboard_event(69 | 0x80); - set_emul_num_lock_state(get_emul_num_lock_state() ^ 1); - qDebug() << "qemu NumLock state was synchronized with host key value (" << - get_emul_num_lock_state() << ")"; - } - - if (this->isSpecialKey(event)) { - virtio_keyboard_event(224); - } - - /* for auto release */ - this->keyCodeList.append(event->nativeScanCode()); - - do_qt_keyboard_key_event(KEY_PRESSED, event->nativeScanCode()); + this->kbd->keyPressed(event); } void SkinView::keyReleaseEvent(QKeyEvent *event) { - qDebug() << "key released :" << event->key() << event->text() << event->nativeScanCode() << event->modifiers(); - -#if 0 - /* TODO: multi-touch */ - if (event->key() == Qt::Key_Shift && event->modifiers() == Qt::ControlModifier) { - get_emul_multi_touch_state()->multitouch_enable = 1; - qDebug() << "enabled multi-touch = mode 1"; - } else if (event->key() == Qt::Key_Shift || event->key() == Qt::Key_Control) { - clear_finger_slot(false); - qDebug() << "disable multi-touch"; - } -#endif - - if (event->key() == Qt::Key_NumLock || event->key() == Qt::Key_CapsLock) { - return; - } - - if (this->isSpecialKey(event)) { - virtio_keyboard_event(224); - } - - do_qt_keyboard_key_event(KEY_RELEASED, event->nativeScanCode()); - - /* remove keycode from list */ - this->keyCodeList.removeOne(event->nativeScanCode()); + this->kbd->keyReleased(event); } SkinView::~SkinView() diff --git a/tizen/src/ui/skinview.h b/tizen/src/ui/skinview.h index eeaae0a210..abbdc42303 100644 --- a/tizen/src/ui/skinview.h +++ b/tizen/src/ui/skinview.h @@ -32,9 +32,7 @@ #include -extern "C" { -void virtio_keyboard_event(int keycode); -} +#include "keyboardhelper.h" class SkinView : public QGraphicsView { @@ -53,12 +51,10 @@ protected: void keyPressEvent(QKeyEvent *event); void keyReleaseEvent(QKeyEvent *event); void focusOutEvent(QFocusEvent *event); - void autoKeyRelease(void); - bool isSpecialKey(QKeyEvent *event); QPoint grabWinPos; QPoint grabPos; - QList keyCodeList; + KeyboardHelper *kbd; private: void createItems();