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) wxWindows 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 #include "wx/x11/privx.h"
  19 #include "wx/iconbndl.h"
  20 #include "wx/image.h"
  21 #include "wx/icon.h"
  22 #include "wx/log.h"
  23 #include "wx/utils.h"
  24
  25 #ifdef __VMS
  26 #pragma message disable nosimpint
  27 #endif
  28 #include <X11/Xlib.h>
  29 #include <X11/Xatom.h>
  30 #ifdef __VMS
  31 #pragma message enable nosimpint
  32 #endif
  33
  34 #ifdef __WXGTK20__
  35 #include <gdk/gdk.h>
  36 #include <gdk/gdkx.h>
  37 #endif
  38
  39 // Various X11 Atoms used in this file:
  40 static Atom _NET_WM_ICON = 0;
  41 static Atom _NET_WM_STATE = 0;
  42 static Atom _NET_WM_STATE_FULLSCREEN = 0;
  43 static Atom _NET_WM_STATE_STAYS_ON_TOP = 0;
  44 static Atom _NET_WM_WINDOW_TYPE = 0;
  45 static Atom _NET_WM_WINDOW_TYPE_NORMAL = 0;
  46 static Atom _KDE_NET_WM_WINDOW_TYPE_OVERRIDE = 0;
  47 static Atom _WIN_LAYER = 0;
  48 static Atom KWIN_RUNNING = 0;
  49 #ifndef __WXGTK20__
  50 static Atom _NET_SUPPORTING_WM_CHECK = 0;
  51 static Atom _NET_SUPPORTED = 0;
  52 #endif
  53
  54 #define wxMAKE_ATOM(name, display) \
  55     if (name == 0) name = XInternAtom((display), #name, False)
  56
  57
  58 // Is the window mapped?
  59 static bool IsMapped(Display *display, Window window)
  60 {
  61     XWindowAttributes attr;
  62     XGetWindowAttributes(display, window, &attr);
  63     return (attr.map_state != IsUnmapped);
  64 }
  65
  66
  67
  68 // Suspends X11 errors. Used when we expect errors but they are not fatal
  69 // for us.
  70 class wxX11ErrorsSuspender
  71 {
  72 public:
  73     wxX11ErrorsSuspender(Display *d) : m_display(d)
  74     {
  75         m_old = XSetErrorHandler(handler);
  76     }
  77     ~wxX11ErrorsSuspender()
  78     {
  79         XFlush(m_display);
  80         XSetErrorHandler(m_old);
  81     }
  82
  83 private:
  84     Display *m_display;
  85     int (*m_old)(Display*, XErrorEvent *);
  86     static int handler(Display *, XErrorEvent *) { return 0; }
  87 };
  88
  89
  90
  91 // ----------------------------------------------------------------------------
  92 // Setting icons for window manager:
  93 // ----------------------------------------------------------------------------
  94
  95 void wxSetIconsX11( WXDisplay* display, WXWindow window,
  96                     const wxIconBundle& ib )
  97 {
  98 #if !wxUSE_NANOX
  99     size_t size = 0;
 100     size_t i, max = ib.m_icons.GetCount();
 101
 102     for( i = 0; i < max; ++i )
 103         if( ib.m_icons[i].Ok() )
 104             size += 2 + ib.m_icons[i].GetWidth() * ib.m_icons[i].GetHeight();
 105
 106     wxMAKE_ATOM(_NET_WM_ICON, (Display*)display);
 107
 108     if( size > 0 )
 109     {
 110 //       The code below is correct for 64-bit machines also.
 111 //       wxUint32* data = new wxUint32[size];
 112 //       wxUint32* ptr = data;
 113         unsigned long* data = new unsigned long[size];
 114         unsigned long* ptr = data;
 115
 116         for( i = 0; i < max; ++i )
 117         {
 118             const wxImage image = ib.m_icons[i].ConvertToImage();
 119             int width = image.GetWidth(), height = image.GetHeight();
 120             unsigned char* imageData = image.GetData();
 121             unsigned char* imageDataEnd = imageData + ( width * height * 3 );
 122             bool hasMask = image.HasMask();
 123             unsigned char rMask, gMask, bMask;
 124             unsigned char r, g, b, a;
 125
 126             if( hasMask )
 127             {
 128                 rMask = image.GetMaskRed();
 129                 gMask = image.GetMaskGreen();
 130                 bMask = image.GetMaskBlue();
 131             }
 132             else // no mask, but still init the variables to avoid warnings
 133             {
 134                 rMask =
 135                 gMask =
 136                 bMask = 0;
 137             }
 138
 139             *ptr++ = width;
 140             *ptr++ = height;
 141
 142             while( imageData < imageDataEnd ) {
 143                 r = imageData[0];
 144                 g = imageData[1];
 145                 b = imageData[2];
 146                 if( hasMask && r == rMask && g == gMask && b == bMask )
 147                     a = 0;
 148                 else
 149                     a = 255;
 150
 151                 *ptr++ = ( a << 24 ) | ( r << 16 ) | ( g << 8 ) | b;
 152
 153                 imageData += 3;
 154             }
 155         }
 156
 157         XChangeProperty( (Display*)display,
 158                          (Window)window,
 159                          _NET_WM_ICON,
 160                          XA_CARDINAL, 32,
 161                          PropModeReplace,
 162                          (unsigned char*)data, size );
 163         delete[] data;
 164     }
 165     else
 166     {
 167         XDeleteProperty( (Display*)display,
 168                          (Window)window,
 169                          _NET_WM_ICON );
 170     }
 171 #endif
 172 }
 173
 174
 175 // ----------------------------------------------------------------------------
 176 // Fullscreen mode:
 177 // ----------------------------------------------------------------------------
 178
 179 // NB: Setting fullscreen mode under X11 is a complicated matter. There was
 180 //     no standard way of doing it until recently. ICCCM doesn't know the
 181 //     concept of fullscreen windows and the only way to make a window
 182 //     fullscreen is to remove decorations, resize it to cover entire screen
 183 //     and set WIN_LAYER_ABOVE_DOCK.
 184 //
 185 //     This doesn't always work, though. Specifically, at least kwin from
 186 //     KDE 3 ignores the hint. The only way to make kwin accept our request
 187 //     is to emulate the way Qt does it. That is, unmap the window, set
 188 //     _NET_WM_WINDOW_TYPE to _KDE_NET_WM_WINDOW_TYPE_OVERRIDE (KDE extension),
 189 //     add _NET_WM_STATE_STAYS_ON_TOP (ditto) to _NET_WM_STATE and map
 190 //     the window again.
 191 //
 192 //     Version 1.2 of Window Manager Specification (aka wm-spec aka
 193 //     Extended Window Manager Hints) introduced _NET_WM_STATE_FULLSCREEN
 194 //     window state which provides cleanest and simplest possible way of
 195 //     making a window fullscreen. WM-spec is a de-facto standard adopted
 196 //     by GNOME and KDE folks, but _NET_WM_STATE_FULLSCREEN isn't yet widely
 197 //     supported. As of January 2003, only GNOME 2's default WM Metacity
 198 //     implements, KDE will support it from version 3.2. At toolkits level,
 199 //     GTK+ >= 2.1.2 uses it as the only method of making windows fullscreen
 200 //     (that's why wxGTK will *not* switch to using gtk_window_fullscreen
 201 //     unless it has better compatiblity with older WMs).
 202 //
 203 //
 204 //     This is what wxWindows does in wxSetFullScreenStateX11:
 205 //       1) if _NET_WM_STATE_FULLSCREEN is supported, use it
 206 //       2) otherwise try WM-specific hacks (KDE, IceWM)
 207 //       3) use _WIN_LAYER and hope that the WM will recognize it
 208 //     The code was tested with:
 209 //     twm, IceWM, WindowMaker, Metacity, kwin, sawfish, lesstif-mwm
 210
 211
 212 #define  WIN_LAYER_NORMAL       4
 213 #define  WIN_LAYER_ABOVE_DOCK  10
 214
 215 static void wxWinHintsSetLayer(Display *display, Window rootWnd,
 216                                Window window, int layer)
 217 {
 218     wxX11ErrorsSuspender noerrors(display);
 219
 220     XEvent xev;
 221
 222     wxMAKE_ATOM( _WIN_LAYER, display );
 223
 224     if (IsMapped(display, window))
 225     {
 226         xev.type = ClientMessage;
 227         xev.xclient.type = ClientMessage;
 228         xev.xclient.window = window;
 229         xev.xclient.message_type = _WIN_LAYER;
 230         xev.xclient.format = 32;
 231         xev.xclient.data.l[0] = (long)layer;
 232         xev.xclient.data.l[1] = CurrentTime;
 233
 234         XSendEvent(display, rootWnd, False,
 235                    SubstructureNotifyMask, (XEvent*) &xev);
 236     }
 237     else
 238     {
 239         long data[1];
 240
 241         data[0] = layer;
 242         XChangeProperty(display, window,
 243                         _WIN_LAYER, XA_CARDINAL, 32,
 244                         PropModeReplace, (unsigned char *)data, 1);
 245     }
 246 }
 247
 248
 249
 250 #ifdef __WXGTK20__
 251 static bool wxQueryWMspecSupport(Display* WXUNUSED(display),
 252                                  Window WXUNUSED(rootWnd),
 253                                  Atom (feature))
 254 {
 255     GdkAtom gatom = gdk_x11_xatom_to_atom(feature);
 256     return gdk_net_wm_supports(gatom);
 257 }
 258 #else
 259 static bool wxQueryWMspecSupport(Display *display, Window rootWnd, Atom feature)
 260 {
 261     wxMAKE_ATOM(_NET_SUPPORTING_WM_CHECK, display);
 262     wxMAKE_ATOM(_NET_SUPPORTED, display);
 263
 264     // FIXME: We may want to cache these checks. Note that we can't simply
 265     //        remember the results in global variable because the WM may go
 266     //        away and be replaced by another one! One possible approach
 267     //        would be invalidate the case every 15 seconds or so. Since this
 268     //        code is currently only used by wxTopLevelWindow::ShowFullScreen,
 269     //        it is not important that it is not optimized.
 270     //
 271     //        If the WM supports ICCCM (i.e. the root window has
 272     //        _NET_SUPPORTING_WM_CHECK property that points to a WM-owned
 273     //        window), we could watch for DestroyNotify event on the window
 274     //        and invalidate our cache when the windows goes away (= WM
 275     //        is replaced by another one). This is what GTK+ 2 does.
 276     //        Let's do it only if it is needed, it requires changes to
 277     //        the event loop.
 278
 279     Atom type;
 280     Window *wins;
 281     Atom *atoms;
 282     int format;
 283     unsigned long after;
 284     unsigned long nwins, natoms;
 285
 286     // Is the WM ICCCM supporting?
 287     XGetWindowProperty(display, rootWnd,
 288                        _NET_SUPPORTING_WM_CHECK, 0, LONG_MAX,
 289                        False, XA_WINDOW, &type, &format, &nwins,
 290                        &after, (unsigned char **)&wins);
 291     if ( type != XA_WINDOW || nwins <= 0 || wins[0] == None )
 292        return FALSE;
 293     XFree(wins);
 294
 295     // Query for supported features:
 296     XGetWindowProperty(display, rootWnd,
 297                        _NET_SUPPORTED, 0, LONG_MAX,
 298                        False, XA_ATOM, &type, &format, &natoms,
 299                        &after, (unsigned char **)&atoms);
 300     if ( type != XA_ATOM || atoms == NULL )
 301         return FALSE;
 302
 303     // Lookup the feature we want:
 304     for (unsigned i = 0; i < natoms; i++)
 305     {
 306         if ( atoms[i] == feature )
 307         {
 308             XFree(atoms);
 309             return TRUE;
 310         }
 311     }
 312     XFree(atoms);
 313     return FALSE;
 314 }
 315 #endif
 316
 317
 318 #define _NET_WM_STATE_REMOVE        0
 319 #define _NET_WM_STATE_ADD           1
 320
 321 static void wxWMspecSetState(Display *display, Window rootWnd,
 322                              Window window, int operation, Atom state)
 323 {
 324     wxMAKE_ATOM(_NET_WM_STATE, display);
 325
 326     if ( IsMapped(display, window) )
 327     {
 328         XEvent xev;
 329         xev.type = ClientMessage;
 330         xev.xclient.type = ClientMessage;
 331         xev.xclient.serial = 0;
 332         xev.xclient.send_event = True;
 333         xev.xclient.display = display;
 334         xev.xclient.window = window;
 335         xev.xclient.message_type = _NET_WM_STATE;
 336         xev.xclient.format = 32;
 337         xev.xclient.data.l[0] = operation;
 338         xev.xclient.data.l[1] = state;
 339         xev.xclient.data.l[2] = None;
 340
 341         XSendEvent(display, rootWnd,
 342                    False,
 343                    SubstructureRedirectMask | SubstructureNotifyMask,
 344                    &xev);
 345     }
 346     // FIXME - must modify _NET_WM_STATE property list if the window
 347     //         wasn't mapped!
 348 }
 349
 350 static void wxWMspecSetFullscreen(Display *display, Window rootWnd,
 351                                   Window window, bool fullscreen)
 352 {
 353     wxMAKE_ATOM(_NET_WM_STATE_FULLSCREEN, display);
 354     wxWMspecSetState(display, rootWnd,
 355                      window,
 356                      fullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE,
 357                       _NET_WM_STATE_FULLSCREEN);
 358 }
 359
 360
 361 // Is the user running KDE's kwin window manager? At least kwin from KDE 3
 362 // sets KWIN_RUNNING property on the root window.
 363 static bool wxKwinRunning(Display *display, Window rootWnd)
 364 {
 365     wxMAKE_ATOM(KWIN_RUNNING, display);
 366
 367     long *data;
 368     Atom type;
 369     int format;
 370     unsigned long nitems, after;
 371     if (XGetWindowProperty(display, rootWnd,
 372                            KWIN_RUNNING, 0, 1, False, KWIN_RUNNING,
 373                            &type, &format, &nitems, &after,
 374                            (unsigned char**)&data) != Success)
 375     {
 376         return FALSE;
 377     }
 378
 379     bool retval = (type == KWIN_RUNNING &&
 380                    nitems == 1 && data && data[0] == 1);
 381     XFree(data);
 382     return retval;
 383 }
 384
 385 // KDE's kwin is Qt-centric so much than no normal method of fullscreen
 386 // mode will work with it. We have to carefully emulate the Qt way.
 387 static void wxSetKDEFullscreen(Display *display, Window rootWnd,
 388                                Window w, bool fullscreen, wxRect *origRect)
 389 {
 390     long data[2];
 391     unsigned lng;
 392
 393     wxMAKE_ATOM(_NET_WM_WINDOW_TYPE, display);
 394     wxMAKE_ATOM(_NET_WM_WINDOW_TYPE_NORMAL, display);
 395     wxMAKE_ATOM(_KDE_NET_WM_WINDOW_TYPE_OVERRIDE, display);
 396     wxMAKE_ATOM(_NET_WM_STATE_STAYS_ON_TOP, display);
 397
 398     if (fullscreen)
 399     {
 400         data[0] = _KDE_NET_WM_WINDOW_TYPE_OVERRIDE;
 401         data[1] = _NET_WM_WINDOW_TYPE_NORMAL;
 402         lng = 2;
 403     }
 404     else
 405     {
 406         data[0] = _NET_WM_WINDOW_TYPE_NORMAL;
 407         data[1] = None;
 408         lng = 1;
 409     }
 410
 411     // it is neccessary to unmap the window, otherwise kwin will ignore us:
 412     XSync(display, False);
 413
 414     bool wasMapped = IsMapped(display, w);
 415     if (wasMapped)
 416     {
 417         XUnmapWindow(display, w);
 418         XSync(display, False);
 419     }
 420
 421     XChangeProperty(display, w, _NET_WM_WINDOW_TYPE, XA_ATOM, 32,
 422                         PropModeReplace, (unsigned char *) &data, lng);
 423     XSync(display, False);
 424
 425     if (wasMapped)
 426     {
 427         XMapRaised(display, w);
 428         XSync(display, False);
 429     }
 430
 431     wxWMspecSetState(display, rootWnd, w,
 432                      fullscreen ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE,
 433                      _NET_WM_STATE_STAYS_ON_TOP);
 434     XSync(display, False);
 435
 436     if (!fullscreen)
 437     {
 438         // NB: like many other WMs, kwin ignores first request for window
 439         //     position change after the window was mapped. This additional
 440         //     move+resize event will ensure that the window is restored in
 441         //     exactly same position as before it was made fullscreen (because
 442         //     wxTopLevelWindow::ShowFullScreen will call SetSize, thus
 443         //     setting the position for second time).
 444         XMoveResizeWindow(display, w,
 445                           origRect->x, origRect->y,
 446                           origRect->width, origRect->height);
 447         XSync(display, False);
 448     }
 449 }
 450
 451
 452 wxX11FullScreenMethod wxGetFullScreenMethodX11(WXDisplay* display,
 453                                                WXWindow rootWindow)
 454 {
 455     Window root = (Window)rootWindow;
 456     Display *disp = (Display*)display;
 457
 458     // if WM supports _NET_WM_STATE_FULLSCREEN from wm-spec 1.2, use it:
 459     wxMAKE_ATOM(_NET_WM_STATE_FULLSCREEN, disp);
 460     if (wxQueryWMspecSupport(disp, root, _NET_WM_STATE_FULLSCREEN))
 461     {
 462         wxLogTrace(_T("fullscreen"),
 463                    _T("detected _NET_WM_STATE_FULLSCREEN support"));
 464         return wxX11_FS_WMSPEC;
 465     }
 466
 467     // if the user is running KDE's kwin WM, use a legacy hack because
 468     // kwin doesn't understand any other method:
 469     if (wxKwinRunning(disp, root))
 470     {
 471         wxLogTrace(_T("fullscreen"), _T("detected kwin"));
 472         return wxX11_FS_KDE;
 473     }
 474
 475     // finally, fall back to ICCCM heuristic method:
 476     wxLogTrace(_T("fullscreen"), _T("unknown WM, using _WIN_LAYER"));
 477     return wxX11_FS_GENERIC;
 478 }
 479
 480
 481 void wxSetFullScreenStateX11(WXDisplay* display, WXWindow rootWindow,
 482                              WXWindow window, bool show,
 483                              wxRect *origRect,
 484                              wxX11FullScreenMethod method)
 485 {
 486     // NB: please see the comment under "Fullscreen mode:" title above
 487     //     for implications of changing this code.
 488
 489     Window wnd = (Window)window;
 490     Window root = (Window)rootWindow;
 491     Display *disp = (Display*)display;
 492
 493     if (method == wxX11_FS_AUTODETECT)
 494         method = wxGetFullScreenMethodX11(display, rootWindow);
 495
 496     switch (method)
 497     {
 498         case wxX11_FS_WMSPEC:
 499             wxWMspecSetFullscreen(disp, root, wnd, show);
 500             break;
 501         case wxX11_FS_KDE:
 502             wxSetKDEFullscreen(disp, root, wnd, show, origRect);
 503             break;
 504         default:
 505             wxWinHintsSetLayer(disp, root, wnd,
 506                                show ? WIN_LAYER_ABOVE_DOCK : WIN_LAYER_NORMAL);
 507             break;
 508     }
 509 }
 510
 511 bool wxGetKeyState(wxKeyCode key)
 512 {
 513   Display *pDisplay = (Display*) wxGetDisplay();
 514   int iKey = wxCharCodeWXToX(key);
 515   int          iKeyMask = 0;
 516   Window       wDummy1, wDummy2;
 517   int          iDummy3, iDummy4, iDummy5, iDummy6;
 518   unsigned int iMask;
 519   XModifierKeymap* map = XGetModifierMapping(pDisplay);
 520   KeyCode keyCode = XKeysymToKeycode(pDisplay,iKey);
 521   if(keyCode == NoSymbol) return false;
 522   for(int i = 0; i < 8; ++i) {
 523     if( map->modifiermap[map->max_keypermod * i] == keyCode) {
 524       iKeyMask = 1 << i;
 525     }
 526   }
 527   XQueryPointer(pDisplay, DefaultRootWindow(pDisplay), &wDummy1, &wDummy2,
 528                 &iDummy3, &iDummy4, &iDummy5, &iDummy6, &iMask );
 529   XFreeModifiermap(map);
 530   return (iMask & iKeyMask) != 0;
 531 }
 532
 533 #endif
 534