GTK: A bunch more removal of deprecated raw GtkWidget access, focusing on GtkWidget->window

ui/gfx/gtk_preserve_window.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/gfx/gtk_preserve_window.h"
 
 #include <gdk/gdk.h>
 #include <gtk/gtk.h>
 
 #include "ui/base/gtk/gtk_compat.h"
@@ skipping 45 matching lines @@
 }
 
 GtkWidget* gtk_preserve_window_new() {
   return GTK_WIDGET(g_object_new(GTK_TYPE_PRESERVE_WINDOW, NULL));
 }
 
 static void gtk_preserve_window_destroy(GtkObject* object) {
   GtkWidget* widget = reinterpret_cast<GtkWidget*>(object);
   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
 
-  if (widget->window) {
-    gdk_window_set_user_data(widget->window, NULL);
+  GdkWindow* window = gtk_widget_get_window(widget);

[tony, 2012/01/04 19:08:01]

Nit: Maybe call this gdk_window too?

+  if (window) {
+    gdk_window_set_user_data(window, NULL);
     // If the window is preserved, someone else must destroy it.
     if (!priv->preserve_window)
-      gdk_window_destroy(widget->window);
-    widget->window = NULL;
+      gdk_window_destroy(window);
+    gtk_widget_set_window(widget, NULL);
   }
 
   GTK_OBJECT_CLASS(gtk_preserve_window_parent_class)->destroy(object);
 }
 
 static void gtk_preserve_window_realize(GtkWidget* widget) {
   g_return_if_fail(GTK_IS_PRESERVE_WINDOW(widget));
 
-  if (widget->window) {
+  GdkWindow* gdk_window = gtk_widget_get_window(widget);
+  if (gdk_window) {
     GtkAllocation allocation;
     gtk_widget_get_allocation(widget, &allocation);
 
-    gdk_window_reparent(widget->window,
+    gdk_window_reparent(gdk_window,
                         gtk_widget_get_parent_window(widget),
                         allocation.x,
                         allocation.y);
     GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
     if (!priv->delegate_resize) {
-      gdk_window_resize(gtk_widget_get_window(widget),
+      gdk_window_resize(gdk_window,
                         allocation.width,
                         allocation.height);
     }
     widget->style = gtk_style_attach(widget->style, widget->window);
-    gtk_style_set_background(widget->style, widget->window, GTK_STATE_NORMAL);
+    gtk_style_set_background(gtk_widget_get_style(widget),
+                             gdk_window, GTK_STATE_NORMAL);
 
     gint event_mask = gtk_widget_get_events(widget);
     event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK;
-    gdk_window_set_events(widget->window, (GdkEventMask) event_mask);
-    gdk_window_set_user_data(widget->window, widget);
+    gdk_window_set_events(gdk_window, (GdkEventMask) event_mask);
+    gdk_window_set_user_data(gdk_window, widget);
 
     // Deprecated as of GTK 2.22. Used for compatibility.
     // It should be: gtk_widget_set_realized(widget, TRUE)
     GTK_WIDGET_SET_FLAGS(widget, GTK_REALIZED);
   } else {
     GTK_WIDGET_CLASS(gtk_preserve_window_parent_class)->realize(widget);
   }
 }
 
 static void gtk_preserve_window_unrealize(GtkWidget* widget) {
@@ skipping 12 matching lines @@
       gtk_widget_set_mapped(widget, FALSE);
     }
 
     // This is the behavior from GtkWidget, inherited by GtkFixed.
     // It is unclear why we should not call the potentially overridden
     // unrealize method (via the callback), but doing so causes errors.
     container_class->forall(
         GTK_CONTAINER(widget), FALSE,
         reinterpret_cast<GtkCallback>(gtk_widget_unrealize), NULL);
 
+    GdkWindow* gdk_window = gtk_widget_get_window(widget);
+
     gtk_style_detach(widget->style);
-    gdk_window_reparent(widget->window, gdk_get_default_root_window(), 0, 0);
+    gdk_window_reparent(gdk_window, gdk_get_default_root_window(), 0, 0);
     gtk_selection_remove_all(widget);
-    gdk_window_set_user_data(widget->window, NULL);
+    gdk_window_set_user_data(gdk_window, NULL);
 
     gtk_widget_set_realized(widget, FALSE);
   } else {
     GTK_WIDGET_CLASS(gtk_preserve_window_parent_class)->unrealize(widget);
   }
 }
 
 gboolean gtk_preserve_window_get_preserve(GtkPreserveWindow* window) {
   g_return_val_if_fail(GTK_IS_PRESERVE_WINDOW(window), FALSE);
   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(window);
 
   return priv->preserve_window;
 }
 
 void gtk_preserve_window_set_preserve(GtkPreserveWindow* window,
                                       gboolean value) {
   g_return_if_fail(GTK_IS_PRESERVE_WINDOW(window));
   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(window);
   priv->preserve_window = value;
 
   GtkWidget* widget = GTK_WIDGET(window);
-  if (value && !widget->window) {
+  GdkWindow* gdk_window = gtk_widget_get_window(widget);
+  if (value && !gdk_window) {
     GdkWindowAttr attributes;
     gint attributes_mask;
 
     // We may not know the width and height, so we rely on the fact
     // that a size-allocation will resize it later.
     attributes.width = 1;
     attributes.height = 1;
 
     attributes.window_type = GDK_WINDOW_CHILD;
     attributes.wclass = GDK_INPUT_OUTPUT;
     attributes.override_redirect = TRUE;
 
     attributes.visual = gtk_widget_get_visual(widget);
     attributes.colormap = gtk_widget_get_colormap(widget);
 
     attributes.event_mask = gtk_widget_get_events(widget);
     attributes.event_mask |= GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK;
 
     attributes_mask = GDK_WA_VISUAL | GDK_WA_COLORMAP | GDK_WA_NOREDIR;
-    widget->window = gdk_window_new(
+    gdk_window = gdk_window_new(
         gdk_get_default_root_window(), &attributes, attributes_mask);
-  } else if (!value && widget->window && !gtk_widget_get_realized(widget)) {
-    gdk_window_destroy(widget->window);
-    widget->window = NULL;
+    gtk_widget_set_window(widget, gdk_window);
+  } else if (!value && gdk_window && !gtk_widget_get_realized(widget)) {
+    gdk_window_destroy(gdk_window);
+    gtk_widget_set_window(widget, NULL);
   }
 }
 
 void gtk_preserve_window_size_allocate(GtkWidget* widget,
                                        GtkAllocation* allocation) {
   g_return_if_fail(GTK_IS_PRESERVE_WINDOW(widget));
 
-  widget->allocation = *allocation;
+  gtk_widget_set_allocation(widget, allocation);
 
   if (gtk_widget_get_realized(widget)) {
     GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
+    GdkWindow* gdk_window = gtk_widget_get_window(widget);
     if (priv->delegate_resize) {
-      gdk_window_move(widget->window, allocation->x, allocation->y);
+      gdk_window_move(gdk_window, allocation->x, allocation->y);
     } else {
       gdk_window_move_resize(
-          widget->window, allocation->x, allocation->y,
+          gdk_window, allocation->x, allocation->y,
           allocation->width, allocation->height);
     }
   }
 
   // Propagate resize to children
   guint16 border_width = GTK_CONTAINER(widget)->border_width;
   GList *children = GTK_FIXED(widget)->children;
   while (children) {
     GtkFixedChild *child = reinterpret_cast<GtkFixedChild*>(children->data);
     if (gtk_widget_get_visible(child->widget)) {
@@ skipping 12 matching lines @@
   }
 }
 
 void gtk_preserve_window_delegate_resize(GtkPreserveWindow* widget,
                                          gboolean delegate) {
   GtkPreserveWindowPrivate* priv = GTK_PRESERVE_WINDOW_GET_PRIVATE(widget);
   priv->delegate_resize = delegate;
 }
 
 G_END_DECLS