org.handhelds.familiar/packages/qte/qte-2.3.10/kernel-keymap.patch

   1
   2 #
   3 # Patch managed by http://www.holgerschurig.de/patcher.html
   4 #
   5
   6 --- qt-2.3.10-snapshot-20050131/src/kernel/qkeyboard_qws.cpp~kernel-keymap
   7 +++ qt-2.3.10-snapshot-20050131/src/kernel/qkeyboard_qws.cpp
   8 @@ -30,6 +30,42 @@
   9  **
  10  **********************************************************************/
  11
  12 +/****************************************************************************
  13 +**
  14 +** Keyboard Handling Redesign
  15 +** Copyright 2003, Chris Larson <kergoth@handhelds.org>
  16 +** Copyright 2004,2005 Holger Hans Peter Frether <freyther@handhelds.org>
  17 +**
  18 +** TODO: (key: . = in progress, x = completed)
  19 +**
  20 +** [.] Tty driver should load its initial keymap from the kernel,
  21 +**     thereby ensuring keymap consistency between X, console, and qt/e
  22 +**     [x] Read kernel keymappings.
  23 +**     [x] Read kernel keycode -> unicode map.
  24 +**     [x] Use them, along with the existing keyM, to push events up.
  25 +**     [x] Create a new table, from transformed keycode -> qt keycode, rather
  26 +**         than the existing raw keycode -> qt keycode.
  27 +**     [ ] Adapt handleKey to deal with keys that have no unicode value, such as
  28 +**         keypresses that are mapped to strings in the string table. (e.g. F keys)
  29 +** [x] Cursor orientation change based on display rotation should not
  30 +**     be bound to Ipaq or 5xxx, but instead as a runtime choice based
  31 +**     on whether or not we're using a Transformed display driver.
  32 +** [.] Double check that VT handling, particularly with regard to switching,
  33 +**     is handled properly.
  34 +** [ ] Add a generic means of dealing with additional (outside the realm of
  35 +**     ctrl, alt, shift, altgr) modifiers.  Also ensure a means of binding
  36 +**     a keypress/combination to a 'lock' of said additional modifiers.
  37 +**
  38 +** Holgers Todo
  39 +**
  40 +** [ ] Fix NumLock handling
  41 +** [ ] Fix Keypad handling
  42 +** [ ] Fix LED handling (LED_NUM and LED_CAP) don't seem to work
  43 +** [ ] Fix CTRL+ALT+H (somehow takes the function of CTRL+ALT+BACKSPACE)
  44 +**
  45 +**********************************************************************/
  46 +
  47 +
  48  #include "qwindowsystem_qws.h"
  49  #include "qwsutils_qws.h"
  50  #include "qgfx_qws.h"
  51 @@ -45,15 +81,18 @@
  52  #include <ctype.h>
  53
  54  #include <unistd.h>
  55 -#ifdef _OS_LINUX_
  56 -#include <linux/kd.h>
  57 -#endif
  58 +#include <sys/wait.h>
  59  #include <sys/ioctl.h>
  60  #include <sys/types.h>
  61  #include <sys/stat.h>
  62  #include <fcntl.h>
  63  #include <errno.h>
  64  #include <signal.h>
  65 +#include <termios.h>
  66 +#ifdef _OS_LINUX_
  67 +#include <linux/kd.h>
  68 +#include <linux/keyboard.h>
  69 +#endif
  70
  71  #ifdef QT_QWS_TIP2
  72  #include <qcopchannel_qws.h>
  73 @@ -135,17 +174,6 @@
  74  };
  75  #endif
  76
  77 -#ifdef QT_QWS_SL5XXX
  78 -#include <asm/sharp_char.h>
  79 -#endif
  80 -
  81 -#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
  82 -#define QT_QWS_AUTOREPEAT_MANUALLY
  83 -#endif
  84 -
  85 -
  86 -
  87 -#if defined(QT_QWS_IPAQ) || defined(QT_QWS_SL5XXX)
  88  static int dir_keyrot = -1;
  89
  90  static int xform_dirkey(int key)
  91 @@ -169,7 +197,6 @@
  92      int xf = qt_screen->transformOrientation() + dir_keyrot;
  93      return (key-Qt::Key_Left+xf)%4+Qt::Key_Left;
  94  }
  95 -#endif
  96
  97  #define VTSWITCHSIG SIGUSR2
  98
  99 @@ -300,11 +327,19 @@
 100      {  Qt::Key_F35,            0xffff  , 0xffff  , 0xffff  }, // 21 light
 101      {  Qt::Key_Escape,         0xffff  , 0xffff  , 0xffff  }, // 22
 102
 103 +#ifdef QT_QWS_SL6000
 104      // Direction key code are for *UNROTATED* display.
 105 -    {  Qt::Key_Up,             0xffff  , 0xffff  , 0xffff  }, // 23
 106 -    {  Qt::Key_Right,          0xffff  , 0xffff  , 0xffff  }, // 24
 107 -    {  Qt::Key_Left,           0xffff  , 0xffff  , 0xffff  }, // 25
 108 -    {  Qt::Key_Down,           0xffff  , 0xffff  , 0xffff  }, // 26
 109 +    {  Qt::Key_Left,           0xffff  , 0xffff  , 0xffff  }, // 23
 110 +    {  Qt::Key_Up,             0xffff  , 0xffff  , 0xffff  }, // 24
 111 +    {  Qt::Key_Down,           0xffff  , 0xffff  , 0xffff  }, // 25
 112 +    {  Qt::Key_Right,          0xffff  , 0xffff  , 0xffff  }, // 26
 113 +#else
 114 +    // Direction key code are for *UNROTATED* display.
 115 +    {   Qt::Key_Up,             0xffff  , 0xffff  , 0xffff  }, // 23
 116 +    {   Qt::Key_Right,          0xffff  , 0xffff  , 0xffff  }, // 24
 117 +    {   Qt::Key_Left,           0xffff  , 0xffff  , 0xffff  }, // 25
 118 +    {   Qt::Key_Down,           0xffff  , 0xffff  , 0xffff  }, // 26
 119 +#endif
 120
 121      {  Qt::Key_F33,            0xffff  , 0xffff  , 0xffff  }, // 27 OK
 122      {  Qt::Key_F12,            0xffff  , 0xffff  , 0xffff  }, // 28 40 home
 123 @@ -369,7 +404,7 @@
 124      {  Qt::Key_unknown,        0xffff  , 0xffff  , 0xffff  }, // 63
 125      {  Qt::Key_unknown,        0xffff  , 0xffff  , 0xffff  }, // 64
 126      {  Qt::Key_unknown,        0xffff  , 0xffff  , 0xffff  }, // 65
 127 -    {  Qt::Key_unknown,        0xffff  , 0xffff  , 0xffff  }, // 66
 128 +    {   Qt::Key_F14,    0xffff  , 0xffff  , 0xffff  }, // 66
 129      {  Qt::Key_Meta,           0xffff  , 0xffff  , 0xffff  }, // 67
 130      {  Qt::Key_unknown,        0xffff  , 0xffff  , 0xffff  }, // 68
 131      {  Qt::Key_unknown,        0xffff  , 0xffff  , 0xffff  }, // 69
 132 @@ -649,12 +684,61 @@
 133  public:
 134      QWSTtyKeyboardHandler(const QString&);
 135      virtual ~QWSTtyKeyboardHandler();
 136 +    void readKeyboardMap();
 137 +    void readUnicodeMap();
 138 +    void handleKey(unsigned char code);
 139
 140  private slots:
 141      void readKeyboardData();
 142
 143  private:
 144 +    void modifyModifier( int map, int modify, bool release );
 145 +    void modifyLock( unsigned int lock, bool release );
 146 +    void handleExtra( unsigned int key, bool release );
 147 +    static void restoreLeds();
 148 +    static void toggleLed(unsigned int);
 149 +    int  map_to_modif ();
 150 +
 151 +private:
 152      struct termios origTermData;
 153 +    unsigned short acm[E_TABSZ];
 154 +    struct KeyMap {
 155 +        enum ExtraKey{
 156 +            Key_AltGr    = 0x01ffff,
 157 +            Key_Console1  = 0x02ffff,
 158 +            Key_Console2  = 0x03ffff,
 159 +            Key_Console3  = 0x04ffff,
 160 +            Key_Console4  = 0x05ffff,
 161 +            Key_Console5  = 0x06ffff,
 162 +            Key_Console6  = 0x07ffff,
 163 +            Key_Console7  = 0x08ffff,
 164 +            Key_Console8  = 0x09ffff,
 165 +            Key_Console9  = 0x0affff,
 166 +            Key_Console10 = 0x0bffff,
 167 +            Key_Console11 = 0x0cffff,
 168 +            Key_Console12 = 0x0dffff,
 169 +            Key_NumLock   = 0x0effff,
 170 +            Key_ShiftLock = 0x0fffff,
 171 +            Key_CtrlLock  = 0x10ffff,
 172 +            Key_AltLock   = 0x11ffff,
 173 +            Key_AltGrLock = 0x12ffff
 174 +        };
 175 +
 176 +        KeyMap( Qt::Key _key = Qt::Key_unknown, unsigned short _code = 0 )
 177 +            : key( _key ), code( _code )
 178 +            {}
 179 +        KeyMap( ExtraKey _key,  unsigned short _code )
 180 +            : key( _key ), code( _code )
 181 +            {}
 182 +        unsigned int    key; // 16 Bit
 183 +        unsigned short code;
 184 +    };
 185 +
 186 +    KeyMap kernel_map[(1<<KG_CAPSSHIFT)][NR_KEYS];
 187 +    int current_map;
 188 +    int modifier;
 189 +    bool numlock  : 1;
 190 +    bool capslock : 1;
 191  };
 192
 193
 194 @@ -814,6 +898,7 @@
 195      fn = FALSE;
 196
 197      numLock = FALSE;
 198 +#if 0
 199      sharp_kbdctl_modifstat  st;
 200      int dev = ::open("/dev/sharp_kbdctl", O_RDWR);
 201      if( dev >= 0 ) {
 202 @@ -825,6 +910,7 @@
 203         ::close(dev);
 204      }
 205  #endif
 206 +#endif
 207  #if defined(QT_QWS_IPAQ)
 208      // iPAQ Action Key has ScanCode 0x60: 0x60|0x80 = 0xe0 == extended mode 1 !
 209      ipaq_return_pressed = FALSE;
 210 @@ -954,7 +1040,7 @@
 211             }
 212      } else if ( extended == 2 ) {
 213         switch (code) {
 214 -       case 0x1d:
 215 +       case 0x1d:
 216             return;
 217         case 0x45:
 218             keyCode = Qt::Key_Pause;
 219 @@ -1199,7 +1285,7 @@
 220                 unicode = '`';
 221             } else
 222  #endif
 223 -
 224 +
 225                 if (bCtrl)
 226                     unicode = currentKey->ctrl_unicode;
 227                 else if (bCaps)
 228 @@ -1244,9 +1330,12 @@
 229  //
 230  // Tty keyboard
 231  //
 232 +#include "keyboard_linux_to_qt.h"
 233
 234  QWSTtyKeyboardHandler::QWSTtyKeyboardHandler(const QString& device)
 235 +    : current_map(0), modifier( 0 ), numlock( false ), capslock( false )
 236  {
 237 +    restoreLeds();
 238      kbdFD=open(device.isEmpty() ? "/dev/tty0" : device.latin1(), O_RDWR | O_NDELAY, 0);
 239
 240      if ( kbdFD >= 0 ) {
 241 @@ -1262,11 +1351,7 @@
 242         tcgetattr( kbdFD, &termdata );
 243
 244  #if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
 245 -# ifdef QT_QWS_USE_KEYCODES
 246 -       ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW);
 247 -# else
 248 -       ioctl(kbdFD, KDSKBMODE, K_RAW);
 249 -# endif
 250 +        ioctl(kbdFD, KDSKBMODE, K_MEDIUMRAW);
 251  #endif
 252
 253         termdata.c_iflag = (IGNPAR | IGNBRK) & (~PARMRK) & (~ISTRIP);
 254 @@ -1279,6 +1364,9 @@
 255         cfsetospeed(&termdata, 9600);
 256         tcsetattr(kbdFD, TCSANOW, &termdata);
 257
 258 +       readUnicodeMap();
 259 +       readKeyboardMap();
 260 +
 261         signal(VTSWITCHSIG, vtSwitchHandler);
 262
 263  #if !defined(_OS_FREEBSD_) && !defined(_OS_SOLARIS_)
 264 @@ -1300,6 +1388,7 @@
 265
 266  QWSTtyKeyboardHandler::~QWSTtyKeyboardHandler()
 267  {
 268 +    restoreLeds();
 269      if (kbdFD >= 0)
 270      {
 271
 272 @@ -1328,13 +1417,451 @@
 273         kbdFD = -1;
 274      }
 275  }
 276 +void QWSTtyKeyboardHandler::readUnicodeMap()
 277 +{
 278 +    if (kbdFD < 0)
 279 +        return;
 280 +    if (ioctl(kbdFD,GIO_UNISCRNMAP,acm) != 0)
 281 +        return;
 282 +}
 283 +
 284 +
 285 +void QWSTtyKeyboardHandler::readKeyboardMap()
 286 +{
 287 +    struct kbentry  kbe;
 288 +    if (kbdFD < 0)
 289 +        return;
 290 +
 291 +    for (int map = 0; map < (1<<KG_CAPSSHIFT); ++map) {
 292 +        unsigned short kval;
 293 +        kbe.kb_table = map;
 294 +
 295 +        for (int key = 0; key < NR_KEYS; ++key) {
 296 +            kbe.kb_index = key;
 297 +
 298 +            if (ioctl(kbdFD, KDGKBENT, &kbe) != 0)
 299 +                continue;
 300 +
 301 +            if ((kbe.kb_value == K_HOLE) || (kbe.kb_value == K_NOSUCHMAP))
 302 +                continue;
 303 +
 304 +            kval = KVAL(kbe.kb_value);
 305 +            switch (KTYP(kbe.kb_value)) {
 306 +            /*
 307 +             * Map asciis and letters to Qt KeyCodes
 308 +             * via the map (0-255)
 309 +             */
 310 +            case KT_LETTER:
 311 +            case KT_LATIN:
 312 +                kernel_map[map][key] = KeyMap( linux_to_qt[kval], kval );
 313 +                break;
 314 +
 315 +            /*
 316 +             * Handle the F Keys and map them
 317 +             * to Qt
 318 +             */
 319 +            case KT_FN:
 320 +                if ( kval <= 19 )
 321 +                    kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F1  + kval ), kval );
 322 +                else if ( kval >= 31 && kval <= 33)
 323 +                    kernel_map[map][key] = KeyMap( static_cast<Qt::Key>( Qt::Key_F21 + kval ), kval );
 324 +                else if ( kval >= 34 && kval <= 45 ) {
 325 +                    int off = kval-34;
 326 +                    kernel_map[map][key] = KeyMap(static_cast<KeyMap::ExtraKey>( KeyMap::Key_Console1+off ), kval );
 327 +                }else
 328 +                    switch(kbe.kb_value ) {
 329 +                    case K_INSERT:
 330 +                        kernel_map[map][key] = KeyMap( Qt::Key_Insert, kval );
 331 +                        break;
 332 +                    case K_REMOVE:
 333 +                        kernel_map[map][key] = KeyMap( Qt::Key_Delete, kval ); // right?
 334 +                        break;
 335 +                    case K_SELECT:
 336 +                        kernel_map[map][key] = KeyMap( Qt::Key_End , kval );
 337 +                        break;
 338 +                    case K_PGUP:
 339 +                        kernel_map[map][key] = KeyMap( Qt::Key_Prior, kval );
 340 +                        break;
 341 +                    case K_PGDN:
 342 +                        kernel_map[map][key] = KeyMap( Qt::Key_Next, kval );
 343 +                        break;
 344 +                    case K_MACRO:
 345 +                        kernel_map[map][key] = KeyMap( Qt::Key_Menu, kval );
 346 +                        break;
 347 +                    case K_HELP:
 348 +                        kernel_map[map][key] = KeyMap( Qt::Key_Help, kval );
 349 +                        break;
 350 +                    case K_PAUSE:
 351 +                        kernel_map[map][key] = KeyMap( Qt::Key_Pause, kval );
 352 +                        break;
 353 +                    case K_FIND:
 354 +                    case K_DO:
 355 +                    default:
 356 +                        kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
 357 +                        break;
 358 +                    }
 359 +                break;
 360 +
 361 +            case KT_SPEC:
 362 +                switch ( kbe.kb_value ) {
 363 +                case K_ENTER:
 364 +                    kernel_map[map][key] = KeyMap( Qt::Key_Enter, kval );
 365 +                    break;
 366 +                case K_CAPS:
 367 +                    kernel_map[map][key] = KeyMap( Qt::Key_CapsLock, kval );
 368 +                    break;
 369 +                case K_NUM:
 370 +                    kernel_map[map][key] = KeyMap( Qt::Key_NumLock, kval );
 371 +                    break;
 372 +                case K_HOLD:
 373 +                    kernel_map[map][key] = KeyMap( Qt::Key_ScrollLock, kval );
 374 +                    break;
 375 +                case K_HOLE:
 376 +                case K_SH_REGS:
 377 +                case K_SH_MEM:
 378 +                case K_SH_STAT:
 379 +                case K_BREAK:
 380 +                case K_CONS:
 381 +                case K_SCROLLFORW:
 382 +                case K_SCROLLBACK:
 383 +                case K_BOOT:
 384 +                case K_CAPSON:
 385 +                case K_COMPOSE:
 386 +                case K_SAK:
 387 +                case K_DECRCONSOLE:
 388 +                case K_INCRCONSOLE:
 389 +                case K_SPAWNCONSOLE:
 390 +                case K_BARENUMLOCK:
 391 +                default:
 392 +                    kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
 393 +                    break;
 394 +                }
 395 +                break;
 396 +            case KT_PAD:
 397 +                /*
 398 +                 * Number Values might be wrong
 399 +                 */
 400 +                switch(kbe.kb_value ) {
 401 +                case K_P0:
 402 +                    kernel_map[map][key] = KeyMap( Qt::Key_0, kval );
 403 +                    break;
 404 +                case K_P1:
 405 +                    kernel_map[map][key] = KeyMap( Qt::Key_1, kval );
 406 +                    break;
 407 +                case K_P2:
 408 +                    kernel_map[map][key] = KeyMap( Qt::Key_2, kval );
 409 +                    break;
 410 +                case K_P3:
 411 +                    kernel_map[map][key] = KeyMap( Qt::Key_3, kval );
 412 +                    break;
 413 +                case K_P4:
 414 +                    kernel_map[map][key] = KeyMap( Qt::Key_4, kval );
 415 +                    break;
 416 +                case K_P5:
 417 +                    kernel_map[map][key] = KeyMap( Qt::Key_5, kval );
 418 +                    break;
 419 +                case K_P6:
 420 +                    kernel_map[map][key] = KeyMap( Qt::Key_6, kval );
 421 +                    break;
 422 +                case K_P7:
 423 +                    kernel_map[map][key] = KeyMap( Qt::Key_7, kval );
 424 +                    break;
 425 +                case K_P8:
 426 +                    kernel_map[map][key] = KeyMap( Qt::Key_8, kval );
 427 +                    break;
 428 +                case K_P9:
 429 +                    kernel_map[map][key] = KeyMap( Qt::Key_9, kval );
 430 +                    break;
 431 +                case K_PPLUS:
 432 +                    kernel_map[map][key] = KeyMap( Qt::Key_Plus, kval );
 433 +                    break;
 434 +                case K_PMINUS:
 435 +                    kernel_map[map][key] = KeyMap( Qt::Key_Minus, kval );
 436 +                    break;
 437 +                case K_PSTAR:
 438 +                    kernel_map[map][key] = KeyMap( Qt::Key_multiply, kval );
 439 +                    break;
 440 +                case K_PSLASH:
 441 +                    kernel_map[map][key] = KeyMap( Qt::Key_division, kval );
 442 +                    break;
 443 +                case K_PENTER:
 444 +                    kernel_map[map][key] = KeyMap( Qt::Key_Enter, kval );
 445 +                    break;
 446 +                case K_PCOMMA:
 447 +                    kernel_map[map][key] = KeyMap( Qt::Key_Comma, kval ) ;
 448 +                    break;
 449 +                case K_PPLUSMINUS:
 450 +                    kernel_map[map][key] = KeyMap( Qt::Key_plusminus, kval );
 451 +                case K_PDOT:
 452 +                    break;
 453 +                case K_PPARENL:
 454 +                    kernel_map[map][key] = KeyMap( Qt::Key_ParenLeft, kval );
 455 +                    break;
 456 +                case K_PPARENR:
 457 +                    kernel_map[map][key] = KeyMap( Qt::Key_ParenRight, kval );
 458 +                    break;
 459 +                default:
 460 +                    kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
 461 +                    break;
 462 +                }
 463 +                break;
 464 +            case KT_DEAD:
 465 +                switch(kbe.kb_value ) {
 466 +                case K_DGRAVE:
 467 +                case K_DACUTE:
 468 +                case K_DCIRCM:
 469 +                case K_DTILDE:
 470 +                case K_DDIERE:
 471 +                case K_DCEDIL:
 472 +                default:
 473 +                    kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
 474 +                    break;
 475 +                }
 476 +                break;
 477 +
 478 +            case KT_CONS:
 479 +                kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
 480 +                break;
 481 +
 482 +            case KT_CUR:
 483 +                switch(kbe.kb_value ) {
 484 +                case K_DOWN:
 485 +                    kernel_map[map][key] = KeyMap( Qt::Key_Down, kval );
 486 +                    break;
 487 +                case K_LEFT:
 488 +                    kernel_map[map][key] = KeyMap( Qt::Key_Left, kval );
 489 +                    break;
 490 +                case K_RIGHT:
 491 +                    kernel_map[map][key] = KeyMap( Qt::Key_Right, kval );
 492 +                    break;
 493 +                case K_UP:
 494 +                    kernel_map[map][key] = KeyMap( Qt::Key_Up, kval );
 495 +                    break;
 496 +                }
 497 +                break;
 498 +
 499 +            case KT_SHIFT:
 500 +                switch( kbe.kb_value ) {
 501 +                case K_SHIFT:
 502 +                    kernel_map[map][key] = KeyMap( Qt::Key_Shift, kval );
 503 +                    break;
 504 +                case K_ALT:
 505 +                    kernel_map[map][key] = KeyMap( Qt::Key_Alt, kval );
 506 +                    break;
 507 +                case K_CTRL:
 508 +                    kernel_map[map][key] = KeyMap( Qt::Key_Control, kval );
 509 +                    break;
 510 +                case K_ALTGR:
 511 +                    kernel_map[map][key] = KeyMap( KeyMap::Key_AltGr, kval );
 512 +                    break;
 513 +                case K_SHIFTL:
 514 +                case K_SHIFTR:
 515 +                case K_CTRLL:
 516 +                case K_CTRLR:
 517 +                case K_CAPSSHIFT:
 518 +                default:
 519 +                    kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
 520 +                    break;
 521 +                }
 522 +                break;
 523 +            /*
 524 +             * What is this for?
 525 +             */
 526 +            case KT_ASCII:
 527 +            case KT_LOCK:
 528 +            case KT_SLOCK:
 529 +            default:
 530 +                kernel_map[map][key] = KeyMap( Qt::Key_unknown, kval );
 531 +                //qWarning("keycode %d, map %d, type %d, val %d, acm %c\n", key, map, KTYP(kbe.kb_value), kval, acm[kval]);
 532 +                break;
 533 +            }
 534 +        }
 535 +    }
 536 +}
 537 +int QWSTtyKeyboardHandler::map_to_modif()
 538 +{
 539 +    int modifiers = 0;
 540 +
 541 +    if (current_map & (1<<KG_ALT))
 542 +        modifiers |= Qt::AltButton;
 543 +    else if (current_map & (1<<KG_CTRL))
 544 +        modifiers |= Qt::ControlButton;
 545 +    else if (current_map & (1<<KG_SHIFT))
 546 +        modifiers |= Qt::ShiftButton;
 547 +
 548 +    return modifiers;
 549 +}
 550 +
 551 +/*
 552 + * Handle Extra Keys for VT switching and Quitting
 553 + */
 554 +void QWSTtyKeyboardHandler::handleExtra( unsigned int key, bool release ) {
 555 +    if ( !release ) {
 556 +        int term = 0;
 557 +        if ( (modifier & (1<<KG_ALT)) && (modifier & (1<<KG_CTRL)) ) {
 558 +            if ( key == Qt::Key_Left )
 559 +                term = QMAX(vtQws -1, 1 );
 560 +            else if ( key == Qt::Key_Right )
 561 +                term = QMIN(vtQws +1, 12 );
 562 +        }
 563 +
 564 +        if ( key >= KeyMap::Key_Console1 && key <= KeyMap::Key_Console12 )
 565 +            term = key - KeyMap::Key_Console1 + 1;
 566 +
 567 +        if ( term != 0 ) {
 568 +            current_map = modifier = 0;
 569 +            numlock = capslock = false;
 570 +            ioctl(kbdFD, VT_ACTIVATE, term );
 571 +            return;
 572 +        }
 573 +    }
 574 +
 575 +    if ( (modifier & (1<<KG_ALT)) && (modifier & (1<<KG_CTRL) ) )
 576 +         if ( key == Qt::Key_Delete || key == Qt::Key_Backspace ) {
 577 +             qWarning( "Instructed to quit on %d", key );
 578 +             qApp->quit();
 579 +         }
 580 +}
 581 +
 582 +/*
 583 + * apply modifier
 584 + */
 585 +void QWSTtyKeyboardHandler::modifyModifier( int map, int modify, bool release ) {
 586 +    if (map != -1) {
 587 +        if (release)
 588 +            current_map &= ~map;
 589 +        else
 590 +            current_map |= map;
 591 +    }
 592 +
 593 +    if ( modify != -1 ) {
 594 +        if (release)
 595 +            modifier &= ~modify;
 596 +        else
 597 +            modifier |=  modify;
 598 +    }
 599 +}
 600 +
 601 +void QWSTtyKeyboardHandler::handleKey(unsigned char code)
 602 +{
 603 +    int old_modifier = modifier;
 604 +    bool release = false;
 605 +    bool mod_key = true;
 606 +
 607 +    if (code & 0x80)
 608 +    {
 609 +        release = true;
 610 +        code &= 0x7f;
 611 +    }
 612 +
 613 +    KeyMap key_map = kernel_map[current_map][code];
 614 +    unsigned short unicode = acm[key_map.code];
 615 +    unsigned int   qtKeyCode = key_map.key;
 616 +
 617 +    if ( !release )
 618 +        qWarning( "KeyCode: %d KVAL: %d", qtKeyCode, key_map.code );
 619 +//        qWarning( "Alt:%d Ctrl:%d Shift:%d Key = %d", modifier & (1<<KG_ALT),
 620 +//                  modifier & (1<<KG_CTRL),
 621 +//                  modifier & (1<<KG_SHIFT), key_map.key );
 622 +//    qDebug("code %d, mCode %d, uni '%c', qtKeyCode %d", code, map.code,
 623 +//           QChar(unicode ).isPrint() ?
 624 +//           unicode : '?' , qtKeyCode);
 625 +
 626 +    // Handle map changes based on press/release of modifiers
 627 +    // hardcoded for now
 628 +    int modif = -1;
 629 +    int map   = -1;
 630 +    bool lock = false;
 631 +    switch (qtKeyCode)
 632 +    {
 633 +    case Qt::Key_Alt:
 634 +    case Qt::Key_F22:
 635 +        modif = (1<<KG_ALT);
 636 +        break;
 637 +    case Qt::Key_Control:
 638 +        modif = (1<<KG_CTRL);
 639 +        map   = modif;
 640 +        break;
 641 +    case Qt::Key_Shift:
 642 +        modif = (1<<KG_SHIFT);
 643 +        map   = modif;
 644 +        break;
 645 +    case KeyMap::Key_AltGr:
 646 +        map   = (1<<KG_ALTGR );
 647 +        break;
 648 +    case Qt::Key_Left:
 649 +    case Qt::Key_Right:
 650 +    case Qt::Key_Up:
 651 +    case Qt::Key_Down:
 652 +        mod_key = false;
 653 +        if (qt_screen->isTransformed())
 654 +            qtKeyCode = static_cast<Qt::Key>( xform_dirkey(static_cast<int>( qtKeyCode ) ) );
 655 +        break;
 656 +    /*
 657 +     * handle lock, we don't handle scroll lock!
 658 +     */
 659 +    case Qt::Key_CapsLock:
 660 +    case Qt::Key_NumLock:
 661 +        lock = true;
 662 +    default:
 663 +        mod_key = false;
 664 +        break;
 665 +    }
 666 +
 667 +
 668 +    /*
 669 +     * Change the Map. We handle locks a bit different
 670 +     */
 671 +    if ( lock )
 672 +        modifyLock( qtKeyCode, release );
 673 +    else
 674 +        modifyModifier( map, modif, release );
 675 +
 676 +    handleExtra( qtKeyCode, release );
 677 +
 678 +    /*
 679 +     * do not repeat modifier keys
 680 +     */
 681 +    if ( modifier == old_modifier && mod_key )
 682 +        return;
 683 +
 684 +    processKeyEvent(unicode & 0xff, qtKeyCode, map_to_modif(), !release, 0);
 685 +}
 686
 687  void QWSTtyKeyboardHandler::readKeyboardData()
 688  {
 689      unsigned char buf[81];
 690      int n = ::read(kbdFD, buf, 80 );
 691      for ( int loop = 0; loop < n; loop++ )
 692 -       doKey(buf[loop]);
 693 +       handleKey(buf[loop]);
 694 +}
 695 +
 696 +void QWSTtyKeyboardHandler::modifyLock( unsigned int lock, bool release ) {
 697 +    if ( !release )
 698 +        return;
 699 +
 700 +    if ( lock == Qt::Key_CapsLock ) {
 701 +        toggleLed( LED_CAP );
 702 +        capslock = !capslock;
 703 +    }else if ( lock == Qt::Key_NumLock ) {
 704 +        toggleLed( LED_NUM );
 705 +        numlock = !numlock;
 706 +    }
 707 +}
 708 +
 709 +void QWSTtyKeyboardHandler::restoreLeds() {
 710 +    unsigned int leds;
 711 +    ioctl(kbdFD, KDGETLED, &leds );
 712 +    leds &= ~LED_CAP;
 713 +    leds &= ~LED_NUM;
 714 +    ioctl(kbdFD, KDSETLED, &leds );
 715 +}
 716 +
 717 +void QWSTtyKeyboardHandler::toggleLed(unsigned int led) {
 718 +    unsigned int leds;
 719 +    int ret = ioctl(kbdFD, KDGETLED, &leds );
 720 +    leds = leds & led ? (leds & ~led) : (leds | led);
 721 +    ret = ioctl(kbdFD, KDSETLED, &leds );
 722  }
 723
 724  typedef struct {
 725 @@ -1439,13 +1966,13 @@
 726         return;
 727  #ifdef QT_QWS_TIP2
 728      // custom scan codes - translate them and create a key event immediately
 729 -    if( overrideMap && event.value == 0 || overrideMap->find( event.value ) )
 730 +    if( overrideMap && event.value == 0 || overrideMap->find( event.value ) )
 731      {
 732         if( event.value )
 733         {
 734             int modifiers = 0;
 735             QWSServer::KeyMap *km = overrideMap->find( event.value );
 736 -           switch( km->unicode )
 737 +           switch( km->unicode )
 738             {
 739                 case Key_Menu:
 740                 case Key_Back:
 741 @@ -1473,14 +2000,14 @@
 742                                                         TRUE, FALSE );
 743             }
 744             lastPress = km;
 745 -       }
 746 -       else if( lastPress )
 747 +       }
 748 +       else if( lastPress )
 749         {
 750 -           processKeyEvent( lastPress->unicode, lastPress->key_code, 0,
 751 +           processKeyEvent( lastPress->unicode, lastPress->key_code, 0,
 752                                                             FALSE, FALSE );
 753             lastPress = 0;
 754         }
 755 -    }
 756 +    }
 757      else
 758  #endif
 759      {
 760 @@ -1845,10 +2372,10 @@
 761         handler = new QWSUsbKeyboardHandler(device);
 762      } else if ( type == "TTY" ) {
 763         handler = new QWSTtyKeyboardHandler(device);
 764 -    }
 765 +    }
 766      else if( type == "Samsung" )  {
 767         handler = new QWSSamsungKeypadHandler(device);
 768 -    }
 769 +    }
 770      else {
 771         qWarning( "Keyboard type %s:%s unsupported", spec.latin1(), device.latin1() );
 772      }
 773 --- /dev/null
 774 +++ qt-2.3.10-snapshot-20050131/src/kernel/keyboard_linux_to_qt.h
 775 @@ -0,0 +1,263 @@
 776 +/*
 777 + * Generated with a small python utility found at
 778 + * http://handhelds.org/~zecke/downloads/python_keytable_creator.py
 779 + */
 780 +
 781 +static const Qt::Key linux_to_qt[] = {
 782 +Qt::Key_unknown,
 783 +Qt::Key_unknown,
 784 +Qt::Key_unknown,
 785 +Qt::Key_unknown,
 786 +Qt::Key_unknown,
 787 +Qt::Key_unknown,
 788 +Qt::Key_unknown,
 789 +Qt::Key_unknown,
 790 +Qt::Key_Backspace,
 791 +Qt::Key_Tab,
 792 +Qt::Key_unknown, // LineFeed
 793 +Qt::Key_unknown,
 794 +Qt::Key_unknown,
 795 +Qt::Key_unknown,
 796 +Qt::Key_unknown,  // No Symbol
 797 +Qt::Key_unknown,
 798 +Qt::Key_unknown,
 799 +Qt::Key_unknown,
 800 +Qt::Key_unknown,
 801 +Qt::Key_unknown,
 802 +Qt::Key_unknown,
 803 +Qt::Key_unknown, // No Symbol
 804 +Qt::Key_unknown,
 805 +Qt::Key_unknown,
 806 +Qt::Key_unknown,
 807 +Qt::Key_unknown,
 808 +Qt::Key_unknown,
 809 +Qt::Key_Escape,
 810 +Qt::Key_unknown,
 811 +Qt::Key_unknown,  // No symbol
 812 +Qt::Key_unknown,
 813 +Qt::Key_unknown,
 814 +Qt::Key_Space,
 815 +Qt::Key_Exclam,
 816 +Qt::Key_QuoteDbl,
 817 +Qt::Key_NumberSign,
 818 +Qt::Key_Dollar,
 819 +Qt::Key_Percent,
 820 +Qt::Key_Ampersand,
 821 +Qt::Key_Apostrophe,
 822 +Qt::Key_ParenLeft,
 823 +Qt::Key_ParenRight,
 824 +Qt::Key_Asterisk,
 825 +Qt::Key_Plus,
 826 +Qt::Key_Comma,
 827 +Qt::Key_Minus,
 828 +Qt::Key_Period,
 829 +Qt::Key_Slash,
 830 +Qt::Key_0,
 831 +Qt::Key_1,
 832 +Qt::Key_2,
 833 +Qt::Key_3,
 834 +Qt::Key_4,
 835 +Qt::Key_5,
 836 +Qt::Key_6,
 837 +Qt::Key_7,
 838 +Qt::Key_8,
 839 +Qt::Key_9,
 840 +Qt::Key_Colon,
 841 +Qt::Key_Semicolon,
 842 +Qt::Key_Less,
 843 +Qt::Key_Equal,
 844 +Qt::Key_Greater,
 845 +Qt::Key_Question,
 846 +Qt::Key_At,
 847 +Qt::Key_A,
 848 +Qt::Key_B,
 849 +Qt::Key_C,
 850 +Qt::Key_D,
 851 +Qt::Key_E,
 852 +Qt::Key_F,
 853 +Qt::Key_G,
 854 +Qt::Key_H,
 855 +Qt::Key_I,
 856 +Qt::Key_J,
 857 +Qt::Key_K,
 858 +Qt::Key_L,
 859 +Qt::Key_M,
 860 +Qt::Key_N,
 861 +Qt::Key_O,
 862 +Qt::Key_P,
 863 +Qt::Key_Q,
 864 +Qt::Key_R,
 865 +Qt::Key_S,
 866 +Qt::Key_T,
 867 +Qt::Key_U,
 868 +Qt::Key_V,
 869 +Qt::Key_W,
 870 +Qt::Key_X,
 871 +Qt::Key_Y,
 872 +Qt::Key_Z,
 873 +Qt::Key_BracketLeft,
 874 +Qt::Key_Backslash,
 875 +Qt::Key_BracketRight,
 876 +Qt::Key_AsciiCircum,
 877 +Qt::Key_Underscore,
 878 +Qt::Key_QuoteLeft, // grave
 879 +Qt::Key_A,
 880 +Qt::Key_B,
 881 +Qt::Key_C,
 882 +Qt::Key_D,
 883 +Qt::Key_E,
 884 +Qt::Key_F,
 885 +Qt::Key_G,
 886 +Qt::Key_H,
 887 +Qt::Key_I,
 888 +Qt::Key_J,
 889 +Qt::Key_K,
 890 +Qt::Key_L,
 891 +Qt::Key_M,
 892 +Qt::Key_N,
 893 +Qt::Key_O,
 894 +Qt::Key_P,
 895 +Qt::Key_Q,
 896 +Qt::Key_R,
 897 +Qt::Key_S,
 898 +Qt::Key_T,
 899 +Qt::Key_U,
 900 +Qt::Key_V,
 901 +Qt::Key_W,
 902 +Qt::Key_X,
 903 +Qt::Key_Y,
 904 +Qt::Key_Z,
 905 +Qt::Key_BraceLeft,
 906 +Qt::Key_Bar,
 907 +Qt::Key_BraceRight,
 908 +Qt::Key_AsciiTilde,
 909 +Qt::Key_BackSpace,
 910 +Qt::Key_unknown,
 911 +Qt::Key_unknown,
 912 +Qt::Key_unknown,
 913 +Qt::Key_unknown,
 914 +Qt::Key_unknown,
 915 +Qt::Key_unknown,
 916 +Qt::Key_unknown,
 917 +Qt::Key_unknown,
 918 +Qt::Key_unknown,
 919 +Qt::Key_unknown,
 920 +Qt::Key_unknown,
 921 +Qt::Key_unknown,
 922 +Qt::Key_unknown,
 923 +Qt::Key_unknown,
 924 +Qt::Key_unknown,
 925 +Qt::Key_unknown,
 926 +Qt::Key_unknown,
 927 +Qt::Key_unknown,
 928 +Qt::Key_unknown,
 929 +Qt::Key_unknown,
 930 +Qt::Key_unknown,
 931 +Qt::Key_unknown,
 932 +Qt::Key_unknown,
 933 +Qt::Key_unknown,
 934 +Qt::Key_unknown,
 935 +Qt::Key_unknown,
 936 +Qt::Key_unknown,
 937 +Qt::Key_unknown,
 938 +Qt::Key_unknown,
 939 +Qt::Key_unknown,
 940 +Qt::Key_unknown,
 941 +Qt::Key_unknown,
 942 +Qt::Key_nobreakspace,
 943 +Qt::Key_exclamdown,
 944 +Qt::Key_cent,
 945 +Qt::Key_sterling,
 946 +Qt::Key_currency,
 947 +Qt::Key_yen,
 948 +Qt::Key_brokenbar,
 949 +Qt::Key_section,
 950 +Qt::Key_diaeresis,
 951 +Qt::Key_copyright,
 952 +Qt::Key_ordfeminine,
 953 +Qt::Key_guillemotleft,
 954 +Qt::Key_notsign,
 955 +Qt::Key_hyphen,
 956 +Qt::Key_registered,
 957 +Qt::Key_macron,
 958 +Qt::Key_degree,
 959 +Qt::Key_plusminus,
 960 +Qt::Key_twosuperior,
 961 +Qt::Key_threesuperior,
 962 +Qt::Key_acute,
 963 +Qt::Key_mu,
 964 +Qt::Key_paragraph,
 965 +Qt::Key_periodcentered,
 966 +Qt::Key_cedilla,
 967 +Qt::Key_onesuperior,
 968 +Qt::Key_masculine,
 969 +Qt::Key_guillemotright,
 970 +Qt::Key_onequarter,
 971 +Qt::Key_onehalf,
 972 +Qt::Key_threequarters,
 973 +Qt::Key_questiondown,
 974 +Qt::Key_Agrave,
 975 +Qt::Key_Aacute,
 976 +Qt::Key_Acircumflex,
 977 +Qt::Key_Atilde,
 978 +Qt::Key_Adiaeresis,
 979 +Qt::Key_Aring,
 980 +Qt::Key_AE,
 981 +Qt::Key_Ccedilla,
 982 +Qt::Key_Egrave,
 983 +Qt::Key_Eacute,
 984 +Qt::Key_Ecircumflex,
 985 +Qt::Key_Ediaeresis,
 986 +Qt::Key_Igrave,
 987 +Qt::Key_Iacute,
 988 +Qt::Key_Icircumflex,
 989 +Qt::Key_Idiaeresis,
 990 +Qt::Key_ETH,
 991 +Qt::Key_Ntilde,
 992 +Qt::Key_Ograve,
 993 +Qt::Key_Oacute,
 994 +Qt::Key_Ocircumflex,
 995 +Qt::Key_Otilde,
 996 +Qt::Key_Odiaeresis,
 997 +Qt::Key_multiply,
 998 +Qt::Key_Ooblique,
 999 +Qt::Key_Ugrave,
1000 +Qt::Key_Uacute,
1001 +Qt::Key_Ucircumflex,
1002 +Qt::Key_Udiaeresis,
1003 +Qt::Key_Yacute,
1004 +Qt::Key_THORN,
1005 +Qt::Key_ssharp,
1006 +Qt::Key_agrave,
1007 +Qt::Key_aacute,
1008 +Qt::Key_acircumflex,
1009 +Qt::Key_atilde,
1010 +Qt::Key_adiaeresis,
1011 +Qt::Key_aring,
1012 +Qt::Key_ae,
1013 +Qt::Key_ccedilla,
1014 +Qt::Key_egrave,
1015 +Qt::Key_eacute,
1016 +Qt::Key_ecircumflex,
1017 +Qt::Key_ediaeresis,
1018 +Qt::Key_igrave,
1019 +Qt::Key_iacute,
1020 +Qt::Key_icircumflex,
1021 +Qt::Key_idiaeresis,
1022 +Qt::Key_eth,
1023 +Qt::Key_ntilde,
1024 +Qt::Key_ograve,
1025 +Qt::Key_oacute,
1026 +Qt::Key_ocircumflex,
1027 +Qt::Key_otilde,
1028 +Qt::Key_odiaeresis,
1029 +Qt::Key_division,
1030 +Qt::Key_oslash,
1031 +Qt::Key_ugrave,
1032 +Qt::Key_uacute,
1033 +Qt::Key_ucircumflex,
1034 +Qt::Key_udiaeresis,
1035 +Qt::Key_yacute,
1036 +Qt::Key_thorn,
1037 +Qt::Key_ydiaeresis
1038 +};