Pileus Git - ~andy/gtk/blob - gdk/gdkscreen.c

   1 /*
   2  * gdkscreen.c
   3  *
   4  * Copyright 2001 Sun Microsystems Inc.
   5  *
   6  * Erwann Chenede <erwann.chenede@sun.com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include "gdkscreen.h"
  25 #include "gdkcolor.h"
  26
  27 GType
  28 gdk_screen_get_type (void)
  29 {
  30   static GType object_type = 0;
  31
  32   if (!object_type)
  33     {
  34       static const GTypeInfo object_info =
  35         {
  36           sizeof (GdkScreenClass),
  37           (GBaseInitFunc) NULL,
  38           (GBaseFinalizeFunc) NULL,
  39           NULL,                 /* class_init */
  40           NULL,                 /* class_finalize */
  41           NULL,                 /* class_data */
  42           sizeof (GdkScreen),
  43           0,                    /* n_preallocs */
  44           (GInstanceInitFunc) NULL,
  45         };
  46
  47       object_type = g_type_register_static (G_TYPE_OBJECT,
  48                                             "GdkScreen", &object_info, 0);
  49     }
  50
  51   return object_type;
  52 }
  53
  54 /**
  55  * gdk_screen_get_default_colormap:
  56  * @screen: a #GdkScreen
  57  *
  58  * Gets the default colormap for @screen.
  59  *
  60  * Returns: the default #GdkColormap.
  61  **/
  62 GdkColormap *
  63 gdk_screen_get_default_colormap (GdkScreen *screen)
  64 {
  65   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
  66
  67   return GDK_SCREEN_GET_CLASS (screen)->get_default_colormap (screen);
  68 }
  69
  70 /**
  71  * gdk_screen_set_default_colormap:
  72  * @screen: a #GdkScreen
  73  * @colormap: a #GdkColormap
  74  *
  75  * Sets the default @colormap for @screen.
  76  **/
  77 void
  78 gdk_screen_set_default_colormap (GdkScreen   *screen,
  79                                  GdkColormap *colormap)
  80 {
  81   g_return_if_fail (GDK_IS_SCREEN (screen));
  82   g_return_if_fail (GDK_IS_COLORMAP (colormap));
  83
  84   GDK_SCREEN_GET_CLASS (screen)->set_default_colormap (screen, colormap);
  85 }
  86
  87 /**
  88  * gdk_screen_get_root_window:
  89  * @screen: a #GdkScreen
  90  *
  91  * Gets the root window of @screen.
  92  *
  93  * Returns: the root window
  94  **/
  95 GdkWindow *
  96 gdk_screen_get_root_window (GdkScreen *screen)
  97 {
  98   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
  99
 100   return GDK_SCREEN_GET_CLASS (screen)->get_root_window (screen);
 101 }
 102
 103 /**
 104  * gdk_screen_get_display:
 105  * @screen: a #GdkScreen
 106  *
 107  * Gets the display to which the @screen belongs.
 108  *
 109  * Returns: the display to which @screen belongs
 110  **/
 111 GdkDisplay *
 112 gdk_screen_get_display (GdkScreen *screen)
 113 {
 114   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 115
 116   return GDK_SCREEN_GET_CLASS (screen)->get_display (screen);
 117 }
 118
 119 /**
 120  * gdk_screen_get_number:
 121  * @screen: a #GdkScreen
 122  *
 123  * Gets the index of @screen among the screens in the display
 124  * to which it belongs. (See gdk_screen_get_display())
 125  *
 126  * Returns: the index
 127  **/
 128 gint
 129 gdk_screen_get_number (GdkScreen *screen)
 130 {
 131   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 132
 133   return GDK_SCREEN_GET_CLASS (screen)->get_screen_num (screen);
 134 }
 135
 136 /**
 137  * gdk_screen_get_window_at_pointer:
 138  * @screen: a #GdkScreen
 139  * @win_x: return location for origin of the window under the pointer
 140  * @win_y: return location for origin of the window under the pointer
 141  *
 142  * Obtains the window underneath the mouse pointer, returning the location
 143  * of that window in @win_x, @win_y for @screen. Returns %NULL if the window
 144  * under the mouse pointer is not known to GDK (for example, belongs to
 145  * another application).
 146  *
 147  * Returns: the window under the mouse pointer, or %NULL
 148  **/
 149 GdkWindow *
 150 gdk_screen_get_window_at_pointer (GdkScreen *screen,
 151                                   gint      *win_x,
 152                                   gint      *win_y)
 153 {
 154   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 155
 156   return GDK_SCREEN_GET_CLASS (screen)->get_window_at_pointer (screen, win_x, win_y);
 157 }
 158
 159 /**
 160  * gdk_screen_get_width:
 161  * @screen: a #GdkScreen
 162  *
 163  * Gets the width of @screen in pixels
 164  *
 165  * Returns: the width of @screen in pixels.
 166  **/
 167 gint
 168 gdk_screen_get_width (GdkScreen *screen)
 169 {
 170   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 171
 172   return GDK_SCREEN_GET_CLASS (screen)->get_width (screen);
 173 }
 174
 175 /**
 176  * gdk_screen_get_height:
 177  * @screen: a #GdkScreen
 178  *
 179  * Gets the height of @screen in pixels
 180  *
 181  * Returns: the height of @screen in pixels.
 182  **/
 183 gint
 184 gdk_screen_get_height (GdkScreen *screen)
 185 {
 186   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 187
 188   return GDK_SCREEN_GET_CLASS (screen)->get_height (screen);
 189 }
 190
 191 /**
 192  * gdk_screen_get_width_mm:
 193  * @screen: a #GdkScreen
 194  *
 195  * Gets the width of @screen in millimeters.
 196  * Note that on some X servers this value will not be correct.
 197  *
 198  * Returns: the width of @screen in pixels.
 199  **/
 200 gint
 201 gdk_screen_get_width_mm (GdkScreen *screen)
 202 {
 203   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 204
 205   return GDK_SCREEN_GET_CLASS (screen)->get_width_mm (screen);
 206 }
 207
 208 /**
 209  * gdk_screen_get_height_mm:
 210  * @screen: a #GdkScreen
 211  *
 212  * Returns the height of @screen in millimeters.
 213  * Note that on some X servers this value will not be correct.
 214  *
 215  * Returns: the heigth of @screen in pixels.
 216  **/
 217 gint
 218 gdk_screen_get_height_mm (GdkScreen *screen)
 219 {
 220   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 221
 222   return GDK_SCREEN_GET_CLASS (screen)->get_height_mm (screen);
 223 }
 224
 225 /**
 226  * gdk_screen_close:
 227  * @screen: a #GdkScreen
 228  *
 229  * Closes the @screen connection and cleanup its resources.
 230  * Note that this function is called automatically by gdk_display_close().
 231  **/
 232 void
 233 gdk_screen_close (GdkScreen *screen)
 234 {
 235   g_return_if_fail (GDK_IS_SCREEN (screen));
 236
 237   g_object_run_dispose (G_OBJECT (screen));
 238 }
 239
 240 /**
 241  * gdk_screen_use_virtual_screen:
 242  * @screen : a #GdkScreen.
 243  *
 244  * Determines whether @screen is uses multiple monitors as
 245  * a single virtual screen (e.g. Xinerama mode under X).
 246  *
 247  * Returns: %TRUE if multiple monitors are used as a single screen
 248  ***/
 249 gboolean
 250 gdk_screen_use_virtual_screen (GdkScreen *screen)
 251 {
 252   g_return_val_if_fail (GDK_IS_SCREEN (screen), FALSE);
 253
 254   return GDK_SCREEN_GET_CLASS (screen)->use_virtual_screen (screen);
 255 }
 256
 257 /**
 258  * gdk_screen_get_n_monitors:
 259  * @screen : a #GdkScreen.
 260  *
 261  * Returns the number of monitors being part of the virtual screen
 262  *
 263  * Returns: number of monitors part of the virtual screen or
 264  *          0 if @screen is not in virtual screen mode.
 265  **/
 266 gint
 267 gdk_screen_get_n_monitors (GdkScreen *screen)
 268 {
 269   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 270
 271   return GDK_SCREEN_GET_CLASS (screen)->get_n_monitors (screen);
 272 }
 273
 274 /**
 275  * gdk_screen_get_monitor_geometry:
 276  * @screen : a #GdkScreen.
 277  * @monitor_num: the monitor number.
 278  *
 279  * Returns a #GdkRectangle representing the size and start
 280  * coordinates of the individual monitor within the the entire virtual
 281  * screen.
 282  *
 283  * Note that the virtual screen coordinates can be retrieved via
 284  * gdk_screen_get_width() and gdk_screen_get_height().
 285  *
 286  * Returns: the size and start position of the monitor wrt to
 287  *          the virtual screen.
 288  **/
 289 GdkRectangle *
 290 gdk_screen_get_monitor_geometry (GdkScreen *screen,
 291                                  gint       monitor_num)
 292 {
 293   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 294
 295   return GDK_SCREEN_GET_CLASS (screen)->get_monitor_geometry (screen, monitor_num);
 296 }
 297
 298 /**
 299  * gdk_screen_get_monitor_at_point:
 300  * @screen : a #GdkScreen.
 301  * @x : the x coordinate in the virtual screen.
 302  * @y : the y coordinate in the virtual screen.
 303  *
 304  * Returns the monitor number in which the point (@x,@y) is located.
 305  *
 306  * Returns: the monitor number in which the point (@x,@y) belong, or
 307  *   -1 if the point is not in any monitor.
 308  **/
 309 gint
 310 gdk_screen_get_monitor_at_point (GdkScreen *screen,
 311                                  gint       x,
 312                                  gint       y)
 313 {
 314   g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
 315
 316   return GDK_SCREEN_GET_CLASS (screen)->get_monitor_at_point (screen, x,y);
 317 }
 318
 319 /**
 320  * gdk_screen_get_monitor_num_at_window:
 321  * @screen : a #GdkScreen.
 322  * @anid : a #GdkDrawable ID.
 323  *
 324  * Returns the monitor number in which the largest area of the bounding rectangle
 325  * of @anid resides.
 326  *
 327  * Returns: the monitor number in which most of @anid is located.
 328  **/
 329 gint
 330 gdk_screen_get_monitor_at_window (GdkScreen      *screen,
 331                                   GdkNativeWindow anid)
 332 {
 333   g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
 334
 335   return GDK_SCREEN_GET_CLASS (screen)->get_monitor_at_window (screen, anid);
 336 }