Added MenuConfig setter to MenuItemView, updated rest of the code to use set MenuConfig if it avail…

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"
@@ skipping 78 matching lines @@
       command_(0),
       submenu_(NULL),
       has_mnemonics_(false),
       show_mnemonics_(false),
       has_icons_(false),
       icon_view_(NULL),
       top_margin_(-1),
       bottom_margin_(-1),
       requested_menu_position_(POSITION_BEST_FIT),
       actual_menu_position_(requested_menu_position_),
-      use_right_margin_(true) {
+      use_right_margin_(true),
+      menu_config_(NULL) {
   // NOTE: don't check the delegate for NULL, UpdateMenuPartSizes supplies a
   // NULL delegate.
   Init(NULL, 0, SUBMENU, delegate);
 }
 
 void MenuItemView::ChildPreferredSizeChanged(View* child) {
   pref_size_.SetSize(0, 0);
   PreferredSizeChanged();
 }
 
@@ skipping 102 matching lines @@
     const string16& label,
     const gfx::ImageSkia& icon,
     Type type,
     ui::MenuSeparatorType separator_style) {
   DCHECK_NE(type, EMPTY);
   DCHECK_LE(0, index);
   if (!submenu_)
     CreateSubmenu();
   DCHECK_GE(submenu_->child_count(), index);
   if (type == SEPARATOR) {
-    submenu_->AddChildViewAt(new MenuSeparator(separator_style), index);
+    submenu_->AddChildViewAt(new MenuSeparator(this, separator_style), 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);
   if (!icon.isNull())
     item->SetIcon(icon);
   if (type == SUBMENU)
@@ skipping 290 matching lines @@
     int x = width() - (use_right_margin_ ? item_right_margin_ : 0);
     for (int i = child_count() - 1; i >= 0; --i) {
       View* child = child_at(i);
       if (icon_view_ && (icon_view_ == child))
         continue;
       int width = child->GetPreferredSize().width();
       child->SetBounds(x - width, 0, width, height());
       x -= width - kChildXPadding;
     }
     // Position |icon_view|.
-    const MenuConfig& config = MenuConfig::instance();
+    const MenuConfig& config = GetMenuConfig();
     if (icon_view_) {
       icon_view_->SizeToPreferredSize();
       gfx::Size size = icon_view_->GetPreferredSize();
       int x = config.item_left_margin + (icon_area_width_ - size.width()) / 2;
       int y =
           (height() + GetTopMargin() - GetBottomMargin() - size.height()) / 2;
       icon_view_->SetPosition(gfx::Point(x, y));
     }
   }
 }
 
 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);
 }
 
+const MenuConfig& MenuItemView::GetMenuConfig() const {
+  const MenuItemView* root_menu_item = GetRootMenuItem();
+  if (root_menu_item->menu_config_)
+   return *(root_menu_item->menu_config_);
+
+ return MenuConfig::instance();
+}
+
 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_(NULL),
       top_margin_(-1),
       bottom_margin_(-1),
       requested_menu_position_(POSITION_BEST_FIT),
-      actual_menu_position_(requested_menu_position_) {
+      actual_menu_position_(requested_menu_position_),
+      menu_config_(NULL) {
   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() {
   MenuConfig::Reset();
-  const MenuConfig& config = MenuConfig::instance();
+  const MenuConfig& config = GetMenuConfig();
 
   item_right_margin_ = config.label_to_arrow_padding + config.arrow_width +
                        config.arrow_to_edge_padding;
   icon_area_width_ = config.check_width;
   if (has_icons_)
     icon_area_width_ = std::max(icon_area_width_, GetMaxIconViewWidth());
 
   if (config.always_use_icon_to_label_padding)
     label_start_ = config.item_left_margin + icon_area_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 + icon_area_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();
+  string16 original_title = title();
+  SetTitle(ASCIIToUTF16("blah"));  // Text doesn't matter here.

[sky, 2012/10/05 21:33:40]

I don't like doing this, it may have side effects.

[yefimt, 2012/10/08 20:02:47]

OK, I think this should be better

On 2012/10/05 21:33:40, sky wrote:

+  pref_menu_height_ = GetPreferredSize().height();
+  SetTitle(original_title);
 }
 
 void MenuItemView::Init(MenuItemView* parent,
                         int command,
                         MenuItemView::Type type,
                         MenuDelegate* delegate) {
   delegate_ = delegate;
   controller_ = NULL;
   canceled_ = false;
   parent_menu_item_ = parent;
@@ skipping 35 matching lines @@
 }
 
 int MenuItemView::GetDrawStringFlags() {
   int flags = 0;
   if (base::i18n::IsRTL())
     flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
   else
     flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
 
   if (has_mnemonics_) {
-    if (MenuConfig::instance().show_mnemonics ||
-        GetRootMenuItem()->show_mnemonics_) {
+    if (GetMenuConfig().show_mnemonics || GetRootMenuItem()->show_mnemonics_) {
       flags |= gfx::Canvas::SHOW_PREFIX;
     } else {
       flags |= gfx::Canvas::HIDE_PREFIX;
     }
   }
   return flags;
 }
 
 const gfx::Font& MenuItemView::GetFont() {
   // Check for item-specific font.
   const MenuDelegate* delegate = GetDelegate();
   return delegate ?
-      delegate->GetLabelFont(GetCommand()) : MenuConfig::instance().font;
+      delegate->GetLabelFont(GetCommand()) : GetMenuConfig().font;
 }
 
 void MenuItemView::AddEmptyMenus() {
   DCHECK(HasSubmenu());
   if (!submenu_->has_children()) {
     submenu_->AddChildViewAt(new EmptyMenuMenuItem(this), 0);
   } else {
     for (int i = 0, item_count = submenu_->GetMenuItemCount(); i < item_count;
          ++i) {
       MenuItemView* child = submenu_->GetMenuItemAt(i);
@@ skipping 27 matching lines @@
 
 void MenuItemView::PaintAccelerator(gfx::Canvas* canvas) {
   string16 accel_text = GetAcceleratorText();
   if (accel_text.empty())
     return;
 
   const gfx::Font& font = GetFont();
   int available_height = height() - GetTopMargin() - GetBottomMargin();
   int max_accel_width =
       parent_menu_item_->GetSubmenu()->max_accelerator_width();
-  const MenuConfig& config = MenuConfig::instance();
+  const MenuConfig& config = GetMenuConfig();
   int accel_right_margin = config.align_arrow_and_shortcut ?
                            config.arrow_to_edge_padding :  item_right_margin_;
   gfx::Rect accel_bounds(width() - accel_right_margin - max_accel_width,
                          GetTopMargin(), max_accel_width, available_height);
   accel_bounds.set_x(GetMirroredXForRect(accel_bounds));
   int flags = GetRootMenuItem()->GetDrawStringFlags() |
       gfx::Canvas::TEXT_VALIGN_MIDDLE;
   flags &= ~(gfx::Canvas::TEXT_ALIGN_RIGHT | gfx::Canvas::TEXT_ALIGN_LEFT);
   if (base::i18n::IsRTL())
     flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
@@ skipping 16 matching lines @@
     submenu_->GetMenuItemAt(i)->DestroyAllMenuHosts();
   }
 }
 
 int MenuItemView::GetTopMargin() {
   if (top_margin_ >= 0)
     return top_margin_;
 
   MenuItemView* root = GetRootMenuItem();
   return root && root->has_icons_
-      ? MenuConfig::instance().item_top_margin :
-        MenuConfig::instance().item_no_icon_top_margin;
+      ? GetMenuConfig().item_top_margin :
+        GetMenuConfig().item_no_icon_top_margin;
 }
 
 int MenuItemView::GetBottomMargin() {
   if (bottom_margin_ >= 0)
     return bottom_margin_;
 
   MenuItemView* root = GetRootMenuItem();
   return root && root->has_icons_
-      ? MenuConfig::instance().item_bottom_margin :
-        MenuConfig::instance().item_no_icon_bottom_margin;
+      ? GetMenuConfig().item_bottom_margin :
+        GetMenuConfig().item_no_icon_bottom_margin;
 }
 
 gfx::Size MenuItemView::GetChildPreferredSize() {
   if (!has_children())
     return gfx::Size();
 
   if (IsContainer()) {
     View* child = child_at(0);
     return child->GetPreferredSize();
   }
@@ skipping 34 matching lines @@
       item_right_margin_;
   // Determine the length of the accelerator text.
   string16 text = GetAcceleratorText();
   dimensions.accelerator_width =
       text.empty() ? 0 : GetFont().GetStringWidth(text);
 
   // Determine the height to use.
   dimensions.height = std::max(dimensions.height,
       font.GetHeight() + GetBottomMargin() + GetTopMargin());
   dimensions.height = std::max(dimensions.height,
-      MenuConfig::instance().item_min_height);
+      GetMenuConfig().item_min_height);
   return dimensions;
 }
 
 gfx::Size MenuItemView::CalculatePreferredSize() {
   MenuItemView::MenuItemDimensions dimensions = GetPreferredDimensions();
   return gfx::Size(dimensions.standard_width + dimensions.children_width,
                    dimensions.height);
 }
 
 string16 MenuItemView::GetAcceleratorText() {
   if (id() == kEmptyMenuItemViewID) {
     // Don't query the delegate for menus that represent no children.
     return string16();
   }
 
-  if(!MenuConfig::instance().show_accelerators)
+  if(!GetMenuConfig().show_accelerators)
     return string16();
 
   ui::Accelerator accelerator;
   return (GetDelegate() &&
           GetDelegate()->GetAccelerator(GetCommand(), &accelerator)) ?
       accelerator.GetShortcutText() : string16();
 }
 
 bool MenuItemView::IsContainer() const {
   // Let the first child take over |this| when we only have one child and no
@@ skipping 16 matching lines @@
       temp_width = menu_item->GetMaxIconViewWidth();
     } else if (menu_item->icon_view()) {
       temp_width = menu_item->icon_view()->GetPreferredSize().width();
     }
     width = std::max(width, temp_width);
   }
   return width;
 }
 
 }  // namespace views