ui/gfx/gtk_preserve_window.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/gfx/gtk_preserve_window.h"
   6
   7 #include <gdk/gdk.h>
   8 #include <gtk/gtk.h>
   9
  10 #include "ui/gfx/gtk_compat.h"
  11
  12 G_BEGIN_DECLS
  13
  14 #define GTK_PRESERVE_WINDOW_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \
  15                                             GTK_TYPE_PRESERVE_WINDOW, \
  16                                             GtkPreserveWindowPrivate))
  17
  18 typedef struct _GtkPreserveWindowPrivate GtkPreserveWindowPrivate;
  19
  20 struct _GtkPreserveWindowPrivate {
  21   // If true, don't create/destroy windows on realize/unrealize.
  22   gboolean preserve_window;
  23
  24   // Whether or not we delegate the resize of the GdkWindow
  25   // to someone else.
  26   gboolean delegate_resize;
  27
  28   // Accessible factory and userdata.
  29   AtkObject* (*accessible_factory)(void* userdata);
  30   void* accessible_factory_userdata;
  31 };
  32
  33 G_DEFINE_TYPE(GtkPreserveWindow, gtk_preserve_window, GTK_TYPE_FIXED)
  34
  35 static void gtk_preserve_window_destroy(GtkObject* object);
  36 static void gtk_preserve_window_realize(GtkWidget* widget);
  37 static void gtk_preserve_window_unrealize(GtkWidget* widget);
  38 static void gtk_preserve_window_size_allocate(GtkWidget* widget,
  39                                               GtkAllocation* allocation);
  40 static AtkObject* gtk_preserve_window_get_accessible(GtkWidget* widget);
  41
  42 static void gtk_preserve_window_class_init(GtkPreserveWindowClass *klass) {
  43   GtkWidgetClass* widget_class = reinterpret_cast<GtkWidgetClass*>(klass);
  44   widget_class->realize = gtk_preserve_window_realize;
  45   widget_class->unrealize = gtk_preserve_window_unrealize;
  46   widget_class->size_allocate = gtk_preserve_window_size_allocate;
  47   widget_class->get_accessible = gtk_preserve_window_get_accessible;
  48
  49   GtkObjectClass* object_class = reinterpret_cast<GtkObjectClass*>(klass);
  50   object_class->destroy = gtk_preserve_window_destroy;
  51
  52   GObjectClass* gobject_class = G_OBJECT_CLASS(klass);
  53   g_type_class_add_private(gobject_class, sizeof(GtkPreserveWindowPrivate));
  54 }
  55
  56 static void gtk_preserve_window_init(GtkPreserveWindow* widget) {
  57   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
  58   priv->preserve_window = FALSE;
  59   priv->accessible_factory = NULL;
  60   priv->accessible_factory_userdata = NULL;
  61
  62   // These widgets always have their own window.
  63   gtk_widget_set_has_window(GTK_WIDGET(widget), TRUE);
  64 }
  65
  66 GtkWidget* gtk_preserve_window_new() {
  67   return GTK_WIDGET(g_object_new(GTK_TYPE_PRESERVE_WINDOW, NULL));
  68 }
  69
  70 static void gtk_preserve_window_destroy(GtkObject* object) {
  71   GtkWidget* widget = reinterpret_cast<GtkWidget*>(object);
  72   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
  73
  74   GdkWindow* gdk_window = gtk_widget_get_window(widget);
  75   if (gdk_window) {
  76     gdk_window_set_user_data(gdk_window, NULL);
  77     // If the window is preserved, someone else must destroy it.
  78     if (!priv->preserve_window)
  79       gdk_window_destroy(gdk_window);
  80     gtk_widget_set_window(widget, NULL);
  81   }
  82
  83   GTK_OBJECT_CLASS(gtk_preserve_window_parent_class)->destroy(object);
  84 }
  85
  86 static void gtk_preserve_window_realize(GtkWidget* widget) {
  87   g_return_if_fail(GTK_IS_PRESERVE_WINDOW(widget));
  88
  89   GdkWindow* gdk_window = gtk_widget_get_window(widget);
  90   if (gdk_window) {
  91     GtkAllocation allocation;
  92     gtk_widget_get_allocation(widget, &allocation);
  93
  94     gdk_window_reparent(gdk_window,
  95                         gtk_widget_get_parent_window(widget),
  96                         allocation.x,
  97                         allocation.y);
  98     GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
  99     if (!priv->delegate_resize) {
 100       gdk_window_resize(gdk_window,
 101                         allocation.width,
 102                         allocation.height);
 103     }
 104     gint event_mask = gtk_widget_get_events(widget);
 105     event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK;
 106     gdk_window_set_events(gdk_window, (GdkEventMask) event_mask);
 107     gdk_window_set_user_data(gdk_window, widget);
 108
 109     gtk_widget_set_realized(widget, TRUE);
 110
 111     gtk_widget_style_attach(widget);
 112     gtk_style_set_background(gtk_widget_get_style(widget),
 113                              gdk_window, GTK_STATE_NORMAL);
 114   } else {
 115     GTK_WIDGET_CLASS(gtk_preserve_window_parent_class)->realize(widget);
 116   }
 117 }
 118
 119 static void gtk_preserve_window_unrealize(GtkWidget* widget) {
 120   g_return_if_fail(GTK_IS_PRESERVE_WINDOW(widget));
 121
 122   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
 123   if (priv->preserve_window) {
 124     GtkWidgetClass* widget_class =
 125         GTK_WIDGET_CLASS(gtk_preserve_window_parent_class);
 126     GtkContainerClass* container_class =
 127         GTK_CONTAINER_CLASS(gtk_preserve_window_parent_class);
 128
 129     if (gtk_widget_get_mapped(widget)) {
 130       widget_class->unmap(widget);
 131
 132       gtk_widget_set_mapped(widget, FALSE);
 133     }
 134
 135     // This is the behavior from GtkWidget, inherited by GtkFixed.
 136     // It is unclear why we should not call the potentially overridden
 137     // unrealize method (via the callback), but doing so causes errors.
 138     container_class->forall(
 139         GTK_CONTAINER(widget), FALSE,
 140         reinterpret_cast<GtkCallback>(gtk_widget_unrealize), NULL);
 141
 142     GdkWindow* gdk_window = gtk_widget_get_window(widget);
 143
 144     // TODO(erg): Almost all style handling will need to be overhauled in GTK3.
 145     gtk_style_detach(gtk_widget_get_style(widget));
 146     gdk_window_reparent(gdk_window, gdk_get_default_root_window(), 0, 0);
 147     gtk_selection_remove_all(widget);
 148     gdk_window_set_user_data(gdk_window, NULL);
 149
 150     gtk_widget_set_realized(widget, FALSE);
 151   } else {
 152     GTK_WIDGET_CLASS(gtk_preserve_window_parent_class)->unrealize(widget);
 153   }
 154 }
 155
 156 gboolean gtk_preserve_window_get_preserve(GtkPreserveWindow* window) {
 157   g_return_val_if_fail(GTK_IS_PRESERVE_WINDOW(window), FALSE);
 158   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(window);
 159
 160   return priv->preserve_window;
 161 }
 162
 163 void gtk_preserve_window_set_preserve(GtkPreserveWindow* window,
 164                                       gboolean value) {
 165   g_return_if_fail(GTK_IS_PRESERVE_WINDOW(window));
 166   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(window);
 167   priv->preserve_window = value;
 168
 169   GtkWidget* widget = GTK_WIDGET(window);
 170   GdkWindow* gdk_window = gtk_widget_get_window(widget);
 171   if (value && !gdk_window) {
 172     GdkWindowAttr attributes;
 173     gint attributes_mask;
 174
 175     // We may not know the width and height, so we rely on the fact
 176     // that a size-allocation will resize it later.
 177     attributes.width = 1;
 178     attributes.height = 1;
 179
 180     attributes.window_type = GDK_WINDOW_CHILD;
 181     attributes.wclass = GDK_INPUT_OUTPUT;
 182     attributes.override_redirect = TRUE;
 183
 184     attributes.visual = gtk_widget_get_visual(widget);
 185     attributes.colormap = gtk_widget_get_colormap(widget);
 186
 187     attributes.event_mask = gtk_widget_get_events(widget);
 188     attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK;
 189
 190     attributes_mask = GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_NOREDIR;
 191     gdk_window = gdk_window_new(
 192         gdk_get_default_root_window(), &attributes, attributes_mask);
 193     gtk_widget_set_window(widget, gdk_window);
 194   } else if (!value && gdk_window && !gtk_widget_get_realized(widget)) {
 195     gdk_window_destroy(gdk_window);
 196     gtk_widget_set_window(widget, NULL);
 197   }
 198 }
 199
 200 void gtk_preserve_window_size_allocate(GtkWidget* widget,
 201                                        GtkAllocation* allocation) {
 202   g_return_if_fail(GTK_IS_PRESERVE_WINDOW(widget));
 203
 204   gtk_widget_set_allocation(widget, allocation);
 205
 206   if (gtk_widget_get_realized(widget)) {
 207     GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
 208     GdkWindow* gdk_window = gtk_widget_get_window(widget);
 209     if (priv->delegate_resize) {
 210       gdk_window_move(gdk_window, allocation->x, allocation->y);
 211     } else {
 212       gdk_window_move_resize(
 213           gdk_window, allocation->x, allocation->y,
 214           allocation->width, allocation->height);
 215     }
 216   }
 217
 218   // Propagate resize to children
 219   guint16 border_width = gtk_container_get_border_width(GTK_CONTAINER(widget));
 220   GList *children = GTK_FIXED(widget)->children;
 221   while (children) {
 222     GtkFixedChild *child = reinterpret_cast<GtkFixedChild*>(children->data);
 223     if (gtk_widget_get_visible(child->widget)) {
 224       GtkRequisition child_requisition;
 225       gtk_widget_get_child_requisition(child->widget, &child_requisition);
 226
 227       GtkAllocation child_allocation;
 228       child_allocation.x = child->x + border_width;
 229       child_allocation.y = child->y + border_width;
 230       child_allocation.width = child_requisition.width;
 231       child_allocation.height = child_requisition.height;
 232
 233       gtk_widget_size_allocate(child->widget, &child_allocation);
 234     }
 235     children = children->next;
 236   }
 237 }
 238
 239 void gtk_preserve_window_delegate_resize(GtkPreserveWindow* widget,
 240                                          gboolean delegate) {
 241   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
 242   priv->delegate_resize = delegate;
 243 }
 244
 245 void gtk_preserve_window_set_accessible_factory(
 246     GtkPreserveWindow* widget,
 247     AtkObject* (*factory)(void* userdata),
 248     gpointer userdata) {
 249   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
 250   priv->accessible_factory = factory;
 251   priv->accessible_factory_userdata = userdata;
 252 }
 253
 254 AtkObject* gtk_preserve_window_get_accessible(GtkWidget* widget) {
 255   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
 256   if (priv->accessible_factory) {
 257     return priv->accessible_factory(priv->accessible_factory_userdata);
 258   } else {
 259     return GTK_WIDGET_CLASS(gtk_preserve_window_parent_class)
 260         ->get_accessible(widget);
 261   }
 262 }
 263
 264 G_END_DECLS