1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qkeymapper_p.h"

    43 

    44 #include "qdebug.h"

    45 #include "qtextcodec.h"

    46 #include "qwidget.h"

    47 

    48 #include "qapplication_p.h"

    49 #include "qevent_p.h"

    50 #include "qt_x11_p.h"

    51 

    52 #ifndef QT_NO_XKB

    53 #  include <X11/XKBlib.h>

    54 #endif

    55 

    56 #define XK_MISCELLANY

    57 #define XK_LATIN1

    58 #define XK_KOREAN

    59 #define XK_XKB_KEYS

    60 #include <X11/keysymdef.h>

    61 

    62 #include <ctype.h>

    63 

    64 QT_BEGIN_NAMESPACE

    65 

    66 #ifndef QT_NO_XKB

    67 

    68 // bring in the auto-generated xkbLayoutData

    69 #include "qkeymapper_x11_p.cpp"

    70 

    71 #ifdef QT_LINUXBASE

    72 // LSB's IsKeypadKey define is wrong - see

    73 // http://bugs.linuxbase.org/show_bug.cgi?id=2521

    74 #undef IsKeypadKey

    75 #define IsKeypadKey(keysym) \

    76       (((KeySym)(keysym) >= XK_KP_Space) && ((KeySym)(keysym) <= XK_KP_Equal))

    77 

    78 #undef IsPrivateKeypadKey

    79 #define IsPrivateKeypadKey(keysym) \

    80       (((KeySym)(keysym) >= 0x11000000) && ((KeySym)(keysym) <= 0x1100FFFF))

    81 #endif

    82 

    83 static void getLocaleAndDirection(QLocale *locale,

    84                                   Qt::LayoutDirection *direction,

    85                                   const QByteArray &layoutName,

    86                                   const QByteArray &variantName)

    87 {

    88     int i = 0;

    89     while (xkbLayoutData[i].layout != 0) {

    90         if (layoutName == xkbLayoutData[i].layout && variantName == xkbLayoutData[i].variant) {

    91             *locale = QLocale(xkbLayoutData[i].language, xkbLayoutData[i].country);

    92             *direction = xkbLayoutData[i].direction;

    93             return;

    94         }

    95         ++i;

    96     }

    97     *locale = QLocale::c();

    98     *direction = Qt::LeftToRight;

    99 }

   100 #endif // QT_NO_XKB

   101 

   102 

   103 // from qapplication_x11.cpp

   104 extern uchar qt_alt_mask;

   105 extern uchar qt_meta_mask;

   106 extern uchar qt_super_mask;

   107 extern uchar qt_hyper_mask;

   108 extern uchar qt_mode_switch_mask;

   109 uchar qt_num_lock_mask = 0;

   110 extern bool qt_sendSpontaneousEvent(QObject*, QEvent*);

   111 

   112 // ### we should really resolve conflicts with other masks by

   113 // ### decomposing the Qt::KeyboardModifers in possibleKeys()

   114 #define SETMASK(sym, mask)                                              \

   115     do {                                                                \

   116         if (qt_alt_mask == 0                                            \

   117             && qt_meta_mask != mask                                     \

   118             && qt_super_mask != mask                                    \

   119             && qt_hyper_mask != mask                                    \

   120             && (sym == XK_Alt_L || sym == XK_Alt_R)) {                  \

   121             qt_alt_mask = mask;                                         \

   122         }                                                               \

   123         if (qt_meta_mask == 0                                           \

   124             && qt_alt_mask != mask                                      \

   125             && qt_super_mask != mask                                    \

   126             && qt_hyper_mask != mask                                    \

   127             && (sym == XK_Meta_L || sym == XK_Meta_R)) {                \

   128             qt_meta_mask = mask;                                        \

   129         }                                                               \

   130         if (qt_super_mask == 0                                          \

   131             && qt_alt_mask != mask                                      \

   132             && qt_meta_mask != mask                                     \

   133             && qt_hyper_mask != mask                                    \

   134             && (sym == XK_Super_L || sym == XK_Super_R)) {              \

   135             qt_super_mask = mask;                                       \

   136         }                                                               \

   137         if (qt_hyper_mask == 0                                          \

   138             && qt_alt_mask != mask                                      \

   139             && qt_meta_mask != mask                                     \

   140             && qt_super_mask != mask                                    \

   141             && (sym == XK_Hyper_L || sym == XK_Hyper_R)) {              \

   142             qt_hyper_mask = mask;                                       \

   143         }                                                               \

   144         if (qt_mode_switch_mask == 0                                    \

   145             && qt_alt_mask != mask                                      \

   146             && qt_meta_mask != mask                                     \

   147             && qt_super_mask != mask                                    \

   148             && qt_hyper_mask != mask                                    \

   149             && sym == XK_Mode_switch) {                                 \

   150             qt_mode_switch_mask = mask;                                 \

   151         }                                                               \

   152         if (qt_num_lock_mask == 0                                       \

   153             && sym == XK_Num_Lock) {                                    \

   154             qt_num_lock_mask = mask;                                    \

   155         }                                                               \

   156     } while(false)

   157 

   158 // qt_XTranslateKey() is based on _XTranslateKey() taken from:

   159 

   160 /* $Xorg: KeyBind.c,v 1.4 2001/02/09 02:03:34 xorgcvs Exp $ */

   161 

   162 /*

   163 

   164 Copyright 1985, 1987, 1998  The Open Group

   165 

   166 Permission to use, copy, modify, distribute, and sell this software and its

   167 documentation for any purpose is hereby granted without fee, provided that

   168 the above copyright notice appear in all copies and that both that

   169 copyright notice and this permission notice appear in supporting

   170 documentation.

   171 

   172 The above copyright notice and this permission notice shall be included in

   173 all copies or substantial portions of the Software.

   174 

   175 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

   176 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

   177 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

   178 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

   179 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

   180 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

   181 

   182 Except as contained in this notice, the name of The Open Group shall not be

   183 used in advertising or otherwise to promote the sale, use or other dealings

   184 in this Software without prior written authorization from The Open Group.

   185 

   186 */

   187 static int

   188 qt_XTranslateKey(register QXCoreDesc *dpy,

   189                  KeyCode keycode,

   190                  register unsigned int modifiers,

   191                  unsigned int *modifiers_return,

   192                  KeySym *keysym_return)

   193 {

   194     int per;

   195     register KeySym *syms;

   196     KeySym sym, lsym, usym;

   197 

   198     if (! dpy->keysyms)

   199 	return 0;

   200     *modifiers_return = ((ShiftMask|LockMask)

   201 			 | dpy->mode_switch | dpy->num_lock);

   202     if (((int)keycode < dpy->min_keycode) || ((int)keycode > dpy->max_keycode))

   203     {

   204 	*keysym_return = NoSymbol;

   205 	return 1;

   206     }

   207     per = dpy->keysyms_per_keycode;

   208     syms = &dpy->keysyms[(keycode - dpy->min_keycode) * per];

   209     while ((per > 2) && (syms[per - 1] == NoSymbol))

   210 	per--;

   211     if ((per > 2) && (modifiers & dpy->mode_switch)) {

   212 	syms += 2;

   213 	per -= 2;

   214     }

   215     if ((modifiers & dpy->num_lock) &&

   216 	(per > 1 && (IsKeypadKey(syms[1]) || IsPrivateKeypadKey(syms[1])))) {

   217 	if ((modifiers & ShiftMask) ||

   218 	    ((modifiers & LockMask) && (dpy->lock_meaning == XK_Shift_Lock)))

   219 	    *keysym_return = syms[0];

   220 	else

   221 	    *keysym_return = syms[1];

   222     } else if (!(modifiers & ShiftMask) &&

   223 	(!(modifiers & LockMask) || (dpy->lock_meaning == NoSymbol))) {

   224 	if ((per == 1) || (syms[1] == NoSymbol))

   225 	    XConvertCase(syms[0], keysym_return, &usym);

   226 	else

   227 	    *keysym_return = syms[0];

   228     } else if (!(modifiers & LockMask) ||

   229 	       (dpy->lock_meaning != XK_Caps_Lock)) {

   230 	if ((per == 1) || ((usym = syms[1]) == NoSymbol))

   231 	    XConvertCase(syms[0], &lsym, &usym);

   232 	*keysym_return = usym;

   233     } else {

   234 	if ((per == 1) || ((sym = syms[1]) == NoSymbol))

   235 	    sym = syms[0];

   236 	XConvertCase(sym, &lsym, &usym);

   237 	if (!(modifiers & ShiftMask) && (sym != syms[0]) &&

   238 	    ((sym != usym) || (lsym == usym)))

   239 	    XConvertCase(syms[0], &lsym, &usym);

   240 	*keysym_return = usym;

   241     }

   242     if (*keysym_return == XK_VoidSymbol)

   243 	*keysym_return = NoSymbol;

   244     return 1;

   245 }

   246 

   247 

   248 

   249 

   250 QKeyMapperPrivate::QKeyMapperPrivate()

   251     : keyboardInputDirection(Qt::LeftToRight), useXKB(false)

   252 {

   253     memset(&coreDesc, 0, sizeof(coreDesc));

   254 

   255 #ifndef QT_NO_XKB

   256     int opcode = -1;

   257     int xkbEventBase = -1;

   258     int xkbErrorBase = -1;

   259     int xkblibMajor = XkbMajorVersion;

   260     int xkblibMinor = XkbMinorVersion;

   261     if (XkbQueryExtension(X11->display, &opcode, &xkbEventBase, &xkbErrorBase, &xkblibMajor, &xkblibMinor))

   262         useXKB = true;

   263 #endif

   264 

   265 #if 0

   266     qDebug() << "useXKB =" << useXKB;

   267 #endif

   268 }

   269 

   270 QKeyMapperPrivate::~QKeyMapperPrivate()

   271 {

   272     if (coreDesc.keysyms)

   273         XFree(coreDesc.keysyms);

   274 }

   275 

   276 QList<int> QKeyMapperPrivate::possibleKeys(QKeyEvent *event)

   277 {

   278 #ifndef QT_NO_XKB

   279     if (useXKB)

   280         return possibleKeysXKB(event);

   281 #endif

   282     return possibleKeysCore(event);

   283 }

   284 

   285 enum { MaxBits = sizeof(uint) * 8 };

   286 static QString translateKeySym(KeySym keysym, uint xmodifiers,

   287                                int &code, Qt::KeyboardModifiers &modifiers,

   288                                QByteArray &chars, int &count);

   289 

   290 QList<int> QKeyMapperPrivate::possibleKeysXKB(QKeyEvent *event)

   291 {

   292 #ifndef QT_NO_XKB

   293     const int xkeycode = event->nativeScanCode();

   294     const uint xmodifiers = event->nativeModifiers();

   295 

   296     // first, translate key only using lock modifiers (there are no Qt equivalents for these, so we must

   297     // always use them when determining the baseKeySym)

   298     KeySym baseKeySym;

   299     uint consumedModifiers;

   300     if (!XkbLookupKeySym(X11->display, xkeycode, (xmodifiers & (LockMask | qt_num_lock_mask)),

   301                          &consumedModifiers, &baseKeySym))

   302         return QList<int>();

   303 

   304     QList<int> result;

   305 

   306     // translate sym -> code

   307     Qt::KeyboardModifiers baseModifiers = 0;

   308     int baseCode = -1;

   309     QByteArray chars;

   310     int count = 0;

   311     QString text = translateKeySym(baseKeySym, xmodifiers, baseCode, baseModifiers, chars, count);

   312     if (baseCode == -1) {

   313         if (text.isEmpty())

   314             return QList<int>();

   315         baseCode = text.at(0).unicode();

   316     }

   317 

   318     if (baseCode && baseCode < 0xfffe)

   319         baseCode = QChar(baseCode).toUpper().unicode();

   320     result += (baseCode | baseModifiers);

   321 

   322     int pos1Bits[MaxBits];

   323     int num1Bits = 0;

   324 

   325     for (int i = 0; i < MaxBits; ++i) {

   326         if (consumedModifiers & (1 << i))

   327             pos1Bits[num1Bits++] = i;

   328     }

   329 

   330     const int numPerms = (1 << num1Bits);

   331 

   332     // translate the key again using each permutation of consumedModifiers

   333     for (int i = 1; i < numPerms; ++i) {

   334         uint val = 0;

   335         for (int j = 0; j < num1Bits; ++j) {

   336             if (i & (1 << j))

   337                 val |= (1 << pos1Bits[j]);

   338         }

   339 

   340         if ((xmodifiers & val) != val)

   341             continue;

   342 

   343         KeySym sym;

   344         uint mods;

   345         if (!XkbLookupKeySym(X11->display, xkeycode, val, &mods, &sym))

   346             continue;

   347 

   348         // translate sym -> code

   349         Qt::KeyboardModifiers modifiers = 0;

   350         int code = -1;

   351         chars.clear();

   352         count = 0;

   353         // mask out the modifiers needed to translate keycode

   354         text = translateKeySym(sym, xmodifiers & ~val, code, modifiers, chars, count);

   355         if (code == -1) {

   356             if (text.isEmpty())

   357                 continue;

   358             code = text.at(0).unicode();

   359         }

   360 

   361         if (code && code < 0xfffe)

   362             code = QChar(code).toUpper().unicode();

   363 

   364         if (code == Qt::Key_Tab && (baseModifiers & Qt::ShiftModifier)) {

   365             // map shift+tab to shift+backtab

   366             code = Qt::Key_Backtab;

   367             text = QString();

   368         }

   369 

   370         if (code == baseCode)

   371             continue;

   372 

   373         result += (code | modifiers);

   374     }

   375 

   376 #if 0

   377     qDebug() << "possibleKeysXKB()" << hex << result;

   378 #endif

   379     return result;

   380 #else

   381     Q_UNUSED(event);

   382     return QList<int>();

   383 #endif // QT_NO_XKB

   384 }

   385 

   386 QList<int> QKeyMapperPrivate::possibleKeysCore(QKeyEvent *event)

   387 {

   388     const int xkeycode = event->nativeScanCode();

   389     const uint xmodifiers = event->nativeModifiers();

   390 

   391     // first, translate key only using lock modifiers (there are no Qt equivalents for these, so we must

   392     // always use them when determining the baseKeySym)

   393     KeySym baseKeySym;

   394     uint consumedModifiers;

   395     if (!qt_XTranslateKey(&coreDesc, xkeycode, (xmodifiers & (LockMask | qt_num_lock_mask)),

   396                           &consumedModifiers, &baseKeySym))

   397         return QList<int>();

   398 

   399     QList<int> result;

   400 

   401     // translate sym -> code

   402     Qt::KeyboardModifiers baseModifiers = 0;

   403     int baseCode = -1;

   404     QByteArray chars;

   405     int count = 0;

   406     QString text = translateKeySym(baseKeySym, xmodifiers, baseCode, baseModifiers, chars, count);

   407     if (baseCode == -1) {

   408         if (text.isEmpty())

   409             return QList<int>();

   410         baseCode = text.at(0).unicode();

   411     }

   412 

   413     if (baseCode && baseCode < 0xfffe)

   414         baseCode = QChar(baseCode).toUpper().unicode();

   415     result += (baseCode | baseModifiers);

   416 

   417     int pos1Bits[MaxBits];

   418     int num1Bits = 0;

   419 

   420     for (int i = 0; i < MaxBits; ++i) {

   421         if (consumedModifiers & (1 << i))

   422             pos1Bits[num1Bits++] = i;

   423     }

   424 

   425     const int numPerms = (1 << num1Bits);

   426 

   427     // translate the key again using each permutation of consumedModifiers

   428     for (int i = 1; i < numPerms; ++i) {

   429         uint val = 0;

   430         for (int j = 0; j < num1Bits; ++j) {

   431             if (i & (1 << j))

   432                 val |= (1 << pos1Bits[j]);

   433         }

   434 

   435         if ((xmodifiers & val) != val)

   436             continue;

   437 

   438         KeySym sym;

   439         uint mods;

   440         if (!qt_XTranslateKey(&coreDesc, xkeycode, val, &mods, &sym))

   441             continue;

   442 

   443         // translate sym -> code

   444         Qt::KeyboardModifiers modifiers = 0;

   445         int code = -1;

   446         chars.clear();

   447         count = 0;

   448         // mask out the modifiers needed to translate keycode

   449         text = translateKeySym(sym, xmodifiers & ~val, code, modifiers, chars, count);

   450         if (code == -1) {

   451             if (text.isEmpty())

   452                 continue;

   453             code = text.at(0).unicode();

   454         }

   455 

   456         if (code && code < 0xfffe)

   457             code = QChar(code).toUpper().unicode();

   458 

   459         if (code == Qt::Key_Tab && (baseModifiers & Qt::ShiftModifier)) {

   460             // map shift+tab to shift+backtab

   461             code = Qt::Key_Backtab;

   462             text = QString();

   463         }

   464 

   465         if (code == baseCode)

   466             continue;

   467 

   468         result += (code | modifiers);

   469     }

   470 

   471 #if 0

   472     qDebug() << "possibleKeysCore()" << hex << result;

   473 #endif

   474     return result;

   475 }

   476 

   477 // for parsing the _XKB_RULES_NAMES property

   478 enum {

   479     RulesFileIndex = 0,

   480     ModelIndex = 1,

   481     LayoutIndex = 2,

   482     VariantIndex = 3,

   483     OptionsIndex = 4

   484 };

   485 

   486 void QKeyMapperPrivate::clearMappings()

   487 {

   488 #ifndef QT_NO_XKB

   489     if (useXKB) {

   490         // try to determine the layout name and input direction by reading the _XKB_RULES_NAMES property off

   491         // the root window

   492         QByteArray layoutName;

   493         QByteArray variantName;

   494 

   495         Atom type = XNone;

   496         int format = 0;

   497         ulong nitems = 0;

   498         ulong bytesAfter = 0;

   499         uchar *data = 0;

   500         if (XGetWindowProperty(X11->display, RootWindow(X11->display, 0), ATOM(_XKB_RULES_NAMES), 0, 1024,

   501                                false, XA_STRING, &type, &format, &nitems, &bytesAfter, &data) == Success

   502             && type == XA_STRING && format == 8 && nitems > 2) {

   503             /*

   504               index 0 == rules file name

   505               index 1 == model name

   506               index 2 == layout name

   507               index 3 == variant name

   508               index 4 == options

   509             */

   510             char *names[5] = { 0, 0, 0, 0, 0 };

   511             char *p = reinterpret_cast<char *>(data), *end = p + nitems;

   512             int i = 0;

   513             do {

   514                 names[i++] = p;

   515                 p += qstrlen(p) + 1;

   516             } while (p < end);

   517 

   518             layoutName = QByteArray::fromRawData(names[2], qstrlen(names[2]));

   519             variantName = QByteArray::fromRawData(names[3], qstrlen(names[3]));

   520         }

   521 

   522         // ### ???

   523         // if (keyboardLayoutName.isEmpty())

   524         //     qWarning("Qt: unable to determine keyboard layout, please talk to qt-bugs@trolltech.com"); ?

   525 

   526         getLocaleAndDirection(&keyboardInputLocale,

   527                               &keyboardInputDirection,

   528                               layoutName,

   529                               variantName);

   530 

   531 #if 0

   532         qDebug() << "keyboard input locale ="

   533                  << keyboardInputLocale.name()

   534                  << "direction ="

   535                  << keyboardInputDirection;

   536 #endif

   537 

   538         if (data)

   539             XFree(data);

   540     } else

   541 #endif // QT_NO_XKB

   542         {

   543             if (coreDesc.keysyms)

   544                 XFree(coreDesc.keysyms);

   545 

   546             coreDesc.min_keycode = 8;

   547             coreDesc.max_keycode = 255;

   548             XDisplayKeycodes(X11->display, &coreDesc.min_keycode, &coreDesc.max_keycode);

   549 

   550             coreDesc.keysyms_per_keycode = 0;

   551             coreDesc.keysyms = XGetKeyboardMapping(X11->display,

   552                                                    coreDesc.min_keycode,

   553                                                    coreDesc.max_keycode - coreDesc.min_keycode + 1,

   554                                                    &coreDesc.keysyms_per_keycode);

   555 

   556 #if 0

   557             qDebug() << "min_keycode =" << coreDesc.min_keycode;

   558             qDebug() << "max_keycode =" << coreDesc.max_keycode;

   559             qDebug() << "keysyms_per_keycode =" << coreDesc.keysyms_per_keycode;

   560             qDebug() << "keysyms =" << coreDesc.keysyms;

   561 #endif

   562 

   563             // ### cannot get/guess the locale with the core protocol

   564             keyboardInputLocale = QLocale::c();

   565             // ### could examine group 0 for RTL keys

   566             keyboardInputDirection = Qt::LeftToRight;

   567         }

   568 

   569     qt_alt_mask = 0;

   570     qt_meta_mask = 0;

   571     qt_super_mask = 0;

   572     qt_hyper_mask = 0;

   573     qt_mode_switch_mask = 0;

   574 

   575     // look at the modifier mapping, and get the correct masks for alt, meta, super, hyper, and mode_switch

   576 #ifndef QT_NO_XKB

   577     if (useXKB) {

   578         XkbDescPtr xkbDesc = XkbGetMap(X11->display, XkbAllClientInfoMask, XkbUseCoreKbd);

   579         for (int i = xkbDesc->min_key_code; i < xkbDesc->max_key_code; ++i) {

   580             const uint mask = xkbDesc->map->modmap ? xkbDesc->map->modmap[i] : 0;

   581             if (mask == 0) {

   582                 // key is not bound to a modifier

   583                 continue;

   584             }

   585 

   586             for (int j = 0; j < XkbKeyGroupsWidth(xkbDesc, i); ++j) {

   587                 KeySym keySym = XkbKeySym(xkbDesc, i, j);

   588                 if (keySym == NoSymbol)

   589                     continue;

   590                 SETMASK(keySym, mask);

   591             }

   592         }

   593         XkbFreeKeyboard(xkbDesc, XkbAllComponentsMask, true);

   594     } else

   595 #endif // QT_NO_XKB

   596         {

   597             coreDesc.lock_meaning = NoSymbol;

   598 

   599             XModifierKeymap *map = XGetModifierMapping(X11->display);

   600 

   601             if (map) {

   602                 int i, maskIndex = 0, mapIndex = 0;

   603                 for (maskIndex = 0; maskIndex < 8; maskIndex++) {

   604                     for (i = 0; i < map->max_keypermod; i++) {

   605                         if (map->modifiermap[mapIndex]) {

   606                             KeySym sym;

   607                             int x = 0;

   608                             do {

   609                                 sym = XKeycodeToKeysym(X11->display, map->modifiermap[mapIndex], x++);

   610                             } while (sym == NoSymbol && x < coreDesc.keysyms_per_keycode);

   611                             const uchar mask = 1 << maskIndex;

   612                             SETMASK(sym, mask);

   613                         }

   614                         mapIndex++;

   615                     }

   616                 }

   617 

   618                 // determine the meaning of the Lock modifier

   619                 for (i = 0; i < map->max_keypermod; ++i) {

   620                     for (int x = 0; x < coreDesc.keysyms_per_keycode; ++x) {

   621                         KeySym sym = XKeycodeToKeysym(X11->display, map->modifiermap[LockMapIndex], x);

   622                         if (sym == XK_Caps_Lock || sym == XK_ISO_Lock) {

   623                             coreDesc.lock_meaning = XK_Caps_Lock;

   624                             break;

   625                         } else if (sym == XK_Shift_Lock) {

   626                             coreDesc.lock_meaning = XK_Shift_Lock;

   627                         }

   628                     }

   629                 }

   630 

   631                 XFreeModifiermap(map);

   632             }

   633 

   634             // for qt_XTranslateKey()

   635             coreDesc.num_lock = qt_num_lock_mask;

   636             coreDesc.mode_switch = qt_mode_switch_mask;

   637 

   638 #if 0

   639             qDebug() << "lock_meaning =" << coreDesc.lock_meaning;

   640             qDebug() << "num_lock =" << coreDesc.num_lock;

   641             qDebug() << "mode_switch =" << coreDesc.mode_switch;

   642 #endif

   643         }

   644 

   645     // set default modifier masks if needed

   646     if( qt_alt_mask == 0 )

   647         qt_alt_mask = Mod1Mask;

   648     if( qt_meta_mask == 0 )

   649         qt_meta_mask = Mod4Mask;

   650 

   651     // if we don't have a meta key (or it's hidden behind alt), use super or hyper to generate

   652     // Qt::Key_Meta and Qt::MetaModifier, since most newer XFree86/Xorg installations map the Windows

   653     // key to Super

   654     if (qt_meta_mask == 0 || qt_meta_mask == qt_alt_mask) {

   655         // no meta keys... s,meta,super,

   656         qt_meta_mask = qt_super_mask;

   657         if (qt_meta_mask == 0 || qt_meta_mask == qt_alt_mask) {

   658             // no super keys either? guess we'll use hyper then

   659             qt_meta_mask = qt_hyper_mask;

   660         }

   661     }

   662 

   663 #if 0

   664     qDebug() << "qt_alt_mask =" << hex << qt_alt_mask;

   665     qDebug() << "qt_meta_mask =" << hex << qt_meta_mask;

   666     qDebug() << "qt_super_mask =" << hex << qt_super_mask;

   667     qDebug() << "qt_hyper_mask =" << hex << qt_hyper_mask;

   668     qDebug() << "qt_mode_switch_mask =" << hex << qt_mode_switch_mask;

   669     qDebug() << "qt_num_lock_mask =" << hex << qt_num_lock_mask;

   670 #endif

   671 }

   672 

   673 extern bool qt_sm_blockUserInput;

   674 

   675 //

   676 // Keyboard event translation

   677 //

   678 

   679 #ifndef XK_ISO_Left_Tab

   680 #define XK_ISO_Left_Tab         0xFE20

   681 #endif

   682 

   683 #ifndef XK_dead_hook

   684 #define XK_dead_hook            0xFE61

   685 #endif

   686 

   687 #ifndef XK_dead_horn

   688 #define XK_dead_horn            0xFE62

   689 #endif

   690 

   691 #ifndef XK_Codeinput

   692 #define XK_Codeinput            0xFF37

   693 #endif

   694 

   695 #ifndef XK_Kanji_Bangou

   696 #define XK_Kanji_Bangou         0xFF37 /* same as codeinput */

   697 #endif

   698 

   699 // Fix old X libraries

   700 #ifndef XK_KP_Home

   701 #define XK_KP_Home              0xFF95

   702 #endif

   703 #ifndef XK_KP_Left

   704 #define XK_KP_Left              0xFF96

   705 #endif

   706 #ifndef XK_KP_Up

   707 #define XK_KP_Up                0xFF97

   708 #endif

   709 #ifndef XK_KP_Right

   710 #define XK_KP_Right             0xFF98

   711 #endif

   712 #ifndef XK_KP_Down

   713 #define XK_KP_Down              0xFF99

   714 #endif

   715 #ifndef XK_KP_Prior

   716 #define XK_KP_Prior             0xFF9A

   717 #endif

   718 #ifndef XK_KP_Next

   719 #define XK_KP_Next              0xFF9B

   720 #endif

   721 #ifndef XK_KP_End

   722 #define XK_KP_End               0xFF9C

   723 #endif

   724 #ifndef XK_KP_Insert

   725 #define XK_KP_Insert            0xFF9E

   726 #endif

   727 #ifndef XK_KP_Delete

   728 #define XK_KP_Delete            0xFF9F

   729 #endif

   730 

   731 // the next lines are taken on 10/2009 from X.org (X11/XF86keysym.h), defining some special

   732 // multimedia keys. They are included here as not every system has them.

   733 #define XF86XK_MonBrightnessUp     0x1008FF02

   734 #define XF86XK_MonBrightnessDown   0x1008FF03

   735 #define XF86XK_KbdLightOnOff       0x1008FF04

   736 #define XF86XK_KbdBrightnessUp     0x1008FF05

   737 #define XF86XK_KbdBrightnessDown   0x1008FF06

   738 #define XF86XK_Standby             0x1008FF10

   739 #define XF86XK_AudioLowerVolume	   0x1008FF11

   740 #define XF86XK_AudioMute           0x1008FF12

   741 #define XF86XK_AudioRaiseVolume    0x1008FF13

   742 #define XF86XK_AudioPlay           0x1008FF14

   743 #define XF86XK_AudioStop           0x1008FF15

   744 #define XF86XK_AudioPrev           0x1008FF16

   745 #define XF86XK_AudioNext           0x1008FF17

   746 #define XF86XK_HomePage            0x1008FF18

   747 #define XF86XK_Mail                0x1008FF19

   748 #define XF86XK_Start               0x1008FF1A

   749 #define XF86XK_Search              0x1008FF1B

   750 #define XF86XK_AudioRecord         0x1008FF1C

   751 #define XF86XK_Calculator          0x1008FF1D

   752 #define XF86XK_Memo                0x1008FF1E

   753 #define XF86XK_ToDoList            0x1008FF1F

   754 #define XF86XK_Calendar            0x1008FF20

   755 #define XF86XK_PowerDown           0x1008FF21

   756 #define XF86XK_ContrastAdjust      0x1008FF22

   757 #define XF86XK_Back                0x1008FF26

   758 #define XF86XK_Forward             0x1008FF27

   759 #define XF86XK_Stop                0x1008FF28

   760 #define XF86XK_Refresh             0x1008FF29

   761 #define XF86XK_PowerOff            0x1008FF2A

   762 #define XF86XK_WakeUp              0x1008FF2B

   763 #define XF86XK_Eject               0x1008FF2C

   764 #define XF86XK_ScreenSaver         0x1008FF2D

   765 #define XF86XK_WWW                 0x1008FF2E

   766 #define XF86XK_Sleep               0x1008FF2F

   767 #define XF86XK_Favorites           0x1008FF30

   768 #define XF86XK_AudioPause          0x1008FF31

   769 #define XF86XK_AudioMedia          0x1008FF32

   770 #define XF86XK_MyComputer          0x1008FF33

   771 #define XF86XK_LightBulb           0x1008FF35

   772 #define XF86XK_Shop                0x1008FF36

   773 #define XF86XK_History             0x1008FF37

   774 #define XF86XK_OpenURL             0x1008FF38

   775 #define XF86XK_AddFavorite         0x1008FF39

   776 #define XF86XK_HotLinks            0x1008FF3A

   777 #define XF86XK_BrightnessAdjust    0x1008FF3B

   778 #define XF86XK_Finance             0x1008FF3C

   779 #define XF86XK_Community           0x1008FF3D

   780 #define XF86XK_AudioRewind         0x1008FF3E

   781 #define XF86XK_BackForward         0x1008FF3F

   782 #define XF86XK_Launch0             0x1008FF40

   783 #define XF86XK_Launch1             0x1008FF41

   784 #define XF86XK_Launch2             0x1008FF42

   785 #define XF86XK_Launch3             0x1008FF43

   786 #define XF86XK_Launch4             0x1008FF44

   787 #define XF86XK_Launch5             0x1008FF45

   788 #define XF86XK_Launch6             0x1008FF46

   789 #define XF86XK_Launch7             0x1008FF47

   790 #define XF86XK_Launch8             0x1008FF48

   791 #define XF86XK_Launch9             0x1008FF49

   792 #define XF86XK_LaunchA             0x1008FF4A

   793 #define XF86XK_LaunchB             0x1008FF4B

   794 #define XF86XK_LaunchC             0x1008FF4C

   795 #define XF86XK_LaunchD             0x1008FF4D

   796 #define XF86XK_LaunchE             0x1008FF4E

   797 #define XF86XK_LaunchF             0x1008FF4F

   798 #define XF86XK_ApplicationLeft     0x1008FF50

   799 #define XF86XK_ApplicationRight    0x1008FF51

   800 #define XF86XK_Book                0x1008FF52

   801 #define XF86XK_CD                  0x1008FF53

   802 #define XF86XK_Calculater          0x1008FF54

   803 #define XF86XK_Clear               0x1008FF55

   804 #define XF86XK_ClearGrab           0x1008FE21

   805 #define XF86XK_Close               0x1008FF56

   806 #define XF86XK_Copy                0x1008FF57

   807 #define XF86XK_Cut                 0x1008FF58

   808 #define XF86XK_Display             0x1008FF59

   809 #define XF86XK_DOS                 0x1008FF5A

   810 #define XF86XK_Documents           0x1008FF5B

   811 #define XF86XK_Excel               0x1008FF5C

   812 #define XF86XK_Explorer            0x1008FF5D

   813 #define XF86XK_Game                0x1008FF5E

   814 #define XF86XK_Go                  0x1008FF5F

   815 #define XF86XK_iTouch              0x1008FF60

   816 #define XF86XK_LogOff              0x1008FF61

   817 #define XF86XK_Market              0x1008FF62

   818 #define XF86XK_Meeting             0x1008FF63

   819 #define XF86XK_MenuKB              0x1008FF65

   820 #define XF86XK_MenuPB              0x1008FF66

   821 #define XF86XK_MySites             0x1008FF67

   822 #define XF86XK_News                0x1008FF69

   823 #define XF86XK_OfficeHome          0x1008FF6A

   824 #define XF86XK_Option              0x1008FF6C

   825 #define XF86XK_Paste               0x1008FF6D

   826 #define XF86XK_Phone               0x1008FF6E

   827 #define XF86XK_Reply               0x1008FF72

   828 #define XF86XK_Reload              0x1008FF73

   829 #define XF86XK_RotateWindows       0x1008FF74

   830 #define XF86XK_RotationPB          0x1008FF75

   831 #define XF86XK_RotationKB          0x1008FF76

   832 #define XF86XK_Save                0x1008FF77

   833 #define XF86XK_Send                0x1008FF7B

   834 #define XF86XK_Spell               0x1008FF7C

   835 #define XF86XK_SplitScreen         0x1008FF7D

   836 #define XF86XK_Support             0x1008FF7E

   837 #define XF86XK_TaskPane            0x1008FF7F

   838 #define XF86XK_Terminal            0x1008FF80

   839 #define XF86XK_Tools               0x1008FF81

   840 #define XF86XK_Travel              0x1008FF82

   841 #define XF86XK_Video               0x1008FF87

   842 #define XF86XK_Word                0x1008FF89

   843 #define XF86XK_Xfer                0x1008FF8A

   844 #define XF86XK_ZoomIn              0x1008FF8B

   845 #define XF86XK_ZoomOut             0x1008FF8C

   846 #define XF86XK_Away                0x1008FF8D

   847 #define XF86XK_Messenger           0x1008FF8E

   848 #define XF86XK_WebCam              0x1008FF8F

   849 #define XF86XK_MailForward         0x1008FF90

   850 #define XF86XK_Pictures            0x1008FF91

   851 #define XF86XK_Music               0x1008FF92

   852 #define XF86XK_Battery             0x1008FF93

   853 #define XF86XK_Bluetooth           0x1008FF94

   854 #define XF86XK_WLAN                0x1008FF95

   855 #define XF86XK_UWB                 0x1008FF96

   856 #define XF86XK_AudioForward        0x1008FF97

   857 #define XF86XK_AudioRepeat         0x1008FF98

   858 #define XF86XK_AudioRandomPlay     0x1008FF99

   859 #define XF86XK_Subtitle            0x1008FF9A

   860 #define XF86XK_AudioCycleTrack     0x1008FF9B

   861 #define XF86XK_Time                0x1008FF9F

   862 #define XF86XK_Select              0x1008FFA0

   863 #define XF86XK_View                0x1008FFA1

   864 #define XF86XK_TopMenu             0x1008FFA2

   865 #define XF86XK_Suspend             0x1008FFA7

   866 #define XF86XK_Hibernate           0x1008FFA8

   867 

   868 

   869 // end of XF86keysyms.h

   870 

   871 // Special keys used by Qtopia, mapped into the X11 private keypad range.

   872 #define QTOPIAXK_Select         0x11000601

   873 #define QTOPIAXK_Yes            0x11000602

   874 #define QTOPIAXK_No             0x11000603

   875 #define QTOPIAXK_Cancel         0x11000604

   876 #define QTOPIAXK_Printer        0x11000605

   877 #define QTOPIAXK_Execute        0x11000606

   878 #define QTOPIAXK_Sleep          0x11000607

   879 #define QTOPIAXK_Play           0x11000608

   880 #define QTOPIAXK_Zoom           0x11000609

   881 #define QTOPIAXK_Context1       0x1100060A

   882 #define QTOPIAXK_Context2       0x1100060B

   883 #define QTOPIAXK_Context3       0x1100060C

   884 #define QTOPIAXK_Context4       0x1100060D

   885 #define QTOPIAXK_Call           0x1100060E

   886 #define QTOPIAXK_Hangup         0x1100060F

   887 #define QTOPIAXK_Flip           0x11000610

   888 

   889 // keyboard mapping table

   890 static const unsigned int KeyTbl[] = {

   891 

   892     // misc keys

   893 

   894     XK_Escape,                  Qt::Key_Escape,

   895     XK_Tab,                     Qt::Key_Tab,

   896     XK_ISO_Left_Tab,            Qt::Key_Backtab,

   897     XK_BackSpace,               Qt::Key_Backspace,

   898     XK_Return,                  Qt::Key_Return,

   899     XK_Insert,                  Qt::Key_Insert,

   900     XK_Delete,                  Qt::Key_Delete,

   901     XK_Clear,                   Qt::Key_Delete,

   902     XK_Pause,                   Qt::Key_Pause,

   903     XK_Print,                   Qt::Key_Print,

   904     0x1005FF60,                 Qt::Key_SysReq,         // hardcoded Sun SysReq

   905     0x1007ff00,                 Qt::Key_SysReq,         // hardcoded X386 SysReq

   906 

   907     // cursor movement

   908 

   909     XK_Home,                    Qt::Key_Home,

   910     XK_End,                     Qt::Key_End,

   911     XK_Left,                    Qt::Key_Left,

   912     XK_Up,                      Qt::Key_Up,

   913     XK_Right,                   Qt::Key_Right,

   914     XK_Down,                    Qt::Key_Down,

   915     XK_Prior,                   Qt::Key_PageUp,

   916     XK_Next,                    Qt::Key_PageDown,

   917 

   918     // modifiers

   919 

   920     XK_Shift_L,                 Qt::Key_Shift,

   921     XK_Shift_R,                 Qt::Key_Shift,

   922     XK_Shift_Lock,              Qt::Key_Shift,

   923     XK_Control_L,               Qt::Key_Control,

   924     XK_Control_R,               Qt::Key_Control,

   925     XK_Meta_L,                  Qt::Key_Meta,

   926     XK_Meta_R,                  Qt::Key_Meta,

   927     XK_Alt_L,                   Qt::Key_Alt,

   928     XK_Alt_R,                   Qt::Key_Alt,

   929     XK_Caps_Lock,               Qt::Key_CapsLock,

   930     XK_Num_Lock,                Qt::Key_NumLock,

   931     XK_Scroll_Lock,             Qt::Key_ScrollLock,

   932     XK_Super_L,                 Qt::Key_Super_L,

   933     XK_Super_R,                 Qt::Key_Super_R,

   934     XK_Menu,                    Qt::Key_Menu,

   935     XK_Hyper_L,                 Qt::Key_Hyper_L,

   936     XK_Hyper_R,                 Qt::Key_Hyper_R,

   937     XK_Help,                    Qt::Key_Help,

   938     0x1000FF74,                 Qt::Key_Backtab,        // hardcoded HP backtab

   939     0x1005FF10,                 Qt::Key_F11,            // hardcoded Sun F36 (labeled F11)

   940     0x1005FF11,                 Qt::Key_F12,            // hardcoded Sun F37 (labeled F12)

   941 

   942     // numeric and function keypad keys

   943 

   944     XK_KP_Space,                Qt::Key_Space,

   945     XK_KP_Tab,                  Qt::Key_Tab,

   946     XK_KP_Enter,                Qt::Key_Enter,

   947     //XK_KP_F1,                 Qt::Key_F1,

   948     //XK_KP_F2,                 Qt::Key_F2,

   949     //XK_KP_F3,                 Qt::Key_F3,

   950     //XK_KP_F4,                 Qt::Key_F4,

   951     XK_KP_Home,                 Qt::Key_Home,

   952     XK_KP_Left,                 Qt::Key_Left,

   953     XK_KP_Up,                   Qt::Key_Up,

   954     XK_KP_Right,                Qt::Key_Right,

   955     XK_KP_Down,                 Qt::Key_Down,

   956     XK_KP_Prior,                Qt::Key_PageUp,

   957     XK_KP_Next,                 Qt::Key_PageDown,

   958     XK_KP_End,                  Qt::Key_End,

   959     XK_KP_Begin,                Qt::Key_Clear,

   960     XK_KP_Insert,               Qt::Key_Insert,

   961     XK_KP_Delete,               Qt::Key_Delete,

   962     XK_KP_Equal,                Qt::Key_Equal,

   963     XK_KP_Multiply,             Qt::Key_Asterisk,

   964     XK_KP_Add,                  Qt::Key_Plus,

   965     XK_KP_Separator,            Qt::Key_Comma,

   966     XK_KP_Subtract,             Qt::Key_Minus,

   967     XK_KP_Decimal,              Qt::Key_Period,

   968     XK_KP_Divide,               Qt::Key_Slash,

   969 

   970     // International input method support keys

   971 

   972     // International & multi-key character composition

   973     XK_ISO_Level3_Shift,        Qt::Key_AltGr,

   974     XK_Multi_key,		Qt::Key_Multi_key,

   975     XK_Codeinput,		Qt::Key_Codeinput,

   976     XK_SingleCandidate,		Qt::Key_SingleCandidate,

   977     XK_MultipleCandidate,	Qt::Key_MultipleCandidate,

   978     XK_PreviousCandidate,	Qt::Key_PreviousCandidate,

   979 

   980     // Misc Functions

   981     XK_Mode_switch,		Qt::Key_Mode_switch,

   982     XK_script_switch,		Qt::Key_Mode_switch,

   983 

   984     // Japanese keyboard support

   985     XK_Kanji,			Qt::Key_Kanji,

   986     XK_Muhenkan,		Qt::Key_Muhenkan,

   987     //XK_Henkan_Mode,		Qt::Key_Henkan_Mode,

   988     XK_Henkan_Mode,		Qt::Key_Henkan,

   989     XK_Henkan,			Qt::Key_Henkan,

   990     XK_Romaji,			Qt::Key_Romaji,

   991     XK_Hiragana,		Qt::Key_Hiragana,

   992     XK_Katakana,		Qt::Key_Katakana,

   993     XK_Hiragana_Katakana,	Qt::Key_Hiragana_Katakana,

   994     XK_Zenkaku,			Qt::Key_Zenkaku,

   995     XK_Hankaku,			Qt::Key_Hankaku,

   996     XK_Zenkaku_Hankaku,		Qt::Key_Zenkaku_Hankaku,

   997     XK_Touroku,			Qt::Key_Touroku,

   998     XK_Massyo,			Qt::Key_Massyo,

   999     XK_Kana_Lock,		Qt::Key_Kana_Lock,

  1000     XK_Kana_Shift,		Qt::Key_Kana_Shift,

  1001     XK_Eisu_Shift,		Qt::Key_Eisu_Shift,

  1002     XK_Eisu_toggle,		Qt::Key_Eisu_toggle,

  1003     //XK_Kanji_Bangou,		Qt::Key_Kanji_Bangou,

  1004     //XK_Zen_Koho,		Qt::Key_Zen_Koho,

  1005     //XK_Mae_Koho,		Qt::Key_Mae_Koho,

  1006     XK_Kanji_Bangou,		Qt::Key_Codeinput,

  1007     XK_Zen_Koho,		Qt::Key_MultipleCandidate,

  1008     XK_Mae_Koho,		Qt::Key_PreviousCandidate,

  1009 

  1010 #ifdef XK_KOREAN

  1011     // Korean keyboard support

  1012     XK_Hangul,			Qt::Key_Hangul,

  1013     XK_Hangul_Start,		Qt::Key_Hangul_Start,

  1014     XK_Hangul_End,		Qt::Key_Hangul_End,

  1015     XK_Hangul_Hanja,		Qt::Key_Hangul_Hanja,

  1016     XK_Hangul_Jamo,		Qt::Key_Hangul_Jamo,

  1017     XK_Hangul_Romaja,		Qt::Key_Hangul_Romaja,

  1018     //XK_Hangul_Codeinput,	Qt::Key_Hangul_Codeinput,

  1019     XK_Hangul_Codeinput,	Qt::Key_Codeinput,

  1020     XK_Hangul_Jeonja,		Qt::Key_Hangul_Jeonja,

  1021     XK_Hangul_Banja,		Qt::Key_Hangul_Banja,

  1022     XK_Hangul_PreHanja,		Qt::Key_Hangul_PreHanja,

  1023     XK_Hangul_PostHanja,	Qt::Key_Hangul_PostHanja,

  1024     //XK_Hangul_SingleCandidate,Qt::Key_Hangul_SingleCandidate,

  1025     //XK_Hangul_MultipleCandidate,Qt::Key_Hangul_MultipleCandidate,

  1026     //XK_Hangul_PreviousCandidate,Qt::Key_Hangul_PreviousCandidate,

  1027     XK_Hangul_SingleCandidate,	Qt::Key_SingleCandidate,

  1028     XK_Hangul_MultipleCandidate,Qt::Key_MultipleCandidate,

  1029     XK_Hangul_PreviousCandidate,Qt::Key_PreviousCandidate,

  1030     XK_Hangul_Special,		Qt::Key_Hangul_Special,

  1031     //XK_Hangul_switch,		Qt::Key_Hangul_switch,

  1032     XK_Hangul_switch,		Qt::Key_Mode_switch,

  1033 #endif  // XK_KOREAN

  1034 

  1035     // dead keys

  1036     XK_dead_grave,              Qt::Key_Dead_Grave,

  1037     XK_dead_acute,              Qt::Key_Dead_Acute,

  1038     XK_dead_circumflex,         Qt::Key_Dead_Circumflex,

  1039     XK_dead_tilde,              Qt::Key_Dead_Tilde,

  1040     XK_dead_macron,             Qt::Key_Dead_Macron,

  1041     XK_dead_breve,              Qt::Key_Dead_Breve,

  1042     XK_dead_abovedot,           Qt::Key_Dead_Abovedot,

  1043     XK_dead_diaeresis,          Qt::Key_Dead_Diaeresis,

  1044     XK_dead_abovering,          Qt::Key_Dead_Abovering,

  1045     XK_dead_doubleacute,        Qt::Key_Dead_Doubleacute,

  1046     XK_dead_caron,              Qt::Key_Dead_Caron,

  1047     XK_dead_cedilla,            Qt::Key_Dead_Cedilla,

  1048     XK_dead_ogonek,             Qt::Key_Dead_Ogonek,

  1049     XK_dead_iota,               Qt::Key_Dead_Iota,

  1050     XK_dead_voiced_sound,       Qt::Key_Dead_Voiced_Sound,

  1051     XK_dead_semivoiced_sound,   Qt::Key_Dead_Semivoiced_Sound,

  1052     XK_dead_belowdot,           Qt::Key_Dead_Belowdot,

  1053     XK_dead_hook,               Qt::Key_Dead_Hook,

  1054     XK_dead_horn,               Qt::Key_Dead_Horn,

  1055 

  1056     // Special keys from X.org - This include multimedia keys,

  1057 	// wireless/bluetooth/uwb keys, special launcher keys, etc.

  1058     XF86XK_Back,                Qt::Key_Back,

  1059     XF86XK_Forward,             Qt::Key_Forward,

  1060     XF86XK_Stop,                Qt::Key_Stop,

  1061     XF86XK_Refresh,             Qt::Key_Refresh,

  1062     XF86XK_Favorites,           Qt::Key_Favorites,

  1063     XF86XK_AudioMedia,          Qt::Key_LaunchMedia,

  1064     XF86XK_OpenURL,             Qt::Key_OpenUrl,

  1065     XF86XK_HomePage,            Qt::Key_HomePage,

  1066     XF86XK_Search,              Qt::Key_Search,

  1067     XF86XK_AudioLowerVolume,    Qt::Key_VolumeDown,

  1068     XF86XK_AudioMute,           Qt::Key_VolumeMute,

  1069     XF86XK_AudioRaiseVolume,    Qt::Key_VolumeUp,

  1070     XF86XK_AudioPlay,           Qt::Key_MediaPlay,

  1071     XF86XK_AudioStop,           Qt::Key_MediaStop,

  1072     XF86XK_AudioPrev,           Qt::Key_MediaPrevious,

  1073     XF86XK_AudioNext,           Qt::Key_MediaNext,

  1074     XF86XK_AudioRecord,         Qt::Key_MediaRecord,

  1075     XF86XK_Mail,                Qt::Key_LaunchMail,

  1076     XF86XK_MyComputer,          Qt::Key_Launch0,  // ### Qt 5: remap properly

  1077     XF86XK_Calculator,          Qt::Key_Launch1,

  1078     XF86XK_Memo,                Qt::Key_Memo,

  1079     XF86XK_ToDoList,            Qt::Key_ToDoList,

  1080     XF86XK_Calendar,            Qt::Key_Calendar,

  1081     XF86XK_PowerDown,           Qt::Key_PowerDown,

  1082     XF86XK_ContrastAdjust,      Qt::Key_ContrastAdjust,

  1083     XF86XK_Standby,             Qt::Key_Standby,

  1084     XF86XK_MonBrightnessUp,     Qt::Key_MonBrightnessUp,

  1085     XF86XK_MonBrightnessDown,   Qt::Key_MonBrightnessDown,

  1086     XF86XK_KbdLightOnOff,       Qt::Key_KeyboardLightOnOff,

  1087     XF86XK_KbdBrightnessUp,     Qt::Key_KeyboardBrightnessUp,

  1088     XF86XK_KbdBrightnessDown,   Qt::Key_KeyboardBrightnessDown,

  1089     XF86XK_PowerOff,            Qt::Key_PowerOff,

  1090     XF86XK_WakeUp,              Qt::Key_WakeUp,

  1091     XF86XK_Eject,               Qt::Key_Eject,

  1092     XF86XK_ScreenSaver,         Qt::Key_ScreenSaver,

  1093     XF86XK_WWW,                 Qt::Key_WWW,

  1094     XF86XK_Sleep,               Qt::Key_Sleep,

  1095     XF86XK_LightBulb,           Qt::Key_LightBulb,

  1096     XF86XK_Shop,                Qt::Key_Shop,

  1097     XF86XK_History,             Qt::Key_History,

  1098     XF86XK_AddFavorite,         Qt::Key_AddFavorite,

  1099     XF86XK_HotLinks,            Qt::Key_HotLinks,

  1100     XF86XK_BrightnessAdjust,    Qt::Key_BrightnessAdjust,

  1101     XF86XK_Finance,             Qt::Key_Finance,

  1102     XF86XK_Community,           Qt::Key_Community,

  1103     XF86XK_AudioRewind,         Qt::Key_AudioRewind,

  1104     XF86XK_BackForward,         Qt::Key_BackForward,

  1105     XF86XK_ApplicationLeft,     Qt::Key_ApplicationLeft,

  1106     XF86XK_ApplicationRight,    Qt::Key_ApplicationRight,

  1107     XF86XK_Book,                Qt::Key_Book,

  1108     XF86XK_CD,                  Qt::Key_CD,

  1109     XF86XK_Calculater,          Qt::Key_Calculator,

  1110     XF86XK_Clear,               Qt::Key_Clear,

  1111     XF86XK_ClearGrab,           Qt::Key_ClearGrab,

  1112     XF86XK_Close,               Qt::Key_Close,

  1113     XF86XK_Copy,                Qt::Key_Copy,

  1114     XF86XK_Cut,                 Qt::Key_Cut,

  1115     XF86XK_Display,             Qt::Key_Display,

  1116     XF86XK_DOS,                 Qt::Key_DOS,

  1117     XF86XK_Documents,           Qt::Key_Documents,

  1118     XF86XK_Excel,               Qt::Key_Excel,

  1119     XF86XK_Explorer,            Qt::Key_Explorer,

  1120     XF86XK_Game,                Qt::Key_Game,

  1121     XF86XK_Go,                  Qt::Key_Go,

  1122     XF86XK_iTouch,              Qt::Key_iTouch,

  1123     XF86XK_LogOff,              Qt::Key_LogOff,

  1124     XF86XK_Market,              Qt::Key_Market,

  1125     XF86XK_Meeting,             Qt::Key_Meeting,

  1126     XF86XK_MenuKB,              Qt::Key_MenuKB,

  1127     XF86XK_MenuPB,              Qt::Key_MenuPB,

  1128     XF86XK_MySites,             Qt::Key_MySites,

  1129     XF86XK_News,                Qt::Key_News,

  1130     XF86XK_OfficeHome,          Qt::Key_OfficeHome,

  1131     XF86XK_Option,              Qt::Key_Option,

  1132     XF86XK_Paste,               Qt::Key_Paste,

  1133     XF86XK_Phone,               Qt::Key_Phone,

  1134     XF86XK_Reply,               Qt::Key_Reply,

  1135     XF86XK_Reload,              Qt::Key_Reload,