-
-#
-# Patch managed by http://www.holgerschurig.de/patcher.html
-#
-
---- qt-2.3.10-snapshot-20050131/src/kernel/qkeyboard_qws.cpp~kernel-keymap
-+++ qt-2.3.10-snapshot-20050131/src/kernel/qkeyboard_qws.cpp
-@@ -30,6 +30,42 @@
- **
- **********************************************************************/
-
-+/****************************************************************************
-+**
-+** Keyboard Handling Redesign
-+** Copyright 2003, Chris Larson <kergoth@handhelds.org>
-+** Copyright 2004,2005 Holger Hans Peter Frether <freyther@handhelds.org>
-+**
-+** TODO: (key: . = in progress, x = completed)
-+**
-+** [.] Tty driver should load its initial keymap from the kernel,
-+** thereby ensuring keymap consistency between X, console, and qt/e
-+** [x] Read kernel keymappings.
-+** [x] Read kernel keycode -> unicode map.
-+** [x] Use them, along with the existing keyM, to push events up.
-+** [x] Create a new table, from transformed keycode -> qt keycode, rather
-+** than the existing raw keycode -> qt keycode.
-+** [ ] Adapt handleKey to deal with keys that have no unicode value, such as
-+** keypresses that are mapped to strings in the string table. (e.g. F keys)
-+** [x] Cursor orientation change based on display rotation should not
-+** be bound to Ipaq or 5xxx, but instead as a runtime choice based
-+** on whether or not we're using a Transformed display driver.
-+** [.] Double check that VT handling, particularly with regard to switching,
-+** is handled properly.
-+** [ ] Add a generic means of dealing with additional (outside the realm of
-+** ctrl, alt, shift, altgr) modifiers. Also ensure a means of binding
-+** a keypress/combination to a 'lock' of said additional modifiers.
-+**
-+** Holgers Todo
-+**
-+** [ ] Fix NumLock handling
-+** [ ] Fix Keypad handling
-+** [ ] Fix LED handling (LED_NUM and LED_CAP) don't seem to work
-+** [ ] Fix CTRL+ALT+H (somehow takes the function of CTRL+ALT+BACKSPACE)
-+**
-+**********************************************************************/
-+
-+
- #include "qwindowsystem_qws.h"
- #include "qwsutils_qws.h"
- #include "qgfx_qws.h"
-@@ -45,15 +81,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 +174,6 @@
- };
- #endif
-
--#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 +197,6 @@
- int xf = qt_screen->transformOrientation() + dir_keyrot;
- return (key-Qt::Key_Left+xf)%4+Qt::Key_Left;
- }
--#endif
-
- #define VTSWITCHSIG SIGUSR2
-
-@@ -300,11 +327,19 @@
- { Qt::Key_F35, 0xffff , 0xffff , 0xffff }, // 21 light
- { Qt::Key_Escape, 0xffff , 0xffff , 0xffff }, // 22
-
-+#ifdef QT_QWS_SL6000
- // Direction key code are for *UNROTATED* display.
-- { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // 23
-- { Qt::Key_Right, 0xffff , 0xffff , 0xffff }, // 24
-- { Qt::Key_Left, 0xffff , 0xffff , 0xffff }, // 25
-- { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // 26
-+ { Qt::Key_Left, 0xffff , 0xffff , 0xffff }, // 23
-+ { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // 24
-+ { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // 25
-+ { Qt::Key_Right, 0xffff , 0xffff , 0xffff }, // 26
-+#else
-+ // Direction key code are for *UNROTATED* display.
-+ { Qt::Key_Up, 0xffff , 0xffff , 0xffff }, // 23
-+ { Qt::Key_Right, 0xffff , 0xffff , 0xffff }, // 24
-+ { Qt::Key_Left, 0xffff , 0xffff , 0xffff }, // 25
-+ { Qt::Key_Down, 0xffff , 0xffff , 0xffff }, // 26
-+#endif
-
- { Qt::Key_F33, 0xffff , 0xffff , 0xffff }, // 27 OK
- { Qt::Key_F12, 0xffff , 0xffff , 0xffff }, // 28 40 home
-@@ -369,7 +404,7 @@
- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 63
- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 64
- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 65
-- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 66
-+ { Qt::Key_F14, 0xffff , 0xffff , 0xffff }, // 66
- { Qt::Key_Meta, 0xffff , 0xffff , 0xffff }, // 67
- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 68
- { Qt::Key_unknown, 0xffff , 0xffff , 0xffff }, // 69
-@@ -649,12 +684,61 @@
- public:
- QWSTtyKeyboardHandler(const QString&);
- virtual ~QWSTtyKeyboardHandler();
-+ void readKeyboardMap();
-+ void readUnicodeMap();
-+ void handleKey(unsigned char code);
-
- 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 ();
+Index: src/kernel/kernelkeyboard.cpp
+===================================================================
+--- /dev/null 1970-01-01 00:00:00.000000000 +0000
++++ src/kernel/kernelkeyboard.cpp 2006-04-01 23:42:35.154645456 +0200
+@@ -0,0 +1,701 @@
++/*
+
-+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
-+ };
++ Copyright (C) 2003 Chris Larson
++ Copyright (C) 2004, 2005 Holger Hans Peter Freyther
++ All rights reserved.
+
-+ 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;
-+ };
++ Redistribution and use in source and binary forms, with or without
++ modification, are permitted provided that the following conditions are met:
+
-+ KeyMap kernel_map[(1<<KG_CAPSSHIFT)][NR_KEYS];
-+ int current_map;
-+ int modifier;
-+ bool numlock : 1;
-+ bool capslock : 1;
- };
-
-
-@@ -814,6 +898,7 @@
- fn = FALSE;
-
- numLock = FALSE;
-+#if 0
- sharp_kbdctl_modifstat st;
- int dev = ::open("/dev/sharp_kbdctl", O_RDWR);
- if( dev >= 0 ) {
-@@ -825,6 +910,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;
-@@ -954,7 +1040,7 @@
- }
- } else if ( extended == 2 ) {
- switch (code) {
-- case 0x1d:
-+ case 0x1d:
- return;
- case 0x45:
- keyCode = Qt::Key_Pause;
-@@ -1199,7 +1285,7 @@
- unicode = '`';
- } else
- #endif
--
++ Redistributions of source code must retain the above copyright notice,
++ this list of conditions and the following disclaimer.
+
- if (bCtrl)
- unicode = currentKey->ctrl_unicode;
- else if (bCaps)
-@@ -1244,9 +1330,12 @@
- //
- // Tty keyboard
- //
++ 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)
++
++ */
++
++/*
++ 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)
++
++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 ) {
-@@ -1262,11 +1351,7 @@
- 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
++ 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);
-@@ -1279,6 +1364,9 @@
- cfsetospeed(&termdata, 9600);
- tcsetattr(kbdFD, TCSANOW, &termdata);
-
++#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_)
-@@ -1300,6 +1388,7 @@
-
- QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler()
- {
++ 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)
- {
-
-@@ -1328,13 +1417,451 @@
- kbdFD = -1;
- }
- }
++ 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)
+
+ for (int key = 0; key < NR_KEYS; ++key) {
+ kbe.kb_index = key;
-+
-+ if (ioctl(kbdFD, KDGKBENT, &kbe) != 0)
-+ continue;
-+
-+ if ((kbe.kb_value == K_HOLE) || (kbe.kb_value == K_NOSUCHMAP))
-+ continue;
++
++
++ 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)) {
+ */
+ case KT_LETTER:
+ case KT_LATIN:
++ case KT_META:
+ kernel_map[map][key] = KeyMap( linux_to_qt[kval], kval );
+ break;
+
+ case KT_FN:
+ if ( kval <= 19 )
+ kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F1 + kval ), kval );
-+ else if ( kval >= 31 && kval <= 33)
-+ kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F21 + kval ), kval );
-+ else if ( kval >= 34 && kval <= 45 ) {
-+ int off = kval-34;
-+ kernel_map[map][key] = KeyMap(static_cast<KeyMap::ExtraKey>( KeyMap::Key_Console1+off ), kval );
-+ }else
++ else if ( kval >= 30 && kval <= 44)
++ kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F21 + (kval - 30) ), kval );
++ else
+ switch(kbe.kb_value ) {
+ case K_INSERT:
+ kernel_map[map][key] = KeyMap( Qt::Key_Insert, kval );
+ 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:
+ default:
+ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
+ case K_HOLD:
+ kernel_map[map][key] = KeyMap( Qt::Key_ScrollLock, kval );
+ break;
-+ case K_HOLE:
++ 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_CAPSON:
+ case K_COMPOSE:
+ case K_SAK:
-+ case K_DECRCONSOLE:
-+ case K_INCRCONSOLE:
+ case K_SPAWNCONSOLE:
+ case K_BARENUMLOCK:
+ default:
+ */
+ switch(kbe.kb_value ) {
+ case K_P0:
-+ kernel_map[map][key] = KeyMap( Qt::Key_0, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_0, 48 );
+ break;
+ case K_P1:
-+ kernel_map[map][key] = KeyMap( Qt::Key_1, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_1, 49 );
+ break;
+ case K_P2:
-+ kernel_map[map][key] = KeyMap( Qt::Key_2, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_2, 50 );
+ break;
+ case K_P3:
-+ kernel_map[map][key] = KeyMap( Qt::Key_3, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_3, 51 );
+ break;
+ case K_P4:
-+ kernel_map[map][key] = KeyMap( Qt::Key_4, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_4, 52 );
+ break;
+ case K_P5:
-+ kernel_map[map][key] = KeyMap( Qt::Key_5, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_5, 53 );
+ break;
+ case K_P6:
-+ kernel_map[map][key] = KeyMap( Qt::Key_6, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_6, 54 );
+ break;
+ case K_P7:
-+ kernel_map[map][key] = KeyMap( Qt::Key_7, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_7, 55 );
+ break;
+ case K_P8:
-+ kernel_map[map][key] = KeyMap( Qt::Key_8, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_8, 56 );
+ break;
+ case K_P9:
-+ kernel_map[map][key] = KeyMap( Qt::Key_9, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_9, 57 );
+ break;
+ case K_PPLUS:
+ kernel_map[map][key] = KeyMap( Qt::Key_Plus, kval );
+ kernel_map[map][key] = KeyMap( Qt::Key_Minus, kval );
+ break;
+ case K_PSTAR:
-+ kernel_map[map][key] = KeyMap( Qt::Key_multiply, kval );
++ kernel_map[map][key] = KeyMap( Qt::Key_multiply, 42 );
+ break;
+ case K_PSLASH:
+ kernel_map[map][key] = KeyMap( Qt::Key_division, kval );
+ }
+ break;
+
-+ case KT_CONS:
-+ kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
++ /*
++ * 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:
+ 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:
-+ case K_CTRLL:
++ kernel_map[map][key] = KeyMap( KeyMap::Key_ShiftR, kval );
++ break;
++ case K_CTRLL:
+ case K_CTRLR:
+ case K_CAPSSHIFT:
+ default:
+ if ( !release ) {
+ int term = 0;
+ if ( (modifier & (1<<KG_ALT)) && (modifier & (1<<KG_CTRL)) ) {
-+ if ( key == Qt::Key_Left )
++ if ( key == Qt::Key_Left || key == KeyMap::Key_DecConsole )
+ term = QMAX(vtQws -1, 1 );
-+ else if ( key == Qt::Key_Right )
++ else if ( key == Qt::Key_Right || key == KeyMap::Key_IncConsole )
+ term = QMIN(vtQws +1, 12 );
+ }
+
+ }
+}
+
-+void QWSTtyKeyboardHandler::handleKey(unsigned char code)
++void QWSTtyKeyboardHandler::handleKey(unsigned int code, bool release)
+{
+ int old_modifier = modifier;
-+ bool release = false;
+ bool mod_key = true;
+
-+ if (code & 0x80)
-+ {
-+ release = true;
-+ code &= 0x7f;
-+ }
-+
+ KeyMap key_map = kernel_map[current_map][code];
-+ unsigned short unicode = acm[key_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 = acm[key_map.code] & 0xff;
+ unsigned int qtKeyCode = key_map.key;
+
-+ if ( !release )
-+ qWarning( "KeyCode: %d KVAL: %d", qtKeyCode, key_map.code );
++// 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 );
+ switch (qtKeyCode)
+ {
+ case Qt::Key_Alt:
-+ case Qt::Key_F22:
++ 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 ) ) );
+ */
+ case Qt::Key_CapsLock:
+ case Qt::Key_NumLock:
++ unicode = 0xffff;
+ lock = true;
+ default:
+ mod_key = false;
+ if ( modifier == old_modifier && mod_key )
+ return;
+
-+ processKeyEvent(unicode & 0xff, qtKeyCode, map_to_modif(), !release, 0);
++ processKeyEvent(unicode, qtKeyCode, map_to_modif(), !release, 0);
+}
-
- void QWSTtyKeyboardHandler::readKeyboardData()
- {
- unsigned char buf[81];
- int n = ::read(kbdFD, buf, 80 );
- for ( int loop = 0; loop < n; loop++ )
-- doKey(buf[loop]);
-+ handleKey(buf[loop]);
++
++
++/*
++ * 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 ) {
+ 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
+===================================================================
+--- src/kernel/qkeyboard_qws.cpp.orig 2006-04-01 23:36:22.499297680 +0200
++++ 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
- typedef struct {
-@@ -1439,13 +1966,13 @@
- return;
#ifdef QT_QWS_TIP2
- // custom scan codes - translate them and create a key event immediately
-- if( overrideMap && event.value == 0 || overrideMap->find( event.value ) )
-+ if( overrideMap && event.value == 0 || overrideMap->find( event.value ) )
- {
- if( event.value )
- {
- int modifiers = 0;
- QWSServer::KeyMap *km = overrideMap->find( event.value );
-- switch( km->unicode )
-+ switch( km->unicode )
- {
- case Key_Menu:
- case Key_Back:
-@@ -1473,14 +2000,14 @@
- TRUE, FALSE );
- }
- lastPress = km;
-- }
-- else if( lastPress )
-+ }
-+ else if( lastPress )
- {
-- processKeyEvent( lastPress->unicode, lastPress->key_code, 0,
-+ processKeyEvent( lastPress->unicode, lastPress->key_code, 0,
- FALSE, FALSE );
- lastPress = 0;
- }
-- }
-+ }
- else
- #endif
- {
-@@ -1845,10 +2372,10 @@
- handler = new QWSUsbKeyboardHandler(device);
- } else if ( type == "TTY" ) {
- handler = new QWSTtyKeyboardHandler(device);
-- }
-+ }
- else if( type == "Samsung" ) {
- handler = new QWSSamsungKeypadHandler(device);
-- }
-+ }
- else {
- qWarning( "Keyboard type %s:%s unsupported", spec.latin1(), device.latin1() );
+ #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);
}
---- /dev/null
-+++ qt-2.3.10-snapshot-20050131/src/kernel/keyboard_linux_to_qt.h
+ #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
++++ 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
+ */
+
+static const Qt::Key linux_to_qt[] = {
-+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_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_unknown, // LineFeed
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown, // No Symbol
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown, // No Symbol
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
-+Qt::Key_unknown,
++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_unknown,
-+Qt::Key_unknown, // No symbol
-+Qt::Key_unknown,
-+Qt::Key_unknown,
++Qt::Key_Backslash,
++Qt::Key_BracketRight,
++Qt::Key_AsciiCircum,
++Qt::Key_Underscore,
+Qt::Key_Space,
+Qt::Key_Exclam,
+Qt::Key_QuoteDbl,
git.openpandora.org / openembedded.git / commitdiff