Make disabled browser actions on GTK right-clickable and draggable.

chrome/browser/ui/gtk/browser_actions_toolbar_gtk.cc

 // Copyright (c) 2012 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/browser_actions_toolbar_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <algorithm>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/message_loop.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/commands/command_service.h"
 #include "chrome/browser/extensions/api/commands/command_service_factory.h"
 #include "chrome/browser/extensions/extension_action_icon_factory.h"
 #include "chrome/browser/extensions/extension_context_menu_model.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
+#include "chrome/browser/ui/gtk/custom_button.h"
 #include "chrome/browser/ui/gtk/extensions/extension_popup_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_chrome_button.h"
 #include "chrome/browser/ui/gtk/gtk_chrome_shrinkable_hbox.h"
 #include "chrome/browser/ui/gtk/gtk_theme_service.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/hover_controller_gtk.h"
 #include "chrome/browser/ui/gtk/menu_gtk.h"
 #include "chrome/browser/ui/gtk/view_id_util.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_action.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "ui/base/accelerators/accelerator_gtk.h"
 #include "ui/base/gtk/gtk_compat.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia_paint.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/image/image.h"
+#include "ui/gfx/image/image_skia_operations.h"
 
 using extensions::Extension;
 
 namespace {
 
 // The width of the browser action buttons.
 const int kButtonWidth = 27;
 
 // The padding between browser action buttons.
 const int kButtonPadding = 4;
@@ skipping 57 matching lines @@
 
     DCHECK(extension_->browser_action());
 
     UpdateState();
 
     signals_.Connect(button(), "button-press-event",
                      G_CALLBACK(OnButtonPress), this);
     signals_.Connect(button(), "clicked",
                      G_CALLBACK(OnClicked), this);
     signals_.Connect(button(), "drag-begin",
-                     G_CALLBACK(&OnDragBegin), this);
+                     G_CALLBACK(OnDragBegin), this);
     signals_.ConnectAfter(widget(), "expose-event",
                      G_CALLBACK(OnExposeEvent), this);
     if (toolbar_->browser()->window()) {
       // If the window exists already, then the browser action button has been
       // recreated after the window was created, for example when the extension
       // is reloaded.
       ConnectBrowserActionPopupAccelerator();
     } else {
       // Window doesn't exist yet, wait for it.
       signals_.Connect(toolbar->widget(), "realize",
@@ skipping 73 matching lines @@
     int tab_id = toolbar_->GetCurrentTabId();
     if (tab_id < 0)
       return;
 
     std::string tooltip = extension_->browser_action()->GetTitle(tab_id);
     if (tooltip.empty())
       gtk_widget_set_has_tooltip(button(), FALSE);
     else
       gtk_widget_set_tooltip_text(button(), tooltip.c_str());
 
+    enabled_ = extension_->browser_action()->GetIsVisible(tab_id);
+    if (!enabled_)
+      button_->SetPaintOverride(GTK_STATE_INSENSITIVE);
+    else
+      button_->UnsetPaintOverride();
+
     gfx::Image image = icon_factory_.GetIcon(tab_id);
-    if (!image.IsEmpty())
-      SetImage(image.ToGdkPixbuf());
-    bool enabled = extension_->browser_action()->GetIsVisible(tab_id);
-    gtk_widget_set_sensitive(button(), enabled);
+    if (!image.IsEmpty()) {
+      if (enabled_) {
+        SetImage(image);
+      } else {
+        SetImage(gfx::Image(gfx::ImageSkiaOperations::CreateTransparentImage(
+            image.AsImageSkia(), .25)));
+      }
+    }
 
     gtk_widget_queue_draw(button());
   }
 
   gfx::Image GetIcon() {
     return icon_factory_.GetIcon(toolbar_->GetCurrentTabId());
   }
 
   MenuGtk* GetContextMenu() {
     if (!extension_->ShowConfigureContextMenus())
@@ skipping 19 matching lines @@
         break;
       case ExtensionToolbarModel::ACTION_SHOW_POPUP:
         ExtensionPopupGtk::Show(popup_url, browser, widget,
                                 ExtensionPopupGtk::SHOW);
         break;
     }
   }
 
   // MenuGtk::Delegate implementation.
   virtual void StoppedShowing() {
-    button_->UnsetPaintOverride();
+    if (enabled_)
+      button_->UnsetPaintOverride();
+    else
+      button_->SetPaintOverride(GTK_STATE_INSENSITIVE);
 
     // If the context menu was showing for the overflow menu, re-assert the
     // grab that was shadowed.
     if (toolbar_->overflow_menu_.get())
       gtk_util::GrabAllInput(toolbar_->overflow_menu_->widget());
   }
 
   virtual void CommandWillBeExecuted() {
     // If the context menu was showing for the overflow menu, and a command
     // is executed, then stop showing the overflow menu.
     if (toolbar_->overflow_menu_.get())
       toolbar_->overflow_menu_->Cancel();
   }
 
   // ExtensionContextMenuModel::PopupDelegate implementation.
   virtual void InspectPopup(ExtensionAction* action) {
     GURL popup_url = action->GetPopupUrl(toolbar_->GetCurrentTabId());
     ExtensionPopupGtk::Show(popup_url, toolbar_->browser(), widget(),
                             ExtensionPopupGtk::SHOW_AND_INSPECT);
   }
 
-  void SetImage(GdkPixbuf* image) {
+  void SetImage(const gfx::Image& image) {
     if (!image_) {
-      image_ = gtk_image_new_from_pixbuf(image);
+      image_ = gtk_image_new_from_pixbuf(image.ToGdkPixbuf());
       gtk_button_set_image(GTK_BUTTON(button()), image_);
     } else {
-      gtk_image_set_from_pixbuf(GTK_IMAGE(image_), image);
+      gtk_image_set_from_pixbuf(GTK_IMAGE(image_), image.ToGdkPixbuf());
     }
   }
 
   static gboolean OnButtonPress(GtkWidget* widget,
                                 GdkEventButton* event,
-                                BrowserActionButton* action) {
+                                BrowserActionButton* button) {
     if (event->button != 3)
       return FALSE;
 
-    MenuGtk* menu = action->GetContextMenu();
+    MenuGtk* menu = button->GetContextMenu();
     if (!menu)
       return FALSE;
 
-    action->button_->SetPaintOverride(GTK_STATE_ACTIVE);
+    button->button_->SetPaintOverride(GTK_STATE_ACTIVE);
     menu->PopupForWidget(widget, event->button, event->time);
 
     return TRUE;
   }
 
-  static void OnClicked(GtkWidget* widget, BrowserActionButton* action) {
-    action->Activate(widget);
+  static void OnClicked(GtkWidget* widget, BrowserActionButton* button) {
+    if (button->enabled_)
+      button->Activate(widget);
   }
 
   static gboolean OnExposeEvent(GtkWidget* widget,
                                 GdkEventExpose* event,
                                 BrowserActionButton* button) {
     int tab_id = button->toolbar_->GetCurrentTabId();
     if (tab_id < 0)
       return FALSE;
 
     ExtensionAction* action = button->extension_->browser_action();
@@ skipping 99 matching lines @@
 
   // The toolbar containing this button.
   BrowserActionsToolbarGtk* toolbar_;
 
   // The extension that contains this browser action.
   const Extension* extension_;
 
   // The button for this browser action.
   scoped_ptr<CustomDrawButton> button_;
 
+  // Whether the browser action is enabled (equivalent to whether a page action
+  // is visible).
+  bool enabled_;
+
   // The top level widget (parent of |button_|).
   ui::OwnedWidgetGtk alignment_;
 
   // The one image subwidget in |button_|. We keep this out so we don't alter
   // the widget hierarchy while changing the button image because changing the
   // GTK widget hierarchy invalidates all tooltips and several popular
   // extensions change browser action icon in a loop.
   GtkWidget* image_;
 
   // The object that will be used to get the browser action icon for us.
@@ skipping 625 matching lines @@
 
   menu->PopupAsContext(gfx::Point(event->x_root, event->y_root),
                        event->time);
   return TRUE;
 }
 
 void BrowserActionsToolbarGtk::OnButtonShowOrHide(GtkWidget* sender) {
   if (!resize_animation_.is_animating())
     UpdateChevronVisibility();
 }