diff options
Diffstat (limited to 'recipes/qte/qte-2.3.10/kernel-keymap.patch')
-rw-r--r-- | recipes/qte/qte-2.3.10/kernel-keymap.patch | 1293 |
1 files changed, 1293 insertions, 0 deletions
diff --git a/recipes/qte/qte-2.3.10/kernel-keymap.patch b/recipes/qte/qte-2.3.10/kernel-keymap.patch new file mode 100644 index 0000000000..0111c83b45 --- /dev/null +++ b/recipes/qte/qte-2.3.10/kernel-keymap.patch @@ -0,0 +1,1293 @@ +--- /dev/null 2004-07-13 00:58:01.000000000 +0000 ++++ qte/src/kernel/kernelkeyboard.cpp 2007-04-07 01:00:36.000000000 +0000 +@@ -0,0 +1,769 @@ ++/* ++ ++ Copyright (C) 2003 Chris Larson ++ Copyright (C) 2004, 2005 Holger Hans Peter Freyther ++ All rights reserved. ++ ++ Redistribution and use in source and binary forms, with or without ++ modification, are permitted provided that the following conditions are met: ++ ++ Redistributions of source code must retain the above copyright notice, ++ this list of conditions and the following disclaimer. ++ ++ Redistributions in binary form must reproduce the above copyright ++ notice, this list of conditions and the following disclaimer in the ++ documentation and/or other materials provided with the distribution. ++ ++ Neither the name Chris Larson nor the names of its ++ contributors may be used to endorse or promote products derived ++ from this software without specific prior written permission. ++ ++ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS ++ FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ++ COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, ++ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES ++ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR ++ SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ++ HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, ++ STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING ++ IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE ++ POSSIBILITY OF SUCH DAMAGE. ++ ++*/ ++ ++/* ++ Copyright (C) 2005 ROAD GmbH ++ ++ 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., 59 Temple Place, Suite 330, ++ Boston, MA 02111-1307 USA ++ ++ ++ Changes Done: ++ -ShiftL and ShiftR modifier handling ++ -Keypad handling improved ++ -Handle unmapped keys by lookin them up in the first column ++ -Handle AutoRepeat ++ -Handle Keys >127 ++ -Handle Increment and Decrement the Console ++ -Handle the Home Key ++ -Fix handling of Function Keys ++ -Fix handling of the unicode value (to fix QPopupMenu,QAction) ++ ++ */ ++ ++/* ++ Paul Sokolovsky, 2007-04: ++ ++ 1. Added support for nicely named and extensible key bindings. ++ E.g., in loadkeys do: ++ keycode 155 = F100 ++ string F100 = "power" ++ where 155 is keycode a power button happens to have on your machine, F100 is ++ arbitrary function key (please use F100-F120), and "power" is OPIE binding. ++ Currently defined bindings are "power", "backlight", "record" ++ 2. K_DO ("Do") keycode is mapped to OPIE power button by default. Kernel uses ++ K_DO for KEY_POWER input subsystem keycode. So, if your device does the right ++ thing, it will work out of the box. ++ 3. Implemented NumLock handling for numeric keypad. ++ */ ++ ++/* ++ This is an alternative implementation of the QWSTtyKeyboardHandler ++ of Trolltech's QtE. ++ ++ Instead of using a hardcoded incomplete map, this implementation ++ imports the Keymap from a Linux Kernel. ++ ++ */ ++ ++ ++// ++// Tty keyboard ++// ++#include "keyboard_linux_to_qt.h" ++ ++QWSTtyKeyboardHandler::QWSTtyKeyboardHandler(const QString& device) ++ : current_map(0), modifier( 0 ), numlock( false ), capslock( false ) ++{ ++ restoreLeds(); ++ kbdFD=open(device.isEmpty() ? "/dev/tty0" : device.latin1(), O_RDWR | O_NDELAY, 0); ++ ++ if ( kbdFD >= 0 ) { ++ QSocketNotifier *notifier; ++ notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this ); ++ connect( notifier, SIGNAL(activated(int)),this, ++ SLOT(readKeyboardData()) ); ++ ++ // save for restore. ++ tcgetattr( kbdFD, &origTermData ); ++ ++ struct termios termdata; ++ tcgetattr( kbdFD, &termdata ); ++ ++#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) ++ ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW); ++#endif ++ ++ termdata.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP); ++ termdata.c_oflag = 0; ++ termdata.c_cflag = CREAD | CS8; ++ termdata.c_lflag = 0; ++ termdata.c_cc[VTIME]=0; ++ termdata.c_cc[VMIN]=1; ++ cfsetispeed(&termdata, 9600); ++ cfsetospeed(&termdata, 9600); ++ tcsetattr(kbdFD, TCSANOW, &termdata); ++ ++ readUnicodeMap(); ++ readKeyboardMap(); ++ ++ signal(VTSWITCHSIG, vtSwitchHandler); ++ ++#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) ++ struct vt_mode vtMode; ++ ioctl(kbdFD, VT_GETMODE, &vtMode); ++ ++ // let us control VT switching ++ vtMode.mode = VT_PROCESS; ++ vtMode.relsig = VTSWITCHSIG; ++ vtMode.acqsig = VTSWITCHSIG; ++ ioctl(kbdFD, VT_SETMODE, &vtMode); ++ ++ struct vt_stat vtStat; ++ ioctl(kbdFD, VT_GETSTATE, &vtStat); ++ vtQws = vtStat.v_active; ++#endif ++ } ++} ++ ++QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler() ++{ ++ restoreLeds(); ++ if (kbdFD >= 0) ++ { ++#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) ++ struct vt_mode vtMode; ++ ioctl(kbdFD, VT_GETMODE, &vtMode); ++ ++ /* Mickey says: "Better give up control of VT switching. ++ * Hey, I really hate that OS-will-reacquire-resources on process-death ++ * kind of thinking! ++ */ ++ vtMode.mode = VT_AUTO; ++ vtMode.relsig = 0; ++ vtMode.acqsig = 0; ++ ioctl(kbdFD, VT_SETMODE, &vtMode); ++ ++ signal(VTSWITCHSIG, 0); ++ qDebug( "~QWSTtyKeyboardHandler() - released VT." ); ++#endif ++ ++#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) ++ ioctl(kbdFD, KDSKBMODE, K_XLATE); ++#endif ++ tcsetattr(kbdFD, TCSANOW, &origTermData); ++ ::close(kbdFD); ++ kbdFD = -1; ++ } ++} ++void QWSTtyKeyboardHandler::readUnicodeMap() ++{ ++ if (kbdFD < 0) ++ return; ++ if (ioctl(kbdFD,GIO_UNISCRNMAP,acm) != 0) ++ return; ++} ++ ++static Qt::Key getSpecialKey(int fKey) ++{ ++ struct kbsentry kbs; ++ kbs.kb_func = fKey; ++ ++ if (ioctl(kbdFD, KDGKBSENT, &kbs) != 0) ++ return Qt::Key_unknown; ++ const char *str = (const char *)kbs.kb_string; ++ ++ if (!strcmp("record", str)) ++ return Qt::Key_F24; ++ else if (!strcmp("power", str)) ++ return Qt::Key_F34; ++ else if (!strcmp("backlight", str)) ++ return Qt::Key_F35; ++ ++ return Qt::Key_unknown; ++} ++ ++void QWSTtyKeyboardHandler::readKeyboardMap() ++{ ++ struct kbentry kbe; ++ if (kbdFD < 0) ++ return; ++ ++ for (int map = 0; map < (1<<KG_CAPSSHIFT); ++map) { ++ unsigned short kval; ++ kbe.kb_table = map; ++ ++ for (int key = 0; key < NR_KEYS; ++key) { ++ kbe.kb_index = key; ++ ++ ++ if ( (ioctl(kbdFD, KDGKBENT, &kbe) != 0) || ++ ((kbe.kb_value == K_HOLE) || (kbe.kb_value == K_NOSUCHMAP)) ) { ++ kernel_map[map][key] = KeyMap( KeyMap::Key_NotMapped, 0 ); ++ continue; ++ } ++ ++ kval = KVAL(kbe.kb_value); ++ switch (KTYP(kbe.kb_value)) { ++ /* ++ * Map asciis and letters to Qt KeyCodes ++ * via the map (0-255) ++ */ ++ case KT_LETTER: ++ case KT_LATIN: ++ case KT_META: ++ kernel_map[map][key] = KeyMap( linux_to_qt[kval], kval ); ++ break; ++ ++ /* ++ * Handle the F Keys and map them ++ * to Qt ++ */ ++ case KT_FN: ++ if ( kval <= 19 ) ++ kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F1 + kval ), kval ); ++ else if ( kval >= 30 && kval <= 44) ++ kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F21 + (kval - 30) ), kval ); ++ else { ++ Qt::Key specialKey = getSpecialKey(kval); ++ if (specialKey != Qt::Key_unknown) { ++ kernel_map[map][key] = KeyMap( specialKey, kval ); ++ } ++ else ++ switch(kbe.kb_value ) { ++ case K_INSERT: ++ kernel_map[map][key] = KeyMap( Qt::Key_Insert, kval ); ++ break; ++ case K_REMOVE: ++ kernel_map[map][key] = KeyMap( Qt::Key_Delete, kval ); // right? ++ break; ++ case K_SELECT: ++ kernel_map[map][key] = KeyMap( Qt::Key_End , kval ); ++ break; ++ case K_PGUP: ++ kernel_map[map][key] = KeyMap( Qt::Key_Prior, kval ); ++ break; ++ case K_PGDN: ++ kernel_map[map][key] = KeyMap( Qt::Key_Next, kval ); ++ break; ++ case K_MACRO: ++ kernel_map[map][key] = KeyMap( Qt::Key_Menu, kval ); ++ break; ++ case K_HELP: ++ kernel_map[map][key] = KeyMap( Qt::Key_Help, kval ); ++ break; ++ case K_PAUSE: ++ kernel_map[map][key] = KeyMap( Qt::Key_Pause, kval ); ++ break; ++ case K_FIND: ++ kernel_map[map][key] = KeyMap( Qt::Key_Home, kval ); ++ break; ++ case K_DO: ++ kernel_map[map][key] = KeyMap( Qt::Key_F34, kval ); ++ break; ++ default: ++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval ); ++ break; ++ } ++ } ++ break; ++ ++ case KT_SPEC: ++ switch ( kbe.kb_value ) { ++ case K_ENTER: ++ kernel_map[map][key] = KeyMap( Qt::Key_Enter, kval ); ++ break; ++ case K_CAPS: ++ kernel_map[map][key] = KeyMap( Qt::Key_CapsLock, kval ); ++ break; ++ case K_NUM: ++ kernel_map[map][key] = KeyMap( Qt::Key_NumLock, kval ); ++ break; ++ case K_HOLD: ++ kernel_map[map][key] = KeyMap( Qt::Key_ScrollLock, kval ); ++ break; ++ case K_DECRCONSOLE: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_DecConsole, kval ); ++ break; ++ case K_INCRCONSOLE: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_IncConsole, kval ); ++ break; ++ case K_HOLE: ++ case K_SH_REGS: ++ case K_SH_MEM: ++ case K_SH_STAT: ++ case K_BREAK: ++ case K_CONS: ++ case K_SCROLLFORW: ++ case K_SCROLLBACK: ++ case K_BOOT: ++ case K_CAPSON: ++ case K_COMPOSE: ++ case K_SAK: ++ case K_SPAWNCONSOLE: ++ case K_BARENUMLOCK: ++ default: ++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval ); ++ break; ++ } ++ break; ++ case KT_PAD: ++ /* ++ * Number Values might be wrong ++ */ ++ switch(kbe.kb_value ) { ++ case K_P0: ++ kernel_map[map][key] = KeyMap( Qt::Key_0, kbe.kb_value ); ++ break; ++ case K_P1: ++ kernel_map[map][key] = KeyMap( Qt::Key_1, kbe.kb_value ); ++ break; ++ case K_P2: ++ kernel_map[map][key] = KeyMap( Qt::Key_2, kbe.kb_value ); ++ break; ++ case K_P3: ++ kernel_map[map][key] = KeyMap( Qt::Key_3, kbe.kb_value ); ++ break; ++ case K_P4: ++ kernel_map[map][key] = KeyMap( Qt::Key_4, kbe.kb_value ); ++ break; ++ case K_P5: ++ kernel_map[map][key] = KeyMap( Qt::Key_5, kbe.kb_value ); ++ break; ++ case K_P6: ++ kernel_map[map][key] = KeyMap( Qt::Key_6, kbe.kb_value ); ++ break; ++ case K_P7: ++ kernel_map[map][key] = KeyMap( Qt::Key_7, kbe.kb_value ); ++ break; ++ case K_P8: ++ kernel_map[map][key] = KeyMap( Qt::Key_8, kbe.kb_value ); ++ break; ++ case K_P9: ++ kernel_map[map][key] = KeyMap( Qt::Key_9, kbe.kb_value ); ++ break; ++ case K_PPLUS: ++ kernel_map[map][key] = KeyMap( Qt::Key_Plus, '+' ); ++ break; ++ case K_PMINUS: ++ kernel_map[map][key] = KeyMap( Qt::Key_Minus, '-' ); ++ break; ++ case K_PSTAR: ++ kernel_map[map][key] = KeyMap( Qt::Key_multiply, '*' ); ++ break; ++ case K_PSLASH: ++ kernel_map[map][key] = KeyMap( Qt::Key_division, '/' ); ++ break; ++ case K_PENTER: ++ kernel_map[map][key] = KeyMap( Qt::Key_Enter, kval ); ++ break; ++ case K_PCOMMA: ++ kernel_map[map][key] = KeyMap( Qt::Key_Comma, '.' ) ; ++ break; ++ case K_PPLUSMINUS: ++ kernel_map[map][key] = KeyMap( Qt::Key_plusminus, kval ); ++ break; ++ case K_PDOT: ++ kernel_map[map][key] = KeyMap( Qt::Key_Comma, '.' ) ; ++ break; ++ case K_PPARENL: ++ kernel_map[map][key] = KeyMap( Qt::Key_ParenLeft, kval ); ++ break; ++ case K_PPARENR: ++ kernel_map[map][key] = KeyMap( Qt::Key_ParenRight, kval ); ++ break; ++ default: ++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval ); ++ break; ++ } ++ break; ++ case KT_DEAD: ++ switch(kbe.kb_value ) { ++ case K_DGRAVE: ++ case K_DACUTE: ++ case K_DCIRCM: ++ case K_DTILDE: ++ case K_DDIERE: ++ case K_DCEDIL: ++ default: ++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval ); ++ break; ++ } ++ break; ++ ++ /* ++ * Console keys ++ */ ++ case KT_CONS: ++ if ( kval < 10 ) ++ kernel_map[map][key] = KeyMap(static_cast<KeyMap::ExtraKey>( KeyMap::Key_Console1+kval ), kval ); ++ else ++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval ); ++ break; ++ ++ case KT_CUR: ++ switch(kbe.kb_value ) { ++ case K_DOWN: ++ kernel_map[map][key] = KeyMap( Qt::Key_Down, kval ); ++ break; ++ case K_LEFT: ++ kernel_map[map][key] = KeyMap( Qt::Key_Left, kval ); ++ break; ++ case K_RIGHT: ++ kernel_map[map][key] = KeyMap( Qt::Key_Right, kval ); ++ break; ++ case K_UP: ++ kernel_map[map][key] = KeyMap( Qt::Key_Up, kval ); ++ break; ++ } ++ break; ++ ++ case KT_SHIFT: ++ switch( kbe.kb_value ) { ++ case K_SHIFT: ++ kernel_map[map][key] = KeyMap( Qt::Key_Shift, kval ); ++ break; ++ case K_ALT: ++ kernel_map[map][key] = KeyMap( Qt::Key_Alt, kval ); ++ break; ++ case K_CTRL: ++ kernel_map[map][key] = KeyMap( Qt::Key_Control, kval ); ++ break; ++ case K_ALTGR: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_AltGr, kval ); ++ break; ++ case K_SHIFTL: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_ShiftL, kval ); ++ break; ++ case K_SHIFTR: ++ kernel_map[map][key] = KeyMap( KeyMap::Key_ShiftR, kval ); ++ break; ++ case K_CTRLL: ++ case K_CTRLR: ++ case K_CAPSSHIFT: ++ default: ++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval ); ++ break; ++ } ++ break; ++ /* ++ * What is this for? ++ */ ++ case KT_ASCII: ++ case KT_LOCK: ++ case KT_SLOCK: ++ default: ++ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval ); ++ //qWarning("keycode %d, map %d, type %d, val %d, acm %c\n", key, map, KTYP(kbe.kb_value), kval, acm[kval]); ++ break; ++ } ++ } ++ } ++} ++int QWSTtyKeyboardHandler::map_to_modif() ++{ ++ int modifiers = 0; ++ ++ if (current_map & (1<<KG_ALT)) ++ modifiers |= Qt::AltButton; ++ else if (current_map & (1<<KG_CTRL)) ++ modifiers |= Qt::ControlButton; ++ else if (current_map & (1<<KG_SHIFT)) ++ modifiers |= Qt::ShiftButton; ++ ++ return modifiers; ++} ++ ++/* ++ * Handle Extra Keys for VT switching and Quitting ++ */ ++void QWSTtyKeyboardHandler::handleExtra( unsigned int key, bool release ) { ++ if ( !release ) { ++ int term = 0; ++ if ( (modifier & (1<<KG_ALT)) && (modifier & (1<<KG_CTRL)) ) { ++ if ( key == Qt::Key_Left || key == KeyMap::Key_DecConsole ) ++ term = QMAX(vtQws -1, 1 ); ++ else if ( key == Qt::Key_Right || key == KeyMap::Key_IncConsole ) ++ term = QMIN(vtQws +1, 12 ); ++ } ++ ++ if ( key >= KeyMap::Key_Console1 && key <= KeyMap::Key_Console12 ) ++ term = key - KeyMap::Key_Console1 + 1; ++ ++ if ( term != 0 ) { ++ current_map = modifier = 0; ++ numlock = capslock = false; ++ ioctl(kbdFD, VT_ACTIVATE, term ); ++ return; ++ } ++ } ++ ++ if ( (modifier & (1<<KG_ALT)) && (modifier & (1<<KG_CTRL) ) ) ++ if ( key == Qt::Key_Delete || key == Qt::Key_Backspace ) { ++ qWarning( "Instructed to quit on %d", key ); ++ qApp->quit(); ++ } ++} ++ ++/* ++ * apply modifier ++ */ ++void QWSTtyKeyboardHandler::modifyModifier( int map, int modify, bool release ) { ++ if (map != -1) { ++ if (release) ++ current_map &= ~map; ++ else ++ current_map |= map; ++ } ++ ++ if ( modify != -1 ) { ++ if (release) ++ modifier &= ~modify; ++ else ++ modifier |= modify; ++ } ++} ++ ++static Qt::Key numpad2cursor[NR_PAD] = { ++ Qt::Key_Insert, ++ Qt::Key_End, ++ Qt::Key_Down, ++ Qt::Key_Next, ++ Qt::Key_Left, ++ Qt::Key_5, ++ Qt::Key_Right, ++ Qt::Key_Home, ++ Qt::Key_Up, ++ Qt::Key_Prior, ++}; ++ ++void QWSTtyKeyboardHandler::handleKey(unsigned int code, bool release) ++{ ++ int old_modifier = modifier; ++ bool mod_key = true; ++ ++ KeyMap key_map = kernel_map[current_map][code]; ++ if( key_map.key == KeyMap::Key_NotMapped ) { ++ qWarning("Unmapped Key Pressed fixing up map:%d modif:%d code:%d", current_map, modifier, code); ++ key_map = kernel_map[0][code]; ++ } ++ ++ unsigned short unicode = 0xffff; ++ if (key_map.code < 0x100) ++ unicode = acm[key_map.code & 0xff] & 0xff; ++ unsigned int qtKeyCode = key_map.key; ++ ++// if ( !release ) ++// qWarning( "KeyCode: %d KVAL: %d", qtKeyCode, key_map.code ); ++// qWarning( "Alt:%d Ctrl:%d Shift:%d Key = %d", modifier & (1<<KG_ALT), ++// modifier & (1<<KG_CTRL), ++// modifier & (1<<KG_SHIFT), key_map.key ); ++// qDebug("code %d, mCode %d, uni '%c', qtKeyCode %d", code, map.code, ++// QChar(unicode ).isPrint() ? ++// unicode : '?' , qtKeyCode); ++ ++ // Handle map changes based on press/release of modifiers ++ // hardcoded for now ++ int modif = -1; ++ int map = -1; ++ bool lock = false; ++ switch (qtKeyCode) ++ { ++ case Qt::Key_Alt: ++ unicode = 0xffff; ++ modif = (1<<KG_ALT); ++ map = modif; ++ break; ++ case Qt::Key_Control: ++ unicode = 0xffff; ++ modif = (1<<KG_CTRL); ++ map = modif; ++ break; ++ case Qt::Key_Shift: ++ unicode = 0xffff; ++ modif = (1<<KG_SHIFT); ++ map = modif; ++ break; ++ case KeyMap::Key_AltGr: ++ map = (1<<KG_ALTGR ); ++ break; ++ case KeyMap::Key_ShiftL: ++ unicode = 0xfff; ++ map = (1<<KG_SHIFTL); ++ break; ++ case KeyMap::Key_ShiftR: ++ unicode = 0xfff; ++ map = (1<<KG_SHIFTR); ++ break; ++ case Qt::Key_Left: ++ case Qt::Key_Right: ++ case Qt::Key_Up: ++ case Qt::Key_Down: ++ unicode = 0xffff; ++ mod_key = false; ++ if (qt_screen->isTransformed()) ++ qtKeyCode = static_cast<Qt::Key>( xform_dirkey(static_cast<int>( qtKeyCode ) ) ); ++ break; ++ /* ++ * handle lock, we don't handle scroll lock! ++ */ ++ case Qt::Key_CapsLock: ++ case Qt::Key_NumLock: ++ unicode = 0xffff; ++ lock = true; ++ default: ++ mod_key = false; ++ break; ++ } ++ ++ ++ /* ++ * Change the Map. We handle locks a bit different ++ */ ++ if ( lock ) ++ modifyLock( qtKeyCode, release ); ++ else ++ modifyModifier( map, modif, release ); ++ ++ handleExtra( qtKeyCode, release ); ++ ++ // Do NumLock ++ if (KTYP(key_map.code) == KT_PAD) { ++ if (!numlock) { ++ qtKeyCode = numpad2cursor[KVAL(key_map.code)]; ++ } else { ++ unicode = KVAL(key_map.code) + '0'; ++ } ++ } ++ ++ /* ++ * do not repeat modifier keys ++ */ ++ if ( modifier == old_modifier && mod_key ) ++ return; ++ ++ processKeyEvent(unicode, qtKeyCode, map_to_modif(), !release, 0); ++} ++ ++ ++/* ++ * We will read the keys off the kernel. We have two cases here ++ * 1. ) keycode < 128, bit8 is the down/up bit and the rest is ++ * is the value of the key. we can simply process it ++ * 2. ) keycode > 128, the first byte is either empty or 0x80. ++ * We need to save the status ( press/release ) the following ++ * two bytes. ++ * The difficulty is we might have not read all keys into the ++ * buffer. This makes the reading of highkeys a bit harder and ++ * I've decided against rereading, or adding a special case for ++ * the 'all' buffers in loop instead we have a simple state machine. ++ */ ++void QWSTtyKeyboardHandler::readKeyboardData() ++{ ++ unsigned char buf[81]; ++ unsigned char code; ++ bool release = false; ++ bool release_bit; ++ ++ bool highKey = false; ++ unsigned int highKeyCode = 0; ++ unsigned int highNeedMoreKey = 0; ++ ++ int n = ::read(kbdFD, buf, 80 ); ++ for ( int loop = 0; loop < n; loop++ ) { ++ code = buf[loop] & 0x7f; ++ release_bit = buf[loop] & 0x80; ++ ++ if ( highKey ) { ++ if ( highNeedMoreKey == 2 ) { ++ highNeedMoreKey--; ++ highKeyCode = code << 7; ++ }else if ( highNeedMoreKey == 1 ) { ++ highNeedMoreKey = 0; ++ highKeyCode |= code; ++ highKey = false; ++ if ( highKeyCode > 127 && highKeyCode < NR_KEYS ) ++ handleKey( highKeyCode, release ); ++ } ++ }else if (code == 0) { ++ highKey = true; ++ highNeedMoreKey = 2; ++ release = release_bit; ++ }else { ++ release = release_bit; ++ handleKey(code, release); ++ } ++ } ++} ++ ++void QWSTtyKeyboardHandler::modifyLock( unsigned int lock, bool release ) { ++ if ( !release ) ++ return; ++ ++ if ( lock == Qt::Key_CapsLock ) { ++ toggleLed( LED_CAP ); ++ capslock = !capslock; ++ }else if ( lock == Qt::Key_NumLock ) { ++ toggleLed( LED_NUM ); ++ numlock = !numlock; ++ } ++} ++ ++void QWSTtyKeyboardHandler::restoreLeds() { ++ unsigned int leds; ++ ioctl(kbdFD, KDGETLED, &leds ); ++ leds &= ~LED_CAP; ++ leds &= ~LED_NUM; ++ ioctl(kbdFD, KDSETLED, &leds ); ++} ++ ++void QWSTtyKeyboardHandler::toggleLed(unsigned int led) { ++ unsigned int leds; ++ int ret = ioctl(kbdFD, KDGETLED, &leds ); ++ leds = leds & led ? (leds & ~led) : (leds | led); ++ ret = ioctl(kbdFD, KDSETLED, &leds ); ++} ++ ++void QWSTtyKeyboardHandler::processKeyEvent(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ) { ++ static int last_unicode = -1; ++ static int last_keycode = -1; ++ ++ autoRepeat = false; ++ if( last_unicode == unicode && last_keycode == keycode && isPress ) ++ autoRepeat = true; ++ ++ QWSPC101KeyboardHandler::processKeyEvent(unicode, keycode, modifiers, isPress, autoRepeat); ++ ++ if ( isPress ) { ++ last_unicode = unicode; ++ last_keycode = keycode; ++ } else { ++ last_unicode = last_keycode = -1; ++ } ++} +Index: src/kernel/qkeyboard_qws.cpp +=================================================================== +--- qte/src/kernel/qkeyboard_qws.cpp.orig 2006-04-01 23:36:22.499297680 +0200 ++++ qte/src/kernel/qkeyboard_qws.cpp 2006-04-01 23:38:19.913448016 +0200 +@@ -45,15 +45,18 @@ + #include <ctype.h> + + #include <unistd.h> +-#ifdef _OS_LINUX_ +-#include <linux/kd.h> +-#endif ++#include <sys/wait.h> + #include <sys/ioctl.h> + #include <sys/types.h> + #include <sys/stat.h> + #include <fcntl.h> + #include <errno.h> + #include <signal.h> ++#include <termios.h> ++#ifdef _OS_LINUX_ ++#include <linux/kd.h> ++#include <linux/keyboard.h> ++#endif + + #ifdef QT_QWS_TIP2 + #include <qcopchannel_qws.h> +@@ -135,17 +138,6 @@ + }; + + +-#ifdef QT_QWS_SL5XXX +-#include <asm/sharp_char.h> +-#endif +- +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) +-#define QT_QWS_AUTOREPEAT_MANUALLY +-#endif +- +- +- +-#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX) + static int dir_keyrot = -1; + + static int xform_dirkey(int key) +@@ -169,7 +161,6 @@ + int xf = qt_screen->transformOrientation() + dir_keyrot; + return (key-Qt::Key_Left+xf)%4+Qt::Key_Left; + } +-#endif + + #define VTSWITCHSIG SIGUSR2 + +@@ -643,18 +634,81 @@ + ioctl(0, KDSETLED, leds); + } + ++/* ++ * This class was extended by: ++ * ++ * Copyright 2002 Chris Larson ++ * Copyright 2004, 2005 Holger Hans Peter Freyther ++ */ + class QWSTtyKeyboardHandler : public QWSPC101KeyboardHandler + { + Q_OBJECT + public: + QWSTtyKeyboardHandler(const QString&); + virtual ~QWSTtyKeyboardHandler(); ++ void readKeyboardMap(); ++ void readUnicodeMap(); ++ void handleKey(unsigned int key, bool release); + + private slots: + void readKeyboardData(); + + private: ++ void modifyModifier( int map, int modify, bool release ); ++ void modifyLock( unsigned int lock, bool release ); ++ void handleExtra( unsigned int key, bool release ); ++ static void restoreLeds(); ++ static void toggleLed(unsigned int); ++ int map_to_modif (); ++ ++private: + struct termios origTermData; ++ unsigned short acm[E_TABSZ]; ++ struct KeyMap { ++ enum ExtraKey{ ++ Key_AltGr = 0x01ffff, ++ Key_Console1 = 0x02ffff, ++ Key_Console2 = 0x03ffff, ++ Key_Console3 = 0x04ffff, ++ Key_Console4 = 0x05ffff, ++ Key_Console5 = 0x06ffff, ++ Key_Console6 = 0x07ffff, ++ Key_Console7 = 0x08ffff, ++ Key_Console8 = 0x09ffff, ++ Key_Console9 = 0x0affff, ++ Key_Console10 = 0x0bffff, ++ Key_Console11 = 0x0cffff, ++ Key_Console12 = 0x0dffff, ++ Key_NumLock = 0x0effff, ++ Key_ShiftLock = 0x0fffff, ++ Key_CtrlLock = 0x10ffff, ++ Key_AltLock = 0x11ffff, ++ Key_AltGrLock = 0x12ffff, ++ Key_ShiftL = 0x130000, ++ Key_ShiftR = 0x130001, ++ Key_IncConsole= 0x130002, ++ Key_DecConsole= 0x130003, ++ Key_NotMapped = 0x130004, ++ }; ++ ++ KeyMap( Qt::Key _key = Qt::Key_unknown, unsigned short _code = 0 ) ++ : key( _key ), code( _code ) ++ {} ++ KeyMap( ExtraKey _key, unsigned short _code ) ++ : key( _key ), code( _code ) ++ {} ++ unsigned int key; // 16 Bit ++ unsigned short code; ++ }; ++ ++ KeyMap kernel_map[(1<<KG_CAPSSHIFT)][NR_KEYS]; ++ int current_map; ++ int modifier; ++ bool numlock : 1; ++ bool capslock : 1; ++ ++protected: ++ void processKeyEvent(int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ); + }; + + +@@ -814,6 +868,7 @@ + fn = FALSE; + + numLock = FALSE; ++#if 0 + sharp_kbdctl_modifstat st; + int dev = ::open("/dev/sharp_kbdctl", O_RDWR); + if( dev >= 0 ) { +@@ -825,6 +880,7 @@ + ::close(dev); + } + #endif ++#endif + #if defined(QT_QWS_IPAQ) + // iPAQ Action Key has ScanCode 0x60: 0x60|0x80 = 0xe0 == extended mode 1 ! + ipaq_return_pressed = FALSE; +@@ -1250,98 +1306,10 @@ + // + // Tty keyboard + // +- +-QWSTtyKeyboardHandler::QWSTtyKeyboardHandler(const QString& device) +-{ +- kbdFD=open(device.isEmpty() ? "/dev/tty0" : device.latin1(), O_RDWR | O_NDELAY, 0); +- +- if ( kbdFD >= 0 ) { +- QSocketNotifier *notifier; +- notifier = new QSocketNotifier( kbdFD, QSocketNotifier::Read, this ); +- connect( notifier, SIGNAL(activated(int)),this, +- SLOT(readKeyboardData()) ); +- +- // save for restore. +- tcgetattr( kbdFD, &origTermData ); +- +- struct termios termdata; +- tcgetattr( kbdFD, &termdata ); +- +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +-# ifdef QT_QWS_USE_KEYCODES +- ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW); +-# else +- ioctl(kbdFD, KDSKBMODE, K_RAW); +-# endif +-#endif +- +- termdata.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP); +- termdata.c_oflag = 0; +- termdata.c_cflag = CREAD | CS8; +- termdata.c_lflag = 0; +- termdata.c_cc[VTIME]=0; +- termdata.c_cc[VMIN]=1; +- cfsetispeed(&termdata, 9600); +- cfsetospeed(&termdata, 9600); +- tcsetattr(kbdFD, TCSANOW, &termdata); +- +- signal(VTSWITCHSIG, vtSwitchHandler); +- +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +- struct vt_mode vtMode; +- ioctl(kbdFD, VT_GETMODE, &vtMode); +- +- // let us control VT switching +- vtMode.mode = VT_PROCESS; +- vtMode.relsig = VTSWITCHSIG; +- vtMode.acqsig = VTSWITCHSIG; +- ioctl(kbdFD, VT_SETMODE, &vtMode); +- +- struct vt_stat vtStat; +- ioctl(kbdFD, VT_GETSTATE, &vtStat); +- vtQws = vtStat.v_active; +-#endif +- } +-} +- +-QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler() +-{ +- if (kbdFD >= 0) +- { +- +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +- struct vt_mode vtMode; +- ioctl(kbdFD, VT_GETMODE, &vtMode); +- +- /* Mickey says: "Better give up control of VT switching. +- * Hey, I really hate that OS-will-reacquire-resources on process-death +- * kind of thinking! +- */ +- vtMode.mode = VT_AUTO; +- vtMode.relsig = 0; +- vtMode.acqsig = 0; +- ioctl(kbdFD, VT_SETMODE, &vtMode); +- +- signal(VTSWITCHSIG, 0); +- qDebug( "~QWSTtyKeyboardHandler() - released VT." ); +-#endif +- +-#if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_) +- ioctl(kbdFD, KDSKBMODE, K_XLATE); +-#endif +- tcsetattr(kbdFD, TCSANOW, &origTermData); +- ::close(kbdFD); +- kbdFD = -1; +- } +-} +- +-void QWSTtyKeyboardHandler::readKeyboardData() +-{ +- unsigned char buf[81]; +- int n = ::read(kbdFD, buf, 80 ); +- for ( int loop = 0; loop < n; loop++ ) +- doKey(buf[loop]); +-} ++/* ++ * Include the alternative implementation ++ */ ++#include "kernelkeyboard.cpp" + + typedef struct { + unsigned short key; +Index: src/kernel/keyboard_linux_to_qt.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ qte/src/kernel/keyboard_linux_to_qt.h 2006-04-01 23:37:03.928999408 +0200 +@@ -0,0 +1,263 @@ ++/* ++ * Generated with a small python utility found at ++ * http://handhelds.org/~zecke/downloads/python_keytable_creator.py ++ */ ++ ++static const Qt::Key linux_to_qt[] = { ++Qt::Key_At, ++Qt::Key_A, ++Qt::Key_B, ++Qt::Key_C, ++Qt::Key_D, ++Qt::Key_E, ++Qt::Key_F, ++Qt::Key_G, ++Qt::Key_Backspace, ++Qt::Key_Tab, ++Qt::Key_J, // Linefeed ++Qt::Key_K, ++Qt::Key_L, ++Qt::Key_Enter, ++Qt::Key_N, ++Qt::Key_O, ++Qt::Key_P, ++Qt::Key_Q, ++Qt::Key_R, ++Qt::Key_S, ++Qt::Key_T, ++Qt::Key_U, ++Qt::Key_V, ++Qt::Key_W, ++Qt::Key_X, ++Qt::Key_Y, ++Qt::Key_Z, ++Qt::Key_Escape, ++Qt::Key_Backslash, ++Qt::Key_BracketRight, ++Qt::Key_AsciiCircum, ++Qt::Key_Underscore, ++Qt::Key_Space, ++Qt::Key_Exclam, ++Qt::Key_QuoteDbl, ++Qt::Key_NumberSign, ++Qt::Key_Dollar, ++Qt::Key_Percent, ++Qt::Key_Ampersand, ++Qt::Key_Apostrophe, ++Qt::Key_ParenLeft, ++Qt::Key_ParenRight, ++Qt::Key_Asterisk, ++Qt::Key_Plus, ++Qt::Key_Comma, ++Qt::Key_Minus, ++Qt::Key_Period, ++Qt::Key_Slash, ++Qt::Key_0, ++Qt::Key_1, ++Qt::Key_2, ++Qt::Key_3, ++Qt::Key_4, ++Qt::Key_5, ++Qt::Key_6, ++Qt::Key_7, ++Qt::Key_8, ++Qt::Key_9, ++Qt::Key_Colon, ++Qt::Key_Semicolon, ++Qt::Key_Less, ++Qt::Key_Equal, ++Qt::Key_Greater, ++Qt::Key_Question, ++Qt::Key_At, ++Qt::Key_A, ++Qt::Key_B, ++Qt::Key_C, ++Qt::Key_D, ++Qt::Key_E, ++Qt::Key_F, ++Qt::Key_G, ++Qt::Key_H, ++Qt::Key_I, ++Qt::Key_J, ++Qt::Key_K, ++Qt::Key_L, ++Qt::Key_M, ++Qt::Key_N, ++Qt::Key_O, ++Qt::Key_P, ++Qt::Key_Q, ++Qt::Key_R, ++Qt::Key_S, ++Qt::Key_T, ++Qt::Key_U, ++Qt::Key_V, ++Qt::Key_W, ++Qt::Key_X, ++Qt::Key_Y, ++Qt::Key_Z, ++Qt::Key_BracketLeft, ++Qt::Key_Backslash, ++Qt::Key_BracketRight, ++Qt::Key_AsciiCircum, ++Qt::Key_Underscore, ++Qt::Key_QuoteLeft, // grave ++Qt::Key_A, ++Qt::Key_B, ++Qt::Key_C, ++Qt::Key_D, ++Qt::Key_E, ++Qt::Key_F, ++Qt::Key_G, ++Qt::Key_H, ++Qt::Key_I, ++Qt::Key_J, ++Qt::Key_K, ++Qt::Key_L, ++Qt::Key_M, ++Qt::Key_N, ++Qt::Key_O, ++Qt::Key_P, ++Qt::Key_Q, ++Qt::Key_R, ++Qt::Key_S, ++Qt::Key_T, ++Qt::Key_U, ++Qt::Key_V, ++Qt::Key_W, ++Qt::Key_X, ++Qt::Key_Y, ++Qt::Key_Z, ++Qt::Key_BraceLeft, ++Qt::Key_Bar, ++Qt::Key_BraceRight, ++Qt::Key_AsciiTilde, ++Qt::Key_BackSpace, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_unknown, ++Qt::Key_nobreakspace, ++Qt::Key_exclamdown, ++Qt::Key_cent, ++Qt::Key_sterling, ++Qt::Key_currency, ++Qt::Key_yen, ++Qt::Key_brokenbar, ++Qt::Key_section, ++Qt::Key_diaeresis, ++Qt::Key_copyright, ++Qt::Key_ordfeminine, ++Qt::Key_guillemotleft, ++Qt::Key_notsign, ++Qt::Key_hyphen, ++Qt::Key_registered, ++Qt::Key_macron, ++Qt::Key_degree, ++Qt::Key_plusminus, ++Qt::Key_twosuperior, ++Qt::Key_threesuperior, ++Qt::Key_acute, ++Qt::Key_mu, ++Qt::Key_paragraph, ++Qt::Key_periodcentered, ++Qt::Key_cedilla, ++Qt::Key_onesuperior, ++Qt::Key_masculine, ++Qt::Key_guillemotright, ++Qt::Key_onequarter, ++Qt::Key_onehalf, ++Qt::Key_threequarters, ++Qt::Key_questiondown, ++Qt::Key_Agrave, ++Qt::Key_Aacute, ++Qt::Key_Acircumflex, ++Qt::Key_Atilde, ++Qt::Key_Adiaeresis, ++Qt::Key_Aring, ++Qt::Key_AE, ++Qt::Key_Ccedilla, ++Qt::Key_Egrave, ++Qt::Key_Eacute, ++Qt::Key_Ecircumflex, ++Qt::Key_Ediaeresis, ++Qt::Key_Igrave, ++Qt::Key_Iacute, ++Qt::Key_Icircumflex, ++Qt::Key_Idiaeresis, ++Qt::Key_ETH, ++Qt::Key_Ntilde, ++Qt::Key_Ograve, ++Qt::Key_Oacute, ++Qt::Key_Ocircumflex, ++Qt::Key_Otilde, ++Qt::Key_Odiaeresis, ++Qt::Key_multiply, ++Qt::Key_Ooblique, ++Qt::Key_Ugrave, ++Qt::Key_Uacute, ++Qt::Key_Ucircumflex, ++Qt::Key_Udiaeresis, ++Qt::Key_Yacute, ++Qt::Key_THORN, ++Qt::Key_ssharp, ++Qt::Key_agrave, ++Qt::Key_aacute, ++Qt::Key_acircumflex, ++Qt::Key_atilde, ++Qt::Key_adiaeresis, ++Qt::Key_aring, ++Qt::Key_ae, ++Qt::Key_ccedilla, ++Qt::Key_egrave, ++Qt::Key_eacute, ++Qt::Key_ecircumflex, ++Qt::Key_ediaeresis, ++Qt::Key_igrave, ++Qt::Key_iacute, ++Qt::Key_icircumflex, ++Qt::Key_idiaeresis, ++Qt::Key_eth, ++Qt::Key_ntilde, ++Qt::Key_ograve, ++Qt::Key_oacute, ++Qt::Key_ocircumflex, ++Qt::Key_otilde, ++Qt::Key_odiaeresis, ++Qt::Key_division, ++Qt::Key_oslash, ++Qt::Key_ugrave, ++Qt::Key_uacute, ++Qt::Key_ucircumflex, ++Qt::Key_udiaeresis, ++Qt::Key_yacute, ++Qt::Key_thorn, ++Qt::Key_ydiaeresis ++}; |