1 /*
2 * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <linux/fb.h>
29 #include <fcntl.h>
30 #ifndef __USE_GNU // required for dladdr() & Dl_info
31 #define __USE_GNU
32 #endif
33 #include <dlfcn.h>
34 #include <sys/ioctl.h>
35
36 #include <string.h>
37 #include <strings.h>
38
39 #include <assert.h>
40
41 #include <gdk/gdk.h>
42 #include <gdk/gdkx.h>
43
44 #include "glass_wrapper.h"
45
46 static GdkAtom (*_gdk_atom_intern) (const gchar * atom_name,
47 gboolean only_if_exists);
48 static GdkAtom (*_gdk_atom_intern_static_string) (const gchar * atom_name);
49 static gchar *(*_gdk_atom_name) (GdkAtom atom);
50 static cairo_t *(*_gdk_cairo_create) (GdkDrawable * drawable);
51 static GdkColormap *(*_gdk_colormap_new) (GdkVisual * visual,
52 gboolean allocate);
53 static GdkCursor *(*_gdk_cursor_new) (GdkCursorType cursor_type);
54 static GdkCursor *(*_gdk_cursor_new_from_name) (GdkDisplay * display,
55 const gchar * name);
56 static GdkCursor *(*_gdk_cursor_new_from_pixbuf) (GdkDisplay * display,
57 GdkPixbuf * pixbuf,
58 gint x, gint y);
59 static GdkDisplay *(*_gdk_display_get_default) (void);
60 static guint (*_gdk_display_get_default_cursor_size) (GdkDisplay * display);
61 static void (*_gdk_display_get_pointer) (GdkDisplay * display,
62 GdkScreen ** screen,
63 gint * x,
64 gint * y, GdkModifierType * mask);
65 static GdkWindow *(*_gdk_display_get_window_at_pointer) (GdkDisplay * display,
66 gint * win_x,
67 gint * win_y);
68 static gboolean (*_gdk_display_pointer_is_grabbed) (GdkDisplay * display);
69 static gboolean (*_gdk_display_supports_composite) (GdkDisplay * display);
70 static void (*_gdk_drag_abort) (GdkDragContext * context, guint32 time_);
71 static gboolean (*_gdk_drag_motion) (GdkDragContext * context,
72 GdkWindow * dest_window,
73 GdkDragProtocol protocol,
74 gint x_root,
75 gint y_root,
76 GdkDragAction suggested_action,
77 GdkDragAction possible_actions,
78 guint32 time_);
79 static void (*_gdk_drag_drop) (GdkDragContext * context, guint32 time_);
80 static GdkDragContext *(*_gdk_drag_begin) (GdkWindow * window,
81 GList * targets);
82 static GdkDragAction (*_gdk_drag_context_get_actions) (GdkDragContext *
83 context);
84 static GdkDragAction (*_gdk_drag_context_get_selected_action) (GdkDragContext
85 * context);
86 static GdkDragAction (*_gdk_drag_context_get_suggested_action) (GdkDragContext
87 * context);
88 static GList *(*_gdk_drag_context_list_targets) (GdkDragContext * context);
89 static void (*_gdk_drag_find_window_for_screen) (GdkDragContext * context,
90 GdkWindow * drag_window,
91 GdkScreen * screen,
92 gint x_root,
93 gint y_root,
94 GdkWindow ** dest_window,
95 GdkDragProtocol * protocol);
96 static GdkAtom (*_gdk_drag_get_selection) (GdkDragContext * context);
97 static GdkWindow *(*_gdk_drag_context_get_dest_window) (GdkDragContext *
98 context);
99 static void (*_gdk_drag_status) (GdkDragContext * context,
100 GdkDragAction action, guint32 time_);
101 static void (*_gdk_drop_reply) (GdkDragContext * context, gboolean ok,
102 guint32 time_);
103 static void (*_gdk_drop_finish) (GdkDragContext * context, gboolean success,
104 guint32 time_);
105 static GdkScreen *(*_gdk_window_get_screen) (GdkWindow * window);
106 static GdkDisplay *(*_gdk_window_get_display) (GdkWindow * window);
107 static int (*_gdk_window_get_width) (GdkWindow * window);
108 static int (*_gdk_window_get_height) (GdkWindow * window);
109 static void (*_gdk_error_trap_push) (void);
110 static void (*_gdk_event_request_motions) (const GdkEventMotion * event);
111 static void (*_gdk_event_handler_set) (GdkEventFunc func,
112 gpointer data, GDestroyNotify notify);
113 static GdkWindow *(*_gdk_get_default_root_window) (void);
114 static GdkKeymap *(*_gdk_keymap_get_default) (void);
115 static gboolean (*_gdk_keymap_get_entries_for_keyval) (GdkKeymap * keymap,
116 guint keyval,
117 GdkKeymapKey ** keys,
118 gint * n_keys);
119 static guint (*_gdk_keymap_lookup_key) (GdkKeymap * keymap,
120 const GdkKeymapKey * key);
121 static gboolean (*_gdk_keymap_translate_keyboard_state) (GdkKeymap * keymap,
122 guint
123 hardware_keycode,
124 GdkModifierType
125 state, gint group,
126 guint * keyval,
127 gint *
128 effective_group,
129 gint * level,
130 GdkModifierType *
131 consumed_modifiers);
132 static guint32 (*_gdk_keyval_to_unicode) (guint keyval) G_GNUC_CONST;
133 static GdkPixbuf *(*_gdk_pixbuf_get_from_drawable) (GdkPixbuf * dest,
134 GdkDrawable * src,
135 GdkColormap * cmap,
136 int src_x,
137 int src_y,
138 int dest_x,
139 int dest_y,
140 int width, int height);
141 static void (*_gdk_pixbuf_render_pixmap_and_mask) (GdkPixbuf * pixbuf,
142 GdkPixmap ** pixmap_return,
143 GdkBitmap ** mask_return,
144 int alpha_threshold);
145 static void (*_gdk_pixbuf_render_pixmap_and_mask_for_colormap) (GdkPixbuf *
146 pixbuf,
147 GdkColormap *
148 colormap,
149 GdkPixmap **
150 pixmap_return,
151 GdkBitmap **
152 mask_return,
153 int
154 alpha_threshold);
155 static GdkGrabStatus (*_gdk_pointer_grab) (GdkWindow * window,
156 gboolean owner_events,
157 GdkEventMask event_mask,
158 GdkWindow * confine_to,
159 GdkCursor * cursor, guint32 time_);
160 static void (*_gdk_pointer_ungrab) (guint32 time_);
161 static void (*_gdk_property_change) (GdkWindow * window,
162 GdkAtom property,
163 GdkAtom type,
164 gint format,
165 GdkPropMode mode,
166 const guchar * data, gint nelements);
167 static gboolean (*_gdk_property_get) (GdkWindow * window,
168 GdkAtom property,
169 GdkAtom type,
170 gulong offset,
171 gulong length,
172 gint pdelete,
173 GdkAtom * actual_property_type,
174 gint * actual_format,
175 gint * actual_length, guchar ** data);
176 static gboolean (*_gdk_rectangle_intersect) (const GdkRectangle * src1,
177 const GdkRectangle * src2,
178 GdkRectangle * dest);
179 static void (*_gdk_region_destroy) (GdkRegion * region);
180 static GdkRegion *(*_gdk_region_new) (void);
181 static GdkScreen *(*_gdk_screen_get_default) (void);
182 static gint (*_gdk_screen_get_height) (GdkScreen * screen);
183 static gint (*_gdk_screen_get_monitor_at_point) (GdkScreen * screen,
184 gint x, gint y);
185 static void (*_gdk_screen_get_monitor_geometry) (GdkScreen * screen,
186 gint monitor_num,
187 GdkRectangle * dest);
188 static gint (*_gdk_screen_get_n_monitors) (GdkScreen * screen);
189 static gint (*_gdk_screen_get_monitor_width_mm) (GdkScreen *screen,
190 gint monitor_num);
191 static gint (*_gdk_screen_get_monitor_height_mm) (GdkScreen *screen,
192 gint monitor_num);
193 static gint (*_gdk_screen_get_width_mm) (GdkScreen *screen);
194 static gint (*_gdk_screen_get_height_mm) (GdkScreen *screen);
195 static gdouble (*_gdk_screen_get_resolution) (GdkScreen * screen);
196 static GdkColormap *(*_gdk_screen_get_rgba_colormap) (GdkScreen * screen);
197 static GdkColormap *(*_gdk_screen_get_rgb_colormap) (GdkScreen * screen);
198 static GdkWindow *(*_gdk_screen_get_root_window) (GdkScreen * screen);
199 static GdkVisual *(*_gdk_screen_get_system_visual) (GdkScreen * screen);
200 static gint (*_gdk_screen_get_width) (GdkScreen * screen);
201 static gboolean (*_gdk_screen_is_composited) (GdkScreen * screen);
202 static void (*_gdk_selection_convert) (GdkWindow * requestor,
203 GdkAtom selection,
204 GdkAtom target, guint32 time_);
205 static gboolean (*_gdk_selection_owner_set) (GdkWindow * owner,
206 GdkAtom selection,
207 guint32 time_,
208 gboolean send_event);
209 static gint (*_gdk_selection_property_get) (GdkWindow * requestor,
210 guchar ** data,
211 GdkAtom * prop_type,
212 gint * prop_format);
213 static void (*_gdk_selection_send_notify) (GdkNativeWindow requestor,
214 GdkAtom selection,
215 GdkAtom target,
216 GdkAtom property, guint32 time_);
217 static guint (*_gdk_unicode_to_keyval) (guint32 wc) G_GNUC_CONST;
218 static guint (*_gdk_threads_add_idle_full) (gint priority,
219 GSourceFunc function,
220 gpointer data,
221 GDestroyNotify notify);
222 static guint (*_gdk_threads_add_idle) (GSourceFunc function, gpointer data);
223 static guint (*_gdk_threads_add_timeout_full) (gint priority,
224 guint interval,
225 GSourceFunc function,
226 gpointer data,
227 GDestroyNotify notify);
228 static void (*_gdk_threads_enter) (void);
229 static void (*_gdk_threads_init) (void);
230 static void (*_gdk_threads_leave) (void);
231 static void (*_gdk_window_destroy) (GdkWindow * window);
232 static GdkCursor *(*_gdk_window_get_cursor) (GdkWindow * window);
233 static GdkEventMask (*_gdk_window_get_events) (GdkWindow * window);
234 static void (*_gdk_window_get_geometry) (GdkWindow * window,
235 gint * x,
236 gint * y,
237 gint * width,
238 gint * height, gint * depth);
239 static gint (*_gdk_window_get_origin) (GdkWindow * window,
240 gint * x, gint * y);
241 static void (*_gdk_window_input_shape_combine_mask) (GdkWindow * window,
242 GdkBitmap * mask,
243 gint x, gint y);
244 static void (*_gdk_window_shape_combine_region) (GdkWindow *window,
245 const cairo_region_t *shape_region,
246 gint offset_x,
247 gint offset_y);
248 static void (*_gdk_window_input_shape_combine_region) (GdkWindow * window,
249 const cairo_region_t * shape_region,
250 gint offset_x,
251 gint offset_y);
252 static gboolean (*_gdk_window_is_destroyed) (GdkWindow * window);
253 static void (*_gdk_window_move) (GdkWindow * window, gint x, gint y);
254 static GdkWindow *(*_gdk_window_new) (GdkWindow * parent,
255 GdkWindowAttr * attributes,
256 gint attributes_mask);
257 static void (*_gdk_window_register_dnd) (GdkWindow * window);
258 static void (*_gdk_window_resize) (GdkWindow * window,
259 gint width, gint height);
260 static void (*_gdk_window_restack) (GdkWindow * window,
261 GdkWindow * sibling, gboolean above);
262 static void (*_gdk_window_set_cursor) (GdkWindow * window,
263 GdkCursor * cursor);
264 static void (*_gdk_window_set_events) (GdkWindow * window,
265 GdkEventMask event_mask);
266 static void (*_gdk_window_set_functions) (GdkWindow * window,
267 GdkWMFunction functions);
268 static void (*_gdk_window_show) (GdkWindow * window);
269 static Display *(*_gdk_x11_display_get_xdisplay) (GdkDisplay * display);
270 static XID (*_gdk_x11_drawable_get_xid) (GdkDrawable * drawable);
271 static gint (*_gdk_x11_get_default_screen) (void);
272 static Display *(*_gdk_x11_get_default_xdisplay) (void);
273 static guint32 (*_gdk_x11_get_server_time) (GdkWindow * window);
274 static GdkVisual *(*_gdk_x11_screen_lookup_visual) (GdkScreen * screen,
275 VisualID xvisualid);
276 static GdkWindow *(*_gdk_x11_window_foreign_new_for_display) (GdkDisplay *
277 display,
278 Window window);
279 static GdkWindow *(*_gdk_x11_window_lookup_for_display) (GdkDisplay * display,
280 Window window);
281 static gint (*_gdk_visual_get_depth) (GdkVisual * visual);
282
283 static GType (*_gdk_window_object_get_type) (void);
284
285 //----------- GTK 3.0 ------------------------------------------------------
286
287 typedef struct _GdkDeviceManager GdkDeviceManager;
288 struct _GdkRGBA
289 {
290 gdouble red;
291 gdouble green;
292 gdouble blue;
293 gdouble alpha;
294 };
295 typedef struct _GdkRGBA GdkRGBA;
296
297 typedef enum {
298 GDK_DEVICE_TYPE_MASTER,
299 GDK_DEVICE_TYPE_SLAVE,
300 GDK_DEVICE_TYPE_FLOATING
301 } GdkDeviceType;
302
303 typedef enum
304 {
305 GDK_OWNERSHIP_NONE,
306 GDK_OWNERSHIP_WINDOW,
307 GDK_OWNERSHIP_APPLICATION
308 } GdkGrabOwnership;
309
310
311 static GdkVisual * (*_gdk_window_get_visual) (GdkWindow *window);
312 static GdkScreen *(*_gdk_visual_get_screen) (GdkVisual *visual);
313 static GList * (*_gdk_device_manager_list_devices) (GdkDeviceManager *device_manager,
314 GdkDeviceType type);
315 static GdkDeviceManager * (*_gdk_display_get_device_manager) (GdkDisplay *display);
316 static GdkVisual * (*_gdk_screen_get_rgba_visual) (GdkScreen *screen);
317 static GdkInputSource (*_gdk_device_get_source) (GdkDevice *device);
318 static GdkGrabStatus (*_gdk_device_grab) (GdkDevice *device,
319 GdkWindow *window,
320 GdkGrabOwnership grab_ownership,
321 gboolean owner_events,
322 GdkEventMask event_mask,
323 GdkCursor *cursor,
324 guint32 time_);
325 static void (*_gdk_device_ungrab) (GdkDevice *device, guint32 time_);
326 static GdkDevice * (*_gdk_device_manager_get_client_pointer) (GdkDeviceManager *device_manager);
327 static void (*_gdk_device_get_position) (GdkDevice *device,
328 GdkScreen **screen,
329 gint *x,
330 gint *y);
331 static gboolean (*_gdk_display_device_is_grabbed) (GdkDisplay *display,
332 GdkDevice *device);
333 static GdkWindow * (*_gdk_device_get_window_at_position) (GdkDevice *device,
334 gint *win_x,
335 gint *win_y);
336 static void (*_gdk_window_set_background) (GdkWindow *window,
337 const GdkColor *color);
338 static void (*_gdk_window_set_background_rgba) (GdkWindow *window,
339 const GdkRGBA *rgba);
340 static Window (*_gdk_x11_window_get_xid) (GdkWindow *window);
341
342 static GdkPixbuf *(*_gdk_pixbuf_get_from_window) (GdkWindow *window,
343 gint src_x,
344 gint src_y,
345 gint width,
346 gint height);
347
348 static GType (*_gdk_window_get_type) (void);
349
350 static cairo_region_t * (*_gdk_cairo_region_create_from_surface) (cairo_surface_t *surface);
351
352 /***** Utilities ***********************************************************/
353
354
355 #define PRELOAD_SYMBOL_GDK(x) \
356 _##x = dlsym(libgdk, #x); \
357 if (_##x == NULL) { \
358 symbol_load_errors++; \
359 fprintf(stderr,"failed loading %s\n", #x); \
360 }
361
362 int wrapper_load_symbols_gdk (int version, void * libgdk)
363 {
364 int symbol_load_errors = 0;
365
366 PRELOAD_SYMBOL_GDK (gdk_atom_intern);
367 PRELOAD_SYMBOL_GDK (gdk_atom_intern_static_string);
368 PRELOAD_SYMBOL_GDK (gdk_atom_name);
369 PRELOAD_SYMBOL_GDK (gdk_cairo_create);
370 PRELOAD_SYMBOL_GDK (gdk_cursor_new);
371 PRELOAD_SYMBOL_GDK (gdk_cursor_new_from_name);
372 PRELOAD_SYMBOL_GDK (gdk_cursor_new_from_pixbuf);
373 PRELOAD_SYMBOL_GDK (gdk_display_get_default);
374 PRELOAD_SYMBOL_GDK (gdk_display_get_default_cursor_size);
375 PRELOAD_SYMBOL_GDK (gdk_display_get_pointer);
376 PRELOAD_SYMBOL_GDK (gdk_display_get_window_at_pointer);
377 PRELOAD_SYMBOL_GDK (gdk_display_pointer_is_grabbed);
378 PRELOAD_SYMBOL_GDK (gdk_display_supports_composite);
379 PRELOAD_SYMBOL_GDK (gdk_drag_abort);
380 PRELOAD_SYMBOL_GDK (gdk_drag_motion);
381 PRELOAD_SYMBOL_GDK (gdk_drag_drop);
382 PRELOAD_SYMBOL_GDK (gdk_drag_begin);
383 PRELOAD_SYMBOL_GDK (gdk_drag_context_get_actions);
384 PRELOAD_SYMBOL_GDK (gdk_drag_context_get_selected_action);
385 PRELOAD_SYMBOL_GDK (gdk_drag_context_get_suggested_action);
386 PRELOAD_SYMBOL_GDK (gdk_drag_context_list_targets);
387 PRELOAD_SYMBOL_GDK (gdk_drag_find_window_for_screen);
388 PRELOAD_SYMBOL_GDK (gdk_drag_get_selection);
389 PRELOAD_SYMBOL_GDK (gdk_drag_context_get_dest_window);
390 PRELOAD_SYMBOL_GDK (gdk_drag_status);
391 PRELOAD_SYMBOL_GDK (gdk_drop_reply);
392 PRELOAD_SYMBOL_GDK (gdk_drop_finish);
393 PRELOAD_SYMBOL_GDK (gdk_error_trap_push);
394 PRELOAD_SYMBOL_GDK (gdk_event_request_motions);
395 PRELOAD_SYMBOL_GDK (gdk_event_handler_set);
396 PRELOAD_SYMBOL_GDK (gdk_get_default_root_window);
397 PRELOAD_SYMBOL_GDK (gdk_keymap_get_default);
398 PRELOAD_SYMBOL_GDK (gdk_keymap_get_entries_for_keyval);
399 PRELOAD_SYMBOL_GDK (gdk_keymap_lookup_key);
400 PRELOAD_SYMBOL_GDK (gdk_keymap_translate_keyboard_state);
401 PRELOAD_SYMBOL_GDK (gdk_keyval_to_unicode);
402 PRELOAD_SYMBOL_GDK (gdk_pointer_grab);
403 PRELOAD_SYMBOL_GDK (gdk_pointer_ungrab);
404 PRELOAD_SYMBOL_GDK (gdk_property_change);
405 PRELOAD_SYMBOL_GDK (gdk_property_get);
406 PRELOAD_SYMBOL_GDK (gdk_rectangle_intersect);
407 PRELOAD_SYMBOL_GDK (gdk_screen_get_default);
408 PRELOAD_SYMBOL_GDK (gdk_screen_get_height);
409 PRELOAD_SYMBOL_GDK (gdk_screen_get_monitor_at_point);
410 PRELOAD_SYMBOL_GDK (gdk_screen_get_monitor_geometry);
411 PRELOAD_SYMBOL_GDK (gdk_screen_get_n_monitors);
412 PRELOAD_SYMBOL_GDK (gdk_screen_get_monitor_width_mm);
413 PRELOAD_SYMBOL_GDK (gdk_screen_get_monitor_height_mm);
414 PRELOAD_SYMBOL_GDK (gdk_screen_get_width_mm);
415 PRELOAD_SYMBOL_GDK (gdk_screen_get_height_mm);
416 PRELOAD_SYMBOL_GDK (gdk_screen_get_resolution);
417 PRELOAD_SYMBOL_GDK (gdk_screen_get_root_window);
418 PRELOAD_SYMBOL_GDK (gdk_screen_get_system_visual);
419 PRELOAD_SYMBOL_GDK (gdk_screen_get_width);
420 PRELOAD_SYMBOL_GDK (gdk_screen_is_composited);
421 PRELOAD_SYMBOL_GDK (gdk_selection_convert);
422 PRELOAD_SYMBOL_GDK (gdk_selection_owner_set);
423 PRELOAD_SYMBOL_GDK (gdk_selection_property_get);
424 PRELOAD_SYMBOL_GDK (gdk_selection_send_notify);
425 PRELOAD_SYMBOL_GDK (gdk_unicode_to_keyval);
426 PRELOAD_SYMBOL_GDK (gdk_threads_add_idle_full);
427 PRELOAD_SYMBOL_GDK (gdk_threads_add_idle);
428 PRELOAD_SYMBOL_GDK (gdk_threads_add_timeout_full);
429 PRELOAD_SYMBOL_GDK (gdk_threads_enter);
430 PRELOAD_SYMBOL_GDK (gdk_threads_init);
431 PRELOAD_SYMBOL_GDK (gdk_threads_leave);
432 PRELOAD_SYMBOL_GDK (gdk_window_destroy);
433 PRELOAD_SYMBOL_GDK (gdk_window_get_cursor);
434 PRELOAD_SYMBOL_GDK (gdk_window_get_events);
435 PRELOAD_SYMBOL_GDK (gdk_window_get_geometry);
436 PRELOAD_SYMBOL_GDK (gdk_window_get_origin);
437 PRELOAD_SYMBOL_GDK (gdk_window_is_destroyed);
438 PRELOAD_SYMBOL_GDK (gdk_window_move);
439 PRELOAD_SYMBOL_GDK (gdk_window_new);
440 PRELOAD_SYMBOL_GDK (gdk_window_register_dnd);
441 PRELOAD_SYMBOL_GDK (gdk_window_resize);
442 PRELOAD_SYMBOL_GDK (gdk_window_restack);
443 PRELOAD_SYMBOL_GDK (gdk_window_set_cursor);
444 PRELOAD_SYMBOL_GDK (gdk_window_set_events);
445 PRELOAD_SYMBOL_GDK (gdk_window_set_functions);
446 PRELOAD_SYMBOL_GDK (gdk_window_show);
447 PRELOAD_SYMBOL_GDK (gdk_x11_display_get_xdisplay);
448 PRELOAD_SYMBOL_GDK (gdk_x11_get_default_screen);
449 PRELOAD_SYMBOL_GDK (gdk_x11_get_default_xdisplay);
450 PRELOAD_SYMBOL_GDK (gdk_x11_get_server_time);
451 PRELOAD_SYMBOL_GDK (gdk_x11_screen_lookup_visual);
452 PRELOAD_SYMBOL_GDK (gdk_x11_window_foreign_new_for_display);
453 PRELOAD_SYMBOL_GDK (gdk_x11_window_lookup_for_display);
454 PRELOAD_SYMBOL_GDK (gdk_window_get_display);
455 PRELOAD_SYMBOL_GDK (gdk_window_get_height);
456 PRELOAD_SYMBOL_GDK (gdk_window_get_width);
457 PRELOAD_SYMBOL_GDK (gdk_window_get_screen);
458 PRELOAD_SYMBOL_GDK (gdk_visual_get_screen); // 2.2
459
460 if (version == 2) {
461 PRELOAD_SYMBOL_GDK (gdk_colormap_new);
462 PRELOAD_SYMBOL_GDK (gdk_pixbuf_get_from_drawable);
463 PRELOAD_SYMBOL_GDK (gdk_pixbuf_render_pixmap_and_mask);
464 PRELOAD_SYMBOL_GDK (gdk_pixbuf_render_pixmap_and_mask_for_colormap);
465 PRELOAD_SYMBOL_GDK (gdk_region_destroy);
466 PRELOAD_SYMBOL_GDK (gdk_region_new);
467 PRELOAD_SYMBOL_GDK (gdk_screen_get_rgba_colormap);
468 PRELOAD_SYMBOL_GDK (gdk_screen_get_rgb_colormap);
469 PRELOAD_SYMBOL_GDK (gdk_window_input_shape_combine_mask);
470 PRELOAD_SYMBOL_GDK (gdk_x11_drawable_get_xid);
471 PRELOAD_SYMBOL_GDK (gdk_window_object_get_type);
472 PRELOAD_SYMBOL_GDK (gdk_visual_get_depth);
473 }
474
475 if (version == 3) {
476 // gtk version 3 unique symbols
477 PRELOAD_SYMBOL_GDK (gdk_window_get_visual); // both
478 PRELOAD_SYMBOL_GDK (gdk_device_manager_list_devices); //both
479 PRELOAD_SYMBOL_GDK (gdk_display_get_device_manager);
480 PRELOAD_SYMBOL_GDK (gdk_screen_get_rgba_visual);
481 PRELOAD_SYMBOL_GDK (gdk_device_get_source); // both
482 PRELOAD_SYMBOL_GDK (gdk_device_grab);
483 PRELOAD_SYMBOL_GDK (gdk_device_ungrab);
484 PRELOAD_SYMBOL_GDK (gdk_device_manager_get_client_pointer)
485 PRELOAD_SYMBOL_GDK (gdk_device_get_position)
486 PRELOAD_SYMBOL_GDK (gdk_display_device_is_grabbed)
487 PRELOAD_SYMBOL_GDK (gdk_device_get_window_at_position)
488 PRELOAD_SYMBOL_GDK (gdk_window_set_background_rgba)
489 PRELOAD_SYMBOL_GDK (gdk_x11_window_get_xid);
490 PRELOAD_SYMBOL_GDK (gdk_pixbuf_get_from_window);
491 PRELOAD_SYMBOL_GDK (gdk_window_get_type);
492 PRELOAD_SYMBOL_GDK (gdk_cairo_region_create_from_surface);
493 PRELOAD_SYMBOL_GDK (gdk_window_shape_combine_region);
494 PRELOAD_SYMBOL_GDK (gdk_window_input_shape_combine_region);
495 }
496
497 if (symbol_load_errors && wrapper_debug) {
498 fprintf (stderr, "failed to load %d gdk symbols", symbol_load_errors);
499 }
500
501 return symbol_load_errors;
502
503 }
504
505 #define CHECK_LOAD_SYMBOL_GDK(x) \
506 { \
507 if (!_##x) { \
508 if (wrapper_debug) fprintf(stderr,"missing %s\n", #x); \
509 assert(_##x); \
510 } else { \
511 if (wrapper_debug) { \
512 fprintf(stderr,"using %s\n", #x); \
513 fflush(stderr); \
514 } \
515 } \
516 }
517
518
519 GdkAtom gdk_atom_intern (const gchar * atom_name, gboolean only_if_exists)
520 {
521 CHECK_LOAD_SYMBOL_GDK (gdk_atom_intern);
522 return (*_gdk_atom_intern) (atom_name, only_if_exists);
523 }
524
525 GdkAtom gdk_atom_intern_static_string (const gchar * atom_name)
526 {
527 CHECK_LOAD_SYMBOL_GDK (gdk_atom_intern_static_string);
528 return (*_gdk_atom_intern_static_string) (atom_name);
529 }
530
531 gchar *gdk_atom_name (GdkAtom atom)
532 {
533 CHECK_LOAD_SYMBOL_GDK (gdk_atom_name);
534 return (*_gdk_atom_name) (atom);
535 }
536
537 cairo_t *gdk_cairo_create (GdkDrawable * drawable)
538 {
539 CHECK_LOAD_SYMBOL_GDK (gdk_cairo_create);
540 return (*_gdk_cairo_create) (drawable);
541 }
542
543 GdkColormap *gdk_colormap_new (GdkVisual * visual, gboolean allocate)
544 {
545 CHECK_LOAD_SYMBOL_GDK (gdk_colormap_new);
546 return (*_gdk_colormap_new) (visual, allocate);
547 }
548
549 GdkCursor *gdk_cursor_new (GdkCursorType cursor_type)
550 {
551 CHECK_LOAD_SYMBOL_GDK (gdk_cursor_new);
552 return (*_gdk_cursor_new) (cursor_type);
553 }
554
555 GdkCursor *gdk_cursor_new_from_name (GdkDisplay * display, const gchar * name)
556 {
557 CHECK_LOAD_SYMBOL_GDK (gdk_cursor_new_from_name);
558 return (*_gdk_cursor_new_from_name) (display, name);
559 }
560
561 GdkCursor *gdk_cursor_new_from_pixbuf (GdkDisplay * display,
562 GdkPixbuf * pixbuf, gint x, gint y)
563 {
564 CHECK_LOAD_SYMBOL_GDK (gdk_cursor_new_from_pixbuf);
565 return (*_gdk_cursor_new_from_pixbuf) (display, pixbuf, x, y);
566 }
567
568 GdkDisplay *gdk_display_get_default (void)
569 {
570 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_default);
571 return (*_gdk_display_get_default) ();
572 }
573
574 guint gdk_display_get_default_cursor_size (GdkDisplay * display)
575 {
576 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_default_cursor_size);
577 return (*_gdk_display_get_default_cursor_size) (display);
578 }
579
580 void gdk_display_get_pointer (GdkDisplay * display,
581 GdkScreen ** screen,
582 gint * x, gint * y, GdkModifierType * mask)
583 {
584 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_pointer);
585 (*_gdk_display_get_pointer) (display, screen, x, y, mask);
586 }
587
588 GdkWindow *gdk_display_get_window_at_pointer (GdkDisplay * display,
589 gint * win_x, gint * win_y)
590 {
591 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_window_at_pointer);
592 return (*_gdk_display_get_window_at_pointer) (display, win_x, win_y);
593 }
594
595 gboolean gdk_display_pointer_is_grabbed (GdkDisplay * display)
596 {
597 CHECK_LOAD_SYMBOL_GDK (gdk_display_pointer_is_grabbed);
598 return (*_gdk_display_pointer_is_grabbed) (display);
599 }
600
601 gboolean gdk_display_supports_composite (GdkDisplay * display)
602 {
603 CHECK_LOAD_SYMBOL_GDK (gdk_display_supports_composite);
604 return (*_gdk_display_supports_composite) (display);
605 }
606
607 void gdk_drag_abort (GdkDragContext * context, guint32 time_)
608 {
609 CHECK_LOAD_SYMBOL_GDK (gdk_drag_abort);
610 (*_gdk_drag_abort) (context, time_);
611 }
612
613 gboolean gdk_drag_motion (GdkDragContext * context,
614 GdkWindow * dest_window,
615 GdkDragProtocol protocol,
616 gint x_root,
617 gint y_root,
618 GdkDragAction suggested_action,
619 GdkDragAction possible_actions, guint32 time_)
620 {
621 CHECK_LOAD_SYMBOL_GDK (gdk_drag_motion);
622 return (*_gdk_drag_motion) (context, dest_window, protocol, x_root,
623 y_root, suggested_action, possible_actions,
624 time_);
625 }
626
627 void gdk_drag_drop (GdkDragContext * context, guint32 time_)
628 {
629 CHECK_LOAD_SYMBOL_GDK (gdk_drag_drop);
630 (*_gdk_drag_drop) (context, time_);
631 }
632
633 GdkDragContext *gdk_drag_begin (GdkWindow * window, GList * targets)
634 {
635 CHECK_LOAD_SYMBOL_GDK (gdk_drag_begin);
636 return (*_gdk_drag_begin) (window, targets);
637 }
638
639 GdkDragAction gdk_drag_context_get_actions (GdkDragContext * context)
640 {
641 CHECK_LOAD_SYMBOL_GDK (gdk_drag_context_get_actions);
642 return (*_gdk_drag_context_get_actions) (context);
643 }
644
645 GdkDragAction gdk_drag_context_get_selected_action (GdkDragContext * context)
646 {
647 CHECK_LOAD_SYMBOL_GDK (gdk_drag_context_get_selected_action);
648 return (*_gdk_drag_context_get_selected_action) (context);
649 }
650
651 GdkDragAction gdk_drag_context_get_suggested_action (GdkDragContext * context)
652 {
653 CHECK_LOAD_SYMBOL_GDK (gdk_drag_context_get_suggested_action);
654 return (*_gdk_drag_context_get_suggested_action) (context);
655 }
656
657 GList *gdk_drag_context_list_targets (GdkDragContext * context)
658 {
659 CHECK_LOAD_SYMBOL_GDK (gdk_drag_context_list_targets);
660 return (*_gdk_drag_context_list_targets) (context);
661 }
662
663 void gdk_drag_find_window_for_screen (GdkDragContext * context,
664 GdkWindow * drag_window,
665 GdkScreen * screen,
666 gint x_root,
667 gint y_root,
668 GdkWindow ** dest_window,
669 GdkDragProtocol * protocol)
670 {
671 CHECK_LOAD_SYMBOL_GDK (gdk_drag_find_window_for_screen);
672 (*_gdk_drag_find_window_for_screen) (context, drag_window, screen, x_root,
673 y_root, dest_window, protocol);
674 }
675
676 GdkAtom gdk_drag_get_selection (GdkDragContext * context)
677 {
678 CHECK_LOAD_SYMBOL_GDK (gdk_drag_get_selection);
679 return (*_gdk_drag_get_selection) (context);
680 }
681
682 GdkWindow *gdk_drag_context_get_dest_window (GdkDragContext * context)
683 {
684 CHECK_LOAD_SYMBOL_GDK (gdk_drag_context_get_dest_window);
685 return (*_gdk_drag_context_get_dest_window) (context);
686 }
687
688 void gdk_drag_status (GdkDragContext * context,
689 GdkDragAction action, guint32 time_)
690 {
691 CHECK_LOAD_SYMBOL_GDK (gdk_drag_status);
692 (*_gdk_drag_status) (context, action, time_);
693 }
694
695 void gdk_drop_reply (GdkDragContext * context, gboolean ok, guint32 time_)
696 {
697 CHECK_LOAD_SYMBOL_GDK (gdk_drop_reply);
698 (*_gdk_drop_reply) (context, ok, time_);
699 }
700
701 void gdk_drop_finish (GdkDragContext * context,
702 gboolean success, guint32 time_)
703 {
704 CHECK_LOAD_SYMBOL_GDK (gdk_drop_finish);
705 (*_gdk_drop_finish) (context, success, time_);
706 }
707
708 void gdk_error_trap_push (void)
709 {
710 CHECK_LOAD_SYMBOL_GDK (gdk_error_trap_push);
711 return (*_gdk_error_trap_push) ();
712 }
713
714 void gdk_event_request_motions (const GdkEventMotion * event)
715 {
716 CHECK_LOAD_SYMBOL_GDK (gdk_event_request_motions);
717 (*_gdk_event_request_motions) (event);
718 }
719
720 void gdk_event_handler_set (GdkEventFunc func,
721 gpointer data, GDestroyNotify notify)
722 {
723 CHECK_LOAD_SYMBOL_GDK (gdk_event_handler_set);
724 (*_gdk_event_handler_set) (func, data, notify);
725 }
726
727 GdkWindow *gdk_get_default_root_window (void)
728 {
729 CHECK_LOAD_SYMBOL_GDK (gdk_get_default_root_window);
730 return (*_gdk_get_default_root_window) ();
731 }
732
733 GdkKeymap *gdk_keymap_get_default (void)
734 {
735 CHECK_LOAD_SYMBOL_GDK (gdk_keymap_get_default);
736 return (*_gdk_keymap_get_default) ();
737 }
738
739 gboolean gdk_keymap_get_entries_for_keyval (GdkKeymap * keymap,
740 guint keyval,
741 GdkKeymapKey ** keys,
742 gint * n_keys)
743 {
744 CHECK_LOAD_SYMBOL_GDK (gdk_keymap_get_entries_for_keyval);
745 return (*_gdk_keymap_get_entries_for_keyval) (keymap, keyval, keys,
746 n_keys);
747 }
748
749 guint gdk_keymap_lookup_key (GdkKeymap * keymap, const GdkKeymapKey * key)
750 {
751 CHECK_LOAD_SYMBOL_GDK (gdk_keymap_lookup_key);
752 return (*_gdk_keymap_lookup_key) (keymap, key);
753 }
754
755 gboolean gdk_keymap_translate_keyboard_state (GdkKeymap * keymap,
756 guint hardware_keycode,
757 GdkModifierType state,
758 gint group,
759 guint * keyval,
760 gint * effective_group,
761 gint * level,
762 GdkModifierType *
763 consumed_modifiers)
764 {
765 CHECK_LOAD_SYMBOL_GDK (gdk_keymap_translate_keyboard_state);
766 return (*_gdk_keymap_translate_keyboard_state) (keymap, hardware_keycode,
767 state, group, keyval,
768 effective_group, level,
769 consumed_modifiers);
770 }
771
772 guint32 gdk_keyval_to_unicode (guint keyval)
773 {
774 CHECK_LOAD_SYMBOL_GDK (gdk_keyval_to_unicode);
775 return (*_gdk_keyval_to_unicode) (keyval);
776 }
777
778 GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf * dest,
779 GdkDrawable * src,
780 GdkColormap * cmap,
781 int src_x,
782 int src_y,
783 int dest_x,
784 int dest_y, int width, int height)
785 {
786 CHECK_LOAD_SYMBOL_GDK (gdk_pixbuf_get_from_drawable);
787 return (*_gdk_pixbuf_get_from_drawable) (dest, src, cmap, src_x, src_y,
788 dest_x, dest_y, width, height);
789 }
790
791 void gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf * pixbuf,
792 GdkPixmap ** pixmap_return,
793 GdkBitmap ** mask_return,
794 int alpha_threshold)
795 {
796 CHECK_LOAD_SYMBOL_GDK (gdk_pixbuf_render_pixmap_and_mask);
797 (*_gdk_pixbuf_render_pixmap_and_mask) (pixbuf, pixmap_return, mask_return,
798 alpha_threshold);
799 }
800
801 void gdk_pixbuf_render_pixmap_and_mask_for_colormap (GdkPixbuf * pixbuf,
802 GdkColormap * colormap,
803 GdkPixmap **
804 pixmap_return,
805 GdkBitmap ** mask_return,
806 int alpha_threshold)
807 {
808 CHECK_LOAD_SYMBOL_GDK (gdk_pixbuf_render_pixmap_and_mask_for_colormap);
809 (*_gdk_pixbuf_render_pixmap_and_mask_for_colormap) (pixbuf, colormap,
810 pixmap_return,
811 mask_return,
812 alpha_threshold);
813 }
814
815 GdkGrabStatus gdk_pointer_grab (GdkWindow * window,
816 gboolean owner_events,
817 GdkEventMask event_mask,
818 GdkWindow * confine_to,
819 GdkCursor * cursor, guint32 time_)
820 {
821 CHECK_LOAD_SYMBOL_GDK (gdk_pointer_grab);
822 return (*_gdk_pointer_grab) (window, owner_events, event_mask, confine_to,
823 cursor, time_);
824 }
825
826 void gdk_pointer_ungrab (guint32 time_)
827 {
828 CHECK_LOAD_SYMBOL_GDK (gdk_pointer_ungrab);
829 return (*_gdk_pointer_ungrab) (time_);
830 }
831
832 void gdk_property_change (GdkWindow * window,
833 GdkAtom property,
834 GdkAtom type,
835 gint format,
836 GdkPropMode mode,
837 const guchar * data, gint nelements)
838 {
839 CHECK_LOAD_SYMBOL_GDK (gdk_property_change);
840 return (*_gdk_property_change) (window, property, type, format, mode,
841 data, nelements);
842 }
843
844 gboolean gdk_property_get (GdkWindow * window,
845 GdkAtom property,
846 GdkAtom type,
847 gulong offset,
848 gulong length,
849 gint pdelete,
850 GdkAtom * actual_property_type,
851 gint * actual_format,
852 gint * actual_length, guchar ** data)
853 {
854 CHECK_LOAD_SYMBOL_GDK (gdk_property_get);
855 return (*_gdk_property_get) (window, property, type, offset, length,
856 pdelete, actual_property_type, actual_format,
857 actual_length, data);
858 }
859
860 gboolean gdk_rectangle_intersect (const GdkRectangle * src1,
861 const GdkRectangle * src2,
862 GdkRectangle * dest)
863 {
864 CHECK_LOAD_SYMBOL_GDK (gdk_rectangle_intersect);
865 return (*_gdk_rectangle_intersect) (src1, src2, dest);
866 }
867
868 void gdk_region_destroy (GdkRegion * region)
869 {
870 CHECK_LOAD_SYMBOL_GDK (gdk_region_destroy);
871 (*_gdk_region_destroy) (region);
872 }
873
874 GdkRegion *gdk_region_new (void)
875 {
876 CHECK_LOAD_SYMBOL_GDK (gdk_region_new);
877 return (*_gdk_region_new) ();
878 }
879
880 GdkScreen *gdk_screen_get_default (void)
881 {
882 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_default);
883 return (*_gdk_screen_get_default) ();
884 }
885
886 gint gdk_screen_get_height (GdkScreen * screen)
887 {
888 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_height);
889 return (*_gdk_screen_get_height) (screen);
890 }
891
892 gint gdk_screen_get_monitor_at_point (GdkScreen * screen, gint x, gint y)
893 {
894 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_monitor_at_point);
895 return (*_gdk_screen_get_monitor_at_point) (screen, x, y);
896 }
897
898 void gdk_screen_get_monitor_geometry (GdkScreen * screen,
899 gint monitor_num, GdkRectangle * dest)
900 {
901 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_monitor_geometry);
902 (*_gdk_screen_get_monitor_geometry) (screen, monitor_num, dest);
903 }
904
905 gint gdk_screen_get_n_monitors (GdkScreen * screen)
906 {
907 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_n_monitors);
908 return (*_gdk_screen_get_n_monitors) (screen);
909 }
910
911 gint gdk_screen_get_width_mm (GdkScreen * screen)
912 {
913 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_width_mm);
914 return (*_gdk_screen_get_width_mm) (screen);
915 }
916
917 gint gdk_screen_get_height_mm (GdkScreen * screen)
918 {
919 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_height_mm);
920 return (*_gdk_screen_get_height_mm) (screen);
921 }
922
923 gint gdk_screen_get_monitor_width_mm (GdkScreen * screen, gint monitor_num)
924 {
925 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_monitor_width_mm);
926 return (*_gdk_screen_get_monitor_width_mm) (screen, monitor_num);
927 }
928
929 gint gdk_screen_get_monitor_height_mm (GdkScreen * screen, gint monitor_num)
930 {
931 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_monitor_height_mm);
932 return (*_gdk_screen_get_monitor_height_mm) (screen, monitor_num);
933 }
934
935 gdouble gdk_screen_get_resolution (GdkScreen * screen)
936 {
937 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_resolution);
938 return (*_gdk_screen_get_resolution) (screen);
939 }
940
941 GdkColormap *gdk_screen_get_rgba_colormap (GdkScreen * screen)
942 {
943 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_rgba_colormap);
944 return (*_gdk_screen_get_rgba_colormap) (screen);
945 }
946
947 GdkColormap *gdk_screen_get_rgb_colormap (GdkScreen * screen)
948 {
949 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_rgb_colormap);
950 return (*_gdk_screen_get_rgb_colormap) (screen);
951 }
952
953 GdkWindow *gdk_screen_get_root_window (GdkScreen * screen)
954 {
955 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_root_window);
956 return (*_gdk_screen_get_root_window) (screen);
957 }
958
959 GdkVisual *gdk_screen_get_system_visual (GdkScreen * screen)
960 {
961 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_system_visual);
962 return (*_gdk_screen_get_system_visual) (screen);
963 }
964
965 gint gdk_screen_get_width (GdkScreen * screen)
966 {
967 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_width);
968 return (*_gdk_screen_get_width) (screen);
969 }
970
971 gboolean gdk_screen_is_composited (GdkScreen * screen)
972 {
973 CHECK_LOAD_SYMBOL_GDK (gdk_screen_is_composited);
974 return (*_gdk_screen_is_composited) (screen);
975 }
976
977 void gdk_selection_convert (GdkWindow * requestor,
978 GdkAtom selection, GdkAtom target, guint32 time_)
979 {
980 CHECK_LOAD_SYMBOL_GDK (gdk_selection_convert);
981 (*_gdk_selection_convert) (requestor, selection, target, time_);
982 }
983
984 gboolean gdk_selection_owner_set (GdkWindow * owner,
985 GdkAtom selection,
986 guint32 time_, gboolean send_event)
987 {
988 CHECK_LOAD_SYMBOL_GDK (gdk_selection_owner_set);
989 return (*_gdk_selection_owner_set) (owner, selection, time_, send_event);
990 }
991
992 gint gdk_selection_property_get (GdkWindow * requestor,
993 guchar ** data,
994 GdkAtom * prop_type, gint * prop_format)
995 {
996 CHECK_LOAD_SYMBOL_GDK (gdk_selection_property_get);
997 return (*_gdk_selection_property_get) (requestor, data, prop_type,
998 prop_format);
999 }
1000
1001 void gdk_selection_send_notify (GdkNativeWindow requestor,
1002 GdkAtom selection,
1003 GdkAtom target,
1004 GdkAtom property, guint32 time_)
1005 {
1006 CHECK_LOAD_SYMBOL_GDK (gdk_selection_send_notify);
1007 return (*_gdk_selection_send_notify) (requestor, selection, target,
1008 property, time_);
1009 }
1010
1011 guint gdk_unicode_to_keyval (guint32 wc)
1012 {
1013 CHECK_LOAD_SYMBOL_GDK (gdk_unicode_to_keyval);
1014 return (*_gdk_unicode_to_keyval) (wc);
1015 }
1016
1017 guint gdk_threads_add_idle_full (gint priority,
1018 GSourceFunc function,
1019 gpointer data, GDestroyNotify notify)
1020 {
1021 CHECK_LOAD_SYMBOL_GDK (gdk_threads_add_idle_full);
1022 return (*_gdk_threads_add_idle_full) (priority, function, data, notify);
1023 }
1024
1025 guint gdk_threads_add_idle (GSourceFunc function, gpointer data)
1026 {
1027 CHECK_LOAD_SYMBOL_GDK (gdk_threads_add_idle);
1028 return (*_gdk_threads_add_idle) (function, data);
1029 }
1030
1031 guint gdk_threads_add_timeout_full (gint priority,
1032 guint interval,
1033 GSourceFunc function,
1034 gpointer data, GDestroyNotify notify)
1035 {
1036 CHECK_LOAD_SYMBOL_GDK (gdk_threads_add_timeout_full);
1037 return (*_gdk_threads_add_timeout_full) (priority, interval, function,
1038 data, notify);
1039 }
1040
1041 void gdk_threads_enter (void)
1042 {
1043 CHECK_LOAD_SYMBOL_GDK (gdk_threads_enter);
1044 (*_gdk_threads_enter) ();
1045 }
1046
1047 void gdk_threads_init (void)
1048 {
1049 CHECK_LOAD_SYMBOL_GDK (gdk_threads_init);
1050 (*_gdk_threads_init) ();
1051 }
1052
1053 void gdk_threads_leave (void)
1054 {
1055 CHECK_LOAD_SYMBOL_GDK (gdk_threads_leave);
1056 (*_gdk_threads_leave) ();
1057 }
1058
1059 void gdk_window_destroy (GdkWindow * window)
1060 {
1061 CHECK_LOAD_SYMBOL_GDK (gdk_window_destroy);
1062 (*_gdk_window_destroy) (window);
1063 }
1064
1065 GdkCursor *gdk_window_get_cursor (GdkWindow * window)
1066 {
1067 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_cursor);
1068 return (*_gdk_window_get_cursor) (window);
1069 }
1070
1071 GdkEventMask gdk_window_get_events (GdkWindow * window)
1072 {
1073 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_events);
1074 return (*_gdk_window_get_events) (window);
1075 }
1076
1077 void gdk_window_get_geometry (GdkWindow * window,
1078 gint * x,
1079 gint * y,
1080 gint * width, gint * height, gint * depth)
1081 {
1082 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_geometry);
1083 (*_gdk_window_get_geometry) (window, x, y, width, height, depth);
1084 }
1085
1086 gint gdk_window_get_origin (GdkWindow * window, gint * x, gint * y)
1087 {
1088 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_origin);
1089 return (*_gdk_window_get_origin) (window, x, y);
1090 }
1091
1092 gboolean gdk_window_is_destroyed (GdkWindow * window)
1093 {
1094 CHECK_LOAD_SYMBOL_GDK (gdk_window_is_destroyed);
1095 return (*_gdk_window_is_destroyed) (window);
1096 }
1097
1098 void gdk_window_move (GdkWindow * window, gint x, gint y)
1099 {
1100 CHECK_LOAD_SYMBOL_GDK (gdk_window_move);
1101 (*_gdk_window_move) (window, x, y);
1102 }
1103
1104 GdkWindow *gdk_window_new (GdkWindow * parent,
1105 GdkWindowAttr * attributes, gint attributes_mask)
1106 {
1107 CHECK_LOAD_SYMBOL_GDK (gdk_window_new);
1108 return (*_gdk_window_new) (parent, attributes, attributes_mask);
1109 }
1110
1111 void gdk_window_register_dnd (GdkWindow * window)
1112 {
1113 CHECK_LOAD_SYMBOL_GDK (gdk_window_register_dnd);
1114 (*_gdk_window_register_dnd) (window);
1115 }
1116
1117 void gdk_window_resize (GdkWindow * window, gint width, gint height)
1118 {
1119 CHECK_LOAD_SYMBOL_GDK (gdk_window_resize);
1120 (*_gdk_window_resize) (window, width, height);
1121 }
1122
1123 void gdk_window_restack (GdkWindow * window,
1124 GdkWindow * sibling, gboolean above)
1125 {
1126 CHECK_LOAD_SYMBOL_GDK (gdk_window_restack);
1127 (*_gdk_window_restack) (window, sibling, above);
1128 }
1129
1130 void gdk_window_set_cursor (GdkWindow * window, GdkCursor * cursor)
1131 {
1132 CHECK_LOAD_SYMBOL_GDK (gdk_window_set_cursor);
1133 (*_gdk_window_set_cursor) (window, cursor);
1134 }
1135
1136 void gdk_window_set_events (GdkWindow * window, GdkEventMask event_mask)
1137 {
1138 CHECK_LOAD_SYMBOL_GDK (gdk_window_set_events);
1139 (*_gdk_window_set_events) (window, event_mask);
1140 }
1141
1142 void gdk_window_set_functions (GdkWindow * window, GdkWMFunction functions)
1143 {
1144 CHECK_LOAD_SYMBOL_GDK (gdk_window_set_functions);
1145 (*_gdk_window_set_functions) (window, functions);
1146 }
1147
1148 void gdk_window_show (GdkWindow * window)
1149 {
1150 CHECK_LOAD_SYMBOL_GDK (gdk_window_show);
1151 (*_gdk_window_show) (window);
1152 }
1153
1154 Display *gdk_x11_display_get_xdisplay (GdkDisplay * display)
1155 {
1156 CHECK_LOAD_SYMBOL_GDK (gdk_x11_display_get_xdisplay);
1157 return (*_gdk_x11_display_get_xdisplay) (display);
1158 }
1159
1160 XID gdk_x11_drawable_get_xid (GdkDrawable * drawable)
1161 {
1162 if (wrapper_gtk_version == 2) {
1163 CHECK_LOAD_SYMBOL_GDK (gdk_x11_drawable_get_xid);
1164 return (*_gdk_x11_drawable_get_xid) (drawable);
1165 } else {
1166 CHECK_LOAD_SYMBOL_GDK (gdk_x11_window_get_xid);
1167 return (*_gdk_x11_window_get_xid) (drawable);
1168 }
1169 }
1170
1171 gint gdk_x11_get_default_screen (void)
1172 {
1173 CHECK_LOAD_SYMBOL_GDK (gdk_x11_get_default_screen);
1174 return (*_gdk_x11_get_default_screen) ();
1175 }
1176
1177 Display *gdk_x11_get_default_xdisplay (void)
1178 {
1179 CHECK_LOAD_SYMBOL_GDK (gdk_x11_get_default_xdisplay);
1180 return (*_gdk_x11_get_default_xdisplay) ();
1181 }
1182
1183 guint32 gdk_x11_get_server_time (GdkWindow * window)
1184 {
1185 CHECK_LOAD_SYMBOL_GDK (gdk_x11_get_server_time);
1186 return (*_gdk_x11_get_server_time) (window);
1187 }
1188
1189 GdkVisual *gdk_x11_screen_lookup_visual (GdkScreen * screen,
1190 VisualID xvisualid)
1191 {
1192 CHECK_LOAD_SYMBOL_GDK (gdk_x11_screen_lookup_visual);
1193 return (*_gdk_x11_screen_lookup_visual) (screen, xvisualid);
1194 }
1195
1196 GdkWindow *gdk_x11_window_foreign_new_for_display (GdkDisplay * display,
1197 Window window)
1198 {
1199 CHECK_LOAD_SYMBOL_GDK (gdk_x11_window_foreign_new_for_display);
1200 return (*_gdk_x11_window_foreign_new_for_display) (display, window);
1201 }
1202
1203 GdkWindow *gdk_x11_window_lookup_for_display (GdkDisplay * display,
1204 Window window)
1205 {
1206 CHECK_LOAD_SYMBOL_GDK (gdk_x11_window_lookup_for_display);
1207 return (*_gdk_x11_window_lookup_for_display) (display, window);
1208 }
1209
1210 GdkDisplay *gdk_window_get_display (GdkWindow * window)
1211 {
1212 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_display);
1213 return (*_gdk_window_get_display) (window);
1214 }
1215
1216 int gdk_window_get_height (GdkWindow * window)
1217 {
1218 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_height);
1219 return (*_gdk_window_get_height) (window);
1220 }
1221
1222 int gdk_window_get_width (GdkWindow * window)
1223 {
1224 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_width);
1225 return (*_gdk_window_get_width) (window);
1226 }
1227
1228 GdkScreen *gdk_window_get_screen (GdkWindow * window)
1229 {
1230 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_screen);
1231 return (*_gdk_window_get_screen) (window);
1232 }
1233
1234
1235 //--------------------------------------------------------------------------------------
1236
1237
1238 GdkVisual * gdk_window_get_visual (GdkWindow *window)
1239 {
1240 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_visual);
1241 return (*_gdk_window_get_visual)(window);
1242 }
1243
1244 GdkScreen *gdk_visual_get_screen (GdkVisual *visual)
1245 {
1246 CHECK_LOAD_SYMBOL_GDK (gdk_visual_get_screen);
1247 return (*_gdk_visual_get_screen)(visual);
1248 }
1249
1250 //--------------------------------------------------------------------------------------
1251
1252 Window
1253 gdk_x11_window_get_xid(GdkWindow *window)
1254 {
1255 CHECK_LOAD_SYMBOL_GDK (gdk_x11_window_get_xid);
1256 return (*_gdk_x11_window_get_xid)(window);
1257 }
1258
1259 GType
1260 gdk_window_object_get_type (void)
1261 {
1262 if (wrapper_gtk_version == 2) {
1263 return (*_gdk_window_object_get_type)();
1264 } else {
1265 return (*_gdk_window_get_type)();
1266 }
1267 }
1268
1269 cairo_region_t *
1270 gdk_cairo_region_create_from_surface (cairo_surface_t *surface)
1271 {
1272 return (*_gdk_cairo_region_create_from_surface)(surface);
1273 }
1274
1275 //--------------------------------------------------------------------------------------
1276
1277 typedef struct _DeviceGrabContext {
1278 GdkWindow * window;
1279 gboolean grabbed;
1280 } DeviceGrabContext;
1281
1282
1283
1284 gboolean disableGrab = FALSE;
1285 static gboolean configure_transparent_window(GtkWidget *window);
1286 static void configure_opaque_window(GtkWidget *window);
1287
1288 static void grab_mouse_device(GdkDevice *device, DeviceGrabContext *context);
1289 static void ungrab_mouse_device(GdkDevice *device);
1290
1291 gint glass_gdk_visual_get_depth (GdkVisual * visual)
1292 {
1293 // gdk_visual_get_depth is GTK 2.2 +
1294 if (_gdk_visual_get_depth) {
1295 CHECK_LOAD_SYMBOL_GDK (gdk_visual_get_depth);
1296 return (*_gdk_visual_get_depth) (visual);
1297 } else {
1298 return visual ? visual->depth : 0;
1299 }
1300 }
1301
1302 GdkScreen * glass_gdk_window_get_screen(GdkWindow * gdkWindow)
1303 {
1304 if (wrapper_gtk_version == 2) {
1305 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_screen);
1306 return (*_gdk_window_get_screen)(gdkWindow);
1307 } else {
1308 GdkVisual * gdkVisual = gdk_window_get_visual(gdkWindow);
1309 return gdk_visual_get_screen(gdkVisual);
1310 }
1311 }
1312
1313 gboolean
1314 glass_gdk_mouse_devices_grab(GdkWindow *gdkWindow) {
1315 if (wrapper_gtk_version == 2) {
1316 return glass_gdk_mouse_devices_grab_with_cursor(gdkWindow, NULL, TRUE);
1317 } else {
1318 if (disableGrab) {
1319 return TRUE;
1320 }
1321
1322 CHECK_LOAD_SYMBOL_GDK (gdk_device_manager_list_devices);
1323 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_device_manager);
1324 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_default);
1325
1326 DeviceGrabContext context;
1327 GList *devices = (*_gdk_device_manager_list_devices) (
1328 (*_gdk_display_get_device_manager)(
1329 gdk_display_get_default()),
1330 GDK_DEVICE_TYPE_MASTER);
1331
1332 context.window = gdkWindow;
1333 context.grabbed = FALSE;
1334 g_list_foreach(devices, (GFunc) grab_mouse_device, &context);
1335
1336 return context.grabbed;
1337 }
1338 }
1339
1340 gboolean
1341 glass_gdk_mouse_devices_grab_with_cursor(GdkWindow *gdkWindow, GdkCursor *cursor, gboolean owner_events) {
1342 if (disableGrab) {
1343 return TRUE;
1344 }
1345 CHECK_LOAD_SYMBOL_GDK (gdk_pointer_grab);
1346 GdkGrabStatus status = (*_gdk_pointer_grab)(gdkWindow, owner_events, (GdkEventMask)
1347 (GDK_POINTER_MOTION_MASK
1348 | GDK_POINTER_MOTION_HINT_MASK
1349 | GDK_BUTTON_MOTION_MASK
1350 | GDK_BUTTON1_MOTION_MASK
1351 | GDK_BUTTON2_MOTION_MASK
1352 | GDK_BUTTON3_MOTION_MASK
1353 | GDK_BUTTON_PRESS_MASK
1354 | GDK_BUTTON_RELEASE_MASK),
1355 NULL, cursor, GDK_CURRENT_TIME);
1356
1357 return (status == GDK_GRAB_SUCCESS) ? TRUE : FALSE;
1358 }
1359
1360 void
1361 glass_gdk_mouse_devices_ungrab() {
1362 if (wrapper_gtk_version == 2) {
1363 CHECK_LOAD_SYMBOL_GDK (gdk_pointer_ungrab);
1364 (*_gdk_pointer_ungrab)(GDK_CURRENT_TIME);
1365 } else {
1366 CHECK_LOAD_SYMBOL_GDK (gdk_device_manager_list_devices);
1367 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_device_manager);
1368 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_default);
1369
1370 GList *devices = (*_gdk_device_manager_list_devices)(
1371 (*_gdk_display_get_device_manager)(
1372 (*_gdk_display_get_default)()),
1373 GDK_DEVICE_TYPE_MASTER);
1374 g_list_foreach(devices, (GFunc) ungrab_mouse_device, NULL);
1375 }
1376 }
1377
1378 void
1379 glass_gdk_master_pointer_grab(GdkWindow *window, GdkCursor *cursor) {
1380 if (disableGrab) {
1381 CHECK_LOAD_SYMBOL_GDK (gdk_window_set_cursor);
1382 (*_gdk_window_set_cursor)(window, cursor);
1383 return;
1384 }
1385 if (wrapper_gtk_version == 2) {
1386 CHECK_LOAD_SYMBOL_GDK (gdk_pointer_grab);
1387 (*_gdk_pointer_grab)(window, FALSE, (GdkEventMask)
1388 (GDK_POINTER_MOTION_MASK
1389 | GDK_BUTTON_MOTION_MASK
1390 | GDK_BUTTON1_MOTION_MASK
1391 | GDK_BUTTON2_MOTION_MASK
1392 | GDK_BUTTON3_MOTION_MASK
1393 | GDK_BUTTON_RELEASE_MASK),
1394 NULL, cursor, GDK_CURRENT_TIME);
1395 } else {
1396 CHECK_LOAD_SYMBOL_GDK (gdk_device_grab);
1397 CHECK_LOAD_SYMBOL_GDK (gdk_device_manager_get_client_pointer);
1398 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_device_manager);
1399 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_default);
1400
1401 (*_gdk_device_grab)((*_gdk_device_manager_get_client_pointer)(
1402 (*_gdk_display_get_device_manager)(
1403 (*_gdk_display_get_default)())),
1404 window, GDK_OWNERSHIP_NONE, FALSE, GDK_ALL_EVENTS_MASK,
1405 cursor, GDK_CURRENT_TIME);
1406 }
1407 }
1408
1409 void
1410 glass_gdk_master_pointer_ungrab() {
1411 if (wrapper_gtk_version == 2) {
1412 CHECK_LOAD_SYMBOL_GDK (gdk_pointer_ungrab);
1413 (*_gdk_pointer_ungrab)(GDK_CURRENT_TIME);
1414 } else {
1415 CHECK_LOAD_SYMBOL_GDK (gdk_device_ungrab);
1416 CHECK_LOAD_SYMBOL_GDK (gdk_device_manager_get_client_pointer);
1417 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_device_manager);
1418 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_default);
1419 (*_gdk_device_ungrab)((*_gdk_device_manager_get_client_pointer)(
1420 (*_gdk_display_get_device_manager)(
1421 (*_gdk_display_get_default)())),
1422 GDK_CURRENT_TIME);
1423 }
1424 }
1425
1426 void
1427 glass_gdk_master_pointer_get_position(gint *x, gint *y) {
1428 if (wrapper_gtk_version == 2) {
1429 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_pointer);
1430 (*_gdk_display_get_pointer)(gdk_display_get_default(), NULL, x, y, NULL);
1431 } else {
1432 CHECK_LOAD_SYMBOL_GDK (gdk_device_manager_get_client_pointer);
1433 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_device_manager);
1434 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_default);
1435 (*_gdk_device_get_position)((*_gdk_device_manager_get_client_pointer)(
1436 (*_gdk_display_get_device_manager)(
1437 (*_gdk_display_get_default)())),
1438 NULL, x, y);
1439 }
1440 }
1441
1442 gboolean
1443 glass_gdk_device_is_grabbed(GdkDevice *device) {
1444 if (wrapper_gtk_version == 2) {
1445 (void) device;
1446 CHECK_LOAD_SYMBOL_GDK (gdk_display_pointer_is_grabbed);
1447 return (*_gdk_display_pointer_is_grabbed)(gdk_display_get_default());
1448 } else {
1449 CHECK_LOAD_SYMBOL_GDK (gdk_display_device_is_grabbed);
1450 return (*_gdk_display_device_is_grabbed)((*_gdk_display_get_default)(), device);
1451 }
1452 }
1453
1454 void
1455 glass_gdk_device_ungrab(GdkDevice *device) {
1456 if (wrapper_gtk_version == 2) {
1457 (void) device;
1458 CHECK_LOAD_SYMBOL_GDK (gdk_pointer_ungrab);
1459 (*_gdk_pointer_ungrab)(GDK_CURRENT_TIME);
1460 } else {
1461 CHECK_LOAD_SYMBOL_GDK (gdk_device_ungrab);
1462 (*_gdk_device_ungrab)(device, GDK_CURRENT_TIME);
1463 }
1464 }
1465
1466 GdkWindow *
1467 glass_gdk_device_get_window_at_position(GdkDevice *device, gint *x, gint *y) {
1468 if (wrapper_gtk_version == 2) {
1469 (void) device;
1470 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_window_at_pointer);
1471 return (*_gdk_display_get_window_at_pointer)(gdk_display_get_default(), x, y);
1472 } else {
1473 CHECK_LOAD_SYMBOL_GDK (gdk_device_get_window_at_position);
1474 return (*_gdk_device_get_window_at_position)(device, x, y);
1475 }
1476 }
1477
1478 void
1479 glass_gtk_configure_transparency_and_realize(GtkWidget *window,
1480 gboolean transparent) {
1481 if (wrapper_gtk_version == 2) {
1482 glass_configure_window_transparency(window, transparent);
1483 gtk_widget_realize(window);
1484 } else {
1485 CHECK_LOAD_SYMBOL_GDK (gdk_window_set_background_rgba);
1486 gboolean isTransparent = glass_configure_window_transparency(window, transparent);
1487 gtk_widget_realize(window);
1488 if (isTransparent) {
1489 GdkRGBA rgba = { 1.0, 1.0, 1.0, 0.0 };
1490 (*_gdk_window_set_background_rgba)(gtk_widget_get_window(window), &rgba);
1491 }
1492 }
1493 }
1494
1495 void
1496 glass_gtk_window_configure_from_visual(GtkWidget *widget, GdkVisual *visual) {
1497 glass_widget_set_visual(widget, visual);
1498 }
1499
1500 static gboolean
1501 configure_transparent_window(GtkWidget *window) {
1502 GdkScreen *default_screen = (*_gdk_screen_get_default)();
1503 GdkDisplay *default_display = (*_gdk_display_get_default)();
1504
1505 if (wrapper_gtk_version == 2) {
1506 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_rgba_colormap);
1507 CHECK_LOAD_SYMBOL_GDK (gdk_display_supports_composite);
1508 CHECK_LOAD_SYMBOL_GDK (gdk_screen_is_composited);
1509 GdkColormap *colormap = (*_gdk_screen_get_rgba_colormap)(default_screen);
1510 if (colormap
1511 && (*_gdk_display_supports_composite)(default_display)
1512 && (*_gdk_screen_is_composited)(default_screen)) {
1513 gtk_widget_set_colormap(window, colormap);
1514 return TRUE;
1515 }
1516 } else {
1517 CHECK_LOAD_SYMBOL_GDK (gdk_display_supports_composite);
1518 CHECK_LOAD_SYMBOL_GDK (gdk_screen_is_composited);
1519 GdkVisual *visual = (*_gdk_screen_get_rgba_visual)(default_screen);
1520 if (visual
1521 && (*_gdk_display_supports_composite)(default_display)
1522 && (*_gdk_screen_is_composited)(default_screen)) {
1523 glass_widget_set_visual(window, visual);
1524 return TRUE;
1525 }
1526
1527 return FALSE;
1528 }
1529
1530 return FALSE;
1531 }
1532
1533 int
1534 glass_gtk_fixup_typed_key(int key, int keyval) {
1535 if (wrapper_gtk_version == 2) {
1536 if (key == 0) {
1537 // Work around "bug" fixed in gtk-3.0:
1538 // http://mail.gnome.org/archives/commits-list/2011-March/msg06832.html
1539 switch (keyval) {
1540 case 0xFF08 /* Backspace */: return '\b';
1541 case 0xFF09 /* Tab */: return '\t';
1542 case 0xFF0A /* Linefeed */: return '\n';
1543 case 0xFF0B /* Vert. Tab */: return '\v';
1544 case 0xFF0D /* Return */: return '\r';
1545 case 0xFF1B /* Escape */: return '\033';
1546 case 0xFFFF /* Delete */: return '\177';
1547 }
1548 }
1549 }
1550 return key;
1551 }
1552
1553 void
1554 glass_gdk_window_get_size(GdkWindow *window, gint *w, gint *h) {
1555 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_width);
1556 CHECK_LOAD_SYMBOL_GDK (gdk_window_get_height);
1557 *w = (*_gdk_window_get_width)(window);
1558 *h = (*_gdk_window_get_height)(window);
1559 }
1560
1561 void
1562 glass_gdk_display_get_pointer(GdkDisplay* display, gint* x, gint *y) {
1563 if (wrapper_gtk_version == 2) {
1564 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_pointer);
1565 (*_gdk_display_get_pointer)(display, NULL, x, y, NULL);
1566 } else {
1567 CHECK_LOAD_SYMBOL_GDK (gdk_device_get_position);
1568 CHECK_LOAD_SYMBOL_GDK (gdk_device_manager_get_client_pointer);
1569 CHECK_LOAD_SYMBOL_GDK (gdk_display_get_device_manager);
1570 (*_gdk_device_get_position)(
1571 (*_gdk_device_manager_get_client_pointer)(
1572 (*_gdk_display_get_device_manager)(display)), NULL , x, y);
1573 }
1574 }
1575
1576
1577 const guchar*
1578 glass_gtk_selection_data_get_data_with_length(
1579 GtkSelectionData * selectionData,
1580 gint * length) {
1581 if (selectionData == NULL) {
1582 return NULL;
1583 }
1584
1585 *length = gtk_selection_data_get_length(selectionData);
1586 return gtk_selection_data_get_data(selectionData);
1587 }
1588
1589 static void
1590 configure_opaque_window(GtkWidget *window) {
1591 (void) window;
1592 /* We need to pick a visual that really is glx compatible
1593 * instead of using the default visual
1594 *
1595 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_system_visual);
1596 CHECK_LOAD_SYMBOL_GDK (gdk_screen_get_default);
1597 glass_widget_set_visual(window,
1598 gdk_screen_get_system_visual(
1599 gdk_screen_get_default()));
1600 */
1601 }
1602
1603 gboolean
1604 glass_configure_window_transparency(GtkWidget *window, gboolean transparent) {
1605 if (transparent) {
1606 if (configure_transparent_window(window)) {
1607 return TRUE;
1608 }
1609
1610 fprintf(stderr,"Can't create transparent stage, because your screen doesn't"
1611 " support alpha channel."
1612 " You need to enable XComposite extension.\n");
1613 fflush(stderr);
1614 }
1615
1616 configure_opaque_window(window);
1617 return FALSE;
1618 }
1619
1620 static void
1621 grab_mouse_device(GdkDevice *device, DeviceGrabContext *context) {
1622 CHECK_LOAD_SYMBOL_GDK (gdk_device_get_source);
1623 CHECK_LOAD_SYMBOL_GDK (gdk_device_grab);
1624 GdkInputSource source = (*_gdk_device_get_source)(device);
1625 if (source == GDK_SOURCE_MOUSE) {
1626 GdkGrabStatus status = (*_gdk_device_grab)(device,
1627 context->window,
1628 GDK_OWNERSHIP_NONE,
1629 TRUE,
1630 GDK_ALL_EVENTS_MASK,
1631 NULL,
1632 GDK_CURRENT_TIME);
1633 if (status == GDK_GRAB_SUCCESS) {
1634 context->grabbed = TRUE;
1635 }
1636 }
1637 }
1638
1639 static void
1640 ungrab_mouse_device(GdkDevice *device) {
1641 CHECK_LOAD_SYMBOL_GDK (gdk_device_get_source);
1642 CHECK_LOAD_SYMBOL_GDK (gdk_device_ungrab);
1643 GdkInputSource source = (*_gdk_device_get_source)(device);
1644 if (source == GDK_SOURCE_MOUSE) {
1645 (*_gdk_device_ungrab)(device, GDK_CURRENT_TIME);
1646 }
1647 }
1648
1649 GdkPixbuf *
1650 glass_pixbuf_from_window(GdkWindow *window,
1651 gint srcx, gint srcy,
1652 gint width, gint height)
1653 {
1654 GdkPixbuf * ret = NULL;
1655
1656 if (wrapper_gtk_version == 2) {
1657 CHECK_LOAD_SYMBOL_GDK (gdk_pixbuf_get_from_drawable);
1658 ret = (*_gdk_pixbuf_get_from_drawable) (NULL,
1659 window,
1660 NULL,
1661 srcx, srcy,
1662 0, 0,
1663 width, height);
1664 } else {
1665 CHECK_LOAD_SYMBOL_GDK (gdk_pixbuf_get_from_window);
1666 ret = (*_gdk_pixbuf_get_from_window) (window, srcx, srcy, width, height);
1667 }
1668
1669 return ret;
1670 }
1671
1672 void
1673 glass_window_apply_shape_mask(GdkWindow *window,
1674 void* data, uint width, uint height)
1675 {
1676 if (wrapper_gtk_version == 2) {
1677 CHECK_LOAD_SYMBOL_GDK (gdk_window_input_shape_combine_mask);
1678
1679 GdkPixbuf* pixbuf = gdk_pixbuf_new_from_data((guchar *) data,
1680 GDK_COLORSPACE_RGB, TRUE, 8, width, height, width * 4, NULL, NULL);
1681
1682 if (GDK_IS_PIXBUF(pixbuf)) {
1683 GdkBitmap* mask = NULL;
1684 gdk_pixbuf_render_pixmap_and_mask(pixbuf, NULL, &mask, 128);
1685
1686 (*_gdk_window_input_shape_combine_mask)(window, mask, 0, 0);
1687
1688 g_object_unref(pixbuf);
1689 if (mask) {
1690 g_object_unref(mask);
1691 }
1692 }
1693 } else {
1694 CHECK_LOAD_SYMBOL_GDK (gdk_window_shape_combine_region);
1695 CHECK_LOAD_SYMBOL_GDK (gdk_window_input_shape_combine_region);
1696 CHECK_LOAD_SYMBOL_GDK (gdk_cairo_region_create_from_surface);
1697
1698 cairo_surface_t * shape = cairo_image_surface_create_for_data(
1699 (unsigned char *)data,
1700 CAIRO_FORMAT_ARGB32,
1701 width, height,
1702 width * 4
1703 );
1704 cairo_region_t *region = (*_gdk_cairo_region_create_from_surface) (shape);
1705
1706 (*_gdk_window_shape_combine_region) (window, region, 0, 0);
1707
1708 (*_gdk_window_input_shape_combine_region) (window, region, 0, 0);
1709
1710 cairo_region_destroy(region);
1711 cairo_surface_finish (shape);
1712 }
1713 }
1714
1715 void
1716 glass_window_reset_input_shape_mask(GdkWindow *window)
1717 {
1718 if (wrapper_gtk_version == 2) {
1719 CHECK_LOAD_SYMBOL_GDK (gdk_window_input_shape_combine_mask);
1720 (*_gdk_window_input_shape_combine_mask)(window, NULL, 0, 0);
1721 } else {
1722 CHECK_LOAD_SYMBOL_GDK (gdk_window_input_shape_combine_region);
1723 (*_gdk_window_input_shape_combine_region) (window, NULL, 0, 0);
1724 }
1725 }
1726
1727 GdkWindow *
1728 glass_gdk_drag_context_get_dest_window (GdkDragContext * context)
1729 {
1730 CHECK_LOAD_SYMBOL_GDK (gdk_drag_context_get_dest_window);
1731 return ((context != NULL) ? gdk_drag_context_get_dest_window(context) : NULL);
1732 }
1733
1734