1 | /* GDK - The GIMP Drawing Kit |
2 | * gdkdisplay.c |
3 | * |
4 | * Copyright 2001 Sun Microsystems Inc. |
5 | * |
6 | * Erwann Chenede <erwann.chenede@sun.com> |
7 | * |
8 | * This library is free software; you can redistribute it and/or |
9 | * modify it under the terms of the GNU Library General Public |
10 | * License as published by the Free Software Foundation; either |
11 | * version 2 of the License, or (at your option) any later version. |
12 | * |
13 | * This library is distributed in the hope that it will be useful, |
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
16 | * Library General Public License for more details. |
17 | * |
18 | * You should have received a copy of the GNU Library General Public |
19 | * License along with this library. If not, see <http://www.gnu.org/licenses/>. |
20 | */ |
21 | |
22 | #include "config.h" |
23 | |
24 | #include "gdkdisplay.h" |
25 | #include "gdkdisplayprivate.h" |
26 | |
27 | #include "gdkintl.h" |
28 | #include "gdk-private.h" |
29 | |
30 | #include "gdkapplaunchcontext.h" |
31 | #include "gdkclipboardprivate.h" |
32 | #include "gdkdeviceprivate.h" |
33 | #include "gdkdisplaymanagerprivate.h" |
34 | #include "gdkframeclockidleprivate.h" |
35 | #include "gdkeventsprivate.h" |
36 | #include "gdkglcontextprivate.h" |
37 | #include "gdkmonitorprivate.h" |
38 | |
39 | #ifdef HAVE_EGL |
40 | #include <epoxy/egl.h> |
41 | #endif |
42 | #include <math.h> |
43 | #include <stdlib.h> |
44 | |
45 | /** |
46 | * GdkDisplay: |
47 | * |
48 | * `GdkDisplay` objects are the GDK representation of a workstation. |
49 | * |
50 | * Their purpose are two-fold: |
51 | * |
52 | * - To manage and provide information about input devices (pointers, keyboards, etc) |
53 | * - To manage and provide information about output devices (monitors, projectors, etc) |
54 | * |
55 | * Most of the input device handling has been factored out into separate |
56 | * [class@Gdk.Seat] objects. Every display has a one or more seats, which |
57 | * can be accessed with [method@Gdk.Display.get_default_seat] and |
58 | * [method@Gdk.Display.list_seats]. |
59 | * |
60 | * Output devices are represented by [class@Gdk.Monitor] objects, which can |
61 | * be accessed with [method@Gdk.Display.get_monitor_at_surface] and similar APIs. |
62 | */ |
63 | |
64 | enum |
65 | { |
66 | PROP_0, |
67 | PROP_COMPOSITED, |
68 | PROP_RGBA, |
69 | PROP_INPUT_SHAPES, |
70 | LAST_PROP |
71 | }; |
72 | |
73 | static GParamSpec *props[LAST_PROP] = { NULL, }; |
74 | |
75 | enum { |
76 | OPENED, |
77 | CLOSED, |
78 | SEAT_ADDED, |
79 | SEAT_REMOVED, |
80 | SETTING_CHANGED, |
81 | LAST_SIGNAL |
82 | }; |
83 | |
84 | typedef struct _GdkDisplayPrivate GdkDisplayPrivate; |
85 | |
86 | struct _GdkDisplayPrivate { |
87 | /* The base context that all other contexts inherit from. |
88 | * This context is never exposed to public API and is |
89 | * allowed to have a %NULL surface. |
90 | */ |
91 | GdkGLContext *gl_context; |
92 | GError *gl_error; |
93 | |
94 | #ifdef HAVE_EGL |
95 | EGLDisplay egl_display; |
96 | EGLConfig egl_config; |
97 | EGLConfig egl_config_high_depth; |
98 | #endif |
99 | |
100 | guint rgba : 1; |
101 | guint composited : 1; |
102 | guint input_shapes : 1; |
103 | |
104 | GdkDebugFlags debug_flags; |
105 | }; |
106 | |
107 | static void gdk_display_dispose (GObject *object); |
108 | static void gdk_display_finalize (GObject *object); |
109 | |
110 | |
111 | static GdkAppLaunchContext *gdk_display_real_get_app_launch_context (GdkDisplay *display); |
112 | |
113 | static guint signals[LAST_SIGNAL] = { 0 }; |
114 | |
115 | G_DEFINE_TYPE_WITH_PRIVATE (GdkDisplay, gdk_display, G_TYPE_OBJECT) |
116 | |
117 | static void |
118 | gdk_display_get_property (GObject *object, |
119 | guint prop_id, |
120 | GValue *value, |
121 | GParamSpec *pspec) |
122 | { |
123 | GdkDisplay *display = GDK_DISPLAY (object); |
124 | |
125 | switch (prop_id) |
126 | { |
127 | case PROP_COMPOSITED: |
128 | g_value_set_boolean (value, v_boolean: gdk_display_is_composited (display)); |
129 | break; |
130 | |
131 | case PROP_RGBA: |
132 | g_value_set_boolean (value, v_boolean: gdk_display_is_rgba (display)); |
133 | break; |
134 | |
135 | case PROP_INPUT_SHAPES: |
136 | g_value_set_boolean (value, v_boolean: gdk_display_supports_input_shapes (display)); |
137 | break; |
138 | |
139 | default: |
140 | G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
141 | } |
142 | } |
143 | |
144 | static void |
145 | gdk_display_real_make_default (GdkDisplay *display) |
146 | { |
147 | } |
148 | |
149 | static GdkGLContext * |
150 | gdk_display_default_init_gl (GdkDisplay *display, |
151 | GError **error) |
152 | { |
153 | g_set_error_literal (err: error, GDK_GL_ERROR, code: GDK_GL_ERROR_NOT_AVAILABLE, |
154 | _("The current backend does not support OpenGL" )); |
155 | |
156 | return NULL; |
157 | } |
158 | |
159 | static guint |
160 | gdk_display_default_rate_egl_config (GdkDisplay *display, |
161 | gpointer egl_display, |
162 | gpointer config) |
163 | { |
164 | guint distance = 0; |
165 | #ifdef HAVE_EGL |
166 | int tmp; |
167 | |
168 | if (!eglGetConfigAttrib (egl_display, config, EGL_SAMPLE_BUFFERS, &tmp) || tmp != 0) |
169 | distance += 0x20000; |
170 | |
171 | if (!eglGetConfigAttrib (egl_display, config, EGL_DEPTH_SIZE, &tmp) || tmp != 0 || |
172 | !eglGetConfigAttrib (egl_display, config, EGL_STENCIL_SIZE, &tmp) || tmp != 0) |
173 | distance += 0x10000; |
174 | #endif |
175 | |
176 | return distance; |
177 | } |
178 | |
179 | static GdkSeat * |
180 | gdk_display_real_get_default_seat (GdkDisplay *display) |
181 | { |
182 | if (!display->seats) |
183 | return NULL; |
184 | |
185 | return display->seats->data; |
186 | } |
187 | |
188 | static void |
189 | gdk_display_real_opened (GdkDisplay *display) |
190 | { |
191 | _gdk_display_manager_add_display (manager: gdk_display_manager_get (), display); |
192 | } |
193 | |
194 | static void |
195 | gdk_display_class_init (GdkDisplayClass *class) |
196 | { |
197 | GObjectClass *object_class = G_OBJECT_CLASS (class); |
198 | |
199 | object_class->finalize = gdk_display_finalize; |
200 | object_class->dispose = gdk_display_dispose; |
201 | object_class->get_property = gdk_display_get_property; |
202 | |
203 | class->make_default = gdk_display_real_make_default; |
204 | class->get_app_launch_context = gdk_display_real_get_app_launch_context; |
205 | class->init_gl = gdk_display_default_init_gl; |
206 | class->rate_egl_config = gdk_display_default_rate_egl_config; |
207 | class->get_default_seat = gdk_display_real_get_default_seat; |
208 | class->opened = gdk_display_real_opened; |
209 | |
210 | /** |
211 | * GdkDisplay:composited: (attributes org.gtk.Property.get=gdk_display_is_composited) |
212 | * |
213 | * %TRUE if the display properly composites the alpha channel. |
214 | */ |
215 | props[PROP_COMPOSITED] = |
216 | g_param_spec_boolean (name: "composited" , |
217 | P_("Composited" ), |
218 | P_("Composited" ), |
219 | TRUE, |
220 | flags: G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); |
221 | |
222 | /** |
223 | * GdkDisplay:rgba: (attributes org.gtk.Property.get=gdk_display_is_rgba) |
224 | * |
225 | * %TRUE if the display supports an alpha channel. |
226 | */ |
227 | props[PROP_RGBA] = |
228 | g_param_spec_boolean (name: "rgba" , |
229 | P_("RGBA" ), |
230 | P_("RGBA" ), |
231 | TRUE, |
232 | flags: G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); |
233 | |
234 | /** |
235 | * GdkDisplay:input-shapes: (attributes org.gtk.Property.get=gdk_display_supports_input_shapes) |
236 | * |
237 | * %TRUE if the display supports input shapes. |
238 | */ |
239 | props[PROP_INPUT_SHAPES] = |
240 | g_param_spec_boolean (name: "input-shapes" , |
241 | P_("Input shapes" ), |
242 | P_("Input shapes" ), |
243 | TRUE, |
244 | flags: G_PARAM_READABLE | G_PARAM_STATIC_STRINGS); |
245 | |
246 | g_object_class_install_properties (oclass: object_class, n_pspecs: LAST_PROP, pspecs: props); |
247 | |
248 | /** |
249 | * GdkDisplay::opened: |
250 | * @display: the object on which the signal is emitted |
251 | * |
252 | * Emitted when the connection to the windowing system for @display is opened. |
253 | */ |
254 | signals[OPENED] = |
255 | g_signal_new (signal_name: g_intern_static_string (string: "opened" ), |
256 | G_OBJECT_CLASS_TYPE (object_class), |
257 | signal_flags: G_SIGNAL_RUN_LAST, |
258 | G_STRUCT_OFFSET (GdkDisplayClass, opened), |
259 | NULL, NULL, |
260 | NULL, |
261 | G_TYPE_NONE, n_params: 0); |
262 | |
263 | /** |
264 | * GdkDisplay::closed: |
265 | * @display: the object on which the signal is emitted |
266 | * @is_error: %TRUE if the display was closed due to an error |
267 | * |
268 | * Emitted when the connection to the windowing system for @display is closed. |
269 | */ |
270 | signals[CLOSED] = |
271 | g_signal_new (signal_name: g_intern_static_string (string: "closed" ), |
272 | G_OBJECT_CLASS_TYPE (object_class), |
273 | signal_flags: G_SIGNAL_RUN_LAST, |
274 | G_STRUCT_OFFSET (GdkDisplayClass, closed), |
275 | NULL, NULL, |
276 | NULL, |
277 | G_TYPE_NONE, |
278 | n_params: 1, |
279 | G_TYPE_BOOLEAN); |
280 | |
281 | /** |
282 | * GdkDisplay::seat-added: |
283 | * @display: the object on which the signal is emitted |
284 | * @seat: the seat that was just added |
285 | * |
286 | * Emitted whenever a new seat is made known to the windowing system. |
287 | */ |
288 | signals[SEAT_ADDED] = |
289 | g_signal_new (signal_name: g_intern_static_string (string: "seat-added" ), |
290 | G_OBJECT_CLASS_TYPE (object_class), |
291 | signal_flags: G_SIGNAL_RUN_LAST, |
292 | class_offset: 0, NULL, NULL, |
293 | NULL, |
294 | G_TYPE_NONE, n_params: 1, GDK_TYPE_SEAT); |
295 | |
296 | /** |
297 | * GdkDisplay::seat-removed: |
298 | * @display: the object on which the signal is emitted |
299 | * @seat: the seat that was just removed |
300 | * |
301 | * Emitted whenever a seat is removed by the windowing system. |
302 | */ |
303 | signals[SEAT_REMOVED] = |
304 | g_signal_new (signal_name: g_intern_static_string (string: "seat-removed" ), |
305 | G_OBJECT_CLASS_TYPE (object_class), |
306 | signal_flags: G_SIGNAL_RUN_LAST, |
307 | class_offset: 0, NULL, NULL, |
308 | NULL, |
309 | G_TYPE_NONE, n_params: 1, GDK_TYPE_SEAT); |
310 | |
311 | /** |
312 | * GdkDisplay::setting-changed: |
313 | * @display: the object on which the signal is emitted |
314 | * @setting: the name of the setting that changed |
315 | * |
316 | * Emitted whenever a setting changes its value. |
317 | */ |
318 | signals[SETTING_CHANGED] = |
319 | g_signal_new (signal_name: g_intern_static_string (string: "setting-changed" ), |
320 | G_OBJECT_CLASS_TYPE (object_class), |
321 | signal_flags: G_SIGNAL_RUN_LAST, |
322 | class_offset: 0, NULL, NULL, |
323 | NULL, |
324 | G_TYPE_NONE, n_params: 1, G_TYPE_STRING | G_SIGNAL_TYPE_STATIC_SCOPE); |
325 | } |
326 | |
327 | static void |
328 | free_pointer_info (GdkPointerSurfaceInfo *info) |
329 | { |
330 | g_clear_object (&info->surface_under_pointer); |
331 | g_slice_free (GdkPointerSurfaceInfo, info); |
332 | } |
333 | |
334 | static void |
335 | free_device_grab (GdkDeviceGrabInfo *info) |
336 | { |
337 | g_object_unref (object: info->surface); |
338 | g_free (mem: info); |
339 | } |
340 | |
341 | static gboolean |
342 | free_device_grabs_foreach (gpointer key, |
343 | gpointer value, |
344 | gpointer user_data) |
345 | { |
346 | GList *list = value; |
347 | |
348 | g_list_free_full (list, free_func: (GDestroyNotify) free_device_grab); |
349 | |
350 | return TRUE; |
351 | } |
352 | |
353 | static void |
354 | gdk_display_init (GdkDisplay *display) |
355 | { |
356 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
357 | |
358 | display->double_click_time = 250; |
359 | display->double_click_distance = 5; |
360 | |
361 | display->device_grabs = g_hash_table_new (NULL, NULL); |
362 | |
363 | display->pointers_info = g_hash_table_new_full (NULL, NULL, NULL, |
364 | value_destroy_func: (GDestroyNotify) free_pointer_info); |
365 | |
366 | g_queue_init (queue: &display->queued_events); |
367 | |
368 | priv->debug_flags = _gdk_debug_flags; |
369 | |
370 | priv->composited = TRUE; |
371 | priv->rgba = TRUE; |
372 | priv->input_shapes = TRUE; |
373 | } |
374 | |
375 | static void |
376 | gdk_display_dispose (GObject *object) |
377 | { |
378 | GdkDisplay *display = GDK_DISPLAY (object); |
379 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
380 | |
381 | _gdk_display_manager_remove_display (manager: gdk_display_manager_get (), display); |
382 | |
383 | g_queue_clear (queue: &display->queued_events); |
384 | |
385 | g_clear_object (&priv->gl_context); |
386 | #ifdef HAVE_EGL |
387 | g_clear_pointer (&priv->egl_display, eglTerminate); |
388 | #endif |
389 | g_clear_error (err: &priv->gl_error); |
390 | |
391 | G_OBJECT_CLASS (gdk_display_parent_class)->dispose (object); |
392 | } |
393 | |
394 | static void |
395 | gdk_display_finalize (GObject *object) |
396 | { |
397 | GdkDisplay *display = GDK_DISPLAY (object); |
398 | |
399 | g_hash_table_foreach_remove (hash_table: display->device_grabs, |
400 | func: free_device_grabs_foreach, |
401 | NULL); |
402 | g_hash_table_destroy (hash_table: display->device_grabs); |
403 | |
404 | g_hash_table_destroy (hash_table: display->pointers_info); |
405 | |
406 | g_list_free_full (list: display->seats, free_func: g_object_unref); |
407 | |
408 | G_OBJECT_CLASS (gdk_display_parent_class)->finalize (object); |
409 | } |
410 | |
411 | /** |
412 | * gdk_display_close: |
413 | * @display: a `GdkDisplay` |
414 | * |
415 | * Closes the connection to the windowing system for the given display. |
416 | * |
417 | * This cleans up associated resources. |
418 | */ |
419 | void |
420 | gdk_display_close (GdkDisplay *display) |
421 | { |
422 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
423 | |
424 | if (!display->closed) |
425 | { |
426 | display->closed = TRUE; |
427 | |
428 | g_signal_emit (instance: display, signal_id: signals[CLOSED], detail: 0, FALSE); |
429 | g_object_run_dispose (G_OBJECT (display)); |
430 | |
431 | g_object_unref (object: display); |
432 | } |
433 | } |
434 | |
435 | /** |
436 | * gdk_display_is_closed: |
437 | * @display: a `GdkDisplay` |
438 | * |
439 | * Finds out if the display has been closed. |
440 | * |
441 | * Returns: %TRUE if the display is closed. |
442 | */ |
443 | gboolean |
444 | gdk_display_is_closed (GdkDisplay *display) |
445 | { |
446 | g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); |
447 | |
448 | return display->closed; |
449 | } |
450 | |
451 | /*<private> |
452 | * gdk_display_get_event: |
453 | * @display: a `GdkDisplay` |
454 | * |
455 | * Gets the next `GdkEvent` to be processed for @display, |
456 | * fetching events from the windowing system if necessary. |
457 | * |
458 | * Returns: (nullable) (transfer full): the next `GdkEvent` |
459 | * to be processed |
460 | */ |
461 | GdkEvent * |
462 | gdk_display_get_event (GdkDisplay *display) |
463 | { |
464 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
465 | |
466 | if (display->event_pause_count == 0) |
467 | GDK_DISPLAY_GET_CLASS (display)->queue_events (display); |
468 | |
469 | return _gdk_event_unqueue (display); |
470 | } |
471 | |
472 | /** |
473 | * gdk_display_put_event: |
474 | * @display: a `GdkDisplay` |
475 | * @event: (transfer none): a `GdkEvent` |
476 | * |
477 | * Appends the given event onto the front of the event |
478 | * queue for @display. |
479 | * |
480 | * This function is only useful in very special situations |
481 | * and should not be used by applications. |
482 | **/ |
483 | void |
484 | gdk_display_put_event (GdkDisplay *display, |
485 | GdkEvent *event) |
486 | { |
487 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
488 | g_return_if_fail (event != NULL); |
489 | |
490 | _gdk_event_queue_append (display, event: gdk_event_ref (event: (GdkEvent *)event)); |
491 | } |
492 | |
493 | static void |
494 | generate_grab_broken_event (GdkDisplay *display, |
495 | GdkSurface *surface, |
496 | GdkDevice *device, |
497 | gboolean implicit, |
498 | GdkSurface *grab_surface) |
499 | { |
500 | g_return_if_fail (surface != NULL); |
501 | |
502 | if (!GDK_SURFACE_DESTROYED (surface)) |
503 | { |
504 | GdkEvent *event; |
505 | |
506 | event = gdk_grab_broken_event_new (surface, |
507 | device, |
508 | grab_surface, |
509 | implicit); |
510 | |
511 | _gdk_event_queue_append (display, event); |
512 | } |
513 | } |
514 | |
515 | GdkDeviceGrabInfo * |
516 | _gdk_display_get_last_device_grab (GdkDisplay *display, |
517 | GdkDevice *device) |
518 | { |
519 | GList *l; |
520 | |
521 | l = g_hash_table_lookup (hash_table: display->device_grabs, key: device); |
522 | |
523 | if (l) |
524 | { |
525 | l = g_list_last (list: l); |
526 | return l->data; |
527 | } |
528 | |
529 | return NULL; |
530 | } |
531 | |
532 | GdkDeviceGrabInfo * |
533 | _gdk_display_add_device_grab (GdkDisplay *display, |
534 | GdkDevice *device, |
535 | GdkSurface *surface, |
536 | gboolean owner_events, |
537 | GdkEventMask event_mask, |
538 | unsigned long serial_start, |
539 | guint32 time, |
540 | gboolean implicit) |
541 | { |
542 | GdkDeviceGrabInfo *info, *other_info; |
543 | GList *grabs, *l; |
544 | |
545 | info = g_new0 (GdkDeviceGrabInfo, 1); |
546 | |
547 | info->surface = g_object_ref (surface); |
548 | info->serial_start = serial_start; |
549 | info->serial_end = G_MAXULONG; |
550 | info->owner_events = owner_events; |
551 | info->event_mask = event_mask; |
552 | info->time = time; |
553 | info->implicit = implicit; |
554 | |
555 | grabs = g_hash_table_lookup (hash_table: display->device_grabs, key: device); |
556 | |
557 | /* Find the first grab that has a larger start time (if any) and insert |
558 | * before that. I.E we insert after already existing grabs with same |
559 | * start time */ |
560 | for (l = grabs; l != NULL; l = l->next) |
561 | { |
562 | other_info = l->data; |
563 | |
564 | if (info->serial_start < other_info->serial_start) |
565 | break; |
566 | } |
567 | |
568 | grabs = g_list_insert_before (list: grabs, sibling: l, data: info); |
569 | |
570 | /* Make sure the new grab end before next grab */ |
571 | if (l) |
572 | { |
573 | other_info = l->data; |
574 | info->serial_end = other_info->serial_start; |
575 | } |
576 | |
577 | /* Find any previous grab and update its end time */ |
578 | l = g_list_find (list: grabs, data: info); |
579 | l = l->prev; |
580 | if (l) |
581 | { |
582 | other_info = l->data; |
583 | other_info->serial_end = serial_start; |
584 | } |
585 | |
586 | g_hash_table_insert (hash_table: display->device_grabs, key: device, value: grabs); |
587 | |
588 | return info; |
589 | } |
590 | |
591 | static GdkSurface * |
592 | get_current_toplevel (GdkDisplay *display, |
593 | GdkDevice *device, |
594 | int *x_out, |
595 | int *y_out, |
596 | GdkModifierType *state_out) |
597 | { |
598 | GdkSurface *pointer_surface; |
599 | double x, y; |
600 | GdkModifierType state; |
601 | |
602 | pointer_surface = _gdk_device_surface_at_position (device, win_x: &x, win_y: &y, mask: &state); |
603 | |
604 | if (pointer_surface != NULL && |
605 | GDK_SURFACE_DESTROYED (pointer_surface)) |
606 | pointer_surface = NULL; |
607 | |
608 | *x_out = round (x: x); |
609 | *y_out = round (x: y); |
610 | *state_out = state; |
611 | |
612 | return pointer_surface; |
613 | } |
614 | |
615 | static void |
616 | switch_to_pointer_grab (GdkDisplay *display, |
617 | GdkDevice *device, |
618 | GdkDeviceGrabInfo *grab, |
619 | GdkDeviceGrabInfo *last_grab, |
620 | guint32 time, |
621 | gulong serial) |
622 | { |
623 | GdkSurface *new_toplevel; |
624 | GdkPointerSurfaceInfo *info; |
625 | GList *old_grabs; |
626 | GdkModifierType state; |
627 | int x = 0, y = 0; |
628 | |
629 | /* Temporarily unset pointer to make sure we send the crossing events below */ |
630 | old_grabs = g_hash_table_lookup (hash_table: display->device_grabs, key: device); |
631 | g_hash_table_steal (hash_table: display->device_grabs, key: device); |
632 | info = _gdk_display_get_pointer_info (display, device); |
633 | |
634 | if (grab) |
635 | { |
636 | /* New grab is in effect */ |
637 | if (!grab->implicit) |
638 | { |
639 | /* !owner_event Grabbing a surface that we're not inside, current status is |
640 | now NULL (i.e. outside grabbed surface) */ |
641 | if (!grab->owner_events && info->surface_under_pointer != grab->surface) |
642 | _gdk_display_set_surface_under_pointer (display, device, NULL); |
643 | } |
644 | |
645 | grab->activated = TRUE; |
646 | } |
647 | |
648 | if (last_grab) |
649 | { |
650 | new_toplevel = NULL; |
651 | |
652 | if (grab == NULL /* ungrab */ || |
653 | (!last_grab->owner_events && grab->owner_events) /* switched to owner_events */ ) |
654 | { |
655 | new_toplevel = get_current_toplevel (display, device, x_out: &x, y_out: &y, state_out: &state); |
656 | |
657 | if (new_toplevel) |
658 | { |
659 | /* w is now toplevel and x,y in toplevel coords */ |
660 | _gdk_display_set_surface_under_pointer (display, device, surface: new_toplevel); |
661 | info->toplevel_x = x; |
662 | info->toplevel_y = y; |
663 | info->state = state; |
664 | } |
665 | } |
666 | |
667 | if (grab == NULL) /* Ungrabbed, send events */ |
668 | { |
669 | /* We're now ungrabbed, update the surface_under_pointer */ |
670 | _gdk_display_set_surface_under_pointer (display, device, surface: new_toplevel); |
671 | } |
672 | } |
673 | |
674 | g_hash_table_insert (hash_table: display->device_grabs, key: device, value: old_grabs); |
675 | } |
676 | |
677 | void |
678 | _gdk_display_update_last_event (GdkDisplay *display, |
679 | GdkEvent *event) |
680 | { |
681 | if (gdk_event_get_time (event) != GDK_CURRENT_TIME) |
682 | display->last_event_time = gdk_event_get_time (event); |
683 | } |
684 | |
685 | void |
686 | _gdk_display_device_grab_update (GdkDisplay *display, |
687 | GdkDevice *device, |
688 | gulong current_serial) |
689 | { |
690 | GdkDeviceGrabInfo *current_grab, *next_grab; |
691 | GList *grabs; |
692 | guint32 time; |
693 | |
694 | time = display->last_event_time; |
695 | grabs = g_hash_table_lookup (hash_table: display->device_grabs, key: device); |
696 | |
697 | while (grabs != NULL) |
698 | { |
699 | current_grab = grabs->data; |
700 | |
701 | if (current_grab->serial_start > current_serial) |
702 | return; /* Hasn't started yet */ |
703 | |
704 | if (current_grab->serial_end > current_serial) |
705 | { |
706 | /* This one hasn't ended yet. |
707 | its the currently active one or scheduled to be active */ |
708 | |
709 | if (!current_grab->activated) |
710 | { |
711 | if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD) |
712 | switch_to_pointer_grab (display, device, grab: current_grab, NULL, time, serial: current_serial); |
713 | } |
714 | |
715 | break; |
716 | } |
717 | |
718 | next_grab = NULL; |
719 | if (grabs->next) |
720 | { |
721 | /* This is the next active grab */ |
722 | next_grab = grabs->next->data; |
723 | |
724 | if (next_grab->serial_start > current_serial) |
725 | next_grab = NULL; /* Actually its not yet active */ |
726 | } |
727 | |
728 | if ((next_grab == NULL && current_grab->implicit_ungrab) || |
729 | (next_grab != NULL && current_grab->surface != next_grab->surface)) |
730 | generate_grab_broken_event (display, GDK_SURFACE (current_grab->surface), |
731 | device, |
732 | implicit: current_grab->implicit, |
733 | grab_surface: next_grab? next_grab->surface : NULL); |
734 | |
735 | /* Remove old grab */ |
736 | grabs = g_list_delete_link (list: grabs, link_: grabs); |
737 | g_hash_table_insert (hash_table: display->device_grabs, key: device, value: grabs); |
738 | |
739 | if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD) |
740 | switch_to_pointer_grab (display, device, |
741 | grab: next_grab, last_grab: current_grab, |
742 | time, serial: current_serial); |
743 | |
744 | free_device_grab (info: current_grab); |
745 | } |
746 | } |
747 | |
748 | static GList * |
749 | grab_list_find (GList *grabs, |
750 | gulong serial) |
751 | { |
752 | GdkDeviceGrabInfo *grab; |
753 | |
754 | while (grabs) |
755 | { |
756 | grab = grabs->data; |
757 | |
758 | if (serial >= grab->serial_start && serial < grab->serial_end) |
759 | return grabs; |
760 | |
761 | grabs = grabs->next; |
762 | } |
763 | |
764 | return NULL; |
765 | } |
766 | |
767 | static GList * |
768 | find_device_grab (GdkDisplay *display, |
769 | GdkDevice *device, |
770 | gulong serial) |
771 | { |
772 | GList *l; |
773 | |
774 | l = g_hash_table_lookup (hash_table: display->device_grabs, key: device); |
775 | return grab_list_find (grabs: l, serial); |
776 | } |
777 | |
778 | GdkDeviceGrabInfo * |
779 | _gdk_display_has_device_grab (GdkDisplay *display, |
780 | GdkDevice *device, |
781 | gulong serial) |
782 | { |
783 | GList *l; |
784 | |
785 | l = find_device_grab (display, device, serial); |
786 | if (l) |
787 | return l->data; |
788 | |
789 | return NULL; |
790 | } |
791 | |
792 | /* Returns true if last grab was ended |
793 | * If if_child is non-NULL, end the grab only if the grabbed |
794 | * surface is the same as if_child or a descendant of it */ |
795 | gboolean |
796 | _gdk_display_end_device_grab (GdkDisplay *display, |
797 | GdkDevice *device, |
798 | gulong serial, |
799 | GdkSurface *if_child, |
800 | gboolean implicit) |
801 | { |
802 | GdkDeviceGrabInfo *grab; |
803 | GList *l; |
804 | |
805 | l = find_device_grab (display, device, serial); |
806 | |
807 | if (l == NULL) |
808 | return FALSE; |
809 | |
810 | grab = l->data; |
811 | if (grab && (if_child == NULL || if_child == grab->surface)) |
812 | { |
813 | grab->serial_end = serial; |
814 | grab->implicit_ungrab = implicit; |
815 | return l->next == NULL; |
816 | } |
817 | |
818 | return FALSE; |
819 | } |
820 | |
821 | GdkPointerSurfaceInfo * |
822 | _gdk_display_get_pointer_info (GdkDisplay *display, |
823 | GdkDevice *device) |
824 | { |
825 | GdkPointerSurfaceInfo *info; |
826 | GdkSeat *seat; |
827 | |
828 | if (device) |
829 | { |
830 | seat = gdk_device_get_seat (device); |
831 | |
832 | if (device == gdk_seat_get_keyboard (seat)) |
833 | device = gdk_seat_get_pointer (seat); |
834 | } |
835 | |
836 | if (G_UNLIKELY (!device)) |
837 | return NULL; |
838 | |
839 | info = g_hash_table_lookup (hash_table: display->pointers_info, key: device); |
840 | |
841 | if (G_UNLIKELY (!info)) |
842 | { |
843 | info = g_slice_new0 (GdkPointerSurfaceInfo); |
844 | g_hash_table_insert (hash_table: display->pointers_info, key: device, value: info); |
845 | } |
846 | |
847 | return info; |
848 | } |
849 | |
850 | void |
851 | _gdk_display_pointer_info_foreach (GdkDisplay *display, |
852 | GdkDisplayPointerInfoForeach func, |
853 | gpointer user_data) |
854 | { |
855 | GHashTableIter iter; |
856 | gpointer key, value; |
857 | |
858 | g_hash_table_iter_init (iter: &iter, hash_table: display->pointers_info); |
859 | |
860 | while (g_hash_table_iter_next (iter: &iter, key: &key, value: &value)) |
861 | { |
862 | GdkPointerSurfaceInfo *info = value; |
863 | GdkDevice *device = key; |
864 | |
865 | (func) (display, device, info, user_data); |
866 | } |
867 | } |
868 | |
869 | /*< private > |
870 | * gdk_device_grab_info: |
871 | * @display: the display for which to get the grab information |
872 | * @device: device to get the grab information from |
873 | * @grab_surface: (out) (transfer none): location to store current grab surface |
874 | * @owner_events: (out): location to store boolean indicating whether |
875 | * the @owner_events flag to gdk_device_grab() was %TRUE. |
876 | * |
877 | * Determines information about the current keyboard grab. |
878 | * This is not public API and must not be used by applications. |
879 | * |
880 | * Returns: %TRUE if this application currently has the |
881 | * keyboard grabbed. |
882 | */ |
883 | gboolean |
884 | gdk_device_grab_info (GdkDisplay *display, |
885 | GdkDevice *device, |
886 | GdkSurface **grab_surface, |
887 | gboolean *owner_events) |
888 | { |
889 | GdkDeviceGrabInfo *info; |
890 | |
891 | g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); |
892 | g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE); |
893 | |
894 | info = _gdk_display_get_last_device_grab (display, device); |
895 | |
896 | if (info) |
897 | { |
898 | if (grab_surface) |
899 | *grab_surface = info->surface; |
900 | if (owner_events) |
901 | *owner_events = info->owner_events; |
902 | |
903 | return TRUE; |
904 | } |
905 | else |
906 | return FALSE; |
907 | } |
908 | |
909 | /** |
910 | * gdk_display_device_is_grabbed: |
911 | * @display: a `GdkDisplay` |
912 | * @device: a `GdkDevice` |
913 | * |
914 | * Returns %TRUE if there is an ongoing grab on @device for @display. |
915 | * |
916 | * Returns: %TRUE if there is a grab in effect for @device. |
917 | */ |
918 | gboolean |
919 | gdk_display_device_is_grabbed (GdkDisplay *display, |
920 | GdkDevice *device) |
921 | { |
922 | GdkDeviceGrabInfo *info; |
923 | |
924 | g_return_val_if_fail (GDK_IS_DISPLAY (display), TRUE); |
925 | g_return_val_if_fail (GDK_IS_DEVICE (device), TRUE); |
926 | |
927 | /* What we're interested in is the steady state (ie last grab), |
928 | because we're interested e.g. if we grabbed so that we |
929 | can ungrab, even if our grab is not active just yet. */ |
930 | info = _gdk_display_get_last_device_grab (display, device); |
931 | |
932 | return (info && !info->implicit); |
933 | } |
934 | |
935 | /** |
936 | * gdk_display_get_name: |
937 | * @display: a `GdkDisplay` |
938 | * |
939 | * Gets the name of the display. |
940 | * |
941 | * Returns: a string representing the display name. This string is owned |
942 | * by GDK and should not be modified or freed. |
943 | */ |
944 | const char * |
945 | gdk_display_get_name (GdkDisplay *display) |
946 | { |
947 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
948 | |
949 | return GDK_DISPLAY_GET_CLASS (display)->get_name (display); |
950 | } |
951 | |
952 | /** |
953 | * gdk_display_beep: |
954 | * @display: a `GdkDisplay` |
955 | * |
956 | * Emits a short beep on @display |
957 | */ |
958 | void |
959 | gdk_display_beep (GdkDisplay *display) |
960 | { |
961 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
962 | |
963 | GDK_DISPLAY_GET_CLASS (display)->beep (display); |
964 | } |
965 | |
966 | /** |
967 | * gdk_display_sync: |
968 | * @display: a `GdkDisplay` |
969 | * |
970 | * Flushes any requests queued for the windowing system and waits until all |
971 | * requests have been handled. |
972 | * |
973 | * This is often used for making sure that the display is synchronized |
974 | * with the current state of the program. Calling [method@Gdk.Display.sync] |
975 | * before [method@GdkX11.Display.error_trap_pop] makes sure that any errors |
976 | * generated from earlier requests are handled before the error trap is removed. |
977 | * |
978 | * This is most useful for X11. On windowing systems where requests are |
979 | * handled synchronously, this function will do nothing. |
980 | */ |
981 | void |
982 | gdk_display_sync (GdkDisplay *display) |
983 | { |
984 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
985 | |
986 | GDK_DISPLAY_GET_CLASS (display)->sync (display); |
987 | } |
988 | |
989 | /** |
990 | * gdk_display_flush: |
991 | * @display: a `GdkDisplay` |
992 | * |
993 | * Flushes any requests queued for the windowing system. |
994 | * |
995 | * This happens automatically when the main loop blocks waiting for new events, |
996 | * but if your application is drawing without returning control to the main loop, |
997 | * you may need to call this function explicitly. A common case where this function |
998 | * needs to be called is when an application is executing drawing commands |
999 | * from a thread other than the thread where the main loop is running. |
1000 | * |
1001 | * This is most useful for X11. On windowing systems where requests are |
1002 | * handled synchronously, this function will do nothing. |
1003 | */ |
1004 | void |
1005 | gdk_display_flush (GdkDisplay *display) |
1006 | { |
1007 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
1008 | |
1009 | GDK_DISPLAY_GET_CLASS (display)->flush (display); |
1010 | } |
1011 | |
1012 | /** |
1013 | * gdk_display_get_clipboard: |
1014 | * @display: a `GdkDisplay` |
1015 | * |
1016 | * Gets the clipboard used for copy/paste operations. |
1017 | * |
1018 | * Returns: (transfer none): the display's clipboard |
1019 | */ |
1020 | GdkClipboard * |
1021 | gdk_display_get_clipboard (GdkDisplay *display) |
1022 | { |
1023 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
1024 | |
1025 | if (display->clipboard == NULL) |
1026 | display->clipboard = gdk_clipboard_new (display); |
1027 | |
1028 | return display->clipboard; |
1029 | } |
1030 | |
1031 | /** |
1032 | * gdk_display_get_primary_clipboard: |
1033 | * @display: a `GdkDisplay` |
1034 | * |
1035 | * Gets the clipboard used for the primary selection. |
1036 | * |
1037 | * On backends where the primary clipboard is not supported natively, |
1038 | * GDK emulates this clipboard locally. |
1039 | * |
1040 | * Returns: (transfer none): the primary clipboard |
1041 | */ |
1042 | GdkClipboard * |
1043 | gdk_display_get_primary_clipboard (GdkDisplay *display) |
1044 | { |
1045 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
1046 | |
1047 | if (display->primary_clipboard == NULL) |
1048 | display->primary_clipboard = gdk_clipboard_new (display); |
1049 | |
1050 | return display->primary_clipboard; |
1051 | } |
1052 | |
1053 | /** |
1054 | * gdk_display_supports_input_shapes: (attributes org.gtk.Method.get_property=input-shapes) |
1055 | * @display: a `GdkDisplay` |
1056 | * |
1057 | * Returns %TRUE if the display supports input shapes. |
1058 | * |
1059 | * This means that [method@Gdk.Surface.set_input_region] can |
1060 | * be used to modify the input shape of surfaces on @display. |
1061 | * |
1062 | * On modern displays, this value is always %TRUE. |
1063 | * |
1064 | * Returns: %TRUE if surfaces with modified input shape are supported |
1065 | */ |
1066 | gboolean |
1067 | gdk_display_supports_input_shapes (GdkDisplay *display) |
1068 | { |
1069 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1070 | |
1071 | g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); |
1072 | |
1073 | return priv->input_shapes; |
1074 | } |
1075 | |
1076 | void |
1077 | gdk_display_set_input_shapes (GdkDisplay *display, |
1078 | gboolean input_shapes) |
1079 | { |
1080 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1081 | |
1082 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
1083 | |
1084 | if (priv->input_shapes == input_shapes) |
1085 | return; |
1086 | |
1087 | priv->input_shapes = input_shapes; |
1088 | |
1089 | g_object_notify_by_pspec (G_OBJECT (display), pspec: props[PROP_INPUT_SHAPES]); |
1090 | } |
1091 | |
1092 | static GdkAppLaunchContext * |
1093 | gdk_display_real_get_app_launch_context (GdkDisplay *display) |
1094 | { |
1095 | GdkAppLaunchContext *ctx; |
1096 | |
1097 | ctx = g_object_new (GDK_TYPE_APP_LAUNCH_CONTEXT, |
1098 | first_property_name: "display" , display, |
1099 | NULL); |
1100 | |
1101 | return ctx; |
1102 | } |
1103 | |
1104 | /** |
1105 | * gdk_display_get_app_launch_context: |
1106 | * @display: a `GdkDisplay` |
1107 | * |
1108 | * Returns a `GdkAppLaunchContext` suitable for launching |
1109 | * applications on the given display. |
1110 | * |
1111 | * Returns: (transfer full): a new `GdkAppLaunchContext` for @display |
1112 | */ |
1113 | GdkAppLaunchContext * |
1114 | gdk_display_get_app_launch_context (GdkDisplay *display) |
1115 | { |
1116 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
1117 | |
1118 | return GDK_DISPLAY_GET_CLASS (display)->get_app_launch_context (display); |
1119 | } |
1120 | |
1121 | /** |
1122 | * gdk_display_open: |
1123 | * @display_name: the name of the display to open |
1124 | * |
1125 | * Opens a display. |
1126 | * |
1127 | * If opening the display fails, `NULL` is returned. |
1128 | * |
1129 | * Returns: (nullable) (transfer none): a `GdkDisplay` |
1130 | */ |
1131 | GdkDisplay * |
1132 | gdk_display_open (const char *display_name) |
1133 | { |
1134 | return gdk_display_manager_open_display (manager: gdk_display_manager_get (), |
1135 | name: display_name); |
1136 | } |
1137 | |
1138 | gulong |
1139 | _gdk_display_get_next_serial (GdkDisplay *display) |
1140 | { |
1141 | return GDK_DISPLAY_GET_CLASS (display)->get_next_serial (display); |
1142 | } |
1143 | |
1144 | /** |
1145 | * gdk_display_notify_startup_complete: |
1146 | * @display: a `GdkDisplay` |
1147 | * @startup_id: a startup-notification identifier, for which |
1148 | * notification process should be completed |
1149 | * |
1150 | * Indicates to the GUI environment that the application has |
1151 | * finished loading, using a given identifier. |
1152 | * |
1153 | * GTK will call this function automatically for [class@Gtk.Window] |
1154 | * with custom startup-notification identifier unless |
1155 | * [method@Gtk.Window.set_auto_startup_notification] |
1156 | * is called to disable that feature. |
1157 | */ |
1158 | void |
1159 | gdk_display_notify_startup_complete (GdkDisplay *display, |
1160 | const char *startup_id) |
1161 | { |
1162 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
1163 | |
1164 | GDK_DISPLAY_GET_CLASS (display)->notify_startup_complete (display, startup_id); |
1165 | } |
1166 | |
1167 | /** |
1168 | * gdk_display_get_startup_notification_id: |
1169 | * @display: a `GdkDisplay` |
1170 | * |
1171 | * Gets the startup notification ID for a Wayland display, or %NULL |
1172 | * if no ID has been defined. |
1173 | * |
1174 | * Returns: (nullable): the startup notification ID for @display |
1175 | */ |
1176 | const char * |
1177 | gdk_display_get_startup_notification_id (GdkDisplay *display) |
1178 | { |
1179 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
1180 | |
1181 | if (GDK_DISPLAY_GET_CLASS (display)->get_startup_notification_id == NULL) |
1182 | return NULL; |
1183 | |
1184 | return GDK_DISPLAY_GET_CLASS (display)->get_startup_notification_id (display); |
1185 | } |
1186 | |
1187 | void |
1188 | _gdk_display_pause_events (GdkDisplay *display) |
1189 | { |
1190 | display->event_pause_count++; |
1191 | } |
1192 | |
1193 | void |
1194 | _gdk_display_unpause_events (GdkDisplay *display) |
1195 | { |
1196 | g_return_if_fail (display->event_pause_count > 0); |
1197 | |
1198 | display->event_pause_count--; |
1199 | } |
1200 | |
1201 | GdkSurface * |
1202 | gdk_display_create_surface (GdkDisplay *display, |
1203 | GdkSurfaceType surface_type, |
1204 | GdkSurface *parent, |
1205 | int x, |
1206 | int y, |
1207 | int width, |
1208 | int height) |
1209 | { |
1210 | return GDK_DISPLAY_GET_CLASS (display)->create_surface (display, |
1211 | surface_type, |
1212 | parent, |
1213 | x, y, width, height); |
1214 | } |
1215 | |
1216 | /*< private > |
1217 | * gdk_display_get_keymap: |
1218 | * @display: the `GdkDisplay` |
1219 | * |
1220 | * Returns the `GdkKeymap` attached to @display. |
1221 | * |
1222 | * Returns: (transfer none): the `GdkKeymap` attached to @display. |
1223 | */ |
1224 | GdkKeymap * |
1225 | gdk_display_get_keymap (GdkDisplay *display) |
1226 | { |
1227 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
1228 | |
1229 | return GDK_DISPLAY_GET_CLASS (display)->get_keymap (display); |
1230 | } |
1231 | |
1232 | static void |
1233 | gdk_display_init_gl (GdkDisplay *self) |
1234 | { |
1235 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1236 | GdkGLContext *context; |
1237 | gint64 before G_GNUC_UNUSED; |
1238 | gint64 before2 G_GNUC_UNUSED; |
1239 | |
1240 | before = GDK_PROFILER_CURRENT_TIME; |
1241 | |
1242 | if (GDK_DISPLAY_DEBUG_CHECK (self, GL_DISABLE)) |
1243 | { |
1244 | g_set_error_literal (err: &priv->gl_error, GDK_GL_ERROR, |
1245 | code: GDK_GL_ERROR_NOT_AVAILABLE, |
1246 | _("GL support disabled via GDK_DEBUG" )); |
1247 | return; |
1248 | } |
1249 | |
1250 | context = GDK_DISPLAY_GET_CLASS (self)->init_gl (self, &priv->gl_error); |
1251 | if (context == NULL) |
1252 | return; |
1253 | |
1254 | before2 = GDK_PROFILER_CURRENT_TIME; |
1255 | |
1256 | if (!gdk_gl_context_realize (context, error: &priv->gl_error)) |
1257 | { |
1258 | g_object_unref (object: context); |
1259 | return; |
1260 | } |
1261 | |
1262 | gdk_profiler_end_mark (before2, "realize OpenGL context" , NULL); |
1263 | |
1264 | /* Only assign after realize, so GdkGLContext::realize() can use |
1265 | * gdk_display_get_gl_context() == NULL to differentiate between |
1266 | * the display's context and any other context. |
1267 | */ |
1268 | priv->gl_context = context; |
1269 | |
1270 | gdk_gl_backend_use (GDK_GL_CONTEXT_GET_CLASS (context)->backend_type); |
1271 | |
1272 | gdk_profiler_end_mark (before, "initialize OpenGL" , NULL); |
1273 | } |
1274 | |
1275 | /** |
1276 | * gdk_display_prepare_gl: |
1277 | * @self: a `GdkDisplay` |
1278 | * @error: return location for a `GError` |
1279 | * |
1280 | * Checks that OpenGL is available for @self and ensures that it is |
1281 | * properly initialized. |
1282 | * When this fails, an @error will be set describing the error and this |
1283 | * function returns %FALSE. |
1284 | * |
1285 | * Note that even if this function succeeds, creating a `GdkGLContext` |
1286 | * may still fail. |
1287 | * |
1288 | * This function is idempotent. Calling it multiple times will just |
1289 | * return the same value or error. |
1290 | * |
1291 | * You never need to call this function, GDK will call it automatically |
1292 | * as needed. But you can use it as a check when setting up code that |
1293 | * might make use of OpenGL. |
1294 | * |
1295 | * Returns: %TRUE if the display supports OpenGL |
1296 | * |
1297 | * Since: 4.4 |
1298 | **/ |
1299 | gboolean |
1300 | gdk_display_prepare_gl (GdkDisplay *self, |
1301 | GError **error) |
1302 | { |
1303 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1304 | |
1305 | g_return_val_if_fail (GDK_IS_DISPLAY (self), FALSE); |
1306 | g_return_val_if_fail (error == NULL || *error == NULL, FALSE); |
1307 | |
1308 | for (;;) |
1309 | { |
1310 | if (priv->gl_context) |
1311 | return TRUE; |
1312 | |
1313 | if (priv->gl_error != NULL) |
1314 | { |
1315 | if (error) |
1316 | *error = g_error_copy (error: priv->gl_error); |
1317 | |
1318 | |
1319 | return FALSE; |
1320 | } |
1321 | |
1322 | gdk_display_init_gl (self); |
1323 | |
1324 | /* try again */ |
1325 | } |
1326 | } |
1327 | |
1328 | /** |
1329 | * gdk_display_create_gl_context: |
1330 | * @self: a `GdkDisplay` |
1331 | * @error: return location for an error |
1332 | * |
1333 | * Creates a new `GdkGLContext` for the `GdkDisplay`. |
1334 | * |
1335 | * The context is disconnected from any particular surface or surface |
1336 | * and cannot be used to draw to any surface. It can only be used to |
1337 | * draw to non-surface framebuffers like textures. |
1338 | * |
1339 | * If the creation of the `GdkGLContext` failed, @error will be set. |
1340 | * Before using the returned `GdkGLContext`, you will need to |
1341 | * call [method@Gdk.GLContext.make_current] or [method@Gdk.GLContext.realize]. |
1342 | * |
1343 | * Returns: (transfer full): the newly created `GdkGLContext` |
1344 | * |
1345 | * Since: 4.6 |
1346 | */ |
1347 | GdkGLContext * |
1348 | gdk_display_create_gl_context (GdkDisplay *self, |
1349 | GError **error) |
1350 | { |
1351 | g_return_val_if_fail (GDK_IS_DISPLAY (self), NULL); |
1352 | g_return_val_if_fail (error == NULL || *error == NULL, NULL); |
1353 | |
1354 | if (!gdk_display_prepare_gl (self, error)) |
1355 | return NULL; |
1356 | |
1357 | return gdk_gl_context_new (display: self, NULL); |
1358 | } |
1359 | |
1360 | /*< private > |
1361 | * gdk_display_get_gl_context: |
1362 | * @self: the `GdkDisplay` |
1363 | * |
1364 | * Gets the GL context returned from [vfunc@Gdk.Display.init_gl] |
1365 | * previously. |
1366 | * |
1367 | * If that function has not been called yet or did fail, %NULL is |
1368 | * returned. |
1369 | * Call [method@Gdk.Display.prepare_gl] to avoid this. |
1370 | * |
1371 | * Returns: The `GdkGLContext` |
1372 | */ |
1373 | GdkGLContext * |
1374 | gdk_display_get_gl_context (GdkDisplay *self) |
1375 | { |
1376 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1377 | |
1378 | return priv->gl_context; |
1379 | } |
1380 | |
1381 | #ifdef HAVE_EGL |
1382 | #ifdef G_ENABLE_DEBUG |
1383 | static int |
1384 | strvcmp (gconstpointer p1, |
1385 | gconstpointer p2) |
1386 | { |
1387 | const char * const *s1 = p1; |
1388 | const char * const *s2 = p2; |
1389 | |
1390 | return strcmp (s1: *s1, s2: *s2); |
1391 | } |
1392 | |
1393 | static char * |
1394 | describe_extensions (EGLDisplay egl_display) |
1395 | { |
1396 | const char *extensions; |
1397 | char **exts; |
1398 | char *ext; |
1399 | |
1400 | extensions = eglQueryString (egl_display, EGL_EXTENSIONS); |
1401 | |
1402 | exts = g_strsplit (string: extensions, delimiter: " " , max_tokens: -1); |
1403 | qsort (base: exts, nmemb: g_strv_length (str_array: exts), size: sizeof (char *), compar: strvcmp); |
1404 | |
1405 | ext = g_strjoinv (separator: "\n\t" , str_array: exts); |
1406 | if (ext[0] == '\n') |
1407 | ext[0] = ' '; |
1408 | |
1409 | g_strfreev (str_array: exts); |
1410 | |
1411 | return g_strstrip (ext); |
1412 | } |
1413 | |
1414 | static char * |
1415 | describe_egl_config (EGLDisplay egl_display, |
1416 | EGLConfig egl_config) |
1417 | { |
1418 | EGLint red, green, blue, alpha, type; |
1419 | |
1420 | if (egl_config == NULL) |
1421 | return g_strdup (str: "-" ); |
1422 | |
1423 | if (!eglGetConfigAttrib (egl_display, egl_config, EGL_RED_SIZE, &red) || |
1424 | !eglGetConfigAttrib (egl_display, egl_config, EGL_GREEN_SIZE, &green) || |
1425 | !eglGetConfigAttrib (egl_display, egl_config, EGL_BLUE_SIZE, &blue) || |
1426 | !eglGetConfigAttrib (egl_display, egl_config, EGL_ALPHA_SIZE, &alpha)) |
1427 | return g_strdup (str: "Unknown" ); |
1428 | |
1429 | if (epoxy_has_egl_extension (dpy: egl_display, extension: "EGL_EXT_pixel_format_float" )) |
1430 | { |
1431 | if (!eglGetConfigAttrib (egl_display, egl_config, EGL_COLOR_COMPONENT_TYPE_EXT, &type)) |
1432 | type = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT; |
1433 | } |
1434 | else |
1435 | type = EGL_COLOR_COMPONENT_TYPE_FIXED_EXT; |
1436 | |
1437 | return g_strdup_printf (format: "R%dG%dB%dA%d%s" , red, green, blue, alpha, type == EGL_COLOR_COMPONENT_TYPE_FIXED_EXT ? "" : " float" ); |
1438 | } |
1439 | #endif |
1440 | |
1441 | gpointer |
1442 | gdk_display_get_egl_config (GdkDisplay *self) |
1443 | { |
1444 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1445 | |
1446 | return priv->egl_config; |
1447 | } |
1448 | |
1449 | gpointer |
1450 | gdk_display_get_egl_config_high_depth (GdkDisplay *self) |
1451 | { |
1452 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1453 | |
1454 | return priv->egl_config_high_depth; |
1455 | } |
1456 | |
1457 | static EGLDisplay |
1458 | gdk_display_create_egl_display (EGLenum platform, |
1459 | gpointer native_display) |
1460 | { |
1461 | G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME; |
1462 | EGLDisplay egl_display = NULL; |
1463 | |
1464 | if (epoxy_has_egl_extension (NULL, extension: "EGL_KHR_platform_base" )) |
1465 | { |
1466 | PFNEGLGETPLATFORMDISPLAYPROC getPlatformDisplay = |
1467 | (void *) eglGetProcAddress ("eglGetPlatformDisplay" ); |
1468 | |
1469 | if (getPlatformDisplay != NULL) |
1470 | egl_display = getPlatformDisplay (platform, native_display, NULL); |
1471 | if (egl_display != NULL) |
1472 | goto out; |
1473 | } |
1474 | |
1475 | if (epoxy_has_egl_extension (NULL, extension: "EGL_EXT_platform_base" )) |
1476 | { |
1477 | PFNEGLGETPLATFORMDISPLAYEXTPROC getPlatformDisplay = |
1478 | (void *) eglGetProcAddress ("eglGetPlatformDisplayEXT" ); |
1479 | |
1480 | if (getPlatformDisplay != NULL) |
1481 | egl_display = getPlatformDisplay (platform, native_display, NULL); |
1482 | if (egl_display != NULL) |
1483 | goto out; |
1484 | } |
1485 | |
1486 | egl_display = eglGetDisplay ((EGLNativeDisplayType) native_display); |
1487 | |
1488 | out: |
1489 | gdk_profiler_end_mark (start_time, "Create EGL display" , NULL); |
1490 | |
1491 | return egl_display; |
1492 | } |
1493 | |
1494 | #define MAX_EGL_ATTRS 30 |
1495 | |
1496 | typedef enum { |
1497 | GDK_EGL_CONFIG_PERFECT = (1 << 0), |
1498 | GDK_EGL_CONFIG_HDR = (1 << 1), |
1499 | } GdkEGLConfigCreateFlags; |
1500 | |
1501 | static EGLConfig |
1502 | gdk_display_create_egl_config (GdkDisplay *self, |
1503 | GdkEGLConfigCreateFlags flags, |
1504 | GError **error) |
1505 | { |
1506 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1507 | G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME; |
1508 | EGLint attrs[MAX_EGL_ATTRS]; |
1509 | EGLConfig *configs; |
1510 | EGLint count, alloced; |
1511 | EGLConfig best_config; |
1512 | guint best_score; |
1513 | |
1514 | int i = 0; |
1515 | |
1516 | attrs[i++] = EGL_SURFACE_TYPE; |
1517 | attrs[i++] = EGL_WINDOW_BIT; |
1518 | |
1519 | attrs[i++] = EGL_COLOR_BUFFER_TYPE; |
1520 | attrs[i++] = EGL_RGB_BUFFER; |
1521 | |
1522 | attrs[i++] = EGL_RED_SIZE; |
1523 | attrs[i++] = (flags & GDK_EGL_CONFIG_HDR) ? 9 : 8; |
1524 | attrs[i++] = EGL_GREEN_SIZE; |
1525 | attrs[i++] = (flags & GDK_EGL_CONFIG_HDR) ? 9 : 8; |
1526 | attrs[i++] = EGL_BLUE_SIZE; |
1527 | attrs[i++] = (flags & GDK_EGL_CONFIG_HDR) ? 9 : 8; |
1528 | attrs[i++] = EGL_ALPHA_SIZE; |
1529 | attrs[i++] = 8; |
1530 | |
1531 | if (flags & GDK_EGL_CONFIG_HDR && |
1532 | self->have_egl_pixel_format_float) |
1533 | { |
1534 | attrs[i++] = EGL_COLOR_COMPONENT_TYPE_EXT; |
1535 | attrs[i++] = EGL_DONT_CARE; |
1536 | } |
1537 | |
1538 | attrs[i++] = EGL_NONE; |
1539 | g_assert (i < MAX_EGL_ATTRS); |
1540 | |
1541 | if (!eglChooseConfig (priv->egl_display, attrs, NULL, -1, &alloced) || alloced == 0) |
1542 | { |
1543 | g_set_error_literal (err: error, GDK_GL_ERROR, code: GDK_GL_ERROR_NOT_AVAILABLE, |
1544 | _("No EGL configuration available" )); |
1545 | return NULL; |
1546 | } |
1547 | |
1548 | configs = g_new (EGLConfig, alloced); |
1549 | if (!eglChooseConfig (priv->egl_display, attrs, configs, alloced, &count)) |
1550 | { |
1551 | g_set_error_literal (err: error, GDK_GL_ERROR, code: GDK_GL_ERROR_NOT_AVAILABLE, |
1552 | _("Failed to get EGL configurations" )); |
1553 | return NULL; |
1554 | } |
1555 | g_warn_if_fail (alloced == count); |
1556 | |
1557 | best_score = G_MAXUINT; |
1558 | best_config = NULL; |
1559 | |
1560 | for (i = 0; i < count; i++) |
1561 | { |
1562 | guint score = GDK_DISPLAY_GET_CLASS (self)->rate_egl_config (self, priv->egl_display, configs[i]); |
1563 | |
1564 | if (score < best_score) |
1565 | { |
1566 | best_score = score; |
1567 | best_config = configs[i]; |
1568 | } |
1569 | |
1570 | if (score == 0) |
1571 | break; |
1572 | } |
1573 | |
1574 | g_free (mem: configs); |
1575 | |
1576 | gdk_profiler_end_mark (start_time, "Create EGL config" , NULL); |
1577 | |
1578 | if (best_score == G_MAXUINT) |
1579 | { |
1580 | g_set_error_literal (err: error, GDK_GL_ERROR, |
1581 | code: GDK_GL_ERROR_NOT_AVAILABLE, |
1582 | _("No EGL configuration with required features found" )); |
1583 | return NULL; |
1584 | } |
1585 | else if ((flags & GDK_EGL_CONFIG_PERFECT) && best_score != 0) |
1586 | { |
1587 | g_set_error_literal (err: error, GDK_GL_ERROR, |
1588 | code: GDK_GL_ERROR_NOT_AVAILABLE, |
1589 | _("No perfect EGL configuration found" )); |
1590 | return NULL; |
1591 | } |
1592 | |
1593 | return best_config; |
1594 | } |
1595 | |
1596 | #undef MAX_EGL_ATTRS |
1597 | |
1598 | static gboolean |
1599 | gdk_display_check_egl_extensions (EGLDisplay egl_display, |
1600 | const char **extensions, |
1601 | GError **error) |
1602 | { |
1603 | GString *missing = NULL; |
1604 | gsize i, n_missing; |
1605 | |
1606 | n_missing = 0; |
1607 | |
1608 | for (i = 0; extensions[i] != NULL; i++) |
1609 | { |
1610 | if (!epoxy_has_egl_extension (dpy: egl_display, extension: extensions[i])) |
1611 | { |
1612 | if (missing == NULL) |
1613 | { |
1614 | missing = g_string_new (init: extensions[i]); |
1615 | } |
1616 | else |
1617 | { |
1618 | g_string_append (string: missing, val: ", " ); |
1619 | g_string_append (string: missing, val: extensions[i]); |
1620 | } |
1621 | n_missing++; |
1622 | } |
1623 | } |
1624 | |
1625 | if (n_missing) |
1626 | { |
1627 | g_set_error (err: error, GDK_GL_ERROR, code: GDK_GL_ERROR_UNSUPPORTED_PROFILE, |
1628 | /* translators: Arguments are the number of missing extensions |
1629 | * followed by a comma-separated list of their names */ |
1630 | format: g_dngettext (GETTEXT_PACKAGE, |
1631 | msgid: "EGL implementation is missing extension %s" , |
1632 | msgid_plural: "EGL implementation is missing %2$d extensions: %1$s" , |
1633 | n: n_missing), |
1634 | missing->str, (int) n_missing); |
1635 | |
1636 | g_string_free (string: missing, TRUE); |
1637 | return FALSE; |
1638 | } |
1639 | |
1640 | return TRUE; |
1641 | } |
1642 | |
1643 | gboolean |
1644 | gdk_display_init_egl (GdkDisplay *self, |
1645 | int platform, |
1646 | gpointer native_display, |
1647 | gboolean allow_any, |
1648 | GError **error) |
1649 | { |
1650 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1651 | G_GNUC_UNUSED gint64 start_time = GDK_PROFILER_CURRENT_TIME; |
1652 | G_GNUC_UNUSED gint64 start_time2; |
1653 | int major, minor; |
1654 | |
1655 | if (!gdk_gl_backend_can_be_used (backend_type: GDK_GL_EGL, error)) |
1656 | return FALSE; |
1657 | |
1658 | if (!epoxy_has_egl ()) |
1659 | { |
1660 | gboolean sandboxed = gdk_running_in_sandbox (); |
1661 | |
1662 | g_set_error_literal (err: error, GDK_GL_ERROR, |
1663 | code: GDK_GL_ERROR_NOT_AVAILABLE, |
1664 | message: sandboxed ? _("libEGL not available in this sandbox" ) |
1665 | : _("libEGL not available" )); |
1666 | return FALSE; |
1667 | } |
1668 | |
1669 | priv->egl_display = gdk_display_create_egl_display (platform, native_display); |
1670 | |
1671 | if (priv->egl_display == NULL) |
1672 | { |
1673 | g_set_error_literal (err: error, GDK_GL_ERROR, |
1674 | code: GDK_GL_ERROR_NOT_AVAILABLE, |
1675 | _("Failed to create EGL display" )); |
1676 | return FALSE; |
1677 | } |
1678 | |
1679 | start_time2 = GDK_PROFILER_CURRENT_TIME; |
1680 | if (!eglInitialize (priv->egl_display, &major, &minor)) |
1681 | { |
1682 | priv->egl_display = NULL; |
1683 | g_set_error_literal (err: error, GDK_GL_ERROR, |
1684 | code: GDK_GL_ERROR_NOT_AVAILABLE, |
1685 | _("Could not initialize EGL display" )); |
1686 | return FALSE; |
1687 | } |
1688 | gdk_profiler_end_mark (start_time2, "eglInitialize" , NULL); |
1689 | |
1690 | if (major < GDK_EGL_MIN_VERSION_MAJOR || |
1691 | (major == GDK_EGL_MIN_VERSION_MAJOR && minor < GDK_EGL_MIN_VERSION_MINOR)) |
1692 | { |
1693 | g_clear_pointer (&priv->egl_display, eglTerminate); |
1694 | g_set_error (err: error, GDK_GL_ERROR, |
1695 | code: GDK_GL_ERROR_NOT_AVAILABLE, |
1696 | _("EGL version %d.%d is too old. GTK requires %d.%d" ), |
1697 | major, minor, GDK_EGL_MIN_VERSION_MAJOR, GDK_EGL_MIN_VERSION_MINOR); |
1698 | return FALSE; |
1699 | } |
1700 | |
1701 | if (!gdk_display_check_egl_extensions (egl_display: priv->egl_display, |
1702 | extensions: (const char *[]) { |
1703 | "EGL_KHR_create_context" , |
1704 | "EGL_KHR_surfaceless_context" , |
1705 | NULL |
1706 | }, |
1707 | error)) |
1708 | { |
1709 | g_clear_pointer (&priv->egl_display, eglTerminate); |
1710 | return FALSE; |
1711 | } |
1712 | |
1713 | priv->egl_config = gdk_display_create_egl_config (self, |
1714 | flags: allow_any ? 0 : GDK_EGL_CONFIG_PERFECT, |
1715 | error); |
1716 | if (priv->egl_config == NULL) |
1717 | { |
1718 | g_clear_pointer (&priv->egl_display, eglTerminate); |
1719 | return FALSE; |
1720 | } |
1721 | |
1722 | self->have_egl_buffer_age = |
1723 | epoxy_has_egl_extension (dpy: priv->egl_display, extension: "EGL_EXT_buffer_age" ); |
1724 | self->have_egl_no_config_context = |
1725 | epoxy_has_egl_extension (dpy: priv->egl_display, extension: "EGL_KHR_no_config_context" ); |
1726 | self->have_egl_pixel_format_float = |
1727 | epoxy_has_egl_extension (dpy: priv->egl_display, extension: "EGL_EXT_pixel_format_float" ); |
1728 | self->have_egl_win32_libangle = |
1729 | epoxy_has_egl_extension (dpy: priv->egl_display, extension: "EGL_ANGLE_d3d_share_handle_client_buffer" ); |
1730 | |
1731 | if (self->have_egl_no_config_context) |
1732 | priv->egl_config_high_depth = gdk_display_create_egl_config (self, |
1733 | flags: GDK_EGL_CONFIG_HDR, |
1734 | error); |
1735 | if (priv->egl_config_high_depth == NULL) |
1736 | priv->egl_config_high_depth = priv->egl_config; |
1737 | |
1738 | GDK_DISPLAY_NOTE (self, OPENGL, { |
1739 | char *ext = describe_extensions (priv->egl_display); |
1740 | char *std_cfg = describe_egl_config (priv->egl_display, priv->egl_config); |
1741 | char *hd_cfg = describe_egl_config (priv->egl_display, priv->egl_config_high_depth); |
1742 | g_message ("EGL API version %d.%d found\n" |
1743 | " - Vendor: %s\n" |
1744 | " - Version: %s\n" |
1745 | " - Client APIs: %s\n" |
1746 | " - Extensions:\n" |
1747 | "\t%s\n" |
1748 | " - Selected fbconfig: %s\n" |
1749 | " high depth: %s" , |
1750 | major, minor, |
1751 | eglQueryString (priv->egl_display, EGL_VENDOR), |
1752 | eglQueryString (priv->egl_display, EGL_VERSION), |
1753 | eglQueryString (priv->egl_display, EGL_CLIENT_APIS), |
1754 | ext, std_cfg, |
1755 | priv->egl_config_high_depth == priv->egl_config ? "none" : hd_cfg); |
1756 | g_free (hd_cfg); |
1757 | g_free (std_cfg); |
1758 | g_free (ext); |
1759 | }); |
1760 | |
1761 | gdk_profiler_end_mark (start_time, "init EGL" , NULL); |
1762 | |
1763 | return TRUE; |
1764 | } |
1765 | #endif |
1766 | |
1767 | /*<private> |
1768 | * gdk_display_get_egl_display: |
1769 | * @self: a display |
1770 | * |
1771 | * Retrieves the EGL display connection object for the given GDK display. |
1772 | * |
1773 | * This function returns `NULL` if GL is not supported or GDK is using |
1774 | * a different OpenGL framework than EGL. |
1775 | * |
1776 | * Returns: (nullable): the EGL display object |
1777 | */ |
1778 | gpointer |
1779 | gdk_display_get_egl_display (GdkDisplay *self) |
1780 | { |
1781 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self); |
1782 | |
1783 | g_return_val_if_fail (GDK_IS_DISPLAY (self), NULL); |
1784 | |
1785 | #ifdef HAVE_EGL |
1786 | if (!priv->egl_display && |
1787 | !gdk_display_prepare_gl (self, NULL)) |
1788 | return NULL; |
1789 | |
1790 | return priv->egl_display; |
1791 | #else |
1792 | return NULL; |
1793 | #endif |
1794 | } |
1795 | |
1796 | GdkDebugFlags |
1797 | gdk_display_get_debug_flags (GdkDisplay *display) |
1798 | { |
1799 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1800 | |
1801 | return display ? priv->debug_flags : _gdk_debug_flags; |
1802 | } |
1803 | |
1804 | void |
1805 | gdk_display_set_debug_flags (GdkDisplay *display, |
1806 | GdkDebugFlags flags) |
1807 | { |
1808 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1809 | |
1810 | priv->debug_flags = flags; |
1811 | } |
1812 | |
1813 | /** |
1814 | * gdk_display_is_composited: (attributes org.gtk.Method.get_property=composited) |
1815 | * @display: a `GdkDisplay` |
1816 | * |
1817 | * Returns whether surfaces can reasonably be expected to have |
1818 | * their alpha channel drawn correctly on the screen. |
1819 | * |
1820 | * Check [method@Gdk.Display.is_rgba] for whether the display |
1821 | * supports an alpha channel. |
1822 | * |
1823 | * On X11 this function returns whether a compositing manager is |
1824 | * compositing on @display. |
1825 | * |
1826 | * On modern displays, this value is always %TRUE. |
1827 | * |
1828 | * Returns: Whether surfaces with RGBA visuals can reasonably |
1829 | * be expected to have their alpha channels drawn correctly |
1830 | * on the screen. |
1831 | */ |
1832 | gboolean |
1833 | gdk_display_is_composited (GdkDisplay *display) |
1834 | { |
1835 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1836 | |
1837 | g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); |
1838 | |
1839 | return priv->composited; |
1840 | } |
1841 | |
1842 | void |
1843 | gdk_display_set_composited (GdkDisplay *display, |
1844 | gboolean composited) |
1845 | { |
1846 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1847 | |
1848 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
1849 | |
1850 | if (priv->composited == composited) |
1851 | return; |
1852 | |
1853 | priv->composited = composited; |
1854 | |
1855 | g_object_notify_by_pspec (G_OBJECT (display), pspec: props[PROP_COMPOSITED]); |
1856 | } |
1857 | |
1858 | /** |
1859 | * gdk_display_is_rgba: (attributes org.gtk.Method.get_property=rgba) |
1860 | * @display: a `GdkDisplay` |
1861 | * |
1862 | * Returns whether surfaces on this @display are created with an |
1863 | * alpha channel. |
1864 | * |
1865 | * Even if a %TRUE is returned, it is possible that the |
1866 | * surface’s alpha channel won’t be honored when displaying the |
1867 | * surface on the screen: in particular, for X an appropriate |
1868 | * windowing manager and compositing manager must be running to |
1869 | * provide appropriate display. Use [method@Gdk.Display.is_composited] |
1870 | * to check if that is the case. |
1871 | * |
1872 | * On modern displays, this value is always %TRUE. |
1873 | * |
1874 | * Returns: %TRUE if surfaces are created with an alpha channel or |
1875 | * %FALSE if the display does not support this functionality. |
1876 | */ |
1877 | gboolean |
1878 | gdk_display_is_rgba (GdkDisplay *display) |
1879 | { |
1880 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1881 | |
1882 | g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); |
1883 | |
1884 | return priv->rgba; |
1885 | } |
1886 | |
1887 | void |
1888 | gdk_display_set_rgba (GdkDisplay *display, |
1889 | gboolean rgba) |
1890 | { |
1891 | GdkDisplayPrivate *priv = gdk_display_get_instance_private (self: display); |
1892 | |
1893 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
1894 | |
1895 | if (priv->rgba == rgba) |
1896 | return; |
1897 | |
1898 | priv->rgba = rgba; |
1899 | |
1900 | g_object_notify_by_pspec (G_OBJECT (display), pspec: props[PROP_RGBA]); |
1901 | } |
1902 | |
1903 | static void |
1904 | device_removed_cb (GdkSeat *seat, |
1905 | GdkDevice *device, |
1906 | GdkDisplay *display) |
1907 | { |
1908 | g_hash_table_remove (hash_table: display->device_grabs, key: device); |
1909 | g_hash_table_remove (hash_table: display->pointers_info, key: device); |
1910 | |
1911 | /* FIXME: change core pointer and remove from device list */ |
1912 | } |
1913 | |
1914 | void |
1915 | gdk_display_add_seat (GdkDisplay *display, |
1916 | GdkSeat *seat) |
1917 | { |
1918 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
1919 | g_return_if_fail (GDK_IS_SEAT (seat)); |
1920 | |
1921 | display->seats = g_list_append (list: display->seats, g_object_ref (seat)); |
1922 | g_signal_emit (instance: display, signal_id: signals[SEAT_ADDED], detail: 0, seat); |
1923 | |
1924 | g_signal_connect (seat, "device-removed" , G_CALLBACK (device_removed_cb), display); |
1925 | } |
1926 | |
1927 | void |
1928 | gdk_display_remove_seat (GdkDisplay *display, |
1929 | GdkSeat *seat) |
1930 | { |
1931 | GList *link; |
1932 | |
1933 | g_return_if_fail (GDK_IS_DISPLAY (display)); |
1934 | g_return_if_fail (GDK_IS_SEAT (seat)); |
1935 | |
1936 | g_signal_handlers_disconnect_by_func (seat, G_CALLBACK (device_removed_cb), display); |
1937 | |
1938 | link = g_list_find (list: display->seats, data: seat); |
1939 | |
1940 | if (link) |
1941 | { |
1942 | display->seats = g_list_remove_link (list: display->seats, llink: link); |
1943 | g_signal_emit (instance: display, signal_id: signals[SEAT_REMOVED], detail: 0, seat); |
1944 | g_object_unref (object: link->data); |
1945 | g_list_free (list: link); |
1946 | } |
1947 | } |
1948 | |
1949 | /** |
1950 | * gdk_display_get_default_seat: |
1951 | * @display: a `GdkDisplay` |
1952 | * |
1953 | * Returns the default `GdkSeat` for this display. |
1954 | * |
1955 | * Note that a display may not have a seat. In this case, |
1956 | * this function will return %NULL. |
1957 | * |
1958 | * Returns: (transfer none) (nullable): the default seat. |
1959 | **/ |
1960 | GdkSeat * |
1961 | gdk_display_get_default_seat (GdkDisplay *display) |
1962 | { |
1963 | GdkDisplayClass *display_class; |
1964 | |
1965 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
1966 | |
1967 | display_class = GDK_DISPLAY_GET_CLASS (display); |
1968 | |
1969 | return display_class->get_default_seat (display); |
1970 | } |
1971 | |
1972 | /** |
1973 | * gdk_display_list_seats: |
1974 | * @display: a `GdkDisplay` |
1975 | * |
1976 | * Returns the list of seats known to @display. |
1977 | * |
1978 | * Returns: (transfer container) (element-type GdkSeat): the |
1979 | * list of seats known to the `GdkDisplay` |
1980 | */ |
1981 | GList * |
1982 | gdk_display_list_seats (GdkDisplay *display) |
1983 | { |
1984 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
1985 | |
1986 | return g_list_copy (list: display->seats); |
1987 | } |
1988 | |
1989 | /** |
1990 | * gdk_display_get_monitors: |
1991 | * @self: a `GdkDisplay` |
1992 | * |
1993 | * Gets the list of monitors associated with this display. |
1994 | * |
1995 | * Subsequent calls to this function will always return the |
1996 | * same list for the same display. |
1997 | * |
1998 | * You can listen to the GListModel::items-changed signal on |
1999 | * this list to monitor changes to the monitor of this display. |
2000 | * |
2001 | * Returns: (transfer none): a `GListModel` of `GdkMonitor` |
2002 | */ |
2003 | GListModel * |
2004 | gdk_display_get_monitors (GdkDisplay *self) |
2005 | { |
2006 | g_return_val_if_fail (GDK_IS_DISPLAY (self), NULL); |
2007 | |
2008 | return GDK_DISPLAY_GET_CLASS (self)->get_monitors (self); |
2009 | } |
2010 | |
2011 | /** |
2012 | * gdk_display_get_monitor_at_surface: |
2013 | * @display: a `GdkDisplay` |
2014 | * @surface: a `GdkSurface` |
2015 | * |
2016 | * Gets the monitor in which the largest area of @surface |
2017 | * resides. |
2018 | * |
2019 | * Returns a monitor close to @surface if it is outside |
2020 | * of all monitors. |
2021 | * |
2022 | * Returns: (transfer none): the monitor with the largest |
2023 | * overlap with @surface |
2024 | */ |
2025 | GdkMonitor * |
2026 | gdk_display_get_monitor_at_surface (GdkDisplay *display, |
2027 | GdkSurface *surface) |
2028 | { |
2029 | GdkRectangle win; |
2030 | GListModel *monitors; |
2031 | guint i; |
2032 | int area = 0; |
2033 | GdkMonitor *best = NULL; |
2034 | GdkDisplayClass *class; |
2035 | |
2036 | g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); |
2037 | |
2038 | class = GDK_DISPLAY_GET_CLASS (display); |
2039 | if (class->get_monitor_at_surface) |
2040 | { |
2041 | best = class->get_monitor_at_surface (display, surface); |
2042 | |
2043 | if (best) |
2044 | return best; |
2045 | } |
2046 | |
2047 | /* the fallback implementation requires global coordinates */ |
2048 | gdk_surface_get_geometry (surface, x: &win.x, y: &win.y, width: &win.width, height: &win.height); |
2049 | gdk_surface_get_origin (surface, x: &win.x, y: &win.y); |
2050 | |
2051 | monitors = gdk_display_get_monitors (self: display); |
2052 | for (i = 0; i < g_list_model_get_n_items (list: monitors); i++) |
2053 | { |
2054 | GdkMonitor *monitor; |
2055 | GdkRectangle mon, intersect; |
2056 | int overlap; |
2057 | |
2058 | monitor = g_list_model_get_item (list: monitors, position: i); |
2059 | gdk_monitor_get_geometry (monitor, geometry: &mon); |
2060 | gdk_rectangle_intersect (src1: &win, src2: &mon, dest: &intersect); |
2061 | overlap = intersect.width *intersect.height; |
2062 | if (overlap > area) |
2063 | { |
2064 | area = overlap; |
2065 | best = monitor; |
2066 | } |
2067 | g_object_unref (object: monitor); |
2068 | } |
2069 | |
2070 | return best; |
2071 | } |
2072 | |
2073 | void |
2074 | gdk_display_emit_opened (GdkDisplay *display) |
2075 | { |
2076 | g_signal_emit (instance: display, signal_id: signals[OPENED], detail: 0); |
2077 | } |
2078 | |
2079 | /** |
2080 | * gdk_display_get_setting: |
2081 | * @display: a `GdkDisplay` |
2082 | * @name: the name of the setting |
2083 | * @value: location to store the value of the setting |
2084 | * |
2085 | * Retrieves a desktop-wide setting such as double-click time |
2086 | * for the @display. |
2087 | * |
2088 | * Returns: %TRUE if the setting existed and a value was stored |
2089 | * in @value, %FALSE otherwise |
2090 | */ |
2091 | gboolean |
2092 | gdk_display_get_setting (GdkDisplay *display, |
2093 | const char *name, |
2094 | GValue *value) |
2095 | { |
2096 | g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE); |
2097 | g_return_val_if_fail (name != NULL, FALSE); |
2098 | g_return_val_if_fail (value != NULL, FALSE); |
2099 | |
2100 | return GDK_DISPLAY_GET_CLASS (display)->get_setting (display, name, value); |
2101 | } |
2102 | |
2103 | void |
2104 | gdk_display_setting_changed (GdkDisplay *display, |
2105 | const char *name) |
2106 | { |
2107 | g_signal_emit (instance: display, signal_id: signals[SETTING_CHANGED], detail: 0, name); |
2108 | } |
2109 | |
2110 | void |
2111 | gdk_display_set_double_click_time (GdkDisplay *display, |
2112 | guint msec) |
2113 | { |
2114 | display->double_click_time = msec; |
2115 | } |
2116 | |
2117 | void |
2118 | gdk_display_set_double_click_distance (GdkDisplay *display, |
2119 | guint distance) |
2120 | { |
2121 | display->double_click_distance = distance; |
2122 | } |
2123 | |
2124 | void |
2125 | gdk_display_set_cursor_theme (GdkDisplay *display, |
2126 | const char *name, |
2127 | int size) |
2128 | { |
2129 | if (GDK_DISPLAY_GET_CLASS (display)->set_cursor_theme) |
2130 | GDK_DISPLAY_GET_CLASS (display)->set_cursor_theme (display, name, size); |
2131 | } |
2132 | |
2133 | /** |
2134 | * gdk_display_map_keyval: |
2135 | * @display: a `GdkDisplay` |
2136 | * @keyval: a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc. |
2137 | * @keys: (out) (array length=n_keys) (transfer full): return location |
2138 | * for an array of `GdkKeymapKey` |
2139 | * @n_keys: return location for number of elements in returned array |
2140 | * |
2141 | * Obtains a list of keycode/group/level combinations that will |
2142 | * generate @keyval. |
2143 | * |
2144 | * Groups and levels are two kinds of keyboard mode; in general, the level |
2145 | * determines whether the top or bottom symbol on a key is used, and the |
2146 | * group determines whether the left or right symbol is used. |
2147 | * |
2148 | * On US keyboards, the shift key changes the keyboard level, and there |
2149 | * are no groups. A group switch key might convert a keyboard between |
2150 | * Hebrew to English modes, for example. |
2151 | * |
2152 | * `GdkEventKey` contains a %group field that indicates the active |
2153 | * keyboard group. The level is computed from the modifier mask. |
2154 | * |
2155 | * The returned array should be freed with g_free(). |
2156 | * |
2157 | * Returns: %TRUE if keys were found and returned |
2158 | */ |
2159 | gboolean |
2160 | gdk_display_map_keyval (GdkDisplay *display, |
2161 | guint keyval, |
2162 | GdkKeymapKey **keys, |
2163 | int *n_keys) |
2164 | { |
2165 | return gdk_keymap_get_entries_for_keyval (keymap: gdk_display_get_keymap (display), |
2166 | keyval, |
2167 | keys, |
2168 | n_keys); |
2169 | } |
2170 | |
2171 | /** |
2172 | * gdk_display_map_keycode: |
2173 | * @display: a `GdkDisplay` |
2174 | * @keycode: a keycode |
2175 | * @keys: (out) (array length=n_entries) (transfer full) (optional): return |
2176 | * location for array of `GdkKeymapKey` |
2177 | * @keyvals: (out) (array length=n_entries) (transfer full) (optional): return |
2178 | * location for array of keyvals |
2179 | * @n_entries: length of @keys and @keyvals |
2180 | * |
2181 | * Returns the keyvals bound to @keycode. |
2182 | * |
2183 | * The Nth `GdkKeymapKey` in @keys is bound to the Nth keyval in @keyvals. |
2184 | * |
2185 | * When a keycode is pressed by the user, the keyval from |
2186 | * this list of entries is selected by considering the effective |
2187 | * keyboard group and level. |
2188 | * |
2189 | * Free the returned arrays with g_free(). |
2190 | * |
2191 | * Returns: %TRUE if there were any entries |
2192 | */ |
2193 | gboolean |
2194 | gdk_display_map_keycode (GdkDisplay *display, |
2195 | guint keycode, |
2196 | GdkKeymapKey **keys, |
2197 | guint **keyvals, |
2198 | int *n_entries) |
2199 | { |
2200 | return gdk_keymap_get_entries_for_keycode (keymap: gdk_display_get_keymap (display), |
2201 | hardware_keycode: keycode, |
2202 | keys, |
2203 | keyvals, |
2204 | n_entries); |
2205 | } |
2206 | |
2207 | /** |
2208 | * gdk_display_translate_key: |
2209 | * @display: a `GdkDisplay` |
2210 | * @keycode: a keycode |
2211 | * @state: a modifier state |
2212 | * @group: active keyboard group |
2213 | * @keyval: (out) (optional): return location for keyval |
2214 | * @effective_group: (out) (optional): return location for effective group |
2215 | * @level: (out) (optional): return location for level |
2216 | * @consumed: (out) (optional): return location for modifiers that were used |
2217 | * to determine the group or level |
2218 | * |
2219 | * Translates the contents of a `GdkEventKey` into a keyval, effective group, |
2220 | * and level. |
2221 | * |
2222 | * Modifiers that affected the translation and are thus unavailable for |
2223 | * application use are returned in @consumed_modifiers. |
2224 | * |
2225 | * The @effective_group is the group that was actually used for the |
2226 | * translation; some keys such as Enter are not affected by the active |
2227 | * keyboard group. The @level is derived from @state. |
2228 | * |
2229 | * @consumed_modifiers gives modifiers that should be masked out |
2230 | * from @state when comparing this key press to a keyboard shortcut. |
2231 | * For instance, on a US keyboard, the `plus` symbol is shifted, so |
2232 | * when comparing a key press to a `<Control>plus` accelerator `<Shift>` |
2233 | * should be masked out. |
2234 | * |
2235 | * This function should rarely be needed, since `GdkEventKey` already |
2236 | * contains the translated keyval. It is exported for the benefit of |
2237 | * virtualized test environments. |
2238 | * |
2239 | * Returns: %TRUE if there was a keyval bound to keycode/state/group. |
2240 | */ |
2241 | gboolean |
2242 | gdk_display_translate_key (GdkDisplay *display, |
2243 | guint keycode, |
2244 | GdkModifierType state, |
2245 | int group, |
2246 | guint *keyval, |
2247 | int *effective_group, |
2248 | int *level, |
2249 | GdkModifierType *consumed) |
2250 | { |
2251 | return gdk_keymap_translate_keyboard_state (keymap: gdk_display_get_keymap (display), |
2252 | hardware_keycode: keycode, state, group, |
2253 | keyval, |
2254 | effective_group, |
2255 | level, |
2256 | consumed_modifiers: consumed); |
2257 | } |
2258 | |