Added support for icon views (view used instead of icon in a menu item).

ui/views/controls/menu/menu_item_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 "ui/views/controls/menu/menu_item_view.h"
 
 #include "base/i18n/case_conversion.h"
 #include "base/stl_util.h"
 #include "base/utf_string_conversions.h"
 #include "grit/ui_strings.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/canvas.h"
 #include "ui/views/controls/button/menu_button.h"
+#include "ui/views/controls/image_view.h"
 #include "ui/views/controls/menu/menu_config.h"
 #include "ui/views/controls/menu/menu_controller.h"
 #include "ui/views/controls/menu/menu_separator.h"
 #include "ui/views/controls/menu/submenu_view.h"
 
 namespace views {
 
 namespace {
 
 // EmptyMenuMenuItem ---------------------------------------------------------
@@ skipping 29 matching lines @@
 
 // MenuItemView ---------------------------------------------------------------
 
 // static
 const int MenuItemView::kMenuItemViewID = 1001;
 
 // static
 const int MenuItemView::kEmptyMenuItemViewID =
     MenuItemView::kMenuItemViewID + 1;
 
+//static
+gfx::ImageSkia MenuItemView::empty_icon_;
+
+// static
+int MenuItemView::icon_width_ = 0;

[Aaron Boodman, 2012/06/21 08:15:30]

Having this stuff be static is really weird, but I guess you're just sticking
with the current convention.

+
 // static
 int MenuItemView::label_start_;
 
 // static
 int MenuItemView::item_right_margin_;
 
 // static
 int MenuItemView::pref_menu_height_;
 
 // static
 const char MenuItemView::kViewClassName[] = "views/MenuItemView";
 
 MenuItemView::MenuItemView(MenuDelegate* delegate)
     : delegate_(delegate),
       controller_(NULL),
       canceled_(false),
       parent_menu_item_(NULL),
       type_(SUBMENU),
       selected_(false),
       command_(0),
       submenu_(NULL),
       has_mnemonics_(false),
       show_mnemonics_(false),
       has_icons_(false),
+      icon_view_type_(NONE),
       top_margin_(-1),
       bottom_margin_(-1),
       requested_menu_position_(POSITION_BEST_FIT),
       actual_menu_position_(requested_menu_position_),
       use_right_margin_(true) {
   // NOTE: don't check the delegate for NULL, UpdateMenuPartSizes supplies a
   // NULL delegate.
   Init(NULL, 0, SUBMENU, delegate);
 }
 
@@ skipping 113 matching lines @@
   DCHECK_GE(submenu_->child_count(), index);
   if (type == SEPARATOR) {
     submenu_->AddChildViewAt(new MenuSeparator(), index);
     return NULL;
   }
   MenuItemView* item = new MenuItemView(this, item_id, type);
   if (label.empty() && GetDelegate())
     item->SetTitle(GetDelegate()->GetLabel(item_id));
   else
     item->SetTitle(label);
-  item->SetIcon(icon);
+  if (!icon.empty())
+    item->SetIcon(icon);
   if (type == SUBMENU)
     item->CreateSubmenu();
   submenu_->AddChildViewAt(item, index);
   return item;
 }
 
 void MenuItemView::RemoveMenuItemAt(int index) {
   DCHECK(submenu_);
   DCHECK_LE(0, index);
   DCHECK_GT(submenu_->child_count(), index);
@@ skipping 120 matching lines @@
   item->tooltip_ = tooltip;
 }
 
 void MenuItemView::SetIcon(const gfx::ImageSkia& icon, int item_id) {
   MenuItemView* item = GetMenuItemByID(item_id);
   DCHECK(item);
   item->SetIcon(icon);
 }
 
 void MenuItemView::SetIcon(const gfx::ImageSkia& icon) {
-  icon_ = icon;
+  if (icon_view_type_ == IMAGE_VIEW) {
+    View* view = GetIconView();
+    static_cast<ImageView*>(view)->SetImage(&icon);
+    return;
+  }
+
+  ImageView* icon_view = new ImageView();
+  icon_view->SetImage(&icon);
+  SetIconView(icon_view);
+  icon_view_type_ = IMAGE_VIEW;
+}
+
+const gfx::ImageSkia& MenuItemView::GetIcon() {
+  if (icon_view_type_ != IMAGE_VIEW)
+    return empty_icon_;
+
+  View* view = GetIconView();
+  return static_cast<ImageView*>(view)->GetImage();
+}
+
+void MenuItemView::SetIconView(View* icon_view) {
+  DCHECK(icon_view);
+  View* child_view = GetIconView();
+  if (child_view) {
+    RemoveChildView(child_view);
+    delete child_view;
+  }
+  AddChildViewAt(icon_view, 0);
+  icon_view_type_ = SOME_VIEW;
   SchedulePaint();
 }
 
+View* MenuItemView::GetIconView() {
+  if (icon_view_type_ == NONE)
+    return NULL;
+
+  return child_at(0);
+}
+
 void MenuItemView::OnPaint(gfx::Canvas* canvas) {
   PaintButton(canvas, PB_NORMAL);
 }
 
 gfx::Size MenuItemView::GetPreferredSize() {
   if (pref_size_.IsEmpty())
     pref_size_ = CalculatePreferredSize();
   return pref_size_;
 }
 
@@ skipping 95 matching lines @@
     return;
 
   if (IsContainer()) {
     View* child = child_at(0);
     gfx::Size size = child->GetPreferredSize();
     child->SetBounds(0, GetTopMargin(), size.width(), size.height());
   } else {
     // Child views are laid out right aligned and given the full height. To
     // right align start with the last view and progress to the first.
     int x = width() - (use_right_margin_ ? item_right_margin_ : 0);
-    for (int i = child_count() - 1; i >= 0; --i) {
+    int first_non_icon_view = (icon_view_type_ != NONE) ? 1 : 0;

[Aaron Boodman, 2012/06/21 08:15:30]

If you have an icon_view_ member, you can remove this line and just skip the
icon_view_ in the loop below.

[yefimt, 2012/06/22 22:14:40]

Done.

+    for (int i = child_count() - 1; i >= first_non_icon_view; --i) {
       View* child = child_at(i);
       int width = child->GetPreferredSize().width();
       child->SetBounds(x - width, 0, width, height());
       x -= width - kChildXPadding;
     }
+    // Position icon_view
+    const MenuConfig& config = MenuConfig::instance();
+    if (icon_view_type_ != NONE) {
+      View* child = child_at(0);
+      child->SizeToPreferredSize();
+      gfx::Size size = child->GetPreferredSize();
+      int x = config.item_left_margin + (icon_width_ - size.width()) / 2;
+      int y = (height() + GetTopMargin() - GetBottomMargin() -
+               size.height()) / 2;
+      child->SetPosition(gfx::Point(x, y));
+    }
   }
 }
 
 int MenuItemView::GetAcceleratorTextWidth() {
   string16 text = GetAcceleratorText();
   return text.empty() ? 0 : GetFont().GetStringWidth(text);
 }
 
 void MenuItemView::SetMargins(int top_margin, int bottom_margin) {
   top_margin_ = top_margin;
   bottom_margin_ = bottom_margin;
 
   // invalidate GetPreferredSize() cache
   pref_size_.SetSize(0,0);
 }
 
+Border* MenuItemView::GetMenuBorder() {
+  return Border::CreateEmptyBorder(
+             MenuConfig::instance().submenu_vertical_margin_size,
+             MenuConfig::instance().submenu_horizontal_margin_size,
+             MenuConfig::instance().submenu_vertical_margin_size,
+             MenuConfig::instance().submenu_horizontal_margin_size);
+}
+
+Background* MenuItemView::GetMenuBackground() {
+  return NULL;
+}
+
 MenuItemView::MenuItemView(MenuItemView* parent,
                            int command,
                            MenuItemView::Type type)
     : delegate_(NULL),
       controller_(NULL),
       canceled_(false),
       parent_menu_item_(parent),
       type_(type),
       selected_(false),
       command_(command),
       submenu_(NULL),
       has_mnemonics_(false),
       show_mnemonics_(false),
       has_icons_(false),
+      icon_view_type_(NONE),
       top_margin_(-1),
       bottom_margin_(-1),
       requested_menu_position_(POSITION_BEST_FIT),
       actual_menu_position_(requested_menu_position_) {
   Init(parent, command, type, NULL);
 }
 
 MenuItemView::~MenuItemView() {
   delete submenu_;
   STLDeleteElements(&removed_items_);
 }
 
 std::string MenuItemView::GetClassName() const {
   return kViewClassName;
 }
 
 // Calculates all sizes that we can from the OS.
 //
 // This is invoked prior to Running a menu.
-void MenuItemView::UpdateMenuPartSizes(bool has_icons) {
+void MenuItemView::UpdateMenuPartSizes() {
   MenuConfig::Reset();
   const MenuConfig& config = MenuConfig::instance();
 
   item_right_margin_ = config.label_to_arrow_padding + config.arrow_width +
                        config.arrow_to_edge_padding;
+  icon_width_ = config.check_width;
+  if (has_icons_) {
+    for (int i = 0; i < submenu_->GetMenuItemCount(); ++i) {
+      MenuItemView* menu_item = submenu_->GetMenuItemAt(i);
+      if (menu_item->icon_view_type_ != NONE)
+        icon_width_ = std::max(icon_width_,
+            menu_item->child_at(0)->GetPreferredSize().width());
+    }
+  }
 
   if (config.always_use_icon_to_label_padding)
-    label_start_ = config.item_left_margin + config.check_width +
+    label_start_ = config.item_left_margin + icon_width_ +
                    config.icon_to_label_padding;
   else
     // If there are no icons don't pad by the icon to label padding. This
     // makes us look close to system menus.
-    label_start_ = config.item_left_margin + config.check_width +
-                   (has_icons ? config.icon_to_label_padding : 0);
+    label_start_ = config.item_left_margin + icon_width_ +
+                   (has_icons_ ? config.icon_to_label_padding : 0);
 
   if (config.render_gutter)
     label_start_ += config.gutter_width + config.gutter_to_label;
 
   MenuItemView menu_item(NULL);
   menu_item.SetTitle(ASCIIToUTF16("blah"));  // Text doesn't matter here.
   pref_menu_height_ = menu_item.GetPreferredSize().height();
 }
 
 void MenuItemView::Init(MenuItemView* parent,
@@ skipping 30 matching lines @@
   canceled_ = false;
 
   has_mnemonics_ = has_mnemonics;
   show_mnemonics_ = has_mnemonics && show_mnemonics;
 
   AddEmptyMenus();
 
   if (!MenuController::GetActiveInstance()) {
     // Only update the menu size if there are no menus showing, otherwise
     // things may shift around.
-    UpdateMenuPartSizes(has_icons_);
+    UpdateMenuPartSizes();
   }
 }
 
 int MenuItemView::GetDrawStringFlags() {
   int flags = 0;
   if (base::i18n::IsRTL())
     flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
   else
     flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
 
@@ skipping 114 matching lines @@
 gfx::Size MenuItemView::GetChildPreferredSize() {
   if (!has_children())
     return gfx::Size();
 
   if (IsContainer()) {
     View* child = child_at(0);
     return child->GetPreferredSize();
   }
 
   int width = 0;
-  for (int i = 0; i < child_count(); ++i) {
+  int i = (icon_view_type_ != NONE) ? 1 : 0;
+  for (; i < child_count(); ++i) {
     if (i)
       width += kChildXPadding;
-    width += child_at(i)->GetPreferredSize().width();
+    gfx::Size size = child_at(i)->GetPreferredSize();
+    width += size.width();
   }
+  int height = 0;
+  if (icon_view_type_ != NONE)
+    height = child_at(0)->GetPreferredSize().height();
+
   // Return a height of 0 to indicate that we should use the title height
   // instead.
-  return gfx::Size(width, 0);
+  return gfx::Size(width, height);
 }
 
 gfx::Size MenuItemView::CalculatePreferredSize() {
   gfx::Size child_size = GetChildPreferredSize();
   if (IsContainer()) {
     return gfx::Size(
         child_size.width(),
         child_size.height() + GetBottomMargin() + GetTopMargin());
   }
 
@@ skipping 21 matching lines @@
       accelerator.GetShortcutText() : string16();
 }
 
 bool MenuItemView::IsContainer() const {
   // Let the first child take over |this| when we only have one child and no
   // title.  Note that what child_count() returns is the number of children,
   // not the number of menu items.
   return child_count() == 1 && title_.empty();
 }
 
+bool MenuItemView::HasNonIconChildViews() {
+  return child_count() > ((icon_view_type_ != NONE) ? 1 : 0);
+}
+
 }  // namespace views