ui/base/x/x11_util.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef UI_BASE_X_X11_UTIL_H_
   6 #define UI_BASE_X_X11_UTIL_H_
   7
   8 // This file declares utility functions for X11 (Linux only).
   9 //
  10 // These functions do not require the Xlib headers to be included (which is why
  11 // we use a void* for Visual*). The Xlib headers are highly polluting so we try
  12 // hard to limit their spread into the rest of the code.
  13
  14 #include <string>
  15 #include <vector>
  16
  17 #include "base/basictypes.h"
  18 #include "base/event_types.h"
  19 #include "base/memory/ref_counted_memory.h"
  20 #include "ui/base/ui_base_export.h"
  21 #include "ui/events/event_constants.h"
  22 #include "ui/events/keycodes/keyboard_codes.h"
  23 #include "ui/gfx/x/x11_types.h"
  24
  25 typedef unsigned long XSharedMemoryId;  // ShmSeg in the X headers.
  26 typedef unsigned long Cursor;
  27 typedef struct _XcursorImage XcursorImage;
  28 typedef union _XEvent XEvent;
  29
  30 namespace gfx {
  31 class Canvas;
  32 class Insets;
  33 class Point;
  34 class Rect;
  35 }
  36 class SkBitmap;
  37
  38 namespace ui {
  39
  40 // These functions use the default display and this /must/ be called from
  41 // the UI thread. Thus, they don't support multiple displays.
  42
  43 // These functions cache their results ---------------------------------
  44
  45 // Returns true if the system supports XINPUT2.
  46 UI_BASE_EXPORT bool IsXInput2Available();
  47
  48 // X shared memory comes in three flavors:
  49 // 1) No SHM support,
  50 // 2) SHM putimage,
  51 // 3) SHM pixmaps + putimage.
  52 enum SharedMemorySupport {
  53   SHARED_MEMORY_NONE,
  54   SHARED_MEMORY_PUTIMAGE,
  55   SHARED_MEMORY_PIXMAP
  56 };
  57 // Return the shared memory type of our X connection.
  58 UI_BASE_EXPORT SharedMemorySupport QuerySharedMemorySupport(XDisplay* dpy);
  59
  60 // Return true iff the display supports Xrender
  61 UI_BASE_EXPORT bool QueryRenderSupport(XDisplay* dpy);
  62
  63 // Returns an X11 Cursor, sharable across the process.
  64 // |cursor_shape| is an X font cursor shape, see XCreateFontCursor().
  65 UI_BASE_EXPORT ::Cursor GetXCursor(int cursor_shape);
  66
  67 // Creates a custom X cursor from the image. This takes ownership of image. The
  68 // caller must not free/modify the image. The refcount of the newly created
  69 // cursor is set to 1.
  70 UI_BASE_EXPORT ::Cursor CreateReffedCustomXCursor(XcursorImage* image);
  71
  72 // Increases the refcount of the custom cursor.
  73 UI_BASE_EXPORT void RefCustomXCursor(::Cursor cursor);
  74
  75 // Decreases the refcount of the custom cursor, and destroys it if it reaches 0.
  76 UI_BASE_EXPORT void UnrefCustomXCursor(::Cursor cursor);
  77
  78 // Creates a XcursorImage and copies the SkBitmap |bitmap| on it. |bitmap|
  79 // should be non-null. Caller owns the returned object.
  80 UI_BASE_EXPORT XcursorImage* SkBitmapToXcursorImage(const SkBitmap* bitmap,
  81                                                     const gfx::Point& hotspot);
  82
  83 // Coalesce all pending motion events (touch or mouse) that are at the top of
  84 // the queue, and return the number eliminated, storing the last one in
  85 // |last_event|.
  86 UI_BASE_EXPORT int CoalescePendingMotionEvents(const XEvent* xev,
  87                                                XEvent* last_event);
  88
  89 // Hides the host cursor.
  90 UI_BASE_EXPORT void HideHostCursor();
  91
  92 // Returns an invisible cursor.
  93 UI_BASE_EXPORT ::Cursor CreateInvisibleCursor();
  94
  95 // Sets whether |window| should use the OS window frame.
  96 UI_BASE_EXPORT void SetUseOSWindowFrame(XID window, bool use_os_window_frame);
  97
  98 // These functions do not cache their results --------------------------
  99
 100 // Returns true if the shape extension is supported.
 101 UI_BASE_EXPORT bool IsShapeExtensionAvailable();
 102
 103 // Get the X window id for the default root window
 104 UI_BASE_EXPORT XID GetX11RootWindow();
 105
 106 // Returns the user's current desktop.
 107 UI_BASE_EXPORT bool GetCurrentDesktop(int* desktop);
 108
 109 enum HideTitlebarWhenMaximized {
 110   SHOW_TITLEBAR_WHEN_MAXIMIZED = 0,
 111   HIDE_TITLEBAR_WHEN_MAXIMIZED = 1,
 112 };
 113 // Sets _GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED on |window|.
 114 UI_BASE_EXPORT void SetHideTitlebarWhenMaximizedProperty(
 115     XID window,
 116     HideTitlebarWhenMaximized property);
 117
 118 // Clears all regions of X11's default root window by filling black pixels.
 119 UI_BASE_EXPORT void ClearX11DefaultRootWindow();
 120
 121 // Returns true if |window| is visible.
 122 UI_BASE_EXPORT bool IsWindowVisible(XID window);
 123
 124 // Returns the inner bounds of |window| (excluding the non-client area).
 125 UI_BASE_EXPORT bool GetInnerWindowBounds(XID window, gfx::Rect* rect);
 126
 127 // Returns the non-client area extents of |window|. This is a negative inset; it
 128 // represents the negative size of the window border on all sides.
 129 // InnerWindowBounds.Inset(WindowExtents) = OuterWindowBounds.
 130 // Returns false if the window manager does not provide extents information.
 131 UI_BASE_EXPORT bool GetWindowExtents(XID window, gfx::Insets* extents);
 132
 133 // Returns the outer bounds of |window| (including the non-client area).
 134 UI_BASE_EXPORT bool GetOuterWindowBounds(XID window, gfx::Rect* rect);
 135
 136 // Returns true if |window| contains the point |screen_loc|.
 137 UI_BASE_EXPORT bool WindowContainsPoint(XID window, gfx::Point screen_loc);
 138
 139 // Return true if |window| has any property with |property_name|.
 140 UI_BASE_EXPORT bool PropertyExists(XID window,
 141                                    const std::string& property_name);
 142
 143 // Returns the raw bytes from a property with minimal
 144 // interpretation. |out_data| should be freed by XFree() after use.
 145 UI_BASE_EXPORT bool GetRawBytesOfProperty(
 146     XID window,
 147     XAtom property,
 148     scoped_refptr<base::RefCountedMemory>* out_data,
 149     size_t* out_data_items,
 150     XAtom* out_type);
 151
 152 // Get the value of an int, int array, atom array or string property.  On
 153 // success, true is returned and the value is stored in |value|.
 154 //
 155 // TODO(erg): Once we remove the gtk port and are 100% aura, all of these
 156 // should accept an XAtom instead of a string.
 157 UI_BASE_EXPORT bool GetIntProperty(XID window,
 158                                    const std::string& property_name,
 159                                    int* value);
 160 UI_BASE_EXPORT bool GetXIDProperty(XID window,
 161                                    const std::string& property_name,
 162                                    XID* value);
 163 UI_BASE_EXPORT bool GetIntArrayProperty(XID window,
 164                                         const std::string& property_name,
 165                                         std::vector<int>* value);
 166 UI_BASE_EXPORT bool GetAtomArrayProperty(XID window,
 167                                          const std::string& property_name,
 168                                          std::vector<XAtom>* value);
 169 UI_BASE_EXPORT bool GetStringProperty(XID window,
 170                                       const std::string& property_name,
 171                                       std::string* value);
 172
 173 // These setters all make round trips.
 174 UI_BASE_EXPORT bool SetIntProperty(XID window,
 175                                    const std::string& name,
 176                                    const std::string& type,
 177                                    int value);
 178 UI_BASE_EXPORT bool SetIntArrayProperty(XID window,
 179                                         const std::string& name,
 180                                         const std::string& type,
 181                                         const std::vector<int>& value);
 182 UI_BASE_EXPORT bool SetAtomProperty(XID window,
 183                                     const std::string& name,
 184                                     const std::string& type,
 185                                     XAtom value);
 186 UI_BASE_EXPORT bool SetAtomArrayProperty(XID window,
 187                                          const std::string& name,
 188                                          const std::string& type,
 189                                          const std::vector<XAtom>& value);
 190 UI_BASE_EXPORT bool SetStringProperty(XID window,
 191                                       XAtom property,
 192                                       XAtom type,
 193                                       const std::string& value);
 194
 195 // Gets the X atom for default display corresponding to atom_name.
 196 UI_BASE_EXPORT XAtom GetAtom(const char* atom_name);
 197
 198 // Sets the WM_CLASS attribute for a given X11 window.
 199 UI_BASE_EXPORT void SetWindowClassHint(XDisplay* display,
 200                                        XID window,
 201                                        const std::string& res_name,
 202                                        const std::string& res_class);
 203
 204 // Sets the WM_WINDOW_ROLE attribute for a given X11 window.
 205 UI_BASE_EXPORT void SetWindowRole(XDisplay* display,
 206                                   XID window,
 207                                   const std::string& role);
 208
 209 // Determine whether we should default to native decorations or the custom
 210 // frame based on the currently-running window manager.
 211 UI_BASE_EXPORT bool GetCustomFramePrefDefault();
 212
 213 static const int kAllDesktops = -1;
 214 // Queries the desktop |window| is on, kAllDesktops if sticky. Returns false if
 215 // property not found.
 216 bool GetWindowDesktop(XID window, int* desktop);
 217
 218 // Translates an X11 error code into a printable string.
 219 UI_BASE_EXPORT std::string GetX11ErrorString(XDisplay* display, int err);
 220
 221 // Implementers of this interface receive a notification for every X window of
 222 // the main display.
 223 class EnumerateWindowsDelegate {
 224  public:
 225   // |xid| is the X Window ID of the enumerated window.  Return true to stop
 226   // further iteration.
 227   virtual bool ShouldStopIterating(XID xid) = 0;
 228
 229  protected:
 230   virtual ~EnumerateWindowsDelegate() {}
 231 };
 232
 233 // Enumerates all windows in the current display.  Will recurse into child
 234 // windows up to a depth of |max_depth|.
 235 UI_BASE_EXPORT bool EnumerateAllWindows(EnumerateWindowsDelegate* delegate,
 236                                         int max_depth);
 237
 238 // Enumerates the top-level windows of the current display.
 239 UI_BASE_EXPORT void EnumerateTopLevelWindows(
 240     ui::EnumerateWindowsDelegate* delegate);
 241
 242 // Returns all children windows of a given window in top-to-bottom stacking
 243 // order.
 244 UI_BASE_EXPORT bool GetXWindowStack(XID window, std::vector<XID>* windows);
 245
 246 // Copies |source_bounds| from |drawable| to |canvas| at offset |dest_offset|.
 247 // |source_bounds| is in physical pixels, while |dest_offset| is relative to
 248 // the canvas's scale. Note that this function is slow since it uses
 249 // XGetImage() to copy the data from the X server to this process before
 250 // copying it to |canvas|.
 251 UI_BASE_EXPORT bool CopyAreaToCanvas(XID drawable,
 252                                      gfx::Rect source_bounds,
 253                                      gfx::Point dest_offset,
 254                                      gfx::Canvas* canvas);
 255
 256 enum WindowManagerName {
 257   WM_UNKNOWN,
 258
 259   WM_AWESOME,
 260   WM_BLACKBOX,
 261   WM_COMPIZ,
 262   WM_ENLIGHTENMENT,
 263   WM_FLUXBOX,
 264   WM_I3,
 265   WM_ICE_WM,
 266   WM_ION3,
 267   WM_KWIN,
 268   WM_MATCHBOX,
 269   WM_METACITY,
 270   WM_MUFFIN,
 271   WM_MUTTER,
 272   WM_NOTION,
 273   WM_OPENBOX,
 274   WM_QTILE,
 275   WM_RATPOISON,
 276   WM_STUMPWM,
 277   WM_WMII,
 278   WM_XFWM4,
 279 };
 280 // Attempts to guess the window maager. Returns WM_UNKNOWN if we can't
 281 // determine it for one reason or another.
 282 UI_BASE_EXPORT WindowManagerName GuessWindowManager();
 283
 284 // The same as GuessWindowManager(), but returns the raw string.  If we
 285 // can't determine it, return "Unknown".
 286 UI_BASE_EXPORT std::string GuessWindowManagerName();
 287
 288 // Enable the default X error handlers. These will log the error and abort
 289 // the process if called. Use SetX11ErrorHandlers() from x11_util_internal.h
 290 // to set your own error handlers.
 291 UI_BASE_EXPORT void SetDefaultX11ErrorHandlers();
 292
 293 // Returns true if a given window is in full-screen mode.
 294 UI_BASE_EXPORT bool IsX11WindowFullScreen(XID window);
 295
 296 // Returns true if the window manager supports the given hint.
 297 UI_BASE_EXPORT bool WmSupportsHint(XAtom atom);
 298
 299 // Manages a piece of X11 allocated memory as a RefCountedMemory segment. This
 300 // object takes ownership over the passed in memory and will free it with the
 301 // X11 allocator when done.
 302 class UI_BASE_EXPORT XRefcountedMemory : public base::RefCountedMemory {
 303  public:
 304   XRefcountedMemory(unsigned char* x11_data, size_t length);
 305
 306   // Overridden from RefCountedMemory:
 307   const unsigned char* front() const override;
 308   size_t size() const override;
 309
 310  private:
 311   ~XRefcountedMemory() override;
 312
 313   gfx::XScopedPtr<unsigned char> x11_data_;
 314   size_t length_;
 315
 316   DISALLOW_COPY_AND_ASSIGN(XRefcountedMemory);
 317 };
 318
 319 // Keeps track of an image returned by an X function (e.g. XGetImage) and
 320 // makes sure it's XDestroyImage'd.
 321 class UI_BASE_EXPORT XScopedImage {
 322  public:
 323   explicit XScopedImage(XImage* image) : image_(image) {}
 324   ~XScopedImage();
 325
 326   XImage* get() const { return image_; }
 327
 328   XImage* operator->() const { return image_; }
 329
 330   void reset(XImage* image);
 331
 332  private:
 333   XImage* image_;
 334
 335   DISALLOW_COPY_AND_ASSIGN(XScopedImage);
 336 };
 337
 338 // Keeps track of a cursor returned by an X function and makes sure it's
 339 // XFreeCursor'd.
 340 class UI_BASE_EXPORT XScopedCursor {
 341  public:
 342   // Keeps track of |cursor| created with |display|.
 343   XScopedCursor(::Cursor cursor, XDisplay* display);
 344   ~XScopedCursor();
 345
 346   ::Cursor get() const;
 347   void reset(::Cursor cursor);
 348
 349  private:
 350   ::Cursor cursor_;
 351   XDisplay* display_;
 352
 353   DISALLOW_COPY_AND_ASSIGN(XScopedCursor);
 354 };
 355
 356 namespace test {
 357 // Resets the cache used by GetXCursor(). Only useful for tests that may delete
 358 // the display.
 359 UI_BASE_EXPORT void ResetXCursorCache();
 360
 361 // Returns the cached XcursorImage for |cursor|.
 362 UI_BASE_EXPORT const XcursorImage* GetCachedXcursorImage(::Cursor cursor);
 363
 364 }  // namespace test
 365
 366 }  // namespace ui
 367
 368 #endif  // UI_BASE_X_X11_UTIL_H_