GTK: Implement the bookmark bar chevron....

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/text_elider.h"
 #include "app/gtk_dnd_util.h"
@@ skipping 166 matching lines @@
                    G_CALLBACK(&OnDragReceived), this);
 
   gtk_widget_set_app_paintable(widget(), TRUE);
   g_signal_connect(G_OBJECT(widget()), "expose-event",
                    G_CALLBACK(&OnEventBoxExpose), this);
 
   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(G_OBJECT(bookmark_toolbar_.get()), "expose-event",
+  g_signal_connect(bookmark_toolbar_.get(), "expose-event",
                    G_CALLBACK(&OnToolbarExpose), this);
+  g_signal_connect(bookmark_toolbar_.get(), "size-allocate",
+                   G_CALLBACK(&OnToolbarSizeAllocate), this);
   gtk_box_pack_start(GTK_BOX(bookmark_hbox_), bookmark_toolbar_.get(),
                      TRUE, TRUE, 0);
 
+  overflow_button_ = theme_provider_->BuildChromeButton();
+  g_object_set_data(G_OBJECT(overflow_button_), "left-align-popup",
+                    reinterpret_cast<void*>(true));
+  SetOverflowButtonAppearance();
+  ConnectFolderButtonEvents(overflow_button_);
+  gtk_box_pack_start(GTK_BOX(bookmark_hbox_), overflow_button_,
+                     FALSE, FALSE, 0);
+
   gtk_drag_dest_set(bookmark_toolbar_.get(), GTK_DEST_DEFAULT_DROP,
                     NULL, 0, kDragAction);
   GtkDndUtil::SetDestTargetList(bookmark_toolbar_.get(), kDestTargetList);
   g_signal_connect(bookmark_toolbar_.get(), "drag-motion",
                    G_CALLBACK(&OnToolbarDragMotion), this);
   g_signal_connect(bookmark_toolbar_.get(), "drag-leave",
                    G_CALLBACK(&OnToolbarDragLeave), this);
   g_signal_connect(bookmark_toolbar_.get(), "drag-data-received",
                    G_CALLBACK(&OnDragReceived), this);
 
@@ skipping 95 matching lines @@
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
 
   GtkToolItem* item = CreateBookmarkToolItem(parent->GetChild(index));
   gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()),
                      item, index);
 
   SetInstructionState();
+  SetChevronState();
 }
 
 void BookmarkBarGtk::BookmarkNodeRemoved(BookmarkModel* model,
                                          const BookmarkNode* parent,
                                          int old_index,
                                          const BookmarkNode* node) {
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(old_index >= 0 && old_index < GetBookmarkButtonCount());
 
   GtkWidget* to_remove = GTK_WIDGET(gtk_toolbar_get_nth_item(
       GTK_TOOLBAR(bookmark_toolbar_.get()), old_index));
   gtk_container_remove(GTK_CONTAINER(bookmark_toolbar_.get()),
                        to_remove);
 
   SetInstructionState();
+  SetChevronState();
 }
 
 void BookmarkBarGtk::BookmarkNodeChanged(BookmarkModel* model,
                                          const BookmarkNode* node) {
   if (node->GetParent() != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   int index = model_->GetBookmarkBarNode()->IndexOfChild(node);
   DCHECK(index != -1);
 
   GtkToolItem* item = gtk_toolbar_get_nth_item(
       GTK_TOOLBAR(bookmark_toolbar_.get()), index);
   GtkWidget* button = gtk_bin_get_child(GTK_BIN(item));
   bookmark_utils::ConfigureButtonForNode(node, model, button, theme_provider_);
+  SetChevronState();
 }
 
 void BookmarkBarGtk::BookmarkNodeFavIconLoaded(BookmarkModel* model,
                                                const BookmarkNode* node) {
   BookmarkNodeChanged(model, node);
 }
 
 void BookmarkBarGtk::BookmarkNodeChildrenReordered(BookmarkModel* model,
                                                    const BookmarkNode* node) {
   if (node != model_->GetBookmarkBarNode())
@@ skipping 11 matching lines @@
   // Create a button for each of the children on the bookmark bar.
   for (int i = 0; i < node->GetChildCount(); ++i) {
     GtkToolItem* item = CreateBookmarkToolItem(node->GetChild(i));
     gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()), item, -1);
   }
 
   bookmark_utils::ConfigureButtonForNode(model_->other_node(),
       model_, other_bookmarks_button_, theme_provider_);
 
   SetInstructionState();
+  SetChevronState();
 }
 
 void BookmarkBarGtk::SetInstructionState() {
   show_instructions_ = (model_->GetBookmarkBarNode()->GetChildCount() == 0);
   if (show_instructions_) {
     gtk_widget_show_all(instructions_);
   } else {
     gtk_widget_hide(instructions_);
   }
 }
 
+void BookmarkBarGtk::SetChevronState() {
+  int extra_space = 0;
+
+  if (GTK_WIDGET_VISIBLE(overflow_button_))
+    extra_space = overflow_button_->allocation.width;
+
+  int overflow_idx = GetFirstHiddenBookmark(extra_space);
+  if (overflow_idx == -1)
+    gtk_widget_hide(overflow_button_);
+  else
+    gtk_widget_show_all(overflow_button_);
+}
+
 void BookmarkBarGtk::RemoveAllBookmarkButtons() {
   gtk_util::RemoveAllChildren(bookmark_toolbar_.get());
 }
 
 int BookmarkBarGtk::GetBookmarkButtonCount() {
   GList* children = gtk_container_get_children(
       GTK_CONTAINER(bookmark_toolbar_.get()));
   int count = g_list_length(children);
   g_list_free(children);
   return count;
 }
 
+void BookmarkBarGtk::SetOverflowButtonAppearance() {
+  GtkWidget* former_child = gtk_bin_get_child(GTK_BIN(overflow_button_));
+  if (former_child)
+    gtk_widget_destroy(former_child);
+
+  GtkWidget* new_child = theme_provider_->UseGtkTheme() ?
+      gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE) :

[Elliot Glaysher, 2009/09/02 01:19:39]

This arrow, by default, is pretty big, no? You may want to take a look at how I
sized the comparable arrow in the download item. (IIRC, they're supposed to
match the font size.)

+      gtk_image_new_from_pixbuf(ResourceBundle::GetSharedInstance().
+          GetRTLEnabledPixbufNamed(IDR_BOOKMARK_BAR_CHEVRONS));
+
+  gtk_container_add(GTK_CONTAINER(overflow_button_), new_child);
+  SetChevronState();
+}
+
+int BookmarkBarGtk::GetFirstHiddenBookmark(int extra_space) {
+  int rv = 0;
+  bool overflow = false;
+  GList* toolbar_items =
+      gtk_container_get_children(GTK_CONTAINER(bookmark_toolbar_.get()));
+  for (GList* iter = toolbar_items; iter; iter = g_list_next(iter)) {
+    GtkWidget* tool_item = reinterpret_cast<GtkWidget*>(iter->data);
+    if (tool_item->allocation.x + tool_item->allocation.width >
+        bookmark_toolbar_.get()->allocation.width + extra_space) {
+      overflow = true;
+      break;
+    }
+    rv++;
+  }
+
+  g_list_free(toolbar_items);
+
+  if (!overflow)
+    return -1;
+
+  return rv;
+}
+
 bool BookmarkBarGtk::IsAlwaysShown() {
   return profile_->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar);
 }
 
 void BookmarkBarGtk::AnimationProgressed(const Animation* animation) {
   DCHECK_EQ(animation, slide_animation_.get());
 
   gint height = animation->GetCurrentValue() *
       (kBookmarkBarHeight - kBookmarkBarMinimumHeight) +
       kBookmarkBarMinimumHeight;
@@ skipping 19 matching lines @@
     } else {
       DLOG(ERROR) << "Received a theme change notification while we "
                   << "don't have a BookmarkModel. Taking no action.";
     }
 
     // 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());
+
+    SetOverflowButtonAppearance();
   }
 }
 
 GtkWidget* BookmarkBarGtk::CreateBookmarkButton(const BookmarkNode* node) {
   GtkWidget* button = theme_provider_->BuildChromeButton();
   bookmark_utils::ConfigureButtonForNode(node, model_, button, theme_provider_);
 
   // The tool item is also a source for dragging
   gtk_drag_source_set(button, GDK_BUTTON1_MASK,
                       NULL, 0, GDK_ACTION_MOVE);
@@ skipping 54 matching lines @@
   g_signal_connect(G_OBJECT(widget), "clicked",
                    G_CALLBACK(OnFolderClicked), this);
 
   ViewIDUtil::SetID(widget, VIEW_ID_BOOKMARK_MENU);
 }
 
 const BookmarkNode* BookmarkBarGtk::GetNodeForToolButton(GtkWidget* widget) {
   // First check to see if |button| is special cased.
   if (widget == other_bookmarks_button_)
     return model_->other_node();
-  else if (widget == event_box_.get())
+  else if (widget == event_box_.get() || widget == overflow_button_)
     return model_->GetBookmarkBarNode();
 
   // Search the contents of |bookmark_toolbar_| for the corresponding widget
   // and find its index.
   GtkWidget* item_to_find = gtk_widget_get_parent(widget);
   int index_to_use = -1;
   int index = 0;
   GList* children = gtk_container_get_children(
       GTK_CONTAINER(bookmark_toolbar_.get()));
   for (GList* item = children; item; item = item->next, index++) {
@@ skipping 126 matching lines @@
                                            bar->profile_);
 }
 
 // static
 void BookmarkBarGtk::OnFolderClicked(GtkWidget* sender,
                                      BookmarkBarGtk* bar) {
   const BookmarkNode* node = bar->GetNodeForToolButton(sender);
   DCHECK(node);
   DCHECK(bar->page_navigator_);
 
+  int start_child_idx = 0;
+  if (sender == bar->overflow_button_)
+    start_child_idx = bar->GetFirstHiddenBookmark(0);
+
   bar->current_menu_.reset(
       new BookmarkMenuController(bar->browser_, bar->profile_,
                                  bar->page_navigator_,
                                  GTK_WINDOW(gtk_widget_get_toplevel(sender)),
                                  node,
-                                 0,
+                                 start_child_idx,
                                  false));
   GdkEventButton* event =
       reinterpret_cast<GdkEventButton*>(gtk_get_current_event());
   bar->current_menu_->Popup(sender, event->button, event->time);
 }
 
 // static
 gboolean BookmarkBarGtk::OnToolbarExpose(GtkWidget* widget,
                                          GdkEventExpose* event,
                                          BookmarkBarGtk* bar) {
@@ skipping 63 matching lines @@
                                         BookmarkBarGtk* bar) {
   if (bar->toolbar_drop_item_) {
     g_object_unref(bar->toolbar_drop_item_);
     bar->toolbar_drop_item_ = NULL;
   }
 
   gtk_toolbar_set_drop_highlight_item(toolbar, NULL, 0);
 }
 
 // static
+void BookmarkBarGtk::OnToolbarSizeAllocate(GtkWidget* widget,
+                                           GtkAllocation* allocation,
+                                           BookmarkBarGtk* bar) {
+  bar->SetChevronState();
+}
+
+// static
 void BookmarkBarGtk::OnDragReceived(GtkWidget* widget,
                                     GdkDragContext* context,
                                     gint x, gint y,
                                     GtkSelectionData* selection_data,
                                     guint target_type, guint time,
                                     BookmarkBarGtk* bar) {
   gboolean dnd_success = FALSE;
   gboolean delete_selection_data = FALSE;
 
   const BookmarkNode* dest_node;
@@ skipping 127 matching lines @@
   cairo_set_line_width(cr, 1.0);
   cairo_move_to(cr, start_x, widget->allocation.y);
   cairo_line_to(cr, start_x,
                     widget->allocation.y + widget->allocation.height);
   cairo_stroke(cr);
   cairo_destroy(cr);
   cairo_pattern_destroy(pattern);
 
   return TRUE;
 }