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