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