src/unix/utilsx11.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/unix/utilsx11.cpp
   3 // Purpose:     Miscellaneous X11 functions
   4 // Author:      Mattia Barbon, Vaclav Slavik, Robert Roebling
   5 // Modified by:
   6 // Created:     25.03.02
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWidgets team
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #if defined(__WXX11__) || defined(__WXGTK__) || defined(__WXMOTIF__)
  13
  14 // for compilers that support precompilation, includes "wx.h".
  15 #include "wx/wxprec.h"
  16
  17 #include "wx/unix/utilsx11.h"
  18
  19 #ifndef WX_PRECOMP
  20     #include "wx/log.h"
  21     #include "wx/app.h"
  22     #include "wx/icon.h"
  23     #include "wx/image.h"
  24 #endif
  25
  26 #include "wx/iconbndl.h"
  27
  28 #ifdef __VMS
  29 #pragma message disable nosimpint
  30 #endif
  31 #include <X11/Xlib.h>
  32 #include <X11/Xatom.h>
  33 #include <X11/Xutil.h>
  34 #ifdef __VMS
  35 #pragma message enable nosimpint
  36 #endif
  37
  38 #ifdef __WXGTK__
  39 #include <gdk/gdk.h>
  40 #include <gdk/gdkx.h>
  41 #endif
  42
  43 // Various X11 Atoms used in this file:
  44 static Atom _NET_WM_ICON = 0;
  45 static Atom _NET_WM_STATE = 0;
  46 static Atom _NET_WM_STATE_FULLSCREEN = 0;
  47 static Atom _NET_WM_STATE_STAYS_ON_TOP = 0;
  48 static Atom _NET_WM_WINDOW_TYPE = 0;
  49 static Atom _NET_WM_WINDOW_TYPE_NORMAL = 0;
  50 static Atom _KDE_NET_WM_WINDOW_TYPE_OVERRIDE = 0;
  51 static Atom _WIN_LAYER = 0;
  52 static Atom KWIN_RUNNING = 0;
  53 #ifndef __WXGTK20__
  54 static Atom _NET_SUPPORTING_WM_CHECK = 0;
  55 static Atom _NET_SUPPORTED = 0;
  56 #endif
  57
  58 #define wxMAKE_ATOM(name, display) \
  59     if (name == 0) name = XInternAtom((display), #name, False)
  60
  61
  62 // X11 Window is an int type, so use the macro to suppress warnings when
  63 // converting to it
  64 #define WindowCast(w) (Window)(wxPtrToUInt(w))
  65
  66 // Is the window mapped?
  67 static bool IsMapped(Display *display, Window window)
  68 {
  69     XWindowAttributes attr;
  70     XGetWindowAttributes(display, window, &attr);
  71     return (attr.map_state != IsUnmapped);
  72 }
  73
  74
  75
  76 // Suspends X11 errors. Used when we expect errors but they are not fatal
  77 // for us.
  78 extern "C"
  79 {
  80     typedef int (*wxX11ErrorHandler)(Display *, XErrorEvent *);
  81
  82     static int wxX11ErrorsSuspender_handler(Display*, XErrorEvent*) { return 0; }
  83 }
  84
  85 class wxX11ErrorsSuspender
  86 {
  87 public:
  88     wxX11ErrorsSuspender(Display *d) : m_display(d)
  89     {
  90         m_old = XSetErrorHandler(wxX11ErrorsSuspender_handler);
  91     }
  92     ~wxX11ErrorsSuspender()
  93     {
  94         XFlush(m_display);
  95         XSetErrorHandler(m_old);
  96     }
  97
  98 private:
  99     Display *m_display;
 100     wxX11ErrorHandler m_old;
 101 };
 102
 103
 104
 105 // ----------------------------------------------------------------------------
 106 // Setting icons for window manager:
 107 // ----------------------------------------------------------------------------
 108
 109 void
 110 wxSetIconsX11(WXDisplay* display, WXWindow window, const wxIconBundle& ib)
 111 {
 112 #if !wxUSE_NANOX
 113     size_t size = 0;
 114
 115     const size_t numIcons = ib.GetIconCount();
 116     for ( size_t i = 0; i < numIcons; ++i )
 117     {
 118         const wxIcon icon = ib.GetIconByIndex(i);
 119
 120         size += 2 + icon.GetWidth() * icon.GetHeight();
 121     }
 122
 123     wxMAKE_ATOM(_NET_WM_ICON, (Display*)display);
 124
 125     if ( size > 0 )
 126     {
 127         unsigned long* data = new unsigned long[size];
 128         unsigned long* ptr = data;
 129
 130         for ( size_t i = 0; i < numIcons; ++i )
 131         {
 132             const wxImage image = ib.GetIconByIndex(i).ConvertToImage();
 133             int width = image.GetWidth(),
 134                 height = image.GetHeight();
 135             unsigned char* imageData = image.GetData();
 136             unsigned char* imageDataEnd = imageData + ( width * height * 3 );
 137             bool hasMask = image.HasMask();
 138             unsigned char rMask, gMask, bMask;
 139             unsigned char r, g, b, a;
 140
 141             if( hasMask )
 142             {
 143                 rMask = image.GetMaskRed();
 144                 gMask = image.GetMaskGreen();
 145                 bMask = image.GetMaskBlue();
 146             }
 147             else // no mask, but still init the variables to avoid warnings
 148             {
 149                 rMask =
 150                 gMask =
 151                 bMask = 0;
 152             }
 153
 154             *ptr++ = width;
 155             *ptr++ = height;
 156
 157             while ( imageData < imageDataEnd )
 158             {
 159                 r = imageData[0];
 160                 g = imageData[1];
 161                 b = imageData[2];
 162                 if( hasMask && r == rMask && g == gMask && b == bMask )
 163                     a = 0;
 164                 else
 165                     a = 255;
 166
 167                 *ptr++ = ( a << 24 ) | ( r << 16 ) | ( g << 8 ) | b;
 168
 169                 imageData += 3;
 170             }
 171         }
 172
 173         XChangeProperty( (Display*)display,
 174                          WindowCast(window),
 175                          _NET_WM_ICON,
 176                          XA_CARDINAL, 32,
 177                          PropModeReplace,
 178                          (unsigned char*)data, size );
 179         delete[] data;
 180     }
 181     else
 182     {
 183         XDeleteProperty( (Display*)display,
 184                          WindowCast(window),
 185                          _NET_WM_ICON );
 186     }
 187 #endif // !wxUSE_NANOX
 188 }
 189
 190
 191 // ----------------------------------------------------------------------------
 192 // Fullscreen mode:
 193 // ----------------------------------------------------------------------------
 194
 195 // NB: Setting fullscreen mode under X11 is a complicated matter. There was
 196 //     no standard way of doing it until recently. ICCCM doesn't know the
 197 //     concept of fullscreen windows and the only way to make a window
 198 //     fullscreen is to remove decorations, resize it to cover entire screen
 199 //     and set WIN_LAYER_ABOVE_DOCK.
 200 //
 201 //     This doesn't always work, though. Specifically, at least kwin from
 202 //     KDE 3 ignores the hint. The only way to make kwin accept our request
 203 //     is to emulate the way Qt does it. That is, unmap the window, set
 204 //     _NET_WM_WINDOW_TYPE to _KDE_NET_WM_WINDOW_TYPE_OVERRIDE (KDE extension),
 205 //     add _NET_WM_STATE_STAYS_ON_TOP (ditto) to _NET_WM_STATE and map
 206 //     the window again.
 207 //
 208 //     Version 1.2 of Window Manager Specification (aka wm-spec aka
 209 //     Extended Window Manager Hints) introduced _NET_WM_STATE_FULLSCREEN
 210 //     window state which provides cleanest and simplest possible way of
 211 //     making a window fullscreen. WM-spec is a de-facto standard adopted
 212 //     by GNOME and KDE folks, but _NET_WM_STATE_FULLSCREEN isn't yet widely
 213 //     supported. As of January 2003, only GNOME 2's default WM Metacity
 214 //     implements, KDE will support it from version 3.2. At toolkits level,
 215 //     GTK+ >= 2.1.2 uses it as the only method of making windows fullscreen
 216 //     (that's why wxGTK will *not* switch to using gtk_window_fullscreen
 217 //     unless it has better compatibility with older WMs).
 218 //
 219 //
 220 //     This is what wxWidgets does in wxSetFullScreenStateX11:
 221 //       1) if _NET_WM_STATE_FULLSCREEN is supported, use it
 222 //       2) otherwise try WM-specific hacks (KDE, IceWM)
 223 //       3) use _WIN_LAYER and hope that the WM will recognize it
 224 //     The code was tested with:
 225 //     twm, IceWM, WindowMaker, Metacity, kwin, sawfish, lesstif-mwm
 226
 227
 228 #define  WIN_LAYER_NORMAL       4
 229 #define  WIN_LAYER_ABOVE_DOCK  10
 230
 231 static void wxWinHintsSetLayer(Display *display, Window rootWnd,
 232                                Window window, int layer)
 233 {
 234     wxX11ErrorsSuspender noerrors(display);
 235
 236     XEvent xev;
 237
 238     wxMAKE_ATOM( _WIN_LAYER, display );
 239
 240     if (IsMapped(display, window))
 241     {
 242         xev.type = ClientMessage;
 243         xev.xclient.type = ClientMessage;
 244         xev.xclient.window = window;
 245         xev.xclient.message_type = _WIN_LAYER;
 246         xev.xclient.format = 32;
 247         xev.xclient.data.l[0] = (long)layer;
 248         xev.xclient.data.l[1] = CurrentTime;
 249
 250         XSendEvent(display, rootWnd, False,
 251                    SubstructureNotifyMask, (XEvent*) &xev);
 252     }
 253     else
 254     {
 255         long data[1];
 256
 257         data[0] = layer;
 258         XChangeProperty(display, window,
 259                         _WIN_LAYER, XA_CARDINAL, 32,
 260                         PropModeReplace, (unsigned char *)data, 1);
 261     }
 262 }
 263
 264
 265
 266 #ifdef __WXGTK20__
 267 static bool wxQueryWMspecSupport(Display* WXUNUSED(display),
 268                                  Window WXUNUSED(rootWnd),
 269                                  Atom (feature))
 270 {
 271     GdkAtom gatom = gdk_x11_xatom_to_atom(feature);
 272     return gdk_net_wm_supports(gatom);
 273 }
 274 #else
 275 static bool wxQueryWMspecSupport(Display *display, Window rootWnd, Atom feature)
 276 {
 277     wxMAKE_ATOM(_NET_SUPPORTING_WM_CHECK, display);
 278     wxMAKE_ATOM(_NET_SUPPORTED, display);
 279
 280     // FIXME: We may want to cache these checks. Note that we can't simply
 281     //        remember the results in global variable because the WM may go
 282     //        away and be replaced by another one! One possible approach
 283     //        would be invalidate the case every 15 seconds or so. Since this
 284     //        code is currently only used by wxTopLevelWindow::ShowFullScreen,
 285     //        it is not important that it is not optimized.
 286     //
 287     //        If the WM supports ICCCM (i.e. the root window has
 288     //        _NET_SUPPORTING_WM_CHECK property that points to a WM-owned
 289     //        window), we could watch for DestroyNotify event on the window
 290     //        and invalidate our cache when the windows goes away (= WM
 291     //        is replaced by another one). This is what GTK+ 2 does.
 292     //        Let's do it only if it is needed, it requires changes to
 293     //        the event loop.
 294
 295     Atom type;
 296     Window *wins;
 297     Atom *atoms;
 298     int format;
 299     unsigned long after;
 300     unsigned long nwins, natoms;
 301
 302     // Is the WM ICCCM supporting?
 303     XGetWindowProperty(display, rootWnd,
 304                        _NET_SUPPORTING_WM_CHECK, 0, LONG_MAX,
 305                        False, XA_WINDOW, &type, &format, &nwins,
 306                        &after, (unsigned char **)&wins);
 307     if ( type != XA_WINDOW || nwins <= 0 || wins[0] == None )
 308        return false;
 309     XFree(wins);
 310
 311     // Query for supported features:
 312     XGetWindowProperty(display, rootWnd,
 313                        _NET_SUPPORTED, 0, LONG_MAX,
 314                        False, XA_ATOM, &type, &format, &natoms,
 315                        &after, (unsigned char **)&atoms);
 316     if ( type != XA_ATOM || atoms == NULL )
 317         return false;
 318
 319     // Lookup the feature we want:
 320     for (unsigned i = 0; i < natoms; i++)
 321     {
 322         if ( atoms[i] == feature )
 323         {
 324             XFree(atoms);
 325             return true;
 326         }
 327     }
 328     XFree(atoms);
 329     return false;
 330 }
 331 #endif
 332
 333
 334 #define _NET_WM_STATE_REMOVE        0
 335 #define _NET_WM_STATE_ADD           1
 336
 337 static void wxWMspecSetState(Display *display, Window rootWnd,
 338                              Window window, int operation, Atom state)
 339 {
 340     wxMAKE_ATOM(_NET_WM_STATE, display);
 341
 342     if ( IsMapped(display, window) )
 343     {
 344         XEvent xev;
 345         xev.type = ClientMessage;
 346         xev.xclient.type = ClientMessage;
 347         xev.xclient.serial = 0;
 348         xev.xclient.send_event = True;
 349         xev.xclient.display = display;
 350         xev.xclient.window = window;
 351         xev.xclient.message_type = _NET_WM_STATE;
 352         xev.xclient.format = 32;
 353         xev.xclient.data.l[0] = operation;
 354         xev.xclient.data.l[1] = state;
 355         xev.xclient.data.l[2] = None;
 356
 357         XSendEvent(display, rootWnd,
 358                    False,
 359                    SubstructureRedirectMask | SubstructureNotifyMask,
 360                    &xev);
 361     }
 362     // FIXME - must modify _NET_WM_STATE property list if the window
 363     //         wasn't mapped!
 364 }
 365
 366 static void wxWMspecSetFullscreen(Display *display, Window rootWnd,
 367                                   Window window, bool fullscreen)
 368 {
 369     wxMAKE_ATOM(_NET_WM_STATE_FULLSCREEN, display);
 370     wxWMspecSetState(display, rootWnd,
 371                      window,
 372                      fullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE,
 373                       _NET_WM_STATE_FULLSCREEN);
 374 }
 375
 376
 377 // Is the user running KDE's kwin window manager? At least kwin from KDE 3
 378 // sets KWIN_RUNNING property on the root window.
 379 static bool wxKwinRunning(Display *display, Window rootWnd)
 380 {
 381     wxMAKE_ATOM(KWIN_RUNNING, display);
 382
 383     long *data;
 384     Atom type;
 385     int format;
 386     unsigned long nitems, after;
 387     if (XGetWindowProperty(display, rootWnd,
 388                            KWIN_RUNNING, 0, 1, False, KWIN_RUNNING,
 389                            &type, &format, &nitems, &after,
 390                            (unsigned char**)&data) != Success)
 391     {
 392         return false;
 393     }
 394
 395     bool retval = (type == KWIN_RUNNING &&
 396                    nitems == 1 && data && data[0] == 1);
 397     XFree(data);
 398     return retval;
 399 }
 400
 401 // KDE's kwin is Qt-centric so much than no normal method of fullscreen
 402 // mode will work with it. We have to carefully emulate the Qt way.
 403 static void wxSetKDEFullscreen(Display *display, Window rootWnd,
 404                                Window w, bool fullscreen, wxRect *origRect)
 405 {
 406     long data[2];
 407     unsigned lng;
 408
 409     wxMAKE_ATOM(_NET_WM_WINDOW_TYPE, display);
 410     wxMAKE_ATOM(_NET_WM_WINDOW_TYPE_NORMAL, display);
 411     wxMAKE_ATOM(_KDE_NET_WM_WINDOW_TYPE_OVERRIDE, display);
 412     wxMAKE_ATOM(_NET_WM_STATE_STAYS_ON_TOP, display);
 413
 414     if (fullscreen)
 415     {
 416         data[0] = _KDE_NET_WM_WINDOW_TYPE_OVERRIDE;
 417         data[1] = _NET_WM_WINDOW_TYPE_NORMAL;
 418         lng = 2;
 419     }
 420     else
 421     {
 422         data[0] = _NET_WM_WINDOW_TYPE_NORMAL;
 423         data[1] = None;
 424         lng = 1;
 425     }
 426
 427     // it is necessary to unmap the window, otherwise kwin will ignore us:
 428     XSync(display, False);
 429
 430     bool wasMapped = IsMapped(display, w);
 431     if (wasMapped)
 432     {
 433         XUnmapWindow(display, w);
 434         XSync(display, False);
 435     }
 436
 437     XChangeProperty(display, w, _NET_WM_WINDOW_TYPE, XA_ATOM, 32,
 438                     PropModeReplace, (unsigned char *) &data[0], lng);
 439     XSync(display, False);
 440
 441     if (wasMapped)
 442     {
 443         XMapRaised(display, w);
 444         XSync(display, False);
 445     }
 446
 447     wxWMspecSetState(display, rootWnd, w,
 448                      fullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE,
 449                      _NET_WM_STATE_STAYS_ON_TOP);
 450     XSync(display, False);
 451
 452     if (!fullscreen)
 453     {
 454         // NB: like many other WMs, kwin ignores the first request for a window
 455         //     position change after the window was mapped. This additional
 456         //     move+resize event will ensure that the window is restored in
 457         //     exactly the same position as before it was made fullscreen
 458         //     (because wxTopLevelWindow::ShowFullScreen will call SetSize, thus
 459         //     setting the position for the second time).
 460         XMoveResizeWindow(display, w,
 461                           origRect->x, origRect->y,
 462                           origRect->width, origRect->height);
 463         XSync(display, False);
 464     }
 465 }
 466
 467
 468 wxX11FullScreenMethod wxGetFullScreenMethodX11(WXDisplay* display,
 469                                                WXWindow rootWindow)
 470 {
 471     Window root = WindowCast(rootWindow);
 472     Display *disp = (Display*)display;
 473
 474     // if WM supports _NET_WM_STATE_FULLSCREEN from wm-spec 1.2, use it:
 475     wxMAKE_ATOM(_NET_WM_STATE_FULLSCREEN, disp);
 476     if (wxQueryWMspecSupport(disp, root, _NET_WM_STATE_FULLSCREEN))
 477     {
 478         wxLogTrace(_T("fullscreen"),
 479                    _T("detected _NET_WM_STATE_FULLSCREEN support"));
 480         return wxX11_FS_WMSPEC;
 481     }
 482
 483     // if the user is running KDE's kwin WM, use a legacy hack because
 484     // kwin doesn't understand any other method:
 485     if (wxKwinRunning(disp, root))
 486     {
 487         wxLogTrace(_T("fullscreen"), _T("detected kwin"));
 488         return wxX11_FS_KDE;
 489     }
 490
 491     // finally, fall back to ICCCM heuristic method:
 492     wxLogTrace(_T("fullscreen"), _T("unknown WM, using _WIN_LAYER"));
 493     return wxX11_FS_GENERIC;
 494 }
 495
 496
 497 void wxSetFullScreenStateX11(WXDisplay* display, WXWindow rootWindow,
 498                              WXWindow window, bool show,
 499                              wxRect *origRect,
 500                              wxX11FullScreenMethod method)
 501 {
 502     // NB: please see the comment under "Fullscreen mode:" title above
 503     //     for implications of changing this code.
 504
 505     Window wnd = WindowCast(window);
 506     Window root = WindowCast(rootWindow);
 507     Display *disp = (Display*)display;
 508
 509     if (method == wxX11_FS_AUTODETECT)
 510         method = wxGetFullScreenMethodX11(display, rootWindow);
 511
 512     switch (method)
 513     {
 514         case wxX11_FS_WMSPEC:
 515             wxWMspecSetFullscreen(disp, root, wnd, show);
 516             break;
 517         case wxX11_FS_KDE:
 518             wxSetKDEFullscreen(disp, root, wnd, show, origRect);
 519             break;
 520         default:
 521             wxWinHintsSetLayer(disp, root, wnd,
 522                                show ? WIN_LAYER_ABOVE_DOCK : WIN_LAYER_NORMAL);
 523             break;
 524     }
 525 }
 526
 527
 528
 529 // ----------------------------------------------------------------------------
 530 // keycode translations
 531 // ----------------------------------------------------------------------------
 532
 533 #include <X11/keysym.h>
 534
 535 // FIXME what about tables??
 536
 537 int wxCharCodeXToWX(KeySym keySym)
 538 {
 539     int id;
 540     switch (keySym)
 541     {
 542         case XK_Shift_L:
 543         case XK_Shift_R:
 544             id = WXK_SHIFT; break;
 545         case XK_Control_L:
 546         case XK_Control_R:
 547             id = WXK_CONTROL; break;
 548         case XK_Meta_L:
 549         case XK_Meta_R:
 550             id = WXK_ALT; break;
 551         case XK_Caps_Lock:
 552             id = WXK_CAPITAL; break;
 553         case XK_BackSpace:
 554             id = WXK_BACK; break;
 555         case XK_Delete:
 556             id = WXK_DELETE; break;
 557         case XK_Clear:
 558             id = WXK_CLEAR; break;
 559         case XK_Tab:
 560             id = WXK_TAB; break;
 561         case XK_numbersign:
 562             id = '#'; break;
 563         case XK_Return:
 564             id = WXK_RETURN; break;
 565         case XK_Escape:
 566             id = WXK_ESCAPE; break;
 567         case XK_Pause:
 568         case XK_Break:
 569             id = WXK_PAUSE; break;
 570         case XK_Num_Lock:
 571             id = WXK_NUMLOCK; break;
 572         case XK_Scroll_Lock:
 573             id = WXK_SCROLL; break;
 574
 575         case XK_Home:
 576             id = WXK_HOME; break;
 577         case XK_End:
 578             id = WXK_END; break;
 579         case XK_Left:
 580             id = WXK_LEFT; break;
 581         case XK_Right:
 582             id = WXK_RIGHT; break;
 583         case XK_Up:
 584             id = WXK_UP; break;
 585         case XK_Down:
 586             id = WXK_DOWN; break;
 587         case XK_Next:
 588             id = WXK_PAGEDOWN; break;
 589         case XK_Prior:
 590             id = WXK_PAGEUP; break;
 591         case XK_Menu:
 592             id = WXK_MENU; break;
 593         case XK_Select:
 594             id = WXK_SELECT; break;
 595         case XK_Cancel:
 596             id = WXK_CANCEL; break;
 597         case XK_Print:
 598             id = WXK_PRINT; break;
 599         case XK_Execute:
 600             id = WXK_EXECUTE; break;
 601         case XK_Insert:
 602             id = WXK_INSERT; break;
 603         case XK_Help:
 604             id = WXK_HELP; break;
 605
 606         case XK_KP_Multiply:
 607             id = WXK_NUMPAD_MULTIPLY; break;
 608         case XK_KP_Add:
 609             id = WXK_NUMPAD_ADD; break;
 610         case XK_KP_Subtract:
 611             id = WXK_NUMPAD_SUBTRACT; break;
 612         case XK_KP_Divide:
 613             id = WXK_NUMPAD_DIVIDE; break;
 614         case XK_KP_Decimal:
 615             id = WXK_NUMPAD_DECIMAL; break;
 616         case XK_KP_Equal:
 617             id = WXK_NUMPAD_EQUAL; break;
 618         case XK_KP_Space:
 619             id = WXK_NUMPAD_SPACE; break;
 620         case XK_KP_Tab:
 621             id = WXK_NUMPAD_TAB; break;
 622         case XK_KP_Enter:
 623             id = WXK_NUMPAD_ENTER; break;
 624         case XK_KP_0:
 625             id = WXK_NUMPAD0; break;
 626         case XK_KP_1:
 627             id = WXK_NUMPAD1; break;
 628         case XK_KP_2:
 629             id = WXK_NUMPAD2; break;
 630         case XK_KP_3:
 631             id = WXK_NUMPAD3; break;
 632         case XK_KP_4:
 633             id = WXK_NUMPAD4; break;
 634         case XK_KP_5:
 635             id = WXK_NUMPAD5; break;
 636         case XK_KP_6:
 637             id = WXK_NUMPAD6; break;
 638         case XK_KP_7:
 639             id = WXK_NUMPAD7; break;
 640         case XK_KP_8:
 641             id = WXK_NUMPAD8; break;
 642         case XK_KP_9:
 643             id = WXK_NUMPAD9; break;
 644         case XK_KP_Insert:
 645             id = WXK_NUMPAD_INSERT; break;
 646         case XK_KP_End:
 647             id = WXK_NUMPAD_END; break;
 648         case XK_KP_Down:
 649             id = WXK_NUMPAD_DOWN; break;
 650         case XK_KP_Page_Down:
 651             id = WXK_NUMPAD_PAGEDOWN; break;
 652         case XK_KP_Left:
 653             id = WXK_NUMPAD_LEFT; break;
 654         case XK_KP_Right:
 655             id = WXK_NUMPAD_RIGHT; break;
 656         case XK_KP_Home:
 657             id = WXK_NUMPAD_HOME; break;
 658         case XK_KP_Up:
 659             id = WXK_NUMPAD_UP; break;
 660         case XK_KP_Page_Up:
 661             id = WXK_NUMPAD_PAGEUP; break;
 662         case XK_F1:
 663             id = WXK_F1; break;
 664         case XK_F2:
 665             id = WXK_F2; break;
 666         case XK_F3:
 667             id = WXK_F3; break;
 668         case XK_F4:
 669             id = WXK_F4; break;
 670         case XK_F5:
 671             id = WXK_F5; break;
 672         case XK_F6:
 673             id = WXK_F6; break;
 674         case XK_F7:
 675             id = WXK_F7; break;
 676         case XK_F8:
 677             id = WXK_F8; break;
 678         case XK_F9:
 679             id = WXK_F9; break;
 680         case XK_F10:
 681             id = WXK_F10; break;
 682         case XK_F11:
 683             id = WXK_F11; break;
 684         case XK_F12:
 685             id = WXK_F12; break;
 686         case XK_F13:
 687             id = WXK_F13; break;
 688         case XK_F14:
 689             id = WXK_F14; break;
 690         case XK_F15:
 691             id = WXK_F15; break;
 692         case XK_F16:
 693             id = WXK_F16; break;
 694         case XK_F17:
 695             id = WXK_F17; break;
 696         case XK_F18:
 697             id = WXK_F18; break;
 698         case XK_F19:
 699             id = WXK_F19; break;
 700         case XK_F20:
 701             id = WXK_F20; break;
 702         case XK_F21:
 703             id = WXK_F21; break;
 704         case XK_F22:
 705             id = WXK_F22; break;
 706         case XK_F23:
 707             id = WXK_F23; break;
 708         case XK_F24:
 709             id = WXK_F24; break;
 710         default:
 711             id = (keySym <= 255) ? (int)keySym : -1;
 712     }
 713
 714     return id;
 715 }
 716
 717 KeySym wxCharCodeWXToX(int id)
 718 {
 719     KeySym keySym;
 720
 721     switch (id)
 722     {
 723         case WXK_CANCEL:        keySym = XK_Cancel; break;
 724         case WXK_BACK:          keySym = XK_BackSpace; break;
 725         case WXK_TAB:           keySym = XK_Tab; break;
 726         case WXK_CLEAR:         keySym = XK_Clear; break;
 727         case WXK_RETURN:        keySym = XK_Return; break;
 728         case WXK_SHIFT:         keySym = XK_Shift_L; break;
 729         case WXK_CONTROL:       keySym = XK_Control_L; break;
 730         case WXK_ALT:           keySym = XK_Meta_L; break;
 731         case WXK_CAPITAL:       keySym = XK_Caps_Lock; break;
 732         case WXK_MENU :         keySym = XK_Menu; break;
 733         case WXK_PAUSE:         keySym = XK_Pause; break;
 734         case WXK_ESCAPE:        keySym = XK_Escape; break;
 735         case WXK_SPACE:         keySym = ' '; break;
 736         case WXK_PAGEUP:        keySym = XK_Prior; break;
 737         case WXK_PAGEDOWN:      keySym = XK_Next; break;
 738         case WXK_END:           keySym = XK_End; break;
 739         case WXK_HOME :         keySym = XK_Home; break;
 740         case WXK_LEFT :         keySym = XK_Left; break;
 741         case WXK_UP:            keySym = XK_Up; break;
 742         case WXK_RIGHT:         keySym = XK_Right; break;
 743         case WXK_DOWN :         keySym = XK_Down; break;
 744         case WXK_SELECT:        keySym = XK_Select; break;
 745         case WXK_PRINT:         keySym = XK_Print; break;
 746         case WXK_EXECUTE:       keySym = XK_Execute; break;
 747         case WXK_INSERT:        keySym = XK_Insert; break;
 748         case WXK_DELETE:        keySym = XK_Delete; break;
 749         case WXK_HELP :         keySym = XK_Help; break;
 750         case WXK_NUMPAD0:       keySym = XK_KP_0; break; case WXK_NUMPAD_INSERT:     keySym = XK_KP_Insert; break;
 751         case WXK_NUMPAD1:       keySym = XK_KP_1; break; case WXK_NUMPAD_END:           keySym = XK_KP_End; break;
 752         case WXK_NUMPAD2:       keySym = XK_KP_2; break; case WXK_NUMPAD_DOWN:      keySym = XK_KP_Down; break;
 753         case WXK_NUMPAD3:       keySym = XK_KP_3; break; case WXK_NUMPAD_PAGEDOWN:  keySym = XK_KP_Page_Down; break;
 754         case WXK_NUMPAD4:       keySym = XK_KP_4; break; case WXK_NUMPAD_LEFT:         keySym = XK_KP_Left; break;
 755         case WXK_NUMPAD5:       keySym = XK_KP_5; break;
 756         case WXK_NUMPAD6:       keySym = XK_KP_6; break; case WXK_NUMPAD_RIGHT:       keySym = XK_KP_Right; break;
 757         case WXK_NUMPAD7:       keySym = XK_KP_7; break; case WXK_NUMPAD_HOME:       keySym = XK_KP_Home; break;
 758         case WXK_NUMPAD8:       keySym = XK_KP_8; break; case WXK_NUMPAD_UP:             keySym = XK_KP_Up; break;
 759         case WXK_NUMPAD9:       keySym = XK_KP_9; break; case WXK_NUMPAD_PAGEUP:   keySym = XK_KP_Page_Up; break;
 760         case WXK_NUMPAD_DECIMAL:    keySym = XK_KP_Decimal; break; case WXK_NUMPAD_DELETE:   keySym = XK_KP_Delete; break;
 761         case WXK_NUMPAD_MULTIPLY:   keySym = XK_KP_Multiply; break;
 762         case WXK_NUMPAD_ADD:             keySym = XK_KP_Add; break;
 763         case WXK_NUMPAD_SUBTRACT: keySym = XK_KP_Subtract; break;
 764         case WXK_NUMPAD_DIVIDE:        keySym = XK_KP_Divide; break;
 765         case WXK_NUMPAD_ENTER:        keySym = XK_KP_Enter; break;
 766         case WXK_NUMPAD_SEPARATOR:  keySym = XK_KP_Separator; break;
 767         case WXK_F1:            keySym = XK_F1; break;
 768         case WXK_F2:            keySym = XK_F2; break;
 769         case WXK_F3:            keySym = XK_F3; break;
 770         case WXK_F4:            keySym = XK_F4; break;
 771         case WXK_F5:            keySym = XK_F5; break;
 772         case WXK_F6:            keySym = XK_F6; break;
 773         case WXK_F7:            keySym = XK_F7; break;
 774         case WXK_F8:            keySym = XK_F8; break;
 775         case WXK_F9:            keySym = XK_F9; break;
 776         case WXK_F10:           keySym = XK_F10; break;
 777         case WXK_F11:           keySym = XK_F11; break;
 778         case WXK_F12:           keySym = XK_F12; break;
 779         case WXK_F13:           keySym = XK_F13; break;
 780         case WXK_F14:           keySym = XK_F14; break;
 781         case WXK_F15:           keySym = XK_F15; break;
 782         case WXK_F16:           keySym = XK_F16; break;
 783         case WXK_F17:           keySym = XK_F17; break;
 784         case WXK_F18:           keySym = XK_F18; break;
 785         case WXK_F19:           keySym = XK_F19; break;
 786         case WXK_F20:           keySym = XK_F20; break;
 787         case WXK_F21:           keySym = XK_F21; break;
 788         case WXK_F22:           keySym = XK_F22; break;
 789         case WXK_F23:           keySym = XK_F23; break;
 790         case WXK_F24:           keySym = XK_F24; break;
 791         case WXK_NUMLOCK:       keySym = XK_Num_Lock; break;
 792         case WXK_SCROLL:        keySym = XK_Scroll_Lock; break;
 793         default:                keySym = id <= 255 ? (KeySym)id : 0;
 794     }
 795
 796     return keySym;
 797 }
 798
 799
 800 // ----------------------------------------------------------------------------
 801 // check current state of a key
 802 // ----------------------------------------------------------------------------
 803
 804 bool wxGetKeyState(wxKeyCode key)
 805 {
 806     wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
 807         WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));
 808
 809     Display *pDisplay = (Display*) wxGetDisplay();
 810
 811     int iKey = wxCharCodeWXToX(key);
 812     int          iKeyMask = 0;
 813     Window       wDummy1, wDummy2;
 814     int          iDummy3, iDummy4, iDummy5, iDummy6;
 815     unsigned int iMask;
 816     KeyCode keyCode = XKeysymToKeycode(pDisplay,iKey);
 817     if (keyCode == NoSymbol)
 818         return false;
 819
 820     if ( IsModifierKey(iKey) )  // If iKey is a modifier key, use a different method
 821     {
 822         XModifierKeymap *map = XGetModifierMapping(pDisplay);
 823         wxCHECK_MSG( map, false, _T("failed to get X11 modifiers map") );
 824
 825         for (int i = 0; i < 8; ++i)
 826         {
 827             if ( map->modifiermap[map->max_keypermod * i] == keyCode)
 828             {
 829                 iKeyMask = 1 << i;
 830             }
 831         }
 832
 833         XQueryPointer(pDisplay, DefaultRootWindow(pDisplay), &wDummy1, &wDummy2,
 834                         &iDummy3, &iDummy4, &iDummy5, &iDummy6, &iMask );
 835         XFreeModifiermap(map);
 836         return (iMask & iKeyMask) != 0;
 837     }
 838
 839     // From the XLib manual:
 840     // The XQueryKeymap() function returns a bit vector for the logical state of the keyboard,
 841     // where each bit set to 1 indicates that the corresponding key is currently pressed down.
 842     // The vector is represented as 32 bytes. Byte N (from 0) contains the bits for keys 8N to 8N + 7
 843     // with the least-significant bit in the byte representing key 8N.
 844     char key_vector[32];
 845     XQueryKeymap(pDisplay, key_vector);
 846     return key_vector[keyCode >> 3] & (1 << (keyCode & 7));
 847 }
 848
 849 #endif // __WXX11__ || __WXGTK__ || __WXMOTIF__