Make bookmark bar folder buttons look active so long as the menu is open....

chrome/browser/gtk/bookmark_menu_controller_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_menu_controller_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/gfx/gtk_util.h"
 #include "base/string_util.h"
 #include "chrome/browser/gtk/bookmark_context_menu.h"
 #include "chrome/browser/gtk/bookmark_utils_gtk.h"
+#include "chrome/browser/gtk/gtk_chrome_button.h"
 #include "chrome/browser/gtk/gtk_dnd_util.h"
 #include "chrome/browser/gtk/gtk_theme_provider.h"
 #include "chrome/browser/gtk/menu_gtk.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/page_navigator.h"
 #include "chrome/common/gtk_util.h"
 #include "grit/app_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "webkit/glue/window_open_disposition.h"
@@ skipping 23 matching lines @@
                                                PageNavigator* navigator,
                                                GtkWindow* window,
                                                const BookmarkNode* node,
                                                int start_child_index,
                                                bool show_other_folder)
     : browser_(browser),
       profile_(profile),
       page_navigator_(navigator),
       parent_window_(window),
       node_(node),
-      ignore_button_release_(false) {
+      ignore_button_release_(false),
+      triggering_widget_(NULL) {
   menu_.Own(gtk_menu_new());
   BuildMenu(node, start_child_index, menu_.get());
+  g_signal_connect(menu_.get(), "hide",
+                   G_CALLBACK(OnMenuHidden), this);
   gtk_widget_show_all(menu_.get());
 }
 
 BookmarkMenuController::~BookmarkMenuController() {
   profile_->GetBookmarkModel()->RemoveObserver(this);
   menu_.Destroy();
 }
 
 void BookmarkMenuController::Popup(GtkWidget* widget, gint button_type,
                                    guint32 timestamp) {
   profile_->GetBookmarkModel()->AddObserver(this);
 
+  triggering_widget_ = widget;
+  gtk_chrome_button_set_paint_state(GTK_CHROME_BUTTON(widget),
+                                    GTK_STATE_ACTIVE);
   gtk_menu_popup(GTK_MENU(menu_.get()), NULL, NULL,
                  &MenuGtk::MenuPositionFunc,
                  widget, button_type, timestamp);
 }
 
 void BookmarkMenuController::BookmarkModelChanged() {
   gtk_menu_popdown(GTK_MENU(menu_.get()));
 }
 
 void BookmarkMenuController::BookmarkNodeFavIconLoaded(
@@ skipping 67 matching lines @@
   }
 
   if (parent->GetChildCount() == 0) {
     GtkWidget* empty_menu = gtk_menu_item_new_with_label(
         l10n_util::GetStringUTF8(IDS_MENU_EMPTY_SUBMENU).c_str());
     gtk_widget_set_sensitive(empty_menu, FALSE);
     gtk_menu_shell_append(GTK_MENU_SHELL(menu), empty_menu);
   }
 }
 
+// static
 gboolean BookmarkMenuController::OnButtonPressed(
     GtkWidget* sender,
     GdkEventButton* event,
     BookmarkMenuController* controller) {
   controller->ignore_button_release_ = false;
 
   if (event->button == 3) {
     // Show the right click menu and stop processing this button event.
     const BookmarkNode* node = GetNodeFromMenuItem(sender);
     const BookmarkNode* parent = node->GetParent();
     std::vector<const BookmarkNode*> nodes;
     nodes.push_back(node);
     controller->context_menu_.reset(
         new BookmarkContextMenu(
             sender, controller->profile_, controller->browser_,
             controller->page_navigator_, parent, nodes,
             BookmarkContextMenu::BOOKMARK_BAR));
     controller->context_menu_->PopupAsContext(event->time);
     return TRUE;
   }
 
   return FALSE;
 }
 
+// static
 gboolean BookmarkMenuController::OnButtonReleased(
     GtkWidget* sender,
     GdkEventButton* event,
     BookmarkMenuController* controller) {
   if (controller->ignore_button_release_) {
     // Don't handle this message; it was a drag.
     controller->ignore_button_release_ = false;
     return FALSE;
   }
 
   // Releasing either button 1 or 2 should trigger the bookmark menu.
   if (event->button == 1 || event->button == 2) {
     WindowOpenDisposition disposition =
         event_utils::DispositionFromEventFlags(event->state);
     controller->NavigateToMenuItem(sender, disposition);
 
     // We need to manually dismiss the popup menu because we're overriding
     // button-release-event.
     gtk_menu_popdown(GTK_MENU(controller->menu_.get()));
     return TRUE;
   }
 
   return FALSE;
 }
 
+// static
+void BookmarkMenuController::OnMenuHidden(GtkWidget* menu,
+    BookmarkMenuController* controller) {
+  if (controller->triggering_widget_) {
+    gtk_chrome_button_unset_paint_state(
+        GTK_CHROME_BUTTON(controller->triggering_widget_));
+  }
+}
+
+// static
 void BookmarkMenuController::OnMenuItemActivated(
     GtkMenuItem* menu_item, BookmarkMenuController* controller) {
   controller->NavigateToMenuItem(GTK_WIDGET(menu_item), CURRENT_TAB);
 }
 
 // static
 void BookmarkMenuController::OnMenuItemDragBegin(
     GtkWidget* menu_item,
     GdkDragContext* drag_context,
     BookmarkMenuController* controller) {
@@ skipping 29 matching lines @@
 // static
 void BookmarkMenuController::OnMenuItemDragGet(
     GtkWidget* widget, GdkDragContext* context,
     GtkSelectionData* selection_data,
     guint target_type, guint time,
     BookmarkMenuController* controller) {
   const BookmarkNode* node = bookmark_utils::BookmarkNodeForWidget(widget);
   bookmark_utils::WriteBookmarkToSelection(node, selection_data, target_type,
                                            controller->profile_);
 }