Action box menu

chrome/browser/ui/views/browser_action_view.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/views/browser_action_view.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_context_menu_model.h"
@@ skipping 23 matching lines @@
   alpha.setConfig(SkBitmap::kARGB_8888_Config, image.width(), image.height());
   alpha.allocPixels();
   alpha.eraseColor(SkColorSetARGB(64, 0, 0, 0));
 
   return SkBitmapOperations::CreateMaskedBitmap(image, alpha);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
+// BrowserActionView
+
+bool BrowserActionView::Delegate::NeedToShowMultipleIconStates() const {
+  return true;
+}
+
+bool BrowserActionView::Delegate::NeedToShowTooltip() const {
+  return true;
+}
+
+BrowserActionView::BrowserActionView(const Extension* extension,
+                                     Browser* browser,
+                                     BrowserActionView::Delegate* delegate)
+    : browser_(browser),
+      delegate_(delegate),
+      button_(NULL),
+      extension_(extension) {
+}
+
+BrowserActionView::~BrowserActionView() {
+}
+
+gfx::Canvas* BrowserActionView::GetIconWithBadge() {
+  int tab_id = delegate_->GetCurrentTabId();
+
+  SkBitmap icon =
+      *button_->extension()->browser_action()->GetIcon(tab_id).ToSkBitmap();
+
+  // Dim the icon if our button is disabled.
+  if (!button_->IsEnabled(tab_id))
+    icon = MakeTransparent(icon);
+
+  gfx::Canvas* canvas =
+      new gfx::Canvas(gfx::ImageSkiaRep(icon, ui::SCALE_FACTOR_100P), false);
+
+  gfx::Rect bounds(icon.width(), icon.height() + ToolbarView::kVertSpacing);
+  button_->extension()->browser_action()->PaintBadge(canvas, bounds, tab_id);
+
+  return canvas;
+}
+
+void BrowserActionView::Layout() {
+  // We can't rely on button_->GetPreferredSize() here because that's not set
+  // correctly until the first call to
+  // BrowserActionsContainer::RefreshBrowserActionViews(), whereas this can be
+  // called before that when the initial bounds are set (and then not after,
+  // since the bounds don't change).  So instead of setting the height from the
+  // button's preferred size, we use IconHeight(), since that's how big the
+  // button should be regardless of what it's displaying.
+  gfx::Point offset = delegate_->GetViewContentOffset();
+  button_->SetBounds(offset.x(), offset.y(), width() - offset.x(),
+                     BrowserActionsContainer::IconHeight());
+}
+
+void BrowserActionView::ViewHierarchyChanged(bool is_add,
+                                             View* parent,
+                                             View* child) {
+  if (is_add && (child == this)) {
+    button_ = new BrowserActionButton(extension_, browser_, delegate_);
+    button_->set_drag_controller(delegate_);
+
+    AddChildView(button_);
+    button_->UpdateState();
+  }
+}
+
+void BrowserActionView::GetAccessibleState(ui::AccessibleViewState* state) {
+  state->name = l10n_util::GetStringUTF16(
+      IDS_ACCNAME_EXTENSIONS_BROWSER_ACTION);
+  state->role = ui::AccessibilityTypes::ROLE_GROUPING;
+}
+
+gfx::Size BrowserActionView::GetPreferredSize() {
+  return gfx::Size(BrowserActionsContainer::IconWidth(false),
+                   BrowserActionsContainer::IconHeight());
+}
+
+void BrowserActionView::PaintChildren(gfx::Canvas* canvas) {
+  View::PaintChildren(canvas);
+  ExtensionAction* action = button()->browser_action();
+  int tab_id = delegate_->GetCurrentTabId();
+  if (tab_id >= 0)
+    action->PaintBadge(canvas, gfx::Rect(width(), height()), tab_id);
+}
+
+////////////////////////////////////////////////////////////////////////////////
 // BrowserActionButton
 
 BrowserActionButton::BrowserActionButton(const Extension* extension,
-                                         BrowserActionsContainer* panel)
+                                         Browser* browser,
+                                         BrowserActionView::Delegate* delegate)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           MenuButton(this, string16(), NULL, false)),
+      browser_(browser),
       browser_action_(extension->browser_action()),
       extension_(extension),
       ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)),
-      panel_(panel),
+      delegate_(delegate),
       context_menu_(NULL) {
   set_border(NULL);
   set_alignment(TextButton::ALIGN_CENTER);
   set_context_menu_controller(this);
 
   // No UpdateState() here because View hierarchy not setup yet. Our parent
   // should call UpdateState() after creation.
 
+  content::NotificationSource notification_source =
+      content::Source<Profile>(browser_->profile()->GetOriginalProfile());
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED,
                  content::Source<ExtensionAction>(browser_action_));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_COMMAND_ADDED,
-                 content::Source<Profile>(
-                     panel_->profile()->GetOriginalProfile()));
+                 notification_source);
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_COMMAND_REMOVED,
-                 content::Source<Profile>(
-                     panel_->profile()->GetOriginalProfile()));
+                 notification_source);
 }
 
 void BrowserActionButton::Destroy() {
   MaybeUnregisterExtensionCommand(false);
 
   if (context_menu_) {
     context_menu_->Cancel();
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   } else {
     delete this;
@@ skipping 30 matching lines @@
   return true;
 }
 
 void BrowserActionButton::GetAccessibleState(ui::AccessibleViewState* state) {
   views::MenuButton::GetAccessibleState(state);
   state->role = ui::AccessibilityTypes::ROLE_PUSHBUTTON;
 }
 
 void BrowserActionButton::ButtonPressed(views::Button* sender,
                                         const views::Event& event) {
-  panel_->OnBrowserActionExecuted(this);
+  delegate_->OnBrowserActionExecuted(this);
 }
 
 void BrowserActionButton::ShowContextMenuForView(View* source,
                                                  const gfx::Point& point) {
   if (!extension()->ShowConfigureContextMenus())
     return;
 
   SetButtonPushed();
 
   // Reconstructs the menu every time because the menu's contents are dynamic.
   scoped_refptr<ExtensionContextMenuModel> context_menu_contents_(
-      new ExtensionContextMenuModel(extension(), panel_->browser()));
+      new ExtensionContextMenuModel(extension(), browser_));
   views::MenuModelAdapter menu_model_adapter(context_menu_contents_.get());
-  views::MenuRunner menu_runner(menu_model_adapter.CreateMenu());
+  menu_runner_.reset(new views::MenuRunner(menu_model_adapter.CreateMenu()));
 
-  context_menu_ = menu_runner.GetMenu();
+  context_menu_ = menu_runner_->GetMenu();
   gfx::Point screen_loc;
   views::View::ConvertPointToScreen(this, &screen_loc);
-  if (menu_runner.RunMenuAt(GetWidget(), NULL, gfx::Rect(screen_loc, size()),
+  if (menu_runner_->RunMenuAt(GetWidget(), NULL, gfx::Rect(screen_loc, size()),
           views::MenuItemView::TOPLEFT, views::MenuRunner::HAS_MNEMONICS) ==
-      views::MenuRunner::MENU_DELETED)
+          views::MenuRunner::MENU_DELETED) {
     return;
+  }
 
+  menu_runner_.reset();
   SetButtonNotPushed();
   context_menu_ = NULL;
 }
 
 void BrowserActionButton::OnImageLoaded(const gfx::Image& image,
                                         const std::string& extension_id,
                                         int index) {
   browser_action_->CacheIcon(browser_action_->default_icon_path(), image);
 
   // Call back to UpdateState() because a more specific icon might have been set
   // while the load was outstanding.
   UpdateState();
 }
 
 void BrowserActionButton::UpdateState() {
-  int tab_id = panel_->GetCurrentTabId();
+  int tab_id = delegate_->GetCurrentTabId();
   if (tab_id < 0)
     return;
 
+  SetShowMultipleIconStates(delegate_->NeedToShowMultipleIconStates());
+
   if (!IsEnabled(tab_id)) {
     SetState(views::CustomButton::BS_DISABLED);
   } else {
     SetState(menu_visible_ ?
              views::CustomButton::BS_PUSHED :
              views::CustomButton::BS_NORMAL);
   }
 
   SkBitmap icon(*browser_action()->GetIcon(tab_id).ToSkBitmap());
   if (!icon.isNull()) {
@@ skipping 24 matching lines @@
     rb.GetBitmapNamed(IDR_BROWSER_ACTION_P)->copyTo(&bg_p,
         SkBitmap::kARGB_8888_Config);
     SkCanvas bg_p_canvas(bg_p);
     bg_p_canvas.drawBitmap(icon,
         SkIntToScalar((bg_p.width() - icon.width()) / 2),
         SkIntToScalar((bg_p.height() - icon.height()) / 2), &paint);
     SetPushedIcon(bg_p);
   }
 
   // If the browser action name is empty, show the extension name instead.
-  string16 name = UTF8ToUTF16(browser_action()->GetTitle(tab_id));
-  if (name.empty())
-    name = UTF8ToUTF16(extension()->name());
-  SetTooltipText(name);
+  std::string title = browser_action()->GetTitle(tab_id);
+  string16 name = UTF8ToUTF16(title.empty() ? extension()->name() : title);
+  SetTooltipText(delegate_->NeedToShowTooltip() ? name : string16());
   SetAccessibleName(name);
 
   parent()->SchedulePaint();
 }
 
 bool BrowserActionButton::IsPopup() {
-  int tab_id = panel_->GetCurrentTabId();
+  int tab_id = delegate_->GetCurrentTabId();
   return (tab_id < 0) ? false : browser_action_->HasPopup(tab_id);
 }
 
 GURL BrowserActionButton::GetPopupUrl() {
-  int tab_id = panel_->GetCurrentTabId();
+  int tab_id = delegate_->GetCurrentTabId();
   return (tab_id < 0) ? GURL() : browser_action_->GetPopupUrl(tab_id);
 }
 
 void BrowserActionButton::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   switch (type) {
     case chrome::NOTIFICATION_EXTENSION_BROWSER_ACTION_UPDATED:
       UpdateState();
       // The browser action may have become visible/hidden so we need to make
       // sure the state gets updated.
-      panel_->OnBrowserActionVisibilityChanged();
+      delegate_->OnBrowserActionVisibilityChanged();
       break;
     case chrome::NOTIFICATION_EXTENSION_COMMAND_ADDED:
     case chrome::NOTIFICATION_EXTENSION_COMMAND_REMOVED: {
       std::pair<const std::string, const std::string>* payload =
           content::Details<std::pair<const std::string, const std::string> >(
               details).ptr();
       if (extension_->id() == payload->first &&
           payload->second ==
               extension_manifest_values::kBrowserActionCommandEvent) {
         if (type == chrome::NOTIFICATION_EXTENSION_COMMAND_ADDED)
           MaybeRegisterExtensionCommand();
         else
           MaybeUnregisterExtensionCommand(true);
       }
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 }
 
 bool BrowserActionButton::Activate() {
   if (!IsPopup())
     return true;
 
-  panel_->OnBrowserActionExecuted(this);
+  delegate_->OnBrowserActionExecuted(this);
 
   // TODO(erikkay): Run a nested modal loop while the mouse is down to
   // enable menu-like drag-select behavior.
 
   // The return value of this method is returned via OnMousePressed.
   // We need to return false here since we're handing off focus to another
   // widget/view, and true will grab it right back and try to send events
   // to us.
   return false;
 }
@@ skipping 28 matching lines @@
     TextButton::OnMouseExited(event);
 }
 
 bool BrowserActionButton::OnKeyReleased(const views::KeyEvent& event) {
   return IsPopup() ? MenuButton::OnKeyReleased(event)
                    : TextButton::OnKeyReleased(event);
 }
 
 bool BrowserActionButton::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
-  panel_->OnBrowserActionExecuted(this);
+  delegate_->OnBrowserActionExecuted(this);
   return true;
 }
 
 void BrowserActionButton::SetButtonPushed() {
   SetState(views::CustomButton::BS_PUSHED);
   menu_visible_ = true;
 }
 
 void BrowserActionButton::SetButtonNotPushed() {
   SetState(views::CustomButton::BS_NORMAL);
   menu_visible_ = false;
 }
 
 bool BrowserActionButton::IsEnabled(int tab_id) const {
   return browser_action_->GetIsVisible(tab_id);
 }
 
 BrowserActionButton::~BrowserActionButton() {
 }
 
 void BrowserActionButton::MaybeRegisterExtensionCommand() {
   extensions::CommandService* command_service =
-      extensions::CommandServiceFactory::GetForProfile(
-          panel_->browser()->profile());
+      extensions::CommandServiceFactory::GetForProfile(browser_->profile());
   extensions::Command browser_action_command;
   if (command_service->GetBrowserActionCommand(
           extension_->id(),
           extensions::CommandService::ACTIVE_ONLY,
           &browser_action_command,
           NULL)) {
     keybinding_.reset(new ui::Accelerator(
         browser_action_command.accelerator()));
-    panel_->GetFocusManager()->RegisterAccelerator(
+    GetFocusManager()->RegisterAccelerator(
         *keybinding_.get(), ui::AcceleratorManager::kHighPriority, this);
   }
 }
 
 void BrowserActionButton::MaybeUnregisterExtensionCommand(bool only_if_active) {
-  if (!keybinding_.get() || !panel_->GetFocusManager())
+  if (!keybinding_.get() || !GetFocusManager())
     return;
 
   extensions::CommandService* command_service =
-      extensions::CommandServiceFactory::GetForProfile(
-          panel_->browser()->profile());
+      extensions::CommandServiceFactory::GetForProfile(browser_->profile());
 
   extensions::Command browser_action_command;
   if (!only_if_active || !command_service->GetBrowserActionCommand(
           extension_->id(),
           extensions::CommandService::ACTIVE_ONLY,
           &browser_action_command,
           NULL)) {
-    panel_->GetFocusManager()->UnregisterAccelerator(*keybinding_.get(), this);
+    GetFocusManager()->UnregisterAccelerator(*keybinding_.get(), this);
   }
 }
-
-
-////////////////////////////////////////////////////////////////////////////////
-// BrowserActionView
-
-BrowserActionView::BrowserActionView(const Extension* extension,
-                                     BrowserActionsContainer* panel)
-    : panel_(panel) {
-  button_ = new BrowserActionButton(extension, panel);
-  button_->set_drag_controller(panel_);
-  AddChildView(button_);
-  button_->UpdateState();
-}
-
-BrowserActionView::~BrowserActionView() {
-  RemoveChildView(button_);
-  button_->Destroy();
-}
-
-gfx::Canvas* BrowserActionView::GetIconWithBadge() {
-  int tab_id = panel_->GetCurrentTabId();
-
-  SkBitmap icon = *button_->extension()->browser_action()->GetIcon(
-      tab_id).ToSkBitmap();
-
-  // Dim the icon if our button is disabled.
-  if (!button_->IsEnabled(tab_id))
-    icon = MakeTransparent(icon);
-
-  gfx::Canvas* canvas =
-      new gfx::Canvas(gfx::ImageSkiaRep(icon, ui::SCALE_FACTOR_100P), false);
-
-  if (tab_id >= 0) {
-    gfx::Rect bounds(icon.width(), icon.height() + ToolbarView::kVertSpacing);
-    button_->extension()->browser_action()->PaintBadge(canvas, bounds, tab_id);
-  }
-
-  return canvas;
-}
-
-void BrowserActionView::Layout() {
-  // We can't rely on button_->GetPreferredSize() here because that's not set
-  // correctly until the first call to
-  // BrowserActionsContainer::RefreshBrowserActionViews(), whereas this can be
-  // called before that when the initial bounds are set (and then not after,
-  // since the bounds don't change).  So instead of setting the height from the
-  // button's preferred size, we use IconHeight(), since that's how big the
-  // button should be regardless of what it's displaying.
-  button_->SetBounds(0, ToolbarView::kVertSpacing, width(),
-                     BrowserActionsContainer::IconHeight());
-}
-
-void BrowserActionView::GetAccessibleState(ui::AccessibleViewState* state) {
-  state->name = l10n_util::GetStringUTF16(
-      IDS_ACCNAME_EXTENSIONS_BROWSER_ACTION);
-  state->role = ui::AccessibilityTypes::ROLE_GROUPING;
-}
-
-void BrowserActionView::PaintChildren(gfx::Canvas* canvas) {
-  View::PaintChildren(canvas);
-  ExtensionAction* action = button()->browser_action();
-  int tab_id = panel_->GetCurrentTabId();
-  if (tab_id >= 0)
-    action->PaintBadge(canvas, gfx::Rect(width(), height()), tab_id);
-}