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