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

   1 /*
   2  * Copyright © 2010 Intel Corporation
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library 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  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library 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 #include "config.h"
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <glib.h>
  26 #include "gdkscreenprivate.h"
  27 #include "gdkvisualprivate.h"
  28 #include "gdkdisplay.h"
  29 #include "gdkdisplay-wayland.h"
  30 #include "gdkwayland.h"
  31 #include "gdkprivate-wayland.h"
  32
  33 typedef struct _GdkScreenWayland      GdkScreenWayland;
  34 typedef struct _GdkScreenWaylandClass GdkScreenWaylandClass;
  35
  36 #define GDK_TYPE_SCREEN_WAYLAND              (_gdk_screen_wayland_get_type ())
  37 #define GDK_SCREEN_WAYLAND(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_SCREEN_WAYLAND, GdkScreenWayland))
  38 #define GDK_SCREEN_WAYLAND_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_SCREEN_WAYLAND, GdkScreenWaylandClass))
  39 #define GDK_IS_SCREEN_WAYLAND(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_SCREEN_WAYLAND))
  40 #define GDK_IS_SCREEN_WAYLAND_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_SCREEN_WAYLAND))
  41 #define GDK_SCREEN_WAYLAND_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_SCREEN_WAYLAND, GdkScreenWaylandClass))
  42
  43 typedef struct _GdkWaylandMonitor GdkWaylandMonitor;
  44
  45 struct _GdkScreenWayland
  46 {
  47   GdkScreen parent_instance;
  48
  49   GdkDisplay *display;
  50   GdkWindow *root_window;
  51
  52   int width, height;
  53   int width_mm, height_mm;
  54
  55   /* Visual Part */
  56   GdkVisual *visual;
  57
  58   /* Xinerama/RandR 1.2 */
  59   gint               n_monitors;
  60   GdkWaylandMonitor *monitors;
  61   gint               primary_monitor;
  62 };
  63
  64 struct _GdkScreenWaylandClass
  65 {
  66   GdkScreenClass parent_class;
  67
  68   void (* window_manager_changed) (GdkScreenWayland *screen_wayland);
  69 };
  70
  71 struct _GdkWaylandMonitor
  72 {
  73   GdkRectangle  geometry;
  74   int           width_mm;
  75   int           height_mm;
  76   char *        output_name;
  77   char *        manufacturer;
  78 };
  79
  80 G_DEFINE_TYPE (GdkScreenWayland, _gdk_screen_wayland, GDK_TYPE_SCREEN)
  81
  82 static void
  83 init_monitor_geometry (GdkWaylandMonitor *monitor,
  84                        int x, int y, int width, int height)
  85 {
  86   monitor->geometry.x = x;
  87   monitor->geometry.y = y;
  88   monitor->geometry.width = width;
  89   monitor->geometry.height = height;
  90
  91   monitor->width_mm = -1;
  92   monitor->height_mm = -1;
  93   monitor->output_name = NULL;
  94   monitor->manufacturer = NULL;
  95 }
  96
  97 static void
  98 free_monitors (GdkWaylandMonitor *monitors,
  99                gint           n_monitors)
 100 {
 101   int i;
 102
 103   for (i = 0; i < n_monitors; ++i)
 104     {
 105       g_free (monitors[i].output_name);
 106       g_free (monitors[i].manufacturer);
 107     }
 108
 109   g_free (monitors);
 110 }
 111
 112 static void
 113 deinit_multihead (GdkScreen *screen)
 114 {
 115   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
 116
 117   free_monitors (screen_wayland->monitors, screen_wayland->n_monitors);
 118
 119   screen_wayland->n_monitors = 0;
 120   screen_wayland->monitors = NULL;
 121 }
 122
 123 static void
 124 init_multihead (GdkScreen *screen)
 125 {
 126   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
 127
 128   /* No multihead support of any kind for this screen */
 129   screen_wayland->n_monitors = 1;
 130   screen_wayland->monitors = g_new0 (GdkWaylandMonitor, 1);
 131   screen_wayland->primary_monitor = 0;
 132
 133   init_monitor_geometry (screen_wayland->monitors, 0, 0,
 134                          screen_wayland->width, screen_wayland->height);
 135 }
 136
 137 static void
 138 gdk_wayland_screen_dispose (GObject *object)
 139 {
 140   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (object);
 141
 142   if (screen_wayland->root_window)
 143     _gdk_window_destroy (screen_wayland->root_window, TRUE);
 144
 145   G_OBJECT_CLASS (_gdk_screen_wayland_parent_class)->dispose (object);
 146 }
 147
 148 static void
 149 gdk_wayland_screen_finalize (GObject *object)
 150 {
 151   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (object);
 152
 153   if (screen_wayland->root_window)
 154     g_object_unref (screen_wayland->root_window);
 155
 156   g_object_unref (screen_wayland->visual);
 157
 158   deinit_multihead (GDK_SCREEN (object));
 159
 160   G_OBJECT_CLASS (_gdk_screen_wayland_parent_class)->finalize (object);
 161 }
 162
 163 static GdkDisplay *
 164 gdk_wayland_screen_get_display (GdkScreen *screen)
 165 {
 166   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 167
 168   return GDK_SCREEN_WAYLAND (screen)->display;
 169 }
 170
 171 static gint
 172 gdk_wayland_screen_get_width (GdkScreen *screen)
 173 {
 174   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 175
 176   return GDK_SCREEN_WAYLAND (screen)->width;
 177 }
 178
 179 static gint
 180 gdk_wayland_screen_get_height (GdkScreen *screen)
 181 {
 182   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 183
 184   return GDK_SCREEN_WAYLAND (screen)->height;
 185 }
 186
 187 static gint
 188 gdk_wayland_screen_get_width_mm (GdkScreen *screen)
 189 {
 190   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 191
 192   return GDK_SCREEN_WAYLAND (screen)->width_mm;
 193 }
 194
 195 static gint
 196 gdk_wayland_screen_get_height_mm (GdkScreen *screen)
 197 {
 198   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 199
 200   return GDK_SCREEN_WAYLAND (screen)->height_mm;
 201 }
 202
 203 static gint
 204 gdk_wayland_screen_get_number (GdkScreen *screen)
 205 {
 206   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 207
 208   return 0;
 209 }
 210
 211 static GdkWindow *
 212 gdk_wayland_screen_get_root_window (GdkScreen *screen)
 213 {
 214   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 215
 216   return GDK_SCREEN_WAYLAND (screen)->root_window;
 217 }
 218
 219 static gint
 220 gdk_wayland_screen_get_n_monitors (GdkScreen *screen)
 221 {
 222   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 223
 224   return GDK_SCREEN_WAYLAND (screen)->n_monitors;
 225 }
 226
 227 static gint
 228 gdk_wayland_screen_get_primary_monitor (GdkScreen *screen)
 229 {
 230   g_return_val_if_fail (GDK_IS_SCREEN (screen), 0);
 231
 232   return GDK_SCREEN_WAYLAND (screen)->primary_monitor;
 233 }
 234
 235 static gint
 236 gdk_wayland_screen_get_monitor_width_mm (GdkScreen *screen,
 237                                          gint       monitor_num)
 238 {
 239   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
 240
 241   g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
 242   g_return_val_if_fail (monitor_num >= 0, -1);
 243   g_return_val_if_fail (monitor_num < screen_wayland->n_monitors, -1);
 244
 245   return screen_wayland->monitors[monitor_num].width_mm;
 246 }
 247
 248 static gint
 249 gdk_wayland_screen_get_monitor_height_mm (GdkScreen *screen,
 250                                           gint       monitor_num)
 251 {
 252   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
 253
 254   g_return_val_if_fail (GDK_IS_SCREEN (screen), -1);
 255   g_return_val_if_fail (monitor_num >= 0, -1);
 256   g_return_val_if_fail (monitor_num < screen_wayland->n_monitors, -1);
 257
 258   return screen_wayland->monitors[monitor_num].height_mm;
 259 }
 260
 261 static gchar *
 262 gdk_wayland_screen_get_monitor_plug_name (GdkScreen *screen,
 263                                           gint       monitor_num)
 264 {
 265   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
 266
 267   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 268   g_return_val_if_fail (monitor_num >= 0, NULL);
 269   g_return_val_if_fail (monitor_num < screen_wayland->n_monitors, NULL);
 270
 271   return g_strdup (screen_wayland->monitors[monitor_num].output_name);
 272 }
 273
 274 static void
 275 gdk_wayland_screen_get_monitor_geometry (GdkScreen    *screen,
 276                                          gint          monitor_num,
 277                                          GdkRectangle *dest)
 278 {
 279   GdkScreenWayland *screen_wayland = GDK_SCREEN_WAYLAND (screen);
 280
 281   g_return_if_fail (GDK_IS_SCREEN (screen));
 282   g_return_if_fail (monitor_num >= 0);
 283   g_return_if_fail (monitor_num < screen_wayland->n_monitors);
 284
 285   if (dest)
 286     *dest = screen_wayland->monitors[monitor_num].geometry;
 287 }
 288
 289 static GdkVisual *
 290 gdk_wayland_screen_get_system_visual (GdkScreen * screen)
 291 {
 292   return (GdkVisual *) GDK_SCREEN_WAYLAND (screen)->visual;
 293 }
 294
 295 static GdkVisual *
 296 gdk_wayland_screen_get_rgba_visual (GdkScreen *screen)
 297 {
 298   return (GdkVisual *) GDK_SCREEN_WAYLAND (screen)->visual;
 299 }
 300
 301 static gboolean
 302 gdk_wayland_screen_is_composited (GdkScreen *screen)
 303 {
 304   return TRUE;
 305 }
 306
 307 static gchar *
 308 gdk_wayland_screen_make_display_name (GdkScreen *screen)
 309 {
 310   return NULL;
 311 }
 312
 313 static GdkWindow *
 314 gdk_wayland_screen_get_active_window (GdkScreen *screen)
 315 {
 316   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 317
 318   return NULL;
 319 }
 320
 321 static GList *
 322 gdk_wayland_screen_get_window_stack (GdkScreen *screen)
 323 {
 324   return NULL;
 325 }
 326
 327 static void
 328 gdk_wayland_screen_broadcast_client_message (GdkScreen *screen,
 329                                              GdkEvent  *event)
 330 {
 331 }
 332
 333 static gboolean
 334 gdk_wayland_screen_get_setting (GdkScreen   *screen,
 335                                 const gchar *name,
 336                                 GValue      *value)
 337 {
 338   return FALSE;
 339 }
 340
 341 typedef struct _GdkWaylandVisual        GdkWaylandVisual;
 342 typedef struct _GdkWaylandVisualClass   GdkWaylandVisualClass;
 343
 344 struct _GdkWaylandVisual
 345 {
 346   GdkVisual visual;
 347 };
 348
 349 struct _GdkWaylandVisualClass
 350 {
 351   GdkVisualClass parent_class;
 352 };
 353
 354 G_DEFINE_TYPE (GdkWaylandVisual, _gdk_wayland_visual, GDK_TYPE_VISUAL)
 355
 356 static void
 357 _gdk_wayland_visual_class_init (GdkWaylandVisualClass *klass)
 358 {
 359 }
 360
 361 static void
 362 _gdk_wayland_visual_init (GdkWaylandVisual *visual)
 363 {
 364 }
 365
 366 static gint
 367 gdk_wayland_screen_visual_get_best_depth (GdkScreen *screen)
 368 {
 369   return 32;
 370 }
 371
 372 static GdkVisualType
 373 gdk_wayland_screen_visual_get_best_type (GdkScreen *screen)
 374 {
 375   return GDK_VISUAL_TRUE_COLOR;
 376 }
 377
 378 static GdkVisual*
 379 gdk_wayland_screen_visual_get_best (GdkScreen *screen)
 380 {
 381   return GDK_SCREEN_WAYLAND (screen)->visual;
 382 }
 383
 384 static GdkVisual*
 385 gdk_wayland_screen_visual_get_best_with_depth (GdkScreen *screen,
 386                                                gint       depth)
 387 {
 388   return GDK_SCREEN_WAYLAND (screen)->visual;
 389 }
 390
 391 static GdkVisual*
 392 gdk_wayland_screen_visual_get_best_with_type (GdkScreen     *screen,
 393                                               GdkVisualType  visual_type)
 394 {
 395   return GDK_SCREEN_WAYLAND (screen)->visual;
 396 }
 397
 398 static GdkVisual*
 399 gdk_wayland_screen_visual_get_best_with_both (GdkScreen     *screen,
 400                                               gint           depth,
 401                                               GdkVisualType  visual_type)
 402 {
 403   return GDK_SCREEN_WAYLAND (screen)->visual;
 404 }
 405
 406 static void
 407 gdk_wayland_screen_query_depths  (GdkScreen  *screen,
 408                                   gint      **depths,
 409                                   gint       *count)
 410 {
 411   static gint static_depths[] = { 32 };
 412
 413   *count = G_N_ELEMENTS(static_depths);
 414   *depths = static_depths;
 415 }
 416
 417 static void
 418 gdk_wayland_screen_query_visual_types (GdkScreen      *screen,
 419                                        GdkVisualType **visual_types,
 420                                        gint           *count)
 421 {
 422   static GdkVisualType static_visual_types[] = { GDK_VISUAL_TRUE_COLOR };
 423
 424   *count = G_N_ELEMENTS(static_visual_types);
 425   *visual_types = static_visual_types;
 426 }
 427
 428 static GList *
 429 gdk_wayland_screen_list_visuals (GdkScreen *screen)
 430 {
 431   GList *list;
 432   GdkScreenWayland *screen_wayland;
 433
 434   g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
 435   screen_wayland = GDK_SCREEN_WAYLAND (screen);
 436
 437   list = g_list_append (NULL, screen_wayland->visual);
 438
 439   return list;
 440 }
 441
 442 #define GDK_TYPE_WAYLAND_VISUAL              (_gdk_wayland_visual_get_type ())
 443 #define GDK_WAYLAND_VISUAL(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_VISUAL, GdkWaylandVisual))
 444
 445 static GdkVisual *
 446 gdk_wayland_visual_new (GdkScreen *screen)
 447 {
 448   GdkVisual *visual;
 449
 450   visual = g_object_new (GDK_TYPE_WAYLAND_VISUAL, NULL);
 451   visual->screen = GDK_SCREEN (screen);
 452   visual->type = GDK_VISUAL_TRUE_COLOR;
 453   visual->depth = 32;
 454
 455   return visual;
 456 }
 457
 458 GdkScreen *
 459 _gdk_wayland_screen_new (GdkDisplay *display)
 460 {
 461   GdkScreen *screen;
 462   GdkScreenWayland *screen_wayland;
 463
 464   screen = g_object_new (GDK_TYPE_SCREEN_WAYLAND, NULL);
 465
 466   screen_wayland = GDK_SCREEN_WAYLAND (screen);
 467   screen_wayland->display = display;
 468   screen_wayland->width = 8192;
 469   screen_wayland->height = 8192;
 470
 471   screen_wayland->visual = gdk_wayland_visual_new (screen);
 472
 473   screen_wayland->root_window =
 474     _gdk_wayland_screen_create_root_window (screen,
 475                                             screen_wayland->width,
 476                                             screen_wayland->height);
 477
 478   init_multihead (screen);
 479
 480   return screen;
 481 }
 482
 483 static void
 484 _gdk_screen_wayland_class_init (GdkScreenWaylandClass *klass)
 485 {
 486   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 487   GdkScreenClass *screen_class = GDK_SCREEN_CLASS (klass);
 488
 489   object_class->dispose = gdk_wayland_screen_dispose;
 490   object_class->finalize = gdk_wayland_screen_finalize;
 491
 492   screen_class->get_display = gdk_wayland_screen_get_display;
 493   screen_class->get_width = gdk_wayland_screen_get_width;
 494   screen_class->get_height = gdk_wayland_screen_get_height;
 495   screen_class->get_width_mm = gdk_wayland_screen_get_width_mm;
 496   screen_class->get_height_mm = gdk_wayland_screen_get_height_mm;
 497   screen_class->get_number = gdk_wayland_screen_get_number;
 498   screen_class->get_root_window = gdk_wayland_screen_get_root_window;
 499   screen_class->get_n_monitors = gdk_wayland_screen_get_n_monitors;
 500   screen_class->get_primary_monitor = gdk_wayland_screen_get_primary_monitor;
 501   screen_class->get_monitor_width_mm = gdk_wayland_screen_get_monitor_width_mm;
 502   screen_class->get_monitor_height_mm = gdk_wayland_screen_get_monitor_height_mm;
 503   screen_class->get_monitor_plug_name = gdk_wayland_screen_get_monitor_plug_name;
 504   screen_class->get_monitor_geometry = gdk_wayland_screen_get_monitor_geometry;
 505   screen_class->get_monitor_workarea = gdk_wayland_screen_get_monitor_geometry;
 506   screen_class->get_system_visual = gdk_wayland_screen_get_system_visual;
 507   screen_class->get_rgba_visual = gdk_wayland_screen_get_rgba_visual;
 508   screen_class->is_composited = gdk_wayland_screen_is_composited;
 509   screen_class->make_display_name = gdk_wayland_screen_make_display_name;
 510   screen_class->get_active_window = gdk_wayland_screen_get_active_window;
 511   screen_class->get_window_stack = gdk_wayland_screen_get_window_stack;
 512   screen_class->broadcast_client_message = gdk_wayland_screen_broadcast_client_message;
 513   screen_class->get_setting = gdk_wayland_screen_get_setting;
 514   screen_class->visual_get_best_depth = gdk_wayland_screen_visual_get_best_depth;
 515   screen_class->visual_get_best_type = gdk_wayland_screen_visual_get_best_type;
 516   screen_class->visual_get_best = gdk_wayland_screen_visual_get_best;
 517   screen_class->visual_get_best_with_depth = gdk_wayland_screen_visual_get_best_with_depth;
 518   screen_class->visual_get_best_with_type = gdk_wayland_screen_visual_get_best_with_type;
 519   screen_class->visual_get_best_with_both = gdk_wayland_screen_visual_get_best_with_both;
 520   screen_class->query_depths = gdk_wayland_screen_query_depths;
 521   screen_class->query_visual_types = gdk_wayland_screen_query_visual_types;
 522   screen_class->list_visuals = gdk_wayland_screen_list_visuals;
 523 }
 524
 525 static void
 526 _gdk_screen_wayland_init (GdkScreenWayland *screen_wayland)
 527 {
 528 }