GTK: Even more changes from raw allocation access to gtk_widget_get_allocation().

chrome/browser/ui/gtk/download/download_item_gtk.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 "chrome/browser/ui/gtk/download/download_item_gtk.h"
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
@@ skipping 682 matching lines @@
       IDR_DOWNLOAD_BUTTON_LEFT_MIDDLE,
       IDR_DOWNLOAD_BUTTON_CENTER_MIDDLE,
       IDR_DOWNLOAD_BUTTON_RIGHT_MIDDLE_NO_DD,
       IDR_DOWNLOAD_BUTTON_LEFT_BOTTOM,
       IDR_DOWNLOAD_BUTTON_CENTER_BOTTOM,
       IDR_DOWNLOAD_BUTTON_RIGHT_BOTTOM_NO_DD);
 }
 
 gboolean DownloadItemGtk::OnHboxExpose(GtkWidget* widget, GdkEventExpose* e) {
   if (theme_service_->UsingNativeTheme()) {
-    int border_width = GTK_CONTAINER(widget)->border_width;
-    int x = widget->allocation.x + border_width;
-    int y = widget->allocation.y + border_width;
-    int width = widget->allocation.width - border_width * 2;
-    int height = widget->allocation.height - border_width * 2;
+    GtkAllocation allocation;
+    gtk_widget_get_allocation(widget, &allocation);
+    int border_width = gtk_container_get_border_width(GTK_CONTAINER(widget));
+    int x = allocation.x + border_width;
+    int y = allocation.y + border_width;
+    int width = allocation.width - border_width * 2;
+    int height = allocation.height - border_width * 2;
 
     if (IsDangerous()) {
       // Draw a simple frame around the area when we're displaying the warning.
       gtk_paint_shadow(widget->style, widget->window,
                        static_cast<GtkStateType>(widget->state),
                        static_cast<GtkShadowType>(GTK_SHADOW_OUT),
                        &e->area, widget, "frame",
                        x, y, width, height);
     } else {
       // Manually draw the GTK button border around the download item. We draw
       // the left part of the button (the file), a divider, and then the right
       // part of the button (the menu). We can't draw a button on top of each
       // other (*cough*Clearlooks*cough*) so instead, to draw the left part of
       // the button, we instruct GTK to draw the entire button...with a
       // doctored clip rectangle to the left part of the button sans
       // separator. We then repeat this for the right button.
       GtkStyle* style = body_.get()->style;
 
-      GtkAllocation left_allocation = body_.get()->allocation;
-      GdkRectangle left_clip = {
-        left_allocation.x, left_allocation.y,
-        left_allocation.width, left_allocation.height
-      };
+      GtkAllocation left_clip;
+      gtk_widget_get_allocation(body_.get(), &left_clip);
 
-      GtkAllocation right_allocation = menu_button_->allocation;
-      GdkRectangle right_clip = {
-        right_allocation.x, right_allocation.y,
-        right_allocation.width, right_allocation.height
-      };
+      GtkAllocation right_clip;
+      gtk_widget_get_allocation(menu_button_, &right_clip);
 
       GtkShadowType body_shadow =
           GTK_BUTTON(body_.get())->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
       gtk_paint_box(style, widget->window,
                     gtk_widget_get_state(body_.get()),
                     body_shadow,
                     &left_clip, widget, "button",

[Lei Zhang, 2011/12/08 20:50:30]

Is it ok to pass in a GtkAllocation instead of a GdkRectangle? If yes, then
ignore this.

[Elliot Glaysher, 2011/12/08 20:56:41]

they are typedefs

                     x, y, width, height);
 
       GtkShadowType menu_shadow =
           GTK_BUTTON(menu_button_)->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
       gtk_paint_box(style, widget->window,
                     gtk_widget_get_state(menu_button_),
                     menu_shadow,
                     &right_clip, widget, "button",
                     x, y, width, height);
 
       // Doing the math to reverse engineer where we should be drawing our line
       // is hard and relies on copying GTK internals, so instead steal the
       // allocation of the gtk arrow which is close enough (and will error on
       // the conservative side).
-      GtkAllocation arrow_allocation = arrow_->allocation;
+      GtkAllocation arrow_allocation;
+      gtk_widget_get_allocation(arrow_, &arrow_allocation);
       gtk_paint_vline(style, widget->window,
                       gtk_widget_get_state(widget),
                       &e->area, widget, "button",
                       arrow_allocation.y,
                       arrow_allocation.y + arrow_allocation.height,
-                      left_allocation.x + left_allocation.width);
+                      left_clip.x + left_clip.width);
     }
   }
   return FALSE;
 }
 
 gboolean DownloadItemGtk::OnExpose(GtkWidget* widget, GdkEventExpose* e) {
   if (!theme_service_->UsingNativeTheme()) {
     bool is_body = widget == body_.get();
 
     NineBox* nine_box = NULL;
@@ skipping 32 matching lines @@
                                         GdkEventButton* event) {
   if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
     ShowPopupMenu(NULL, event);
     return TRUE;
   }
   return FALSE;
 }
 
 gboolean DownloadItemGtk::OnProgressAreaExpose(GtkWidget* widget,
                                                GdkEventExpose* event) {
+  GtkAllocation allocation;
+  gtk_widget_get_allocation(widget, &allocation);
+
   // Create a transparent canvas.
   gfx::CanvasSkiaPaint canvas(event, false);
   if (complete_animation_.is_animating()) {
     if (get_download()->IsInterrupted()) {
       download_util::PaintDownloadInterrupted(&canvas,
-          widget->allocation.x, widget->allocation.y,
+          allocation.x, allocation.y,
           complete_animation_.GetCurrentValue(),
           download_util::SMALL);
     } else {
       download_util::PaintDownloadComplete(&canvas,
-          widget->allocation.x, widget->allocation.y,
+          allocation.x, allocation.y,
           complete_animation_.GetCurrentValue(),
           download_util::SMALL);
     }
   } else if (get_download()->IsInProgress()) {
     download_util::PaintDownloadProgress(&canvas,
-        widget->allocation.x, widget->allocation.y,
+        allocation.x, allocation.y,
         progress_angle_,
         get_download()->PercentComplete(),
         download_util::SMALL);
   }
 
   // |icon_small_| may be NULL if it is still loading. If the file is an
   // unrecognized type then we will get back a generic system icon. Hence
   // there is no need to use the chromium-specific default download item icon.
   if (icon_small_) {
     const int offset = download_util::kSmallProgressIconOffset;
     canvas.DrawBitmapInt(*icon_small_,
-        widget->allocation.x + offset, widget->allocation.y + offset);
+        allocation.x + offset, allocation.y + offset);
   }
 
   return TRUE;
 }
 
 gboolean DownloadItemGtk::OnMenuButtonPressEvent(GtkWidget* button,
                                                  GdkEventButton* event) {
   if (event->type == GDK_BUTTON_PRESS && event->button == 1) {
     ShowPopupMenu(button, event);
     menu_showing_ = true;
@@ skipping 29 matching lines @@
   get_download()->DangerousDownloadValidated();
 }
 
 void DownloadItemGtk::OnDangerousDecline(GtkWidget* button) {
   UMA_HISTOGRAM_LONG_TIMES("clickjacking.discard_download",
                            base::Time::Now() - creation_time_);
   if (get_download()->IsPartialDownload())
     get_download()->Cancel(true);
   get_download()->Delete(DownloadItem::DELETE_DUE_TO_USER_DISCARD);
 }