Make the bookmark toolbar folders act like a menu bar....

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 83 matching lines @@
                                BrowserWindowGtk* window)
     : profile_(NULL),
       page_navigator_(NULL),
       browser_(browser),
       window_(window),
       model_(NULL),
       instructions_(NULL),
       dragged_node_(NULL),
       toolbar_drop_item_(NULL),
       theme_provider_(GtkThemeProvider::GetFrom(profile)),
-      show_instructions_(true) {
+      show_instructions_(true),
+      menu_bar_helper_(this) {
   Init(profile);
   SetProfile(profile);
 
   registrar_.Add(this, NotificationType::BROWSER_THEME_CHANGED,
                  NotificationService::AllSources());
 }
 
 BookmarkBarGtk::~BookmarkBarGtk() {
   if (model_)
     model_->RemoveObserver(this);
@@ skipping 187 matching lines @@
 
 void BookmarkBarGtk::BookmarkNodeAdded(BookmarkModel* model,
                                        const BookmarkNode* parent,
                                        int index) {
   if (parent != model_->GetBookmarkBarNode()) {
     // We only care about nodes on the bookmark bar.
     return;
   }
   DCHECK(index >= 0 && index <= GetBookmarkButtonCount());
 
-  GtkToolItem* item = CreateBookmarkToolItem(parent->GetChild(index));
+  const BookmarkNode* node = parent->GetChild(index);
+  GtkToolItem* item = CreateBookmarkToolItem(node);
   gtk_toolbar_insert(GTK_TOOLBAR(bookmark_toolbar_.get()),
                      item, index);
+  if (node->is_folder())
+    menu_bar_helper_.Add(gtk_bin_get_child(GTK_BIN(item)));
 
   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));
+  menu_bar_helper_.Remove(gtk_bin_get_child(GTK_BIN(to_remove)));
   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()) {
@@ skipping 26 matching lines @@
 }
 
 void BookmarkBarGtk::CreateAllBookmarkButtons() {
   const BookmarkNode* node = model_->GetBookmarkBarNode();
   DCHECK(node && model_->other_node());
 
   // 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);
+    if (node->is_folder())
+      menu_bar_helper_.Add(gtk_bin_get_child(GTK_BIN(item)));
   }
 
   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);
+  int overflow_idx = GetFirstHiddenBookmark(extra_space, NULL);
   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());
+  menu_bar_helper_.Clear();
+  menu_bar_helper_.Add(other_bookmarks_button_);
+  menu_bar_helper_.Add(overflow_button_);
 }
 
 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) :
       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 BookmarkBarGtk::GetFirstHiddenBookmark(
+    int extra_space, std::vector<GtkWidget*>* showing_folders) {
   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;
     }
+    if (showing_folders &&
+        model_->GetBookmarkBarNode()->GetChild(rv)->is_folder()) {
+      showing_folders->push_back(gtk_bin_get_child(GTK_BIN(tool_item)));
+    }
     rv++;
   }
 
   g_list_free(toolbar_items);
 
   if (!overflow)
     return -1;
 
   return rv;
 }
@@ skipping 66 matching lines @@
   if (node->is_url()) {
     // Connect to 'button-release-event' instead of 'clicked' because we need
     // access to the modifier keys and we do different things on each
     // button.
     g_signal_connect(G_OBJECT(button), "button-press-event",
                      G_CALLBACK(OnButtonPressed), this);
     g_signal_connect(G_OBJECT(button), "clicked",
                      G_CALLBACK(OnClicked), this);
     gtk_util::SetButtonTriggersNavigation(button);
   } else {
-    // TODO(erg): This button can also be a drop target.
     ConnectFolderButtonEvents(button);
   }
 
   return button;
 }
 
 GtkToolItem* BookmarkBarGtk::CreateBookmarkToolItem(const BookmarkNode* node) {
   GtkWidget* button = CreateBookmarkButton(node);
   g_object_set_data(G_OBJECT(button), "left-align-popup",
                     reinterpret_cast<void*>(true));
@@ skipping 162 matching lines @@
                                      guint target_type, guint time,
                                      BookmarkBarGtk* bar) {
   const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(widget);
   bookmark_utils::WriteBookmarkToSelection(node, selection_data, target_type,
                                            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,
-                                 start_child_idx,
-                                 false));
-  GdkEventButton* event =
-      reinterpret_cast<GdkEventButton*>(gtk_get_current_event());
-  bar->current_menu_->Popup(sender, event->button, event->time);
+  bar->PopupForButton(sender);
 }
 
 // static
 gboolean BookmarkBarGtk::OnToolbarExpose(GtkWidget* widget,
                                          GdkEventExpose* event,
                                          BookmarkBarGtk* bar) {
   // A GtkToolbar's expose handler first draws a box. We don't want that so we
   // need to propagate the expose event to all the container's children.
   GList* children = gtk_container_get_children(GTK_CONTAINER(widget));
   for (GList* item = children; item; item = item->next) {
@@ skipping 213 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;
 }
+
+// MenuBarHelper::Delegate implementation --------------------------------------
+void BookmarkBarGtk::PopupForButton(GtkWidget* button) {
+  const BookmarkNode* node = GetNodeForToolButton(button);
+  DCHECK(node);
+  DCHECK(page_navigator_);
+
+  int first_hidden = GetFirstHiddenBookmark(0, NULL);
+  if (button != overflow_button_ && button != other_bookmarks_button_ &&
+      node->GetParent()->IndexOfChild(node) >= first_hidden) {
+    return;
+  }
+
+  current_menu_.reset(
+      new BookmarkMenuController(browser_, profile_,
+                                 page_navigator_,
+                                 GTK_WINDOW(gtk_widget_get_toplevel(button)),
+                                 node,
+                                 button == overflow_button_ ?
+                                     first_hidden : 0,
+                                 false));
+  menu_bar_helper_.MenuStartedShowing(button, current_menu_->widget());
+  GdkEventButton* event =
+      reinterpret_cast<GdkEventButton*>(gtk_get_current_event());
+  current_menu_->Popup(button, event->button, event->time);
+}
+
+void BookmarkBarGtk::PopupForButtonNextTo(GtkWidget* button,
+                                          GtkMenuDirectionType dir) {
+  const BookmarkNode* relative_node = GetNodeForToolButton(button);
+  DCHECK(relative_node);
+
+  // Find out the order of the buttons.
+  std::vector<GtkWidget*> folder_list;
+  const int first_hidden = GetFirstHiddenBookmark(0, &folder_list);
+  if (first_hidden != -1)
+    folder_list.push_back(overflow_button_);
+  folder_list.push_back(other_bookmarks_button_);
+
+  // Find the position of |button|.
+  int button_idx = -1;
+  for (size_t i = 0; i < folder_list.size(); ++i) {
+    if (folder_list[i] == button) {
+      button_idx = i;
+      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]);
+}