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