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