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.
5 #ifndef UI_BASE_X_X11_UTIL_H_
6 #define UI_BASE_X_X11_UTIL_H_
8 // This file declares utility functions for X11 (Linux only).
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.
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/point.h"
24 #include "ui/gfx/x/x11_types.h"
26 typedef unsigned long Atom;
27 typedef unsigned long XSharedMemoryId; // ShmSeg in the X headers.
28 typedef unsigned long Cursor;
29 typedef struct _XcursorImage XcursorImage;
30 typedef union _XEvent XEvent;
32 #if defined(TOOLKIT_GTK)
33 typedef struct _GdkDrawable GdkWindow;
34 typedef struct _GtkWidget GtkWidget;
35 typedef struct _GtkWindow GtkWindow;
47 // These functions use the default display and this /must/ be called from
48 // the UI thread. Thus, they don't support multiple displays.
50 // These functions cache their results ---------------------------------
52 // Check if there's an open connection to an X server.
53 UI_BASE_EXPORT bool XDisplayExists();
55 // Returns true if the system supports XINPUT2.
56 UI_BASE_EXPORT bool IsXInput2Available();
58 // X shared memory comes in three flavors:
61 // 3) SHM pixmaps + putimage.
62 enum SharedMemorySupport {
64 SHARED_MEMORY_PUTIMAGE,
67 // Return the shared memory type of our X connection.
68 UI_BASE_EXPORT SharedMemorySupport QuerySharedMemorySupport(XDisplay* dpy);
70 // Return true iff the display supports Xrender
71 UI_BASE_EXPORT bool QueryRenderSupport(XDisplay* dpy);
73 // Return the default screen number for the display
74 int GetDefaultScreen(XDisplay* display);
76 // Returns an X11 Cursor, sharable across the process.
77 // |cursor_shape| is an X font cursor shape, see XCreateFontCursor().
78 UI_BASE_EXPORT ::Cursor GetXCursor(int cursor_shape);
80 // Resets the cache used by GetXCursor(). Only useful for tests that may delete
82 UI_BASE_EXPORT void ResetXCursorCache();
85 // Creates a custom X cursor from the image. This takes ownership of image. The
86 // caller must not free/modify the image. The refcount of the newly created
87 // cursor is set to 1.
88 UI_BASE_EXPORT ::Cursor CreateReffedCustomXCursor(XcursorImage* image);
90 // Increases the refcount of the custom cursor.
91 UI_BASE_EXPORT void RefCustomXCursor(::Cursor cursor);
93 // Decreases the refcount of the custom cursor, and destroys it if it reaches 0.
94 UI_BASE_EXPORT void UnrefCustomXCursor(::Cursor cursor);
96 // Creates a XcursorImage and copies the SkBitmap |bitmap| on it. |bitmap|
97 // should be non-null. Caller owns the returned object.
98 UI_BASE_EXPORT XcursorImage* SkBitmapToXcursorImage(const SkBitmap* bitmap,
99 const gfx::Point& hotspot);
101 // Coalesce all pending motion events (touch or mouse) that are at the top of
102 // the queue, and return the number eliminated, storing the last one in
104 UI_BASE_EXPORT int CoalescePendingMotionEvents(const XEvent* xev,
108 // Hides the host cursor.
109 UI_BASE_EXPORT void HideHostCursor();
111 // Returns an invisible cursor.
112 UI_BASE_EXPORT ::Cursor CreateInvisibleCursor();
114 // These functions do not cache their results --------------------------
116 // Get the X window id for the default root window
117 UI_BASE_EXPORT XID GetX11RootWindow();
119 // Returns the user's current desktop.
120 bool GetCurrentDesktop(int* desktop);
122 #if defined(TOOLKIT_GTK)
123 // Get the X window id for the given GTK widget.
124 UI_BASE_EXPORT XID GetX11WindowFromGtkWidget(GtkWidget* widget);
125 XID GetX11WindowFromGdkWindow(GdkWindow* window);
127 // Get the GtkWindow* wrapping a given XID, if any.
128 // Returns NULL if there isn't already a GtkWindow* wrapping this XID;
129 // see gdk_window_foreign_new() etc. to wrap arbitrary XIDs.
130 UI_BASE_EXPORT GtkWindow* GetGtkWindowFromX11Window(XID xid);
132 // Get a Visual from the given widget. Since we don't include the Xlib
133 // headers, this is returned as a void*.
134 UI_BASE_EXPORT void* GetVisualFromGtkWidget(GtkWidget* widget);
135 #endif // defined(TOOLKIT_GTK)
137 enum HideTitlebarWhenMaximized {
138 SHOW_TITLEBAR_WHEN_MAXIMIZED = 0,
139 HIDE_TITLEBAR_WHEN_MAXIMIZED = 1,
141 // Sets _GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED on |window|.
142 UI_BASE_EXPORT void SetHideTitlebarWhenMaximizedProperty(
144 HideTitlebarWhenMaximized property);
146 // Clears all regions of X11's default root window by filling black pixels.
147 UI_BASE_EXPORT void ClearX11DefaultRootWindow();
149 // Returns true if |window| is visible.
150 UI_BASE_EXPORT bool IsWindowVisible(XID window);
152 // Returns the bounds of |window|.
153 UI_BASE_EXPORT bool GetWindowRect(XID window, gfx::Rect* rect);
155 // Returns true if |window| contains the point |screen_loc|.
156 UI_BASE_EXPORT bool WindowContainsPoint(XID window, gfx::Point screen_loc);
158 // Return true if |window| has any property with |property_name|.
159 UI_BASE_EXPORT bool PropertyExists(XID window,
160 const std::string& property_name);
162 // Returns the raw bytes from a property with minimal
163 // interpretation. |out_data| should be freed by XFree() after use.
164 UI_BASE_EXPORT bool GetRawBytesOfProperty(
167 scoped_refptr<base::RefCountedMemory>* out_data,
168 size_t* out_data_bytes,
169 size_t* out_data_items,
172 // Get the value of an int, int array, atom array or string property. On
173 // success, true is returned and the value is stored in |value|.
175 // TODO(erg): Once we remove the gtk port and are 100% aura, all of these
176 // should accept an Atom instead of a string.
177 UI_BASE_EXPORT bool GetIntProperty(XID window,
178 const std::string& property_name,
180 UI_BASE_EXPORT bool GetXIDProperty(XID window,
181 const std::string& property_name,
183 UI_BASE_EXPORT bool GetIntArrayProperty(XID window,
184 const std::string& property_name,
185 std::vector<int>* value);
186 UI_BASE_EXPORT bool GetAtomArrayProperty(XID window,
187 const std::string& property_name,
188 std::vector<Atom>* value);
189 UI_BASE_EXPORT bool GetStringProperty(XID window,
190 const std::string& property_name,
193 // These setters all make round trips.
194 UI_BASE_EXPORT bool SetIntProperty(XID window,
195 const std::string& name,
196 const std::string& type,
198 UI_BASE_EXPORT bool SetIntArrayProperty(XID window,
199 const std::string& name,
200 const std::string& type,
201 const std::vector<int>& value);
202 UI_BASE_EXPORT bool SetAtomArrayProperty(XID window,
203 const std::string& name,
204 const std::string& type,
205 const std::vector<Atom>& value);
207 // Gets the X atom for default display corresponding to atom_name.
208 Atom GetAtom(const char* atom_name);
210 // Sets the WM_CLASS attribute for a given X11 window.
211 UI_BASE_EXPORT void SetWindowClassHint(XDisplay* display,
213 const std::string& res_name,
214 const std::string& res_class);
216 // Sets the WM_WINDOW_ROLE attribute for a given X11 window.
217 UI_BASE_EXPORT void SetWindowRole(XDisplay* display,
219 const std::string& role);
221 // Get |window|'s parent window, or None if |window| is the root window.
222 UI_BASE_EXPORT XID GetParentWindow(XID window);
224 // Walk up |window|'s hierarchy until we find a direct child of |root|.
225 XID GetHighestAncestorWindow(XID window, XID root);
227 static const int kAllDesktops = -1;
228 // Queries the desktop |window| is on, kAllDesktops if sticky. Returns false if
229 // property not found.
230 bool GetWindowDesktop(XID window, int* desktop);
232 // Translates an X11 error code into a printable string.
233 UI_BASE_EXPORT std::string GetX11ErrorString(XDisplay* display, int err);
235 // Implementers of this interface receive a notification for every X window of
237 class EnumerateWindowsDelegate {
239 // |xid| is the X Window ID of the enumerated window. Return true to stop
240 // further iteration.
241 virtual bool ShouldStopIterating(XID xid) = 0;
244 virtual ~EnumerateWindowsDelegate() {}
247 // Enumerates all windows in the current display. Will recurse into child
248 // windows up to a depth of |max_depth|.
249 UI_BASE_EXPORT bool EnumerateAllWindows(EnumerateWindowsDelegate* delegate,
252 // Enumerates the top-level windows of the current display.
253 UI_BASE_EXPORT void EnumerateTopLevelWindows(
254 ui::EnumerateWindowsDelegate* delegate);
256 // Returns all children windows of a given window in top-to-bottom stacking
258 UI_BASE_EXPORT bool GetXWindowStack(XID window, std::vector<XID>* windows);
260 // Restack a window in relation to one of its siblings. If |above| is true,
261 // |window| will be stacked directly above |sibling|; otherwise it will stacked
262 // directly below it. Both windows must be immediate children of the same
264 void RestackWindow(XID window, XID sibling, bool above);
266 // Return a handle to a X ShmSeg. |shared_memory_key| is a SysV
267 // IPC key. The shared memory region must contain 32-bit pixels.
268 UI_BASE_EXPORT XSharedMemoryId
269 AttachSharedMemory(XDisplay* display, int shared_memory_support);
270 UI_BASE_EXPORT void DetachSharedMemory(XDisplay* display,
271 XSharedMemoryId shmseg);
273 // Copies |source_bounds| from |drawable| to |canvas| at offset |dest_offset|.
274 // |source_bounds| is in physical pixels, while |dest_offset| is relative to
275 // the canvas's scale. Note that this function is slow since it uses
276 // XGetImage() to copy the data from the X server to this process before
277 // copying it to |canvas|.
278 UI_BASE_EXPORT bool CopyAreaToCanvas(XID drawable,
279 gfx::Rect source_bounds,
280 gfx::Point dest_offset,
281 gfx::Canvas* canvas);
283 // Return a handle to an XRender picture where |pixmap| is a handle to a
284 // pixmap containing Skia ARGB data.
285 UI_BASE_EXPORT XID CreatePictureFromSkiaPixmap(XDisplay* display, XID pixmap);
287 void FreePicture(XDisplay* display, XID picture);
288 void FreePixmap(XDisplay* display, XID pixmap);
290 enum WindowManagerName {
304 // Attempts to guess the window maager. Returns WM_UNKNOWN if we can't
305 // determine it for one reason or another.
306 UI_BASE_EXPORT WindowManagerName GuessWindowManager();
308 // Change desktop for |window| to the desktop of |destination| window.
309 UI_BASE_EXPORT bool ChangeWindowDesktop(XID window, XID destination);
311 // Enable the default X error handlers. These will log the error and abort
312 // the process if called. Use SetX11ErrorHandlers() from x11_util_internal.h
313 // to set your own error handlers.
314 UI_BASE_EXPORT void SetDefaultX11ErrorHandlers();
316 // Return true if a given window is in full-screen mode.
317 UI_BASE_EXPORT bool IsX11WindowFullScreen(XID window);
319 // Returns true if a given size is in list of bogus sizes in mm that X detects
320 // that should be ignored.
321 UI_BASE_EXPORT bool IsXDisplaySizeBlackListed(unsigned long mm_width,
322 unsigned long mm_height);
324 // Manages a piece of X11 allocated memory as a RefCountedMemory segment. This
325 // object takes ownership over the passed in memory and will free it with the
326 // X11 allocator when done.
327 class UI_BASE_EXPORT XRefcountedMemory : public base::RefCountedMemory {
329 XRefcountedMemory(unsigned char* x11_data, size_t length)
330 : x11_data_(length ? x11_data : NULL), length_(length) {}
332 // Overridden from RefCountedMemory:
333 virtual const unsigned char* front() const OVERRIDE;
334 virtual size_t size() const OVERRIDE;
337 virtual ~XRefcountedMemory();
339 unsigned char* x11_data_;
342 DISALLOW_COPY_AND_ASSIGN(XRefcountedMemory);
345 // Keeps track of a string returned by an X function (e.g. XGetAtomName) and
346 // makes sure it's XFree'd.
347 class UI_BASE_EXPORT XScopedString {
349 explicit XScopedString(char* str) : string_(str) {}
352 const char* string() const { return string_; }
357 DISALLOW_COPY_AND_ASSIGN(XScopedString);
360 // Keeps track of an image returned by an X function (e.g. XGetImage) and
361 // makes sure it's XDestroyImage'd.
362 class UI_BASE_EXPORT XScopedImage {
364 explicit XScopedImage(XImage* image) : image_(image) {}
367 XImage* get() const { return image_; }
369 XImage* operator->() const { return image_; }
371 void reset(XImage* image);
376 DISALLOW_COPY_AND_ASSIGN(XScopedImage);
379 // Keeps track of a cursor returned by an X function and makes sure it's
381 class UI_BASE_EXPORT XScopedCursor {
383 // Keeps track of |cursor| created with |display|.
384 XScopedCursor(::Cursor cursor, XDisplay* display);
387 ::Cursor get() const;
388 void reset(::Cursor cursor);
394 DISALLOW_COPY_AND_ASSIGN(XScopedCursor);
399 #endif // UI_BASE_X_X11_UTIL_H_