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 XSharedMemoryId; // ShmSeg in the X headers.
27 typedef unsigned long Cursor;
28 typedef struct _XcursorImage XcursorImage;
29 typedef union _XEvent XEvent;
40 // These functions use the default display and this /must/ be called from
41 // the UI thread. Thus, they don't support multiple displays.
43 // These functions cache their results ---------------------------------
45 // Returns true if the system supports XINPUT2.
46 UI_BASE_EXPORT bool IsXInput2Available();
48 // X shared memory comes in three flavors:
51 // 3) SHM pixmaps + putimage.
52 enum SharedMemorySupport {
54 SHARED_MEMORY_PUTIMAGE,
57 // Return the shared memory type of our X connection.
58 UI_BASE_EXPORT SharedMemorySupport QuerySharedMemorySupport(XDisplay* dpy);
60 // Return true iff the display supports Xrender
61 UI_BASE_EXPORT bool QueryRenderSupport(XDisplay* dpy);
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);
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);
72 // Increases the refcount of the custom cursor.
73 UI_BASE_EXPORT void RefCustomXCursor(::Cursor cursor);
75 // Decreases the refcount of the custom cursor, and destroys it if it reaches 0.
76 UI_BASE_EXPORT void UnrefCustomXCursor(::Cursor cursor);
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);
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
86 UI_BASE_EXPORT int CoalescePendingMotionEvents(const XEvent* xev,
89 // Hides the host cursor.
90 UI_BASE_EXPORT void HideHostCursor();
92 // Returns an invisible cursor.
93 UI_BASE_EXPORT ::Cursor CreateInvisibleCursor();
95 // Sets whether |window| should use the OS window frame.
96 UI_BASE_EXPORT void SetUseOSWindowFrame(XID window, bool use_os_window_frame);
98 // These functions do not cache their results --------------------------
100 // Returns true if the shape extension is supported.
101 UI_BASE_EXPORT bool IsShapeExtensionAvailable();
103 // Get the X window id for the default root window
104 UI_BASE_EXPORT XID GetX11RootWindow();
106 // Returns the user's current desktop.
107 UI_BASE_EXPORT bool GetCurrentDesktop(int* desktop);
109 enum HideTitlebarWhenMaximized {
110 SHOW_TITLEBAR_WHEN_MAXIMIZED = 0,
111 HIDE_TITLEBAR_WHEN_MAXIMIZED = 1,
113 // Sets _GTK_HIDE_TITLEBAR_WHEN_MAXIMIZED on |window|.
114 UI_BASE_EXPORT void SetHideTitlebarWhenMaximizedProperty(
116 HideTitlebarWhenMaximized property);
118 // Clears all regions of X11's default root window by filling black pixels.
119 UI_BASE_EXPORT void ClearX11DefaultRootWindow();
121 // Returns true if |window| is visible.
122 UI_BASE_EXPORT bool IsWindowVisible(XID window);
124 // Returns the bounds of |window|.
125 UI_BASE_EXPORT bool GetWindowRect(XID window, gfx::Rect* rect);
127 // Returns true if |window| contains the point |screen_loc|.
128 UI_BASE_EXPORT bool WindowContainsPoint(XID window, gfx::Point screen_loc);
130 // Return true if |window| has any property with |property_name|.
131 UI_BASE_EXPORT bool PropertyExists(XID window,
132 const std::string& property_name);
134 // Returns the raw bytes from a property with minimal
135 // interpretation. |out_data| should be freed by XFree() after use.
136 UI_BASE_EXPORT bool GetRawBytesOfProperty(
139 scoped_refptr<base::RefCountedMemory>* out_data,
140 size_t* out_data_items,
143 // Get the value of an int, int array, atom array or string property. On
144 // success, true is returned and the value is stored in |value|.
146 // TODO(erg): Once we remove the gtk port and are 100% aura, all of these
147 // should accept an XAtom instead of a string.
148 UI_BASE_EXPORT bool GetIntProperty(XID window,
149 const std::string& property_name,
151 UI_BASE_EXPORT bool GetXIDProperty(XID window,
152 const std::string& property_name,
154 UI_BASE_EXPORT bool GetIntArrayProperty(XID window,
155 const std::string& property_name,
156 std::vector<int>* value);
157 UI_BASE_EXPORT bool GetAtomArrayProperty(XID window,
158 const std::string& property_name,
159 std::vector<XAtom>* value);
160 UI_BASE_EXPORT bool GetStringProperty(XID window,
161 const std::string& property_name,
164 // These setters all make round trips.
165 UI_BASE_EXPORT bool SetIntProperty(XID window,
166 const std::string& name,
167 const std::string& type,
169 UI_BASE_EXPORT bool SetIntArrayProperty(XID window,
170 const std::string& name,
171 const std::string& type,
172 const std::vector<int>& value);
173 UI_BASE_EXPORT bool SetAtomProperty(XID window,
174 const std::string& name,
175 const std::string& type,
177 UI_BASE_EXPORT bool SetAtomArrayProperty(XID window,
178 const std::string& name,
179 const std::string& type,
180 const std::vector<XAtom>& value);
181 UI_BASE_EXPORT bool SetStringProperty(XID window,
184 const std::string& value);
186 // Gets the X atom for default display corresponding to atom_name.
187 UI_BASE_EXPORT XAtom GetAtom(const char* atom_name);
189 // Sets the WM_CLASS attribute for a given X11 window.
190 UI_BASE_EXPORT void SetWindowClassHint(XDisplay* display,
192 const std::string& res_name,
193 const std::string& res_class);
195 // Sets the WM_WINDOW_ROLE attribute for a given X11 window.
196 UI_BASE_EXPORT void SetWindowRole(XDisplay* display,
198 const std::string& role);
200 // Determine whether we should default to native decorations or the custom
201 // frame based on the currently-running window manager.
202 UI_BASE_EXPORT bool GetCustomFramePrefDefault();
204 static const int kAllDesktops = -1;
205 // Queries the desktop |window| is on, kAllDesktops if sticky. Returns false if
206 // property not found.
207 bool GetWindowDesktop(XID window, int* desktop);
209 // Translates an X11 error code into a printable string.
210 UI_BASE_EXPORT std::string GetX11ErrorString(XDisplay* display, int err);
212 // Implementers of this interface receive a notification for every X window of
214 class EnumerateWindowsDelegate {
216 // |xid| is the X Window ID of the enumerated window. Return true to stop
217 // further iteration.
218 virtual bool ShouldStopIterating(XID xid) = 0;
221 virtual ~EnumerateWindowsDelegate() {}
224 // Enumerates all windows in the current display. Will recurse into child
225 // windows up to a depth of |max_depth|.
226 UI_BASE_EXPORT bool EnumerateAllWindows(EnumerateWindowsDelegate* delegate,
229 // Enumerates the top-level windows of the current display.
230 UI_BASE_EXPORT void EnumerateTopLevelWindows(
231 ui::EnumerateWindowsDelegate* delegate);
233 // Returns all children windows of a given window in top-to-bottom stacking
235 UI_BASE_EXPORT bool GetXWindowStack(XID window, std::vector<XID>* windows);
237 // Copies |source_bounds| from |drawable| to |canvas| at offset |dest_offset|.
238 // |source_bounds| is in physical pixels, while |dest_offset| is relative to
239 // the canvas's scale. Note that this function is slow since it uses
240 // XGetImage() to copy the data from the X server to this process before
241 // copying it to |canvas|.
242 UI_BASE_EXPORT bool CopyAreaToCanvas(XID drawable,
243 gfx::Rect source_bounds,
244 gfx::Point dest_offset,
245 gfx::Canvas* canvas);
247 enum WindowManagerName {
269 // Attempts to guess the window maager. Returns WM_UNKNOWN if we can't
270 // determine it for one reason or another.
271 UI_BASE_EXPORT WindowManagerName GuessWindowManager();
273 // The same as GuessWindowManager(), but returns the raw string. If we
274 // can't determine it, return "Unknown".
275 UI_BASE_EXPORT std::string GuessWindowManagerName();
277 // Enable the default X error handlers. These will log the error and abort
278 // the process if called. Use SetX11ErrorHandlers() from x11_util_internal.h
279 // to set your own error handlers.
280 UI_BASE_EXPORT void SetDefaultX11ErrorHandlers();
282 // Returns true if a given window is in full-screen mode.
283 UI_BASE_EXPORT bool IsX11WindowFullScreen(XID window);
285 // Returns true if the window manager supports the given hint.
286 UI_BASE_EXPORT bool WmSupportsHint(XAtom atom);
288 // Manages a piece of X11 allocated memory as a RefCountedMemory segment. This
289 // object takes ownership over the passed in memory and will free it with the
290 // X11 allocator when done.
291 class UI_BASE_EXPORT XRefcountedMemory : public base::RefCountedMemory {
293 XRefcountedMemory(unsigned char* x11_data, size_t length)
294 : x11_data_(length ? x11_data : NULL), length_(length) {}
296 // Overridden from RefCountedMemory:
297 virtual const unsigned char* front() const OVERRIDE;
298 virtual size_t size() const OVERRIDE;
301 virtual ~XRefcountedMemory();
303 unsigned char* x11_data_;
306 DISALLOW_COPY_AND_ASSIGN(XRefcountedMemory);
309 // Keeps track of a string returned by an X function (e.g. XGetAtomName) and
310 // makes sure it's XFree'd.
311 class UI_BASE_EXPORT XScopedString {
313 explicit XScopedString(char* str) : string_(str) {}
316 const char* string() const { return string_; }
321 DISALLOW_COPY_AND_ASSIGN(XScopedString);
324 // Keeps track of an image returned by an X function (e.g. XGetImage) and
325 // makes sure it's XDestroyImage'd.
326 class UI_BASE_EXPORT XScopedImage {
328 explicit XScopedImage(XImage* image) : image_(image) {}
331 XImage* get() const { return image_; }
333 XImage* operator->() const { return image_; }
335 void reset(XImage* image);
340 DISALLOW_COPY_AND_ASSIGN(XScopedImage);
343 // Keeps track of a cursor returned by an X function and makes sure it's
345 class UI_BASE_EXPORT XScopedCursor {
347 // Keeps track of |cursor| created with |display|.
348 XScopedCursor(::Cursor cursor, XDisplay* display);
351 ::Cursor get() const;
352 void reset(::Cursor cursor);
358 DISALLOW_COPY_AND_ASSIGN(XScopedCursor);
362 // Resets the cache used by GetXCursor(). Only useful for tests that may delete
364 UI_BASE_EXPORT void ResetXCursorCache();
366 // Returns the cached XcursorImage for |cursor|.
367 UI_BASE_EXPORT const XcursorImage* GetCachedXcursorImage(::Cursor cursor);
373 #endif // UI_BASE_X_X11_UTIL_H_