Part of Slepp's Projects — Pastebin — TURL — Imagebin — Filebin
Feedback -- English French German Japanese
Create Upload Newest Tools Donate
Sign In | Create Account

Paste Actions

Download Raw
Embed
pBox URL
Post to Twitter
Remove Paste

Paste Details

Raw format, 5 years 7 months old, and 173 hits.

Someone
Tuesday, July 11th, 2006 at 5:19:30am MDT 

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

advertising

Update the Post

Either update this post and resubmit it with changes, or make a new post.

You may also comment on this post.

update paste below
details of the post (optional)

Note: Only the paste content is required, though the following information can be useful to others.

Save name / title?

(space separated, optional)



Please note that information posted here will expire by default in one month. If you do not want it to expire, please set the expiry time above. If it is set to expire, web search engines will not be allowed to index it prior to it expiring. Items that are not marked to expire will be indexable by search engines. Be careful with your passwords. All illegal activities will be reported and any information will be handed over to the authorities, so be good.

worth-right
fantasy-obligation