1 | /* GDK - The GIMP Drawing Kit |
2 | * Copyright (C) 2000 Red Hat, Inc. |
3 | * |
4 | * This library is free software; you can redistribute it and/or |
5 | * modify it under the terms of the GNU Lesser General Public |
6 | * License as published by the Free Software Foundation; either |
7 | * version 2 of the License, or (at your option) any later version. |
8 | * |
9 | * This library is distributed in the hope that it will be useful, |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
12 | * Lesser General Public License for more details. |
13 | * |
14 | * You should have received a copy of the GNU Lesser General Public |
15 | * License along with this library. If not, see <http://www.gnu.org/licenses/>. |
16 | */ |
17 | |
18 | /* |
19 | * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS |
20 | * file for a list of people on the GTK+ Team. See the ChangeLog |
21 | * files for a list of changes. These files are distributed with |
22 | * GTK+ at ftp://ftp.gtk.org/pub/gtk/. |
23 | */ |
24 | |
25 | #include "config.h" |
26 | |
27 | #include "gdkconfig.h" |
28 | #include "gdkdisplaymanagerprivate.h" |
29 | #include "gdkdisplayprivate.h" |
30 | #include "gdkkeysprivate.h" |
31 | #include "gdkintl.h" |
32 | |
33 | #ifdef GDK_WINDOWING_X11 |
34 | #include "x11/gdkx.h" |
35 | #include "x11/gdkprivate-x11.h" |
36 | #endif |
37 | |
38 | #ifdef GDK_WINDOWING_BROADWAY |
39 | #include "broadway/gdkprivate-broadway.h" |
40 | #endif |
41 | |
42 | #ifdef GDK_WINDOWING_MACOS |
43 | #include "macos/gdkmacosdisplay-private.h" |
44 | #endif |
45 | |
46 | #ifdef GDK_WINDOWING_WIN32 |
47 | #include "win32/gdkwin32.h" |
48 | #include "win32/gdkprivate-win32.h" |
49 | #endif |
50 | |
51 | #ifdef GDK_WINDOWING_WAYLAND |
52 | #include "wayland/gdkprivate-wayland.h" |
53 | #endif |
54 | |
55 | /** |
56 | * GdkDisplayManager: |
57 | * |
58 | * A singleton object that offers notification when displays appear or |
59 | * disappear. |
60 | * |
61 | * You can use [func@Gdk.DisplayManager.get] to obtain the `GdkDisplayManager` |
62 | * singleton, but that should be rarely necessary. Typically, initializing |
63 | * GTK opens a display that you can work with without ever accessing the |
64 | * `GdkDisplayManager`. |
65 | * |
66 | * The GDK library can be built with support for multiple backends. |
67 | * The `GdkDisplayManager` object determines which backend is used |
68 | * at runtime. |
69 | * |
70 | * In the rare case that you need to influence which of the backends |
71 | * is being used, you can use [func@Gdk.set_allowed_backends]. Note |
72 | * that you need to call this function before initializing GTK. |
73 | * |
74 | * ## Backend-specific code |
75 | * |
76 | * When writing backend-specific code that is supposed to work with |
77 | * multiple GDK backends, you have to consider both compile time and |
78 | * runtime. At compile time, use the `GDK_WINDOWING_X11`, `GDK_WINDOWING_WIN32` |
79 | * macros, etc. to find out which backends are present in the GDK library |
80 | * you are building your application against. At runtime, use type-check |
81 | * macros like GDK_IS_X11_DISPLAY() to find out which backend is in use: |
82 | * |
83 | * ```c |
84 | * #ifdef GDK_WINDOWING_X11 |
85 | * if (GDK_IS_X11_DISPLAY (display)) |
86 | * { |
87 | * // make X11-specific calls here |
88 | * } |
89 | * else |
90 | * #endif |
91 | * #ifdef GDK_WINDOWING_MACOS |
92 | * if (GDK_IS_MACOS_DISPLAY (display)) |
93 | * { |
94 | * // make Quartz-specific calls here |
95 | * } |
96 | * else |
97 | * #endif |
98 | * g_error ("Unsupported GDK backend"); |
99 | * ``` |
100 | */ |
101 | |
102 | enum { |
103 | PROP_0, |
104 | PROP_DEFAULT_DISPLAY |
105 | }; |
106 | |
107 | enum { |
108 | DISPLAY_OPENED, |
109 | LAST_SIGNAL |
110 | }; |
111 | |
112 | static void gdk_display_manager_set_property (GObject *object, |
113 | guint prop_id, |
114 | const GValue *value, |
115 | GParamSpec *pspec); |
116 | static void gdk_display_manager_get_property (GObject *object, |
117 | guint prop_id, |
118 | GValue *value, |
119 | GParamSpec *pspec); |
120 | |
121 | static guint signals[LAST_SIGNAL] = { 0 }; |
122 | |
123 | G_DEFINE_TYPE (GdkDisplayManager, gdk_display_manager, G_TYPE_OBJECT) |
124 | |
125 | static void |
126 | gdk_display_manager_class_init (GdkDisplayManagerClass *klass) |
127 | { |
128 | GObjectClass *object_class = G_OBJECT_CLASS (klass); |
129 | |
130 | object_class->set_property = gdk_display_manager_set_property; |
131 | object_class->get_property = gdk_display_manager_get_property; |
132 | |
133 | /** |
134 | * GdkDisplayManager::display-opened: |
135 | * @manager: the object on which the signal is emitted |
136 | * @display: the opened display |
137 | * |
138 | * Emitted when a display is opened. |
139 | */ |
140 | signals[DISPLAY_OPENED] = |
141 | g_signal_new (signal_name: g_intern_static_string (string: "display-opened" ), |
142 | G_OBJECT_CLASS_TYPE (object_class), |
143 | signal_flags: G_SIGNAL_RUN_LAST, |
144 | G_STRUCT_OFFSET (GdkDisplayManagerClass, display_opened), |
145 | NULL, NULL, |
146 | NULL, |
147 | G_TYPE_NONE, |
148 | n_params: 1, |
149 | GDK_TYPE_DISPLAY); |
150 | |
151 | /** |
152 | * GdkDisplayManager:default-display: (attributes org.gtk.Property.get=gdk_display_manager_get_default_display) |
153 | * |
154 | * The default display. |
155 | */ |
156 | g_object_class_install_property (oclass: object_class, |
157 | property_id: PROP_DEFAULT_DISPLAY, |
158 | pspec: g_param_spec_object (name: "default-display" , |
159 | P_("Default Display" ), |
160 | P_("The default display for GDK" ), |
161 | GDK_TYPE_DISPLAY, |
162 | flags: G_PARAM_READWRITE|G_PARAM_STATIC_STRINGS)); |
163 | } |
164 | |
165 | static void |
166 | gdk_display_manager_init (GdkDisplayManager *manager) |
167 | { |
168 | } |
169 | |
170 | static void |
171 | gdk_display_manager_set_property (GObject *object, |
172 | guint prop_id, |
173 | const GValue *value, |
174 | GParamSpec *pspec) |
175 | { |
176 | switch (prop_id) |
177 | { |
178 | case PROP_DEFAULT_DISPLAY: |
179 | gdk_display_manager_set_default_display (GDK_DISPLAY_MANAGER (object), |
180 | display: g_value_get_object (value)); |
181 | break; |
182 | default: |
183 | G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
184 | break; |
185 | } |
186 | } |
187 | |
188 | static void |
189 | gdk_display_manager_get_property (GObject *object, |
190 | guint prop_id, |
191 | GValue *value, |
192 | GParamSpec *pspec) |
193 | { |
194 | switch (prop_id) |
195 | { |
196 | case PROP_DEFAULT_DISPLAY: |
197 | g_value_set_object (value, |
198 | v_object: gdk_display_manager_get_default_display (GDK_DISPLAY_MANAGER (object))); |
199 | break; |
200 | default: |
201 | G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); |
202 | break; |
203 | } |
204 | } |
205 | |
206 | static const char *allowed_backends; |
207 | |
208 | /** |
209 | * gdk_set_allowed_backends: |
210 | * @backends: a comma-separated list of backends |
211 | * |
212 | * Sets a list of backends that GDK should try to use. |
213 | * |
214 | * This can be useful if your application does not |
215 | * work with certain GDK backends. |
216 | * |
217 | * By default, GDK tries all included backends. |
218 | * |
219 | * For example: |
220 | * |
221 | * ```c |
222 | * gdk_set_allowed_backends ("wayland,macos,*"); |
223 | * ``` |
224 | * |
225 | * instructs GDK to try the Wayland backend first, followed by the |
226 | * MacOs backend, and then all others. |
227 | * |
228 | * If the `GDK_BACKEND` environment variable is set, it determines |
229 | * what backends are tried in what order, while still respecting the |
230 | * set of allowed backends that are specified by this function. |
231 | * |
232 | * The possible backend names are: |
233 | * |
234 | * - `broadway` |
235 | * - `macos` |
236 | * - `wayland`. |
237 | * - `win32` |
238 | * - `x11` |
239 | * |
240 | * You can also include a `*` in the list to try all remaining backends. |
241 | * |
242 | * This call must happen prior to functions that open a display, such |
243 | * as [func@Gdk.Display.open], `gtk_init()`, or `gtk_init_check()` |
244 | * in order to take effect. |
245 | */ |
246 | void |
247 | gdk_set_allowed_backends (const char *backends) |
248 | { |
249 | allowed_backends = g_strdup (str: backends); |
250 | } |
251 | |
252 | typedef struct _GdkBackend GdkBackend; |
253 | |
254 | struct _GdkBackend { |
255 | const char *name; |
256 | GdkDisplay * (* open_display) (const char *name); |
257 | }; |
258 | |
259 | static GdkBackend gdk_backends[] = { |
260 | #ifdef GDK_WINDOWING_MACOS |
261 | { "macos" , _gdk_macos_display_open }, |
262 | #endif |
263 | #ifdef GDK_WINDOWING_WIN32 |
264 | { "win32" , _gdk_win32_display_open }, |
265 | #endif |
266 | #ifdef GDK_WINDOWING_WAYLAND |
267 | { "wayland" , _gdk_wayland_display_open }, |
268 | #endif |
269 | #ifdef GDK_WINDOWING_X11 |
270 | { "x11" , gdk_x11_display_open }, |
271 | #endif |
272 | #ifdef GDK_WINDOWING_BROADWAY |
273 | { "broadway" , _gdk_broadway_display_open }, |
274 | #endif |
275 | /* NULL-terminating this array so we can use commas above */ |
276 | { NULL, NULL } |
277 | }; |
278 | |
279 | /** |
280 | * gdk_display_manager_get: |
281 | * |
282 | * Gets the singleton `GdkDisplayManager` object. |
283 | * |
284 | * When called for the first time, this function consults the |
285 | * `GDK_BACKEND` environment variable to find out which of the |
286 | * supported GDK backends to use (in case GDK has been compiled |
287 | * with multiple backends). |
288 | * |
289 | * Applications can use [func@set_allowed_backends] to limit what |
290 | * backends wil be used. |
291 | * |
292 | * Returns: (transfer none): The global `GdkDisplayManager` singleton |
293 | */ |
294 | GdkDisplayManager* |
295 | gdk_display_manager_get (void) |
296 | { |
297 | static GdkDisplayManager *manager = NULL; |
298 | |
299 | if (manager == NULL) |
300 | manager = g_object_new (GDK_TYPE_DISPLAY_MANAGER, NULL); |
301 | |
302 | return manager; |
303 | } |
304 | |
305 | /** |
306 | * gdk_display_manager_get_default_display: (attributes org.gtk.Method.get_property=default-display) |
307 | * @manager: a `GdkDisplayManager` |
308 | * |
309 | * Gets the default `GdkDisplay`. |
310 | * |
311 | * Returns: (nullable) (transfer none): a `GdkDisplay` |
312 | */ |
313 | GdkDisplay * |
314 | gdk_display_manager_get_default_display (GdkDisplayManager *manager) |
315 | { |
316 | return manager->default_display; |
317 | } |
318 | |
319 | /** |
320 | * gdk_display_get_default: |
321 | * |
322 | * Gets the default `GdkDisplay`. |
323 | * |
324 | * This is a convenience function for: |
325 | * |
326 | * gdk_display_manager_get_default_display (gdk_display_manager_get ()) |
327 | * |
328 | * Returns: (nullable) (transfer none): a `GdkDisplay`, or %NULL if |
329 | * there is no default display |
330 | */ |
331 | GdkDisplay * |
332 | gdk_display_get_default (void) |
333 | { |
334 | return gdk_display_manager_get_default_display (manager: gdk_display_manager_get ()); |
335 | } |
336 | |
337 | /** |
338 | * gdk_display_manager_set_default_display: |
339 | * @manager: a `GdkDisplayManager` |
340 | * @display: a `GdkDisplay` |
341 | * |
342 | * Sets @display as the default display. |
343 | */ |
344 | void |
345 | gdk_display_manager_set_default_display (GdkDisplayManager *manager, |
346 | GdkDisplay *display) |
347 | { |
348 | manager->default_display = display; |
349 | |
350 | if (display) |
351 | GDK_DISPLAY_GET_CLASS (display)->make_default (display); |
352 | |
353 | g_object_notify (G_OBJECT (manager), property_name: "default-display" ); |
354 | } |
355 | |
356 | /** |
357 | * gdk_display_manager_list_displays: |
358 | * @manager: a `GdkDisplayManager` |
359 | * |
360 | * List all currently open displays. |
361 | * |
362 | * Returns: (transfer container) (element-type GdkDisplay): a newly |
363 | * allocated `GSList` of `GdkDisplay` objects |
364 | */ |
365 | GSList * |
366 | gdk_display_manager_list_displays (GdkDisplayManager *manager) |
367 | { |
368 | return g_slist_copy (list: manager->displays); |
369 | } |
370 | |
371 | /** |
372 | * gdk_display_manager_open_display: |
373 | * @manager: a `GdkDisplayManager` |
374 | * @name: the name of the display to open |
375 | * |
376 | * Opens a display. |
377 | * |
378 | * Returns: (nullable) (transfer none): a `GdkDisplay`, or %NULL |
379 | * if the display could not be opened |
380 | */ |
381 | GdkDisplay * |
382 | gdk_display_manager_open_display (GdkDisplayManager *manager, |
383 | const char *name) |
384 | { |
385 | const char *backend_list; |
386 | GdkDisplay *display; |
387 | char **backends; |
388 | int i, j; |
389 | gboolean allow_any; |
390 | |
391 | if (allowed_backends == NULL) |
392 | allowed_backends = "*" ; |
393 | allow_any = strstr (haystack: allowed_backends, needle: "*" ) != NULL; |
394 | |
395 | backend_list = g_getenv (variable: "GDK_BACKEND" ); |
396 | if (backend_list == NULL) |
397 | backend_list = allowed_backends; |
398 | else if (g_strcmp0 (str1: backend_list, str2: "help" ) == 0) |
399 | { |
400 | fprintf (stderr, format: "Supported GDK backends:" ); |
401 | for (i = 0; gdk_backends[i].name != NULL; i++) |
402 | fprintf (stderr, format: " %s" , gdk_backends[i].name); |
403 | fprintf (stderr, format: "\n" ); |
404 | |
405 | backend_list = allowed_backends; |
406 | } |
407 | backends = g_strsplit (string: backend_list, delimiter: "," , max_tokens: 0); |
408 | |
409 | display = NULL; |
410 | |
411 | for (i = 0; display == NULL && backends[i] != NULL; i++) |
412 | { |
413 | const char *backend = backends[i]; |
414 | gboolean any = g_str_equal (v1: backend, v2: "*" ); |
415 | |
416 | if (!allow_any && !any && !strstr (haystack: allowed_backends, needle: backend)) |
417 | continue; |
418 | |
419 | for (j = 0; gdk_backends[j].name != NULL; j++) |
420 | { |
421 | if ((any && allow_any) || |
422 | (any && strstr (haystack: allowed_backends, needle: gdk_backends[j].name)) || |
423 | g_str_equal (v1: backend, v2: gdk_backends[j].name)) |
424 | { |
425 | GDK_NOTE (MISC, g_message ("Trying %s backend" , gdk_backends[j].name)); |
426 | display = gdk_backends[j].open_display (name); |
427 | if (display) |
428 | break; |
429 | } |
430 | } |
431 | } |
432 | |
433 | g_strfreev (str_array: backends); |
434 | |
435 | return display; |
436 | } |
437 | |
438 | void |
439 | _gdk_display_manager_add_display (GdkDisplayManager *manager, |
440 | GdkDisplay *display) |
441 | { |
442 | if (manager->displays == NULL) |
443 | gdk_display_manager_set_default_display (manager, display); |
444 | |
445 | manager->displays = g_slist_prepend (list: manager->displays, data: display); |
446 | |
447 | g_signal_emit (instance: manager, signal_id: signals[DISPLAY_OPENED], detail: 0, display); |
448 | } |
449 | |
450 | /* NB: This function can be called multiple times per display. */ |
451 | void |
452 | _gdk_display_manager_remove_display (GdkDisplayManager *manager, |
453 | GdkDisplay *display) |
454 | { |
455 | manager->displays = g_slist_remove (list: manager->displays, data: display); |
456 | |
457 | if (manager->default_display == display) |
458 | { |
459 | if (manager->displays) |
460 | gdk_display_manager_set_default_display (manager, display: manager->displays->data); |
461 | else |
462 | gdk_display_manager_set_default_display (manager, NULL); |
463 | } |
464 | } |
465 | |