ui/views/controls/menu/menu_item_view.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ui/views/controls/menu/menu_item_view.h"
   6
   7 #include "base/i18n/case_conversion.h"
   8 #include "base/stl_util.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "ui/accessibility/ax_view_state.h"
  11 #include "ui/base/l10n/l10n_util.h"
  12 #include "ui/base/models/menu_model.h"
  13 #include "ui/gfx/canvas.h"
  14 #include "ui/gfx/geometry/rect.h"
  15 #include "ui/gfx/geometry/vector2d.h"
  16 #include "ui/gfx/image/image.h"
  17 #include "ui/gfx/text_utils.h"
  18 #include "ui/native_theme/common_theme.h"
  19 #include "ui/resources/grit/ui_resources.h"
  20 #include "ui/strings/grit/ui_strings.h"
  21 #include "ui/views/controls/button/menu_button.h"
  22 #include "ui/views/controls/image_view.h"
  23 #include "ui/views/controls/menu/menu_config.h"
  24 #include "ui/views/controls/menu/menu_controller.h"
  25 #include "ui/views/controls/menu/menu_image_util.h"
  26 #include "ui/views/controls/menu/menu_scroll_view_container.h"
  27 #include "ui/views/controls/menu/menu_separator.h"
  28 #include "ui/views/controls/menu/submenu_view.h"
  29 #include "ui/views/widget/widget.h"
  30
  31 namespace views {
  32
  33 namespace {
  34
  35 // EmptyMenuMenuItem ---------------------------------------------------------
  36
  37 // EmptyMenuMenuItem is used when a menu has no menu items. EmptyMenuMenuItem
  38 // is itself a MenuItemView, but it uses a different ID so that it isn't
  39 // identified as a MenuItemView.
  40
  41 class EmptyMenuMenuItem : public MenuItemView {
  42  public:
  43   explicit EmptyMenuMenuItem(MenuItemView* parent)
  44       : MenuItemView(parent, 0, EMPTY) {
  45     // Set this so that we're not identified as a normal menu item.
  46     set_id(kEmptyMenuItemViewID);
  47     SetTitle(l10n_util::GetStringUTF16(IDS_APP_MENU_EMPTY_SUBMENU));
  48     SetEnabled(false);
  49   }
  50
  51   virtual bool GetTooltipText(const gfx::Point& p,
  52                               base::string16* tooltip) const OVERRIDE {
  53     // Empty menu items shouldn't have a tooltip.
  54     return false;
  55   }
  56
  57  private:
  58   DISALLOW_COPY_AND_ASSIGN(EmptyMenuMenuItem);
  59 };
  60
  61 }  // namespace
  62
  63 // Padding between child views.
  64 static const int kChildXPadding = 8;
  65
  66 // MenuItemView ---------------------------------------------------------------
  67
  68 // static
  69 const int MenuItemView::kMenuItemViewID = 1001;
  70
  71 // static
  72 const int MenuItemView::kEmptyMenuItemViewID =
  73     MenuItemView::kMenuItemViewID + 1;
  74
  75 // static
  76 int MenuItemView::icon_area_width_ = 0;
  77
  78 // static
  79 int MenuItemView::label_start_;
  80
  81 // static
  82 int MenuItemView::item_right_margin_;
  83
  84 // static
  85 int MenuItemView::pref_menu_height_;
  86
  87 // static
  88 const char MenuItemView::kViewClassName[] = "MenuItemView";
  89
  90 MenuItemView::MenuItemView(MenuDelegate* delegate)
  91     : delegate_(delegate),
  92       controller_(NULL),
  93       canceled_(false),
  94       parent_menu_item_(NULL),
  95       type_(SUBMENU),
  96       selected_(false),
  97       command_(0),
  98       submenu_(NULL),
  99       has_mnemonics_(false),
 100       show_mnemonics_(false),
 101       has_icons_(false),
 102       icon_view_(NULL),
 103       top_margin_(-1),
 104       bottom_margin_(-1),
 105       left_icon_margin_(0),
 106       right_icon_margin_(0),
 107       requested_menu_position_(POSITION_BEST_FIT),
 108       actual_menu_position_(requested_menu_position_),
 109       use_right_margin_(true) {
 110   // NOTE: don't check the delegate for NULL, UpdateMenuPartSizes() supplies a
 111   // NULL delegate.
 112   Init(NULL, 0, SUBMENU, delegate);
 113 }
 114
 115 void MenuItemView::ChildPreferredSizeChanged(View* child) {
 116   invalidate_dimensions();
 117   PreferredSizeChanged();
 118 }
 119
 120 bool MenuItemView::GetTooltipText(const gfx::Point& p,
 121                                   base::string16* tooltip) const {
 122   *tooltip = tooltip_;
 123   if (!tooltip->empty())
 124     return true;
 125
 126   if (GetType() == SEPARATOR)
 127     return false;
 128
 129   const MenuController* controller = GetMenuController();
 130   if (!controller || controller->exit_type() != MenuController::EXIT_NONE) {
 131     // Either the menu has been closed or we're in the process of closing the
 132     // menu. Don't attempt to query the delegate as it may no longer be valid.
 133     return false;
 134   }
 135
 136   const MenuItemView* root_menu_item = GetRootMenuItem();
 137   if (root_menu_item->canceled_) {
 138     // TODO(sky): if |canceled_| is true, controller->exit_type() should be
 139     // something other than EXIT_NONE, but crash reports seem to indicate
 140     // otherwise. Figure out why this is needed.
 141     return false;
 142   }
 143
 144   const MenuDelegate* delegate = GetDelegate();
 145   CHECK(delegate);
 146   gfx::Point location(p);
 147   ConvertPointToScreen(this, &location);
 148   *tooltip = delegate->GetTooltipText(command_, location);
 149   return !tooltip->empty();
 150 }
 151
 152 void MenuItemView::GetAccessibleState(ui::AXViewState* state) {
 153   state->role = ui::AX_ROLE_MENU_ITEM;
 154
 155   base::string16 item_text;
 156   if (IsContainer()) {
 157     // The first child is taking over, just use its accessible name instead of
 158     // |title_|.
 159     View* child = child_at(0);
 160     ui::AXViewState state;
 161     child->GetAccessibleState(&state);
 162     item_text = state.name;
 163   } else {
 164     item_text = title_;
 165   }
 166   state->name = GetAccessibleNameForMenuItem(item_text, GetMinorText());
 167
 168   switch (GetType()) {
 169     case SUBMENU:
 170       state->AddStateFlag(ui::AX_STATE_HASPOPUP);
 171       break;
 172     case CHECKBOX:
 173     case RADIO:
 174       if (GetDelegate()->IsItemChecked(GetCommand()))
 175         state->AddStateFlag(ui::AX_STATE_CHECKED);
 176       break;
 177     case NORMAL:
 178     case SEPARATOR:
 179     case EMPTY:
 180       // No additional accessibility states currently for these menu states.
 181       break;
 182   }
 183 }
 184
 185 // static
 186 bool MenuItemView::IsBubble(MenuAnchorPosition anchor) {
 187   return anchor == MENU_ANCHOR_BUBBLE_LEFT ||
 188          anchor == MENU_ANCHOR_BUBBLE_RIGHT ||
 189          anchor == MENU_ANCHOR_BUBBLE_ABOVE ||
 190          anchor == MENU_ANCHOR_BUBBLE_BELOW;
 191 }
 192
 193 // static
 194 base::string16 MenuItemView::GetAccessibleNameForMenuItem(
 195       const base::string16& item_text, const base::string16& minor_text) {
 196   base::string16 accessible_name = item_text;
 197
 198   // Filter out the "&" for accessibility clients.
 199   size_t index = 0;
 200   const base::char16 amp = '&';
 201   while ((index = accessible_name.find(amp, index)) != base::string16::npos &&
 202          index + 1 < accessible_name.length()) {
 203     accessible_name.replace(index, accessible_name.length() - index,
 204                             accessible_name.substr(index + 1));
 205
 206     // Special case for "&&" (escaped for "&").
 207     if (accessible_name[index] == '&')
 208       ++index;
 209   }
 210
 211   // Append subtext.
 212   if (!minor_text.empty()) {
 213     accessible_name.push_back(' ');
 214     accessible_name.append(minor_text);
 215   }
 216
 217   return accessible_name;
 218 }
 219
 220 void MenuItemView::Cancel() {
 221   if (controller_ && !canceled_) {
 222     canceled_ = true;
 223     controller_->Cancel(MenuController::EXIT_ALL);
 224   }
 225 }
 226
 227 MenuItemView* MenuItemView::AddMenuItemAt(
 228     int index,
 229     int item_id,
 230     const base::string16& label,
 231     const base::string16& sublabel,
 232     const base::string16& minor_text,
 233     const gfx::ImageSkia& icon,
 234     Type type,
 235     ui::MenuSeparatorType separator_style) {
 236   DCHECK_NE(type, EMPTY);
 237   DCHECK_LE(0, index);
 238   if (!submenu_)
 239     CreateSubmenu();
 240   DCHECK_GE(submenu_->child_count(), index);
 241   if (type == SEPARATOR) {
 242     submenu_->AddChildViewAt(new MenuSeparator(this, separator_style), index);
 243     return NULL;
 244   }
 245   MenuItemView* item = new MenuItemView(this, item_id, type);
 246   if (label.empty() && GetDelegate())
 247     item->SetTitle(GetDelegate()->GetLabel(item_id));
 248   else
 249     item->SetTitle(label);
 250   item->SetSubtitle(sublabel);
 251   item->SetMinorText(minor_text);
 252   if (!icon.isNull())
 253     item->SetIcon(icon);
 254   if (type == SUBMENU)
 255     item->CreateSubmenu();
 256   if (GetDelegate() && !GetDelegate()->IsCommandVisible(item_id))
 257     item->SetVisible(false);
 258   submenu_->AddChildViewAt(item, index);
 259   return item;
 260 }
 261
 262 void MenuItemView::RemoveMenuItemAt(int index) {
 263   DCHECK(submenu_);
 264   DCHECK_LE(0, index);
 265   DCHECK_GT(submenu_->child_count(), index);
 266
 267   View* item = submenu_->child_at(index);
 268   DCHECK(item);
 269   submenu_->RemoveChildView(item);
 270
 271   // RemoveChildView() does not delete the item, which is a good thing
 272   // in case a submenu is being displayed while items are being removed.
 273   // Deletion will be done by ChildrenChanged() or at destruction.
 274   removed_items_.push_back(item);
 275 }
 276
 277 MenuItemView* MenuItemView::AppendMenuItem(int item_id,
 278                                            const base::string16& label,
 279                                            Type type) {
 280   return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
 281       gfx::ImageSkia(), type, ui::NORMAL_SEPARATOR);
 282 }
 283
 284 MenuItemView* MenuItemView::AppendSubMenu(int item_id,
 285                                           const base::string16& label) {
 286   return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
 287       gfx::ImageSkia(), SUBMENU, ui::NORMAL_SEPARATOR);
 288 }
 289
 290 MenuItemView* MenuItemView::AppendSubMenuWithIcon(int item_id,
 291                                                   const base::string16& label,
 292                                                   const gfx::ImageSkia& icon) {
 293   return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
 294                             icon, SUBMENU, ui::NORMAL_SEPARATOR);
 295 }
 296
 297 MenuItemView* MenuItemView::AppendMenuItemWithLabel(
 298     int item_id,
 299     const base::string16& label) {
 300   return AppendMenuItem(item_id, label, NORMAL);
 301 }
 302
 303 MenuItemView* MenuItemView::AppendDelegateMenuItem(int item_id) {
 304   return AppendMenuItem(item_id, base::string16(), NORMAL);
 305 }
 306
 307 void MenuItemView::AppendSeparator() {
 308   AppendMenuItemImpl(0, base::string16(), base::string16(), base::string16(),
 309                      gfx::ImageSkia(), SEPARATOR, ui::NORMAL_SEPARATOR);
 310 }
 311
 312 MenuItemView* MenuItemView::AppendMenuItemWithIcon(int item_id,
 313                                                    const base::string16& label,
 314                                                    const gfx::ImageSkia& icon) {
 315   return AppendMenuItemImpl(item_id, label, base::string16(), base::string16(),
 316                             icon, NORMAL, ui::NORMAL_SEPARATOR);
 317 }
 318
 319 MenuItemView* MenuItemView::AppendMenuItemImpl(
 320     int item_id,
 321     const base::string16& label,
 322     const base::string16& sublabel,
 323     const base::string16& minor_text,
 324     const gfx::ImageSkia& icon,
 325     Type type,
 326     ui::MenuSeparatorType separator_style) {
 327   const int index = submenu_ ? submenu_->child_count() : 0;
 328   return AddMenuItemAt(index, item_id, label, sublabel, minor_text, icon, type,
 329                        separator_style);
 330 }
 331
 332 SubmenuView* MenuItemView::CreateSubmenu() {
 333   if (!submenu_)
 334     submenu_ = new SubmenuView(this);
 335   return submenu_;
 336 }
 337
 338 bool MenuItemView::HasSubmenu() const {
 339   return (submenu_ != NULL);
 340 }
 341
 342 SubmenuView* MenuItemView::GetSubmenu() const {
 343   return submenu_;
 344 }
 345
 346 void MenuItemView::SetTitle(const base::string16& title) {
 347   title_ = title;
 348   invalidate_dimensions();  // Triggers preferred size recalculation.
 349 }
 350
 351 void MenuItemView::SetSubtitle(const base::string16& subtitle) {
 352   subtitle_ = subtitle;
 353   invalidate_dimensions();  // Triggers preferred size recalculation.
 354 }
 355
 356 void MenuItemView::SetMinorText(const base::string16& minor_text) {
 357   minor_text_ = minor_text;
 358   invalidate_dimensions();  // Triggers preferred size recalculation.
 359 }
 360
 361 void MenuItemView::SetSelected(bool selected) {
 362   selected_ = selected;
 363   SchedulePaint();
 364 }
 365
 366 void MenuItemView::SetTooltip(const base::string16& tooltip, int item_id) {
 367   MenuItemView* item = GetMenuItemByID(item_id);
 368   DCHECK(item);
 369   item->tooltip_ = tooltip;
 370 }
 371
 372 void MenuItemView::SetIcon(const gfx::ImageSkia& icon, int item_id) {
 373   MenuItemView* item = GetMenuItemByID(item_id);
 374   DCHECK(item);
 375   item->SetIcon(icon);
 376 }
 377
 378 void MenuItemView::SetIcon(const gfx::ImageSkia& icon) {
 379   if (icon.isNull()) {
 380     SetIconView(NULL);
 381     return;
 382   }
 383
 384   ImageView* icon_view = new ImageView();
 385   icon_view->SetImage(&icon);
 386   SetIconView(icon_view);
 387 }
 388
 389 void MenuItemView::SetIconView(View* icon_view) {
 390   if (icon_view_) {
 391     RemoveChildView(icon_view_);
 392     delete icon_view_;
 393     icon_view_ = NULL;
 394   }
 395   if (icon_view) {
 396     AddChildView(icon_view);
 397     icon_view_ = icon_view;
 398   }
 399   Layout();
 400   SchedulePaint();
 401 }
 402
 403 void MenuItemView::OnPaint(gfx::Canvas* canvas) {
 404   PaintButton(canvas, PB_NORMAL);
 405 }
 406
 407 gfx::Size MenuItemView::GetPreferredSize() const {
 408   const MenuItemDimensions& dimensions(GetDimensions());
 409   return gfx::Size(dimensions.standard_width + dimensions.children_width,
 410                    dimensions.height);
 411 }
 412
 413 const MenuItemView::MenuItemDimensions& MenuItemView::GetDimensions() const {
 414   if (!is_dimensions_valid())
 415     dimensions_ = CalculateDimensions();
 416   DCHECK(is_dimensions_valid());
 417   return dimensions_;
 418 }
 419
 420 MenuController* MenuItemView::GetMenuController() {
 421   return GetRootMenuItem()->controller_;
 422 }
 423
 424 const MenuController* MenuItemView::GetMenuController() const {
 425   return GetRootMenuItem()->controller_;
 426 }
 427
 428 MenuDelegate* MenuItemView::GetDelegate() {
 429   return GetRootMenuItem()->delegate_;
 430 }
 431
 432 const MenuDelegate* MenuItemView::GetDelegate() const {
 433   return GetRootMenuItem()->delegate_;
 434 }
 435
 436 MenuItemView* MenuItemView::GetRootMenuItem() {
 437   return const_cast<MenuItemView*>(
 438       static_cast<const MenuItemView*>(this)->GetRootMenuItem());
 439 }
 440
 441 const MenuItemView* MenuItemView::GetRootMenuItem() const {
 442   const MenuItemView* item = this;
 443   for (const MenuItemView* parent = GetParentMenuItem(); parent;
 444        parent = item->GetParentMenuItem())
 445     item = parent;
 446   return item;
 447 }
 448
 449 base::char16 MenuItemView::GetMnemonic() {
 450   if (!GetRootMenuItem()->has_mnemonics_)
 451     return 0;
 452
 453   size_t index = 0;
 454   do {
 455     index = title_.find('&', index);
 456     if (index != base::string16::npos) {
 457       if (index + 1 != title_.size() && title_[index + 1] != '&') {
 458         base::char16 char_array[] = { title_[index + 1], 0 };
 459         // TODO(jshin): What about Turkish locale? See http://crbug.com/81719.
 460         // If the mnemonic is capital I and the UI language is Turkish,
 461         // lowercasing it results in 'small dotless i', which is different
 462         // from a 'dotted i'. Similar issues may exist for az and lt locales.
 463         return base::i18n::ToLower(char_array)[0];
 464       }
 465       index++;
 466     }
 467   } while (index != base::string16::npos);
 468   return 0;
 469 }
 470
 471 MenuItemView* MenuItemView::GetMenuItemByID(int id) {
 472   if (GetCommand() == id)
 473     return this;
 474   if (!HasSubmenu())
 475     return NULL;
 476   for (int i = 0; i < GetSubmenu()->child_count(); ++i) {
 477     View* child = GetSubmenu()->child_at(i);
 478     if (child->id() == MenuItemView::kMenuItemViewID) {
 479       MenuItemView* result = static_cast<MenuItemView*>(child)->
 480           GetMenuItemByID(id);
 481       if (result)
 482         return result;
 483     }
 484   }
 485   return NULL;
 486 }
 487
 488 void MenuItemView::ChildrenChanged() {
 489   MenuController* controller = GetMenuController();
 490   if (controller) {
 491     // Handles the case where we were empty and are no longer empty.
 492     RemoveEmptyMenus();
 493
 494     // Handles the case where we were not empty, but now are.
 495     AddEmptyMenus();
 496
 497     controller->MenuChildrenChanged(this);
 498
 499     if (submenu_) {
 500       // Force a paint and layout. This handles the case of the top
 501       // level window's size remaining the same, resulting in no
 502       // change to the submenu's size and no layout.
 503       submenu_->Layout();
 504       submenu_->SchedulePaint();
 505       // Update the menu selection after layout.
 506       controller->UpdateSubmenuSelection(submenu_);
 507     }
 508   }
 509
 510   STLDeleteElements(&removed_items_);
 511 }
 512
 513 void MenuItemView::Layout() {
 514   if (!has_children())
 515     return;
 516
 517   if (IsContainer()) {
 518     View* child = child_at(0);
 519     gfx::Size size = child->GetPreferredSize();
 520     child->SetBounds(0, GetTopMargin(), size.width(), size.height());
 521   } else {
 522     // Child views are laid out right aligned and given the full height. To
 523     // right align start with the last view and progress to the first.
 524     int x = width() - (use_right_margin_ ? item_right_margin_ : 0);
 525     for (int i = child_count() - 1; i >= 0; --i) {
 526       View* child = child_at(i);
 527       if (icon_view_ && (icon_view_ == child))
 528         continue;
 529       int width = child->GetPreferredSize().width();
 530       child->SetBounds(x - width, 0, width, height());
 531       x -= width - kChildXPadding;
 532     }
 533     // Position |icon_view|.
 534     const MenuConfig& config = GetMenuConfig();
 535     if (icon_view_) {
 536       icon_view_->SizeToPreferredSize();
 537       gfx::Size size = icon_view_->GetPreferredSize();
 538       int x = config.item_left_margin + left_icon_margin_ +
 539               (icon_area_width_ - size.width()) / 2;
 540       if (type_ == CHECKBOX || type_ == RADIO)
 541         x = label_start_;
 542       int y =
 543           (height() + GetTopMargin() - GetBottomMargin() - size.height()) / 2;
 544       icon_view_->SetPosition(gfx::Point(x, y));
 545     }
 546   }
 547 }
 548
 549 void MenuItemView::SetMargins(int top_margin, int bottom_margin) {
 550   top_margin_ = top_margin;
 551   bottom_margin_ = bottom_margin;
 552
 553   invalidate_dimensions();
 554 }
 555
 556 const MenuConfig& MenuItemView::GetMenuConfig() const {
 557   const MenuController* controller = GetMenuController();
 558   if (controller)
 559     return controller->menu_config_;
 560   return MenuConfig::instance(NULL);
 561 }
 562
 563 MenuItemView::MenuItemView(MenuItemView* parent,
 564                            int command,
 565                            MenuItemView::Type type)
 566     : delegate_(NULL),
 567       controller_(NULL),
 568       canceled_(false),
 569       parent_menu_item_(parent),
 570       type_(type),
 571       selected_(false),
 572       command_(command),
 573       submenu_(NULL),
 574       has_mnemonics_(false),
 575       show_mnemonics_(false),
 576       has_icons_(false),
 577       icon_view_(NULL),
 578       top_margin_(-1),
 579       bottom_margin_(-1),
 580       left_icon_margin_(0),
 581       right_icon_margin_(0),
 582       requested_menu_position_(POSITION_BEST_FIT),
 583       actual_menu_position_(requested_menu_position_),
 584       use_right_margin_(true) {
 585   Init(parent, command, type, NULL);
 586 }
 587
 588 MenuItemView::~MenuItemView() {
 589   delete submenu_;
 590   STLDeleteElements(&removed_items_);
 591 }
 592
 593 const char* MenuItemView::GetClassName() const {
 594   return kViewClassName;
 595 }
 596
 597 // Calculates all sizes that we can from the OS.
 598 //
 599 // This is invoked prior to Running a menu.
 600 void MenuItemView::UpdateMenuPartSizes() {
 601   const MenuConfig& config = GetMenuConfig();
 602
 603   item_right_margin_ = config.label_to_arrow_padding + config.arrow_width +
 604                        config.arrow_to_edge_padding;
 605   icon_area_width_ = config.check_width;
 606   if (has_icons_)
 607     icon_area_width_ = std::max(icon_area_width_, GetMaxIconViewWidth());
 608
 609   label_start_ = config.item_left_margin + icon_area_width_;
 610   int padding = 0;
 611   if (config.always_use_icon_to_label_padding) {
 612     padding = config.icon_to_label_padding;
 613   } else if (config.render_gutter) {
 614     padding = config.item_left_margin;
 615   } else {
 616     padding = (has_icons_ || HasChecksOrRadioButtons()) ?
 617         config.icon_to_label_padding : 0;
 618   }
 619   label_start_ += padding;
 620
 621   if (config.render_gutter)
 622     label_start_ += config.gutter_width + config.gutter_to_label;
 623
 624   EmptyMenuMenuItem menu_item(this);
 625   menu_item.set_controller(GetMenuController());
 626   pref_menu_height_ = menu_item.GetPreferredSize().height();
 627 }
 628
 629 void MenuItemView::Init(MenuItemView* parent,
 630                         int command,
 631                         MenuItemView::Type type,
 632                         MenuDelegate* delegate) {
 633   delegate_ = delegate;
 634   controller_ = NULL;
 635   canceled_ = false;
 636   parent_menu_item_ = parent;
 637   type_ = type;
 638   selected_ = false;
 639   command_ = command;
 640   submenu_ = NULL;
 641   show_mnemonics_ = false;
 642   // Assign our ID, this allows SubmenuItemView to find MenuItemViews.
 643   set_id(kMenuItemViewID);
 644   has_icons_ = false;
 645
 646   // Don't request enabled status from the root menu item as it is just
 647   // a container for real items.  EMPTY items will be disabled.
 648   MenuDelegate* root_delegate = GetDelegate();
 649   if (parent && type != EMPTY && root_delegate)
 650     SetEnabled(root_delegate->IsCommandEnabled(command));
 651 }
 652
 653 void MenuItemView::PrepareForRun(bool is_first_menu,
 654                                  bool has_mnemonics,
 655                                  bool show_mnemonics) {
 656   // Currently we only support showing the root.
 657   DCHECK(!parent_menu_item_);
 658
 659   // Force us to have a submenu.
 660   CreateSubmenu();
 661   actual_menu_position_ = requested_menu_position_;
 662   canceled_ = false;
 663
 664   has_mnemonics_ = has_mnemonics;
 665   show_mnemonics_ = has_mnemonics && show_mnemonics;
 666
 667   AddEmptyMenus();
 668
 669   if (is_first_menu) {
 670     // Only update the menu size if there are no menus showing, otherwise
 671     // things may shift around.
 672     UpdateMenuPartSizes();
 673   }
 674 }
 675
 676 int MenuItemView::GetDrawStringFlags() {
 677   int flags = 0;
 678   if (base::i18n::IsRTL())
 679     flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
 680   else
 681     flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
 682
 683   if (GetRootMenuItem()->has_mnemonics_) {
 684     if (GetMenuConfig().show_mnemonics || GetRootMenuItem()->show_mnemonics_) {
 685       flags |= gfx::Canvas::SHOW_PREFIX;
 686     } else {
 687       flags |= gfx::Canvas::HIDE_PREFIX;
 688     }
 689   }
 690   return flags;
 691 }
 692
 693 const gfx::FontList& MenuItemView::GetFontList() const {
 694   const MenuDelegate* delegate = GetDelegate();
 695   if (delegate) {
 696     const gfx::FontList* font_list = delegate->GetLabelFontList(GetCommand());
 697     if (font_list)
 698       return *font_list;
 699   }
 700   return GetMenuConfig().font_list;
 701 }
 702
 703 void MenuItemView::AddEmptyMenus() {
 704   DCHECK(HasSubmenu());
 705   if (!submenu_->has_children()) {
 706     submenu_->AddChildViewAt(new EmptyMenuMenuItem(this), 0);
 707   } else {
 708     for (int i = 0, item_count = submenu_->GetMenuItemCount(); i < item_count;
 709          ++i) {
 710       MenuItemView* child = submenu_->GetMenuItemAt(i);
 711       if (child->HasSubmenu())
 712         child->AddEmptyMenus();
 713     }
 714   }
 715 }
 716
 717 void MenuItemView::RemoveEmptyMenus() {
 718   DCHECK(HasSubmenu());
 719   // Iterate backwards as we may end up removing views, which alters the child
 720   // view count.
 721   for (int i = submenu_->child_count() - 1; i >= 0; --i) {
 722     View* child = submenu_->child_at(i);
 723     if (child->id() == MenuItemView::kMenuItemViewID) {
 724       MenuItemView* menu_item = static_cast<MenuItemView*>(child);
 725       if (menu_item->HasSubmenu())
 726         menu_item->RemoveEmptyMenus();
 727     } else if (child->id() == EmptyMenuMenuItem::kEmptyMenuItemViewID) {
 728       submenu_->RemoveChildView(child);
 729       delete child;
 730       child = NULL;
 731     }
 732   }
 733 }
 734
 735 void MenuItemView::AdjustBoundsForRTLUI(gfx::Rect* rect) const {
 736   rect->set_x(GetMirroredXForRect(*rect));
 737 }
 738
 739 void MenuItemView::PaintButton(gfx::Canvas* canvas, PaintButtonMode mode) {
 740   const MenuConfig& config = GetMenuConfig();
 741   bool render_selection =
 742       (mode == PB_NORMAL && IsSelected() &&
 743        parent_menu_item_->GetSubmenu()->GetShowSelection(this) &&
 744        (NonIconChildViewsCount() == 0));
 745
 746   MenuDelegate *delegate = GetDelegate();
 747   // Render the background. As MenuScrollViewContainer draws the background, we
 748   // only need the background when we want it to look different, as when we're
 749   // selected.
 750   ui::NativeTheme* native_theme = GetNativeTheme();
 751   SkColor override_color;
 752   if (delegate && delegate->GetBackgroundColor(GetCommand(),
 753                                                render_selection,
 754                                                &override_color)) {
 755     canvas->DrawColor(override_color);
 756   } else if (render_selection) {
 757     gfx::Rect item_bounds(0, 0, width(), height());
 758     AdjustBoundsForRTLUI(&item_bounds);
 759
 760     native_theme->Paint(canvas->sk_canvas(),
 761                         ui::NativeTheme::kMenuItemBackground,
 762                         ui::NativeTheme::kHovered,
 763                         item_bounds,
 764                         ui::NativeTheme::ExtraParams());
 765   }
 766
 767   const int icon_x = config.item_left_margin + left_icon_margin_;
 768   const int top_margin = GetTopMargin();
 769   const int bottom_margin = GetBottomMargin();
 770   const int available_height = height() - top_margin - bottom_margin;
 771
 772   // Render the check.
 773   if (type_ == CHECKBOX && delegate->IsItemChecked(GetCommand())) {
 774     gfx::ImageSkia check = GetMenuCheckImage(render_selection);
 775     // Don't use config.check_width here as it's padded
 776     // to force more padding (AURA).
 777     gfx::Rect check_bounds(icon_x,
 778                            top_margin + (available_height - check.height()) / 2,
 779                            check.width(),
 780                            check.height());
 781     AdjustBoundsForRTLUI(&check_bounds);
 782     canvas->DrawImageInt(check, check_bounds.x(), check_bounds.y());
 783   } else if (type_ == RADIO) {
 784     gfx::ImageSkia image =
 785         GetRadioButtonImage(delegate->IsItemChecked(GetCommand()));
 786     gfx::Rect radio_bounds(icon_x,
 787                            top_margin + (available_height - image.height()) / 2,
 788                            image.width(),
 789                            image.height());
 790     AdjustBoundsForRTLUI(&radio_bounds);
 791     canvas->DrawImageInt(image, radio_bounds.x(), radio_bounds.y());
 792   }
 793
 794   // Render the foreground.
 795   ui::NativeTheme::ColorId color_id;
 796   if (enabled()) {
 797     color_id = render_selection ?
 798         ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor:
 799         ui::NativeTheme::kColorId_EnabledMenuItemForegroundColor;
 800   } else {
 801     bool emphasized = delegate &&
 802                       delegate->GetShouldUseDisabledEmphasizedForegroundColor(
 803                           GetCommand());
 804     color_id = emphasized ?
 805         ui::NativeTheme::kColorId_DisabledEmphasizedMenuItemForegroundColor :
 806         ui::NativeTheme::kColorId_DisabledMenuItemForegroundColor;
 807   }
 808   SkColor fg_color = native_theme->GetSystemColor(color_id);
 809   SkColor override_foreground_color;
 810   if (delegate && delegate->GetForegroundColor(GetCommand(),
 811                                                render_selection,
 812                                                &override_foreground_color))
 813     fg_color = override_foreground_color;
 814
 815   const gfx::FontList& font_list = GetFontList();
 816   int accel_width = parent_menu_item_->GetSubmenu()->max_minor_text_width();
 817   int label_start = GetLabelStartForThisItem();
 818
 819   int width = this->width() - label_start - accel_width -
 820       (!delegate ||
 821        delegate->ShouldReserveSpaceForSubmenuIndicator() ?
 822            item_right_margin_ : config.arrow_to_edge_padding);
 823   gfx::Rect text_bounds(label_start, top_margin, width,
 824                         subtitle_.empty() ? available_height
 825                                           : available_height / 2);
 826   text_bounds.set_x(GetMirroredXForRect(text_bounds));
 827   int flags = GetDrawStringFlags();
 828   if (mode == PB_FOR_DRAG)
 829     flags |= gfx::Canvas::NO_SUBPIXEL_RENDERING;
 830   canvas->DrawStringRectWithFlags(title(), font_list, fg_color, text_bounds,
 831                                   flags);
 832   if (!subtitle_.empty()) {
 833     canvas->DrawStringRectWithFlags(
 834         subtitle_,
 835         font_list,
 836         GetNativeTheme()->GetSystemColor(
 837             ui::NativeTheme::kColorId_ButtonDisabledColor),
 838         text_bounds + gfx::Vector2d(0, font_list.GetHeight()),
 839         flags);
 840   }
 841
 842   PaintMinorText(canvas, render_selection);
 843
 844   // Render the submenu indicator (arrow).
 845   if (HasSubmenu()) {
 846     gfx::ImageSkia arrow = GetSubmenuArrowImage(render_selection);
 847     gfx::Rect arrow_bounds(this->width() - config.arrow_width -
 848                                config.arrow_to_edge_padding,
 849                            top_margin + (available_height - arrow.height()) / 2,
 850                            config.arrow_width,
 851                            arrow.height());
 852     AdjustBoundsForRTLUI(&arrow_bounds);
 853     canvas->DrawImageInt(arrow, arrow_bounds.x(), arrow_bounds.y());
 854   }
 855 }
 856
 857 void MenuItemView::PaintMinorText(gfx::Canvas* canvas,
 858                                   bool render_selection) {
 859   base::string16 minor_text = GetMinorText();
 860   if (minor_text.empty())
 861     return;
 862
 863   int available_height = height() - GetTopMargin() - GetBottomMargin();
 864   int max_accel_width =
 865       parent_menu_item_->GetSubmenu()->max_minor_text_width();
 866   const MenuConfig& config = GetMenuConfig();
 867   int accel_right_margin = config.align_arrow_and_shortcut ?
 868                            config.arrow_to_edge_padding :  item_right_margin_;
 869   gfx::Rect accel_bounds(width() - accel_right_margin - max_accel_width,
 870                          GetTopMargin(), max_accel_width, available_height);
 871   accel_bounds.set_x(GetMirroredXForRect(accel_bounds));
 872   int flags = GetDrawStringFlags();
 873   flags &= ~(gfx::Canvas::TEXT_ALIGN_RIGHT | gfx::Canvas::TEXT_ALIGN_LEFT);
 874   if (base::i18n::IsRTL())
 875     flags |= gfx::Canvas::TEXT_ALIGN_LEFT;
 876   else
 877     flags |= gfx::Canvas::TEXT_ALIGN_RIGHT;
 878   canvas->DrawStringRectWithFlags(
 879       minor_text,
 880       GetFontList(),
 881       GetNativeTheme()->GetSystemColor(render_selection ?
 882           ui::NativeTheme::kColorId_SelectedMenuItemForegroundColor :
 883           ui::NativeTheme::kColorId_ButtonDisabledColor),
 884       accel_bounds,
 885       flags);
 886 }
 887
 888 void MenuItemView::DestroyAllMenuHosts() {
 889   if (!HasSubmenu())
 890     return;
 891
 892   submenu_->Close();
 893   for (int i = 0, item_count = submenu_->GetMenuItemCount(); i < item_count;
 894        ++i) {
 895     submenu_->GetMenuItemAt(i)->DestroyAllMenuHosts();
 896   }
 897 }
 898
 899 int MenuItemView::GetTopMargin() const {
 900   if (top_margin_ >= 0)
 901     return top_margin_;
 902
 903   const MenuItemView* root = GetRootMenuItem();
 904   return root && root->has_icons_
 905       ? GetMenuConfig().item_top_margin :
 906         GetMenuConfig().item_no_icon_top_margin;
 907 }
 908
 909 int MenuItemView::GetBottomMargin() const {
 910   if (bottom_margin_ >= 0)
 911     return bottom_margin_;
 912
 913   const MenuItemView* root = GetRootMenuItem();
 914   return root && root->has_icons_
 915       ? GetMenuConfig().item_bottom_margin :
 916         GetMenuConfig().item_no_icon_bottom_margin;
 917 }
 918
 919 gfx::Size MenuItemView::GetChildPreferredSize() const {
 920   if (!has_children())
 921     return gfx::Size();
 922
 923   if (IsContainer())
 924     return child_at(0)->GetPreferredSize();
 925
 926   int width = 0;
 927   for (int i = 0; i < child_count(); ++i) {
 928     const View* child = child_at(i);
 929     if (icon_view_ && (icon_view_ == child))
 930       continue;
 931     if (i)
 932       width += kChildXPadding;
 933     width += child->GetPreferredSize().width();
 934   }
 935   int height = 0;
 936   if (icon_view_)
 937     height = icon_view_->GetPreferredSize().height();
 938
 939   // If there is no icon view it returns a height of 0 to indicate that
 940   // we should use the title height instead.
 941   return gfx::Size(width, height);
 942 }
 943
 944 MenuItemView::MenuItemDimensions MenuItemView::CalculateDimensions() const {
 945   gfx::Size child_size = GetChildPreferredSize();
 946
 947   MenuItemDimensions dimensions;
 948   // Get the container height.
 949   dimensions.children_width = child_size.width();
 950   dimensions.height = child_size.height();
 951   // Adjust item content height if menu has both items with and without icons.
 952   // This way all menu items will have the same height.
 953   if (!icon_view_ && GetRootMenuItem()->has_icons()) {
 954     dimensions.height = std::max(dimensions.height,
 955                                  GetMenuConfig().check_height);
 956   }
 957   dimensions.height += GetBottomMargin() + GetTopMargin();
 958
 959   // In case of a container, only the container size needs to be filled.
 960   if (IsContainer())
 961     return dimensions;
 962
 963   // Determine the length of the label text.
 964   const gfx::FontList& font_list = GetFontList();
 965
 966   // Get Icon margin overrides for this particular item.
 967   const MenuDelegate* delegate = GetDelegate();
 968   if (delegate) {
 969     delegate->GetHorizontalIconMargins(command_,
 970                                        icon_area_width_,
 971                                        &left_icon_margin_,
 972                                        &right_icon_margin_);
 973   } else {
 974     left_icon_margin_ = 0;
 975     right_icon_margin_ = 0;
 976   }
 977   int label_start = GetLabelStartForThisItem();
 978
 979   int string_width = gfx::GetStringWidth(title_, font_list);
 980   if (!subtitle_.empty()) {
 981     string_width = std::max(string_width,
 982                             gfx::GetStringWidth(subtitle_, font_list));
 983   }
 984
 985   dimensions.standard_width = string_width + label_start +
 986       item_right_margin_;
 987   // Determine the length of the right-side text.
 988   base::string16 minor_text = GetMinorText();
 989   dimensions.minor_text_width =
 990       minor_text.empty() ? 0 : gfx::GetStringWidth(minor_text, font_list);
 991
 992   // Determine the height to use.
 993   dimensions.height =
 994       std::max(dimensions.height,
 995                (subtitle_.empty() ? 0 : font_list.GetHeight()) +
 996                font_list.GetHeight() + GetBottomMargin() + GetTopMargin());
 997   dimensions.height = std::max(dimensions.height,
 998                                GetMenuConfig().item_min_height);
 999   return dimensions;
1000 }
1001
1002 int MenuItemView::GetLabelStartForThisItem() const {
1003   int label_start = label_start_ + left_icon_margin_ + right_icon_margin_;
1004   if ((type_ == CHECKBOX || type_ == RADIO) && icon_view_) {
1005     label_start += icon_view_->size().width() +
1006         GetMenuConfig().icon_to_label_padding;
1007   }
1008   return label_start;
1009 }
1010
1011 base::string16 MenuItemView::GetMinorText() const {
1012   if (id() == kEmptyMenuItemViewID) {
1013     // Don't query the delegate for menus that represent no children.
1014     return base::string16();
1015   }
1016
1017   ui::Accelerator accelerator;
1018   if (GetMenuConfig().show_accelerators && GetDelegate() && GetCommand() &&
1019           GetDelegate()->GetAccelerator(GetCommand(), &accelerator)) {
1020     return accelerator.GetShortcutText();
1021   }
1022
1023   return minor_text_;
1024 }
1025
1026 bool MenuItemView::IsContainer() const {
1027   // Let the first child take over |this| when we only have one child and no
1028   // title.
1029   return (NonIconChildViewsCount() == 1) && title_.empty();
1030 }
1031
1032 int MenuItemView::NonIconChildViewsCount() const {
1033   // Note that what child_count() returns is the number of children,
1034   // not the number of menu items.
1035   return child_count() - (icon_view_ ? 1 : 0);
1036 }
1037
1038 int MenuItemView::GetMaxIconViewWidth() const {
1039   int width = 0;
1040   for (int i = 0; i < submenu_->GetMenuItemCount(); ++i) {
1041     MenuItemView* menu_item = submenu_->GetMenuItemAt(i);
1042     int temp_width = 0;
1043     if (menu_item->GetType() == CHECKBOX ||
1044         menu_item->GetType() == RADIO) {
1045       // If this item has a radio or checkbox, the icon will not affect
1046       // alignment of other items.
1047       continue;
1048     } else if (menu_item->HasSubmenu()) {
1049       temp_width = menu_item->GetMaxIconViewWidth();
1050     } else if (menu_item->icon_view()) {
1051       temp_width = menu_item->icon_view()->GetPreferredSize().width();
1052     }
1053     width = std::max(width, temp_width);
1054   }
1055   return width;
1056 }
1057
1058 bool MenuItemView::HasChecksOrRadioButtons() const {
1059   for (int i = 0; i < submenu_->GetMenuItemCount(); ++i) {
1060     MenuItemView* menu_item = submenu_->GetMenuItemAt(i);
1061     if (menu_item->HasSubmenu()) {
1062       if (menu_item->HasChecksOrRadioButtons())
1063         return true;
1064     } else {
1065       const Type& type = menu_item->GetType();
1066       if (type == CHECKBOX || type == RADIO)
1067         return true;
1068     }
1069   }
1070   return false;
1071 }
1072
1073 }  // namespace views