Pileus Git - ~andy/gtk/blob - gdk/gdkdisplaymanager.c

   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 "gdkinternals.h"
  30 #include "gdkkeysprivate.h"
  31 #include "gdkmarshalers.h"
  32 #include "gdkintl.h"
  33
  34 #ifdef GDK_WINDOWING_X11
  35 #include "x11/gdkx.h"
  36 #endif
  37
  38 #ifdef GDK_WINDOWING_QUARTZ
  39 /* We immediately include gdkquartzdisplaymanager.h here instead of
  40  * gdkquartz.h so that we do not have to enable -xobjective-c for the
  41  * "generic" GDK source code.
  42  */
  43 #include "quartz/gdkquartzdisplaymanager.h"
  44 #endif
  45
  46 #ifdef GDK_WINDOWING_BROADWAY
  47 #include "broadway/gdkbroadwaydisplaymanager.h"
  48 #endif
  49
  50 #ifdef GDK_WINDOWING_WIN32
  51 #include "win32/gdkwin32.h"
  52 #endif
  53
  54 #ifdef GDK_WINDOWING_WAYLAND
  55 #include "wayland/gdkwayland.h"
  56 #endif
  57
  58 /**
  59  * SECTION:gdkdisplaymanager
  60  * @Short_description: Maintains a list of all open GdkDisplays
  61  * @Title: GdkDisplayManager
  62  *
  63  * The purpose of the #GdkDisplayManager singleton object is to offer
  64  * notification when displays appear or disappear or the default display
  65  * changes.
  66  *
  67  * You can use gdk_display_manager_get() to obtain the GdkDisplayManager
  68  * singleton, but that should be rarely necessary. Typically, initializing
  69  * GTK+ opens a display that you can work with without ever accessing the
  70  * GdkDisplayManager.
  71  *
  72  * The GDK library can be built with support for multiple backends.
  73  * The GdkDisplayManager object determines which backend is used
  74  * at runtime.
  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  * <example id="backend-specific">
  84  * <title>Backend-specific code</title>
  85  * <programlisting>
  86  * #ifdef GDK_WINDOWING_X11
  87  *   if (GDK_IS_X11_DISPLAY (display))
  88  *     {
  89  *       /&ast; make X11-specific calls here &ast;/
  90  *     }
  91  *   else
  92  * #endif
  93  * #ifdef GDK_WINDOWING_QUARTZ
  94  *   if (GDK_IS_QUARTZ_DISPLAY (display))
  95  *     {
  96  *       /&ast; make Quartz-specific calls here &ast;/
  97 *     }
  98  *   else
  99  * #endif
 100  *   g_error ("Unsupported GDK backend");
 101  * </programlisting>
 102  * </example>
 103  */
 104
 105
 106 enum {
 107   PROP_0,
 108   PROP_DEFAULT_DISPLAY
 109 };
 110
 111 enum {
 112   DISPLAY_OPENED,
 113   LAST_SIGNAL
 114 };
 115
 116 static void gdk_display_manager_class_init   (GdkDisplayManagerClass *klass);
 117 static void gdk_display_manager_set_property (GObject                *object,
 118                                               guint                   prop_id,
 119                                               const GValue           *value,
 120                                               GParamSpec             *pspec);
 121 static void gdk_display_manager_get_property (GObject                *object,
 122                                               guint                   prop_id,
 123                                               GValue                 *value,
 124                                               GParamSpec             *pspec);
 125
 126 static guint signals[LAST_SIGNAL] = { 0 };
 127
 128 G_DEFINE_TYPE (GdkDisplayManager, gdk_display_manager, G_TYPE_OBJECT)
 129
 130 static void
 131 gdk_display_manager_class_init (GdkDisplayManagerClass *klass)
 132 {
 133   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 134
 135   object_class->set_property = gdk_display_manager_set_property;
 136   object_class->get_property = gdk_display_manager_get_property;
 137
 138   klass->keyval_convert_case = _gdk_display_manager_real_keyval_convert_case;
 139
 140   /**
 141    * GdkDisplayManager::display-opened:
 142    * @manager: the object on which the signal is emitted
 143    * @display: the opened display
 144    *
 145    * The ::display-opened signal is emitted when a display is opened.
 146    *
 147    * Since: 2.2
 148    */
 149   signals[DISPLAY_OPENED] =
 150     g_signal_new (g_intern_static_string ("display-opened"),
 151                   G_OBJECT_CLASS_TYPE (object_class),
 152                   G_SIGNAL_RUN_LAST,
 153                   G_STRUCT_OFFSET (GdkDisplayManagerClass, display_opened),
 154                   NULL, NULL,
 155                   _gdk_marshal_VOID__OBJECT,
 156                   G_TYPE_NONE,
 157                   1,
 158                   GDK_TYPE_DISPLAY);
 159
 160   g_object_class_install_property (object_class,
 161                                    PROP_DEFAULT_DISPLAY,
 162                                    g_param_spec_object ("default-display",
 163                                                         P_("Default Display"),
 164                                                         P_("The default display for GDK"),
 165                                                         GDK_TYPE_DISPLAY,
 166                                                         G_PARAM_READWRITE|G_PARAM_STATIC_NAME|
 167                                                         G_PARAM_STATIC_NICK|G_PARAM_STATIC_BLURB));
 168 }
 169
 170 static void
 171 gdk_display_manager_init (GdkDisplayManager *manager)
 172 {
 173 }
 174
 175 static void
 176 gdk_display_manager_set_property (GObject      *object,
 177                                   guint         prop_id,
 178                                   const GValue *value,
 179                                   GParamSpec   *pspec)
 180 {
 181   switch (prop_id)
 182     {
 183     case PROP_DEFAULT_DISPLAY:
 184       gdk_display_manager_set_default_display (GDK_DISPLAY_MANAGER (object),
 185                                                g_value_get_object (value));
 186       break;
 187     default:
 188       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 189       break;
 190     }
 191 }
 192
 193 static void
 194 gdk_display_manager_get_property (GObject      *object,
 195                                   guint         prop_id,
 196                                   GValue       *value,
 197                                   GParamSpec   *pspec)
 198 {
 199   switch (prop_id)
 200     {
 201     case PROP_DEFAULT_DISPLAY:
 202       g_value_set_object (value,
 203                           gdk_display_manager_get_default_display (GDK_DISPLAY_MANAGER (object)));
 204       break;
 205     default:
 206       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
 207       break;
 208     }
 209 }
 210
 211 /**
 212  * gdk_display_manager_get:
 213  *
 214  * Gets the singleton #GdkDisplayManager object.
 215  *
 216  * When called for the first time, this function consults the
 217  * <envar>GDK_BACKEND</envar> environment variable to find out which
 218  * of the supported GDK backends to use (in case GDK has been compiled
 219  * with multiple backends).
 220  *
 221  * Returns: (transfer none): The global #GdkDisplayManager singleton;
 222  *     gdk_parse_args(), gdk_init(), or gdk_init_check() must have
 223  *     been called first.
 224  *
 225  * Since: 2.2
 226  **/
 227 GdkDisplayManager*
 228 gdk_display_manager_get (void)
 229 {
 230   static GdkDisplayManager *manager = NULL;
 231
 232   if (!manager)
 233     {
 234       const gchar *backend;
 235
 236       backend = g_getenv ("GDK_BACKEND");
 237 #ifdef GDK_WINDOWING_QUARTZ
 238       if (backend == NULL || strcmp (backend, "quartz") == 0)
 239         manager = g_object_new (gdk_quartz_display_manager_get_type (), NULL);
 240       else
 241 #endif
 242 #ifdef GDK_WINDOWING_WIN32
 243       if (backend == NULL || strcmp (backend, "win32") == 0)
 244         manager = g_object_new (gdk_win32_display_manager_get_type (), NULL);
 245       else
 246 #endif
 247 #ifdef GDK_WINDOWING_X11
 248       if (backend == NULL || strcmp (backend, "x11") == 0)
 249         manager = g_object_new (gdk_x11_display_manager_get_type (), NULL);
 250       else
 251 #endif
 252 #ifdef GDK_WINDOWING_WAYLAND
 253       if (backend == NULL || strcmp (backend, "wayland") == 0)
 254         manager = g_object_new (gdk_wayland_display_manager_get_type (), NULL);
 255       else
 256 #endif
 257 #ifdef GDK_WINDOWING_BROADWAY
 258       if (backend == NULL || strcmp (backend, "broadway") == 0)
 259         manager = g_object_new (gdk_broadway_display_manager_get_type (), NULL);
 260       else
 261 #endif
 262       if (backend != NULL)
 263         g_error ("Unsupported GDK backend: %s", backend);
 264       else
 265         g_error ("No GDK backend found");
 266     }
 267
 268   return manager;
 269 }
 270
 271 /**
 272  * gdk_display_manager_get_default_display:
 273  * @manager: a #GdkDisplayManager
 274  *
 275  * Gets the default #GdkDisplay.
 276  *
 277  * Returns: (transfer none): a #GdkDisplay, or %NULL
 278  *     if there is no default display.
 279  *
 280  * Since: 2.2
 281  */
 282 GdkDisplay *
 283 gdk_display_manager_get_default_display (GdkDisplayManager *manager)
 284 {
 285   return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->get_default_display (manager);
 286 }
 287
 288 /**
 289  * gdk_display_get_default:
 290  *
 291  * Gets the default #GdkDisplay. This is a convenience
 292  * function for
 293  * <literal>gdk_display_manager_get_default_display (gdk_display_manager_get ())</literal>.
 294  *
 295  * Returns: (transfer none): a #GdkDisplay, or %NULL if there is no default
 296  *   display.
 297  *
 298  * Since: 2.2
 299  */
 300 GdkDisplay *
 301 gdk_display_get_default (void)
 302 {
 303   return gdk_display_manager_get_default_display (gdk_display_manager_get ());
 304 }
 305
 306 /**
 307  * gdk_screen_get_default:
 308  *
 309  * Gets the default screen for the default display. (See
 310  * gdk_display_get_default ()).
 311  *
 312  * Returns: (transfer none): a #GdkScreen, or %NULL if there is no default display.
 313  *
 314  * Since: 2.2
 315  */
 316 GdkScreen *
 317 gdk_screen_get_default (void)
 318 {
 319   GdkDisplay *default_display;
 320
 321   default_display = gdk_display_get_default ();
 322
 323   if (default_display)
 324     return gdk_display_get_default_screen (default_display);
 325   else
 326     return NULL;
 327 }
 328
 329 /**
 330  * gdk_display_manager_set_default_display:
 331  * @manager: a #GdkDisplayManager
 332  * @display: a #GdkDisplay
 333  *
 334  * Sets @display as the default display.
 335  *
 336  * Since: 2.2
 337  **/
 338 void
 339 gdk_display_manager_set_default_display (GdkDisplayManager *manager,
 340                                          GdkDisplay        *display)
 341 {
 342   GDK_DISPLAY_MANAGER_GET_CLASS (manager)->set_default_display (manager, display);
 343
 344   g_object_notify (G_OBJECT (manager), "default-display");
 345 }
 346
 347 /**
 348  * gdk_display_manager_list_displays:
 349  * @manager: a #GdkDisplayManager
 350  *
 351  * List all currently open displays.
 352  *
 353  * Return value: (transfer container) (element-type GdkDisplay): a newly
 354  *     allocated #GSList of #GdkDisplay objects. Free with g_slist_free()
 355  *     when you are done with it.
 356  *
 357  * Since: 2.2
 358  **/
 359 GSList *
 360 gdk_display_manager_list_displays (GdkDisplayManager *manager)
 361 {
 362   return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->list_displays (manager);
 363 }
 364
 365 /**
 366  * gdk_display_manager_open_display:
 367  * @manager: a #GdkDisplayManager
 368  * @name: the name of the display to open
 369  *
 370  * Opens a display.
 371  *
 372  * Return value: (transfer none): a #GdkDisplay, or %NULL
 373  *     if the display could not be opened
 374  *
 375  * Since: 3.0
 376  */
 377 GdkDisplay *
 378 gdk_display_manager_open_display (GdkDisplayManager *manager,
 379                                   const gchar       *name)
 380 {
 381   return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->open_display (manager, name);
 382 }
 383
 384 /**
 385  * gdk_atom_intern:
 386  * @atom_name: a string.
 387  * @only_if_exists: if %TRUE, GDK is allowed to not create a new atom, but
 388  *   just return %GDK_NONE if the requested atom doesn't already
 389  *   exists. Currently, the flag is ignored, since checking the
 390  *   existance of an atom is as expensive as creating it.
 391  *
 392  * Finds or creates an atom corresponding to a given string.
 393  *
 394  * Returns: (transfer none): the atom corresponding to @atom_name.
 395  */
 396 GdkAtom
 397 gdk_atom_intern (const gchar *atom_name,
 398                  gboolean     only_if_exists)
 399 {
 400   GdkDisplayManager *manager = gdk_display_manager_get ();
 401
 402   return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->atom_intern (manager, atom_name, TRUE);
 403 }
 404
 405 /**
 406  * gdk_atom_intern_static_string:
 407  * @atom_name: a static string
 408  *
 409  * Finds or creates an atom corresponding to a given string.
 410  *
 411  * Note that this function is identical to gdk_atom_intern() except
 412  * that if a new #GdkAtom is created the string itself is used rather
 413  * than a copy. This saves memory, but can only be used if the string
 414  * will <emphasis>always</emphasis> exist. It can be used with statically
 415  * allocated strings in the main program, but not with statically
 416  * allocated memory in dynamically loaded modules, if you expect to
 417  * ever unload the module again (e.g. do not use this function in
 418  * GTK+ theme engines).
 419  *
 420  * Returns: (transfer none): the atom corresponding to @atom_name
 421  *
 422  * Since: 2.10
 423  */
 424 GdkAtom
 425 gdk_atom_intern_static_string (const gchar *atom_name)
 426 {
 427   GdkDisplayManager *manager = gdk_display_manager_get ();
 428
 429   return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->atom_intern (manager, atom_name, FALSE);
 430 }
 431
 432 /**
 433  * gdk_atom_name:
 434  * @atom: a #GdkAtom.
 435  *
 436  * Determines the string corresponding to an atom.
 437  *
 438  * Returns: a newly-allocated string containing the string
 439  *   corresponding to @atom. When you are done with the
 440  *   return value, you should free it using g_free().
 441  */
 442 gchar *
 443 gdk_atom_name (GdkAtom atom)
 444 {
 445   GdkDisplayManager *manager = gdk_display_manager_get ();
 446
 447   return GDK_DISPLAY_MANAGER_GET_CLASS (manager)->get_atom_name (manager, atom);
 448 }