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