GTK: Draw floating bookmark bar correctly during resizes....

chrome/browser/gtk/bookmark_bar_gtk.cc

 // Copyright (c) 2009 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/gtk/bookmark_bar_gtk.h"
 
 #include <vector>
 
 #include "app/gfx/gtk_util.h"
 #include "app/gfx/canvas_paint.h"
@@ skipping 110 matching lines @@
 #if defined(BROWSER_SYNC)
       sync_error_button_(NULL),
       sync_service_(NULL),
 #endif
       dragged_node_(NULL),
       toolbar_drop_item_(NULL),
       theme_provider_(GtkThemeProvider::GetFrom(profile)),
       show_instructions_(true),
       menu_bar_helper_(this),
       floating_(false),
-      last_allocation_width_(-1) {
+      last_allocation_width_(-1),
+      event_box_paint_factory_(this) {
 #if defined(BROWSER_SYNC)
   if (profile->GetProfileSyncService()) {
     // Obtain a pointer to the profile sync service and add our instance as an
     // observer.
     sync_service_ = profile->GetProfileSyncService();
     sync_service_->AddObserver(this);
   }
 #endif
 
   Init(profile);
@@ skipping 78 matching lines @@
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), instructions_,
                      FALSE, FALSE, 0);
 
   gtk_drag_dest_set(instructions_,
       GtkDestDefaults(GTK_DEST_DEFAULT_DROP | GTK_DEST_DEFAULT_MOTION),
       NULL, 0, kDragAction);
   GtkDndUtil::SetDestTargetList(instructions_, kDestTargetList);
   g_signal_connect(instructions_, "drag-data-received",
                    G_CALLBACK(&OnDragReceived), this);
 
-  g_signal_connect(G_OBJECT(event_box_.get()), "expose-event",
+  g_signal_connect(event_box_.get(), "expose-event",
                    G_CALLBACK(&OnEventBoxExpose), this);
   UpdateEventBoxPaintability();
 
   bookmark_toolbar_.Own(gtk_toolbar_new());
   SetToolBarStyle();
   gtk_widget_set_name(bookmark_toolbar_.get(), "chrome-bookmark-toolbar");
   gtk_widget_set_app_paintable(bookmark_toolbar_.get(), TRUE);
   g_signal_connect(bookmark_toolbar_.get(), "expose-event",
                    G_CALLBACK(&OnToolbarExpose), this);
   g_signal_connect(bookmark_toolbar_.get(), "size-allocate",
@@ skipping 367 matching lines @@
     gtk_container_set_border_width(GTK_CONTAINER(bookmark_hbox_), kNTPPadding);
   } else {
     gtk_util::StopActingAsRoundedWindow(paint_box_);
     gtk_event_box_set_visible_window(GTK_EVENT_BOX(paint_box_), FALSE);
     gtk_alignment_set_padding(GTK_ALIGNMENT(ntp_padding_box_), 0, 0, 0, 0);
     gtk_container_set_border_width(GTK_CONTAINER(bookmark_hbox_), 0);
   }
 
   UpdateEventBoxPaintability();
   // |window_| can be NULL during testing.
-  if (window_)
+  if (window_) {
     window_->BookmarkBarIsFloating(floating_);
+    // Listen for parent size allocations.
+    if (floating_ && widget()->parent) {
+      // Only connect once.
+      if (g_signal_handler_find(widget()->parent, G_SIGNAL_MATCH_FUNC,
+          0, NULL, NULL, reinterpret_cast<gpointer>(OnParentSizeAllocate),
+          NULL) == 0) {
+        g_signal_connect(widget()->parent, "size-allocate",

[tony, 2009/10/26 23:55:30]

What happens if you drag a tab from one window to another?  Does the signal
handler get fired from the old bookmarkbargtk?

[Evan Stade, 2009/10/27 00:11:12]

the bookmark bar and the tab contents container should always stay with the same
browser window

[tony, 2009/10/27 00:34:19]

I see, it's the container.  The g_signal_handler_find seems unfortunate, but I
guess it's because the parent can change depending on whether this is floating
or not?

[Evan Stade, 2009/10/27 00:37:48]

it's because we don't want to connect mroe than once. We could also track that
with a boolean, I just don't like member var bloat.

+                         G_CALLBACK(OnParentSizeAllocate), this);
+      }
+    }
+  }
 }
 
 void BookmarkBarGtk::UpdateEventBoxPaintability() {
   gtk_widget_set_app_paintable(event_box_.get(),
                                !theme_provider_->UseGtkTheme() || floating_);
   // When using the GTK+ theme, we need to have the event box be visible so
   // buttons don't get a halo color from the background.  When using Chromium
   // themes, we want to let the background show through the toolbar.
   gtk_event_box_set_visible_window(GTK_EVENT_BOX(event_box_.get()),
                                    theme_provider_->UseGtkTheme());
 }
 
+void BookmarkBarGtk::PaintEventBox() {
+  gfx::Size tab_contents_size;
+  if (GetTabContentsSize(&tab_contents_size) &&
+      tab_contents_size != last_tab_contents_size_) {
+    last_tab_contents_size_ = tab_contents_size;
+    gtk_widget_queue_draw(event_box_.get());
+  }
+}
+
+bool BookmarkBarGtk::GetTabContentsSize(gfx::Size* size) {
+  Browser* browser = browser_;
+  if (!browser) {
+    NOTREACHED();
+    return false;
+  }
+  TabContents* tab_contents = browser->GetSelectedTabContents();
+  if (!tab_contents) {
+    NOTREACHED();
+    return false;
+  }
+  if (!tab_contents->view()) {
+    NOTREACHED();
+    return false;
+  }
+  *size = tab_contents->view()->GetContainerSize();
+  return true;
+}
+
 bool BookmarkBarGtk::IsAlwaysShown() {
   return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 }
 
 void BookmarkBarGtk::AnimationProgressed(const Animation* animation) {
   DCHECK_EQ(animation, slide_animation_.get());
 
   int max_height = ShouldBeFloating() ?
                    kBookmarkBarNTPHeight : kBookmarkBarHeight;
   gint height =
@@ skipping 451 matching lines @@
     cairo_rectangle(cr,
         tabstrip_origin.x(),
         tabstrip_origin.y(),
         event->area.x + event->area.width - tabstrip_origin.x(),
         event->area.y + event->area.height - tabstrip_origin.y());
     cairo_fill(cr);
 
     cairo_destroy(cr);
   } else {
     gfx::Size tab_contents_size;
-    Browser* browser = bar->browser_;
-    if (!browser) {
-      NOTREACHED();
+    if (!bar->GetTabContentsSize(&tab_contents_size))
       return FALSE;
-    }
-    TabContents* tab_contents = browser->GetSelectedTabContents();
-    if (!tab_contents) {
-      NOTREACHED();
-      return FALSE;
-    }
-    if (!tab_contents->view()) {
-      NOTREACHED();
-      return FALSE;
-    }
-    tab_contents_size = tab_contents->view()->GetContainerSize();
     gfx::CanvasPaint canvas(event, true);
     NtpBackgroundUtil::PaintBackgroundDetachedMode(theme_provider, &canvas,
         gfx::Rect(widget->allocation), tab_contents_size.height());
   }
 
   return FALSE;  // Propagate expose to children.
 }
 
 // static
+void BookmarkBarGtk::OnParentSizeAllocate(GtkWidget* widget,
+                                          GtkAllocation* allocation,
+                                          BookmarkBarGtk* bar) {
+  // In floating mode, our layout depends on the size of the tab contents.
+  // We get the size-allocate signal before the tab contents does, hence we
+  // need to post a delayed task so we will paint correctly. Note that
+  // gtk_widget_queue_draw by itself does not work, despite that it claims to
+  // be asynchronous.
+  if (bar->floating_) {
+    MessageLoop::current()->PostTask(FROM_HERE,

[tony, 2009/10/26 23:55:30]

Is this still necessary since we're getting the size allocate from the tab
contents?

[Evan Stade, 2009/10/27 00:11:12]

we are getting it from the tab contents container, and yes. The allocates go off
in this order:

parent
child1
child2
...

+        bar->event_box_paint_factory_.NewRunnableMethod(
+            &BookmarkBarGtk::PaintEventBox));
+  }
+}
+
+// static
 gboolean BookmarkBarGtk::OnSeparatorExpose(GtkWidget* widget,
                                            GdkEventExpose* event,
                                            BookmarkBarGtk* bar) {
   if (bar->theme_provider_->UseGtkTheme())
     return FALSE;
 
   cairo_t* cr = gdk_cairo_create(GDK_DRAWABLE(widget->window));
   cairo_rectangle(cr, event->area.x, event->area.y,
                       event->area.width, event->area.height);
   cairo_clip(cr);
@@ skipping 87 matching lines @@
       break;
     }
   }
   DCHECK_NE(button_idx, -1);
 
   // Find the GtkWidget* for the actual target button.
   int shift = dir == GTK_MENU_DIR_PARENT ? -1 : 1;
   button_idx = (button_idx + shift + folder_list.size()) % folder_list.size();
   PopupForButton(folder_list[button_idx]);
 }