ui/views/controls/combobox/combobox.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/combobox/combobox.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/message_loop/message_loop_proxy.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "grit/ui_resources.h"
  12 #include "ui/accessibility/ax_view_state.h"
  13 #include "ui/base/models/combobox_model.h"
  14 #include "ui/base/resource/resource_bundle.h"
  15 #include "ui/events/event.h"
  16 #include "ui/events/keycodes/keyboard_codes.h"
  17 #include "ui/gfx/animation/throb_animation.h"
  18 #include "ui/gfx/canvas.h"
  19 #include "ui/gfx/image/image.h"
  20 #include "ui/gfx/scoped_canvas.h"
  21 #include "ui/gfx/text_utils.h"
  22 #include "ui/native_theme/common_theme.h"
  23 #include "ui/native_theme/native_theme.h"
  24 #include "ui/views/background.h"
  25 #include "ui/views/color_constants.h"
  26 #include "ui/views/controls/button/custom_button.h"
  27 #include "ui/views/controls/button/label_button.h"
  28 #include "ui/views/controls/combobox/combobox_listener.h"
  29 #include "ui/views/controls/focusable_border.h"
  30 #include "ui/views/controls/menu/menu_item_view.h"
  31 #include "ui/views/controls/menu/menu_runner.h"
  32 #include "ui/views/controls/menu/menu_runner_handler.h"
  33 #include "ui/views/controls/menu/submenu_view.h"
  34 #include "ui/views/controls/prefix_selector.h"
  35 #include "ui/views/ime/input_method.h"
  36 #include "ui/views/mouse_constants.h"
  37 #include "ui/views/painter.h"
  38 #include "ui/views/widget/widget.h"
  39
  40 namespace views {
  41
  42 namespace {
  43
  44 // Menu border widths
  45 const int kMenuBorderWidthLeft = 1;
  46 const int kMenuBorderWidthTop = 1;
  47 const int kMenuBorderWidthRight = 1;
  48
  49 // Limit how small a combobox can be.
  50 const int kMinComboboxWidth = 25;
  51
  52 // Size of the combobox arrow margins
  53 const int kDisclosureArrowLeftPadding = 7;
  54 const int kDisclosureArrowRightPadding = 7;
  55 const int kDisclosureArrowButtonLeftPadding = 11;
  56 const int kDisclosureArrowButtonRightPadding = 12;
  57
  58 // Define the id of the first item in the menu (since it needs to be > 0)
  59 const int kFirstMenuItemId = 1000;
  60
  61 // Used to indicate that no item is currently selected by the user.
  62 const int kNoSelection = -1;
  63
  64 const int kBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON);
  65 const int kHoveredBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON_H);
  66 const int kPressedBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON_P);
  67 const int kFocusedBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON_F);
  68 const int kFocusedHoveredBodyButtonImages[] =
  69     IMAGE_GRID(IDR_COMBOBOX_BUTTON_F_H);
  70 const int kFocusedPressedBodyButtonImages[] =
  71     IMAGE_GRID(IDR_COMBOBOX_BUTTON_F_P);
  72
  73 #define MENU_IMAGE_GRID(x) { \
  74     x ## _MENU_TOP, x ## _MENU_CENTER, x ## _MENU_BOTTOM, }
  75
  76 const int kMenuButtonImages[] = MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON);
  77 const int kHoveredMenuButtonImages[] = MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_H);
  78 const int kPressedMenuButtonImages[] = MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_P);
  79 const int kFocusedMenuButtonImages[] = MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_F);
  80 const int kFocusedHoveredMenuButtonImages[] =
  81     MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_F_H);
  82 const int kFocusedPressedMenuButtonImages[] =
  83     MENU_IMAGE_GRID(IDR_COMBOBOX_BUTTON_F_P);
  84
  85 #undef MENU_IMAGE_GRID
  86
  87 // The transparent button which holds a button state but is not rendered.
  88 class TransparentButton : public CustomButton {
  89  public:
  90   TransparentButton(ButtonListener* listener)
  91       : CustomButton(listener) {
  92     SetAnimationDuration(LabelButton::kHoverAnimationDurationMs);
  93   }
  94   virtual ~TransparentButton() {}
  95
  96   virtual bool OnMousePressed(const ui::MouseEvent& mouse_event) OVERRIDE {
  97     parent()->RequestFocus();
  98     return true;
  99   }
 100
 101   double GetAnimationValue() const {
 102     return hover_animation_->GetCurrentValue();
 103   }
 104
 105  private:
 106   DISALLOW_COPY_AND_ASSIGN(TransparentButton);
 107 };
 108
 109 // Returns the next or previous valid index (depending on |increment|'s value).
 110 // Skips separator or disabled indices. Returns -1 if there is no valid adjacent
 111 // index.
 112 int GetAdjacentIndex(ui::ComboboxModel* model, int increment, int index) {
 113   DCHECK(increment == -1 || increment == 1);
 114
 115   index += increment;
 116   while (index >= 0 && index < model->GetItemCount()) {
 117     if (!model->IsItemSeparatorAt(index) || !model->IsItemEnabledAt(index))
 118       return index;
 119     index += increment;
 120   }
 121   return kNoSelection;
 122 }
 123
 124 // Returns the image resource ids of an array for the body button.
 125 //
 126 // TODO(hajimehoshi): This function should return the images for the 'disabled'
 127 // status. (crbug/270052)
 128 const int* GetBodyButtonImageIds(bool focused,
 129                                  Button::ButtonState state,
 130                                  size_t* num) {
 131   DCHECK(num);
 132   *num = 9;
 133   switch (state) {
 134     case Button::STATE_DISABLED:
 135       return focused ? kFocusedBodyButtonImages : kBodyButtonImages;
 136     case Button::STATE_NORMAL:
 137       return focused ? kFocusedBodyButtonImages : kBodyButtonImages;
 138     case Button::STATE_HOVERED:
 139       return focused ?
 140           kFocusedHoveredBodyButtonImages : kHoveredBodyButtonImages;
 141     case Button::STATE_PRESSED:
 142       return focused ?
 143           kFocusedPressedBodyButtonImages : kPressedBodyButtonImages;
 144     default:
 145       NOTREACHED();
 146   }
 147   return NULL;
 148 }
 149
 150 // Returns the image resource ids of an array for the menu button.
 151 const int* GetMenuButtonImageIds(bool focused,
 152                                  Button::ButtonState state,
 153                                  size_t* num) {
 154   DCHECK(num);
 155   *num = 3;
 156   switch (state) {
 157     case Button::STATE_DISABLED:
 158       return focused ? kFocusedMenuButtonImages : kMenuButtonImages;
 159     case Button::STATE_NORMAL:
 160       return focused ? kFocusedMenuButtonImages : kMenuButtonImages;
 161     case Button::STATE_HOVERED:
 162       return focused ?
 163           kFocusedHoveredMenuButtonImages : kHoveredMenuButtonImages;
 164     case Button::STATE_PRESSED:
 165       return focused ?
 166           kFocusedPressedMenuButtonImages : kPressedMenuButtonImages;
 167     default:
 168       NOTREACHED();
 169   }
 170   return NULL;
 171 }
 172
 173 // Returns the images for the menu buttons.
 174 std::vector<const gfx::ImageSkia*> GetMenuButtonImages(
 175     bool focused,
 176     Button::ButtonState state) {
 177   const int* ids;
 178   size_t num_ids;
 179   ids = GetMenuButtonImageIds(focused, state, &num_ids);
 180   std::vector<const gfx::ImageSkia*> images;
 181   images.reserve(num_ids);
 182   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 183   for (size_t i = 0; i < num_ids; i++)
 184     images.push_back(rb.GetImageSkiaNamed(ids[i]));
 185   return images;
 186 }
 187
 188 // Paints three images in a column at the given location. The center image is
 189 // stretched so as to fit the given height.
 190 void PaintImagesVertically(gfx::Canvas* canvas,
 191                            const gfx::ImageSkia& top_image,
 192                            const gfx::ImageSkia& center_image,
 193                            const gfx::ImageSkia& bottom_image,
 194                            int x, int y, int width, int height) {
 195   canvas->DrawImageInt(top_image,
 196                        0, 0, top_image.width(), top_image.height(),
 197                        x, y, width, top_image.height(), false);
 198   y += top_image.height();
 199   int center_height = height - top_image.height() - bottom_image.height();
 200   canvas->DrawImageInt(center_image,
 201                        0, 0, center_image.width(), center_image.height(),
 202                        x, y, width, center_height, false);
 203   y += center_height;
 204   canvas->DrawImageInt(bottom_image,
 205                        0, 0, bottom_image.width(), bottom_image.height(),
 206                        x, y, width, bottom_image.height(), false);
 207 }
 208
 209 // Paints the arrow button.
 210 void PaintArrowButton(
 211     gfx::Canvas* canvas,
 212     const std::vector<const gfx::ImageSkia*>& arrow_button_images,
 213     int x, int height) {
 214   PaintImagesVertically(canvas,
 215                         *arrow_button_images[0],
 216                         *arrow_button_images[1],
 217                         *arrow_button_images[2],
 218                         x, 0, arrow_button_images[0]->width(), height);
 219 }
 220
 221 }  // namespace
 222
 223 // static
 224 const char Combobox::kViewClassName[] = "views/Combobox";
 225
 226 ////////////////////////////////////////////////////////////////////////////////
 227 // Combobox, public:
 228
 229 Combobox::Combobox(ui::ComboboxModel* model)
 230     : model_(model),
 231       style_(STYLE_NORMAL),
 232       listener_(NULL),
 233       selected_index_(model_->GetDefaultIndex()),
 234       invalid_(false),
 235       dropdown_open_(false),
 236       text_button_(new TransparentButton(this)),
 237       arrow_button_(new TransparentButton(this)),
 238       weak_ptr_factory_(this) {
 239   model_->AddObserver(this);
 240   UpdateFromModel();
 241   SetFocusable(true);
 242   UpdateBorder();
 243
 244   // Initialize the button images.
 245   Button::ButtonState button_states[] = {
 246     Button::STATE_DISABLED,
 247     Button::STATE_NORMAL,
 248     Button::STATE_HOVERED,
 249     Button::STATE_PRESSED,
 250   };
 251   for (int i = 0; i < 2; i++) {
 252     for (size_t state_index = 0; state_index < arraysize(button_states);
 253          state_index++) {
 254       Button::ButtonState state = button_states[state_index];
 255       size_t num;
 256       bool focused = !!i;
 257       const int* ids = GetBodyButtonImageIds(focused, state, &num);
 258       body_button_painters_[focused][state].reset(
 259           Painter::CreateImageGridPainter(ids));
 260       menu_button_images_[focused][state] = GetMenuButtonImages(focused, state);
 261     }
 262   }
 263
 264   text_button_->SetVisible(true);
 265   arrow_button_->SetVisible(true);
 266   text_button_->SetFocusable(false);
 267   arrow_button_->SetFocusable(false);
 268   AddChildView(text_button_);
 269   AddChildView(arrow_button_);
 270 }
 271
 272 Combobox::~Combobox() {
 273   model_->RemoveObserver(this);
 274 }
 275
 276 // static
 277 const gfx::FontList& Combobox::GetFontList() {
 278   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 279   return rb.GetFontList(ui::ResourceBundle::BaseFont);
 280 }
 281
 282 void Combobox::SetStyle(Style style) {
 283   if (style_ == style)
 284     return;
 285
 286   style_ = style;
 287   if (style_ == STYLE_ACTION)
 288     selected_index_ = 0;
 289
 290   UpdateBorder();
 291   UpdateFromModel();
 292   PreferredSizeChanged();
 293 }
 294
 295 void Combobox::ModelChanged() {
 296   selected_index_ = std::min(0, model_->GetItemCount());
 297   UpdateFromModel();
 298   PreferredSizeChanged();
 299 }
 300
 301 void Combobox::SetSelectedIndex(int index) {
 302   if (style_ == STYLE_ACTION)
 303     return;
 304
 305   selected_index_ = index;
 306   SchedulePaint();
 307 }
 308
 309 bool Combobox::SelectValue(const base::string16& value) {
 310   if (style_ == STYLE_ACTION)
 311     return false;
 312
 313   for (int i = 0; i < model()->GetItemCount(); ++i) {
 314     if (value == model()->GetItemAt(i)) {
 315       SetSelectedIndex(i);
 316       return true;
 317     }
 318   }
 319   return false;
 320 }
 321
 322 void Combobox::SetAccessibleName(const base::string16& name) {
 323   accessible_name_ = name;
 324 }
 325
 326 void Combobox::SetInvalid(bool invalid) {
 327   if (invalid == invalid_)
 328     return;
 329
 330   invalid_ = invalid;
 331
 332   UpdateBorder();
 333   SchedulePaint();
 334 }
 335
 336 ui::TextInputClient* Combobox::GetTextInputClient() {
 337   if (!selector_)
 338     selector_.reset(new PrefixSelector(this));
 339   return selector_.get();
 340 }
 341
 342 void Combobox::Layout() {
 343   PrefixDelegate::Layout();
 344
 345   gfx::Insets insets = GetInsets();
 346   int text_button_width = 0;
 347   int arrow_button_width = 0;
 348
 349   switch (style_) {
 350     case STYLE_NORMAL: {
 351       arrow_button_width = width();
 352       break;
 353     }
 354     case STYLE_ACTION: {
 355       arrow_button_width = GetDisclosureArrowLeftPadding() +
 356           ArrowSize().width() +
 357           GetDisclosureArrowRightPadding();
 358       text_button_width = width() - arrow_button_width;
 359       break;
 360     }
 361   }
 362
 363   int arrow_button_x = std::max(0, text_button_width);
 364   text_button_->SetBounds(0, 0, std::max(0, text_button_width), height());
 365   arrow_button_->SetBounds(arrow_button_x, 0, arrow_button_width, height());
 366 }
 367
 368 bool Combobox::IsItemChecked(int id) const {
 369   return false;
 370 }
 371
 372 bool Combobox::IsCommandEnabled(int id) const {
 373   return model()->IsItemEnabledAt(MenuCommandToIndex(id));
 374 }
 375
 376 void Combobox::ExecuteCommand(int id) {
 377   selected_index_ = MenuCommandToIndex(id);
 378   OnPerformAction();
 379 }
 380
 381 bool Combobox::GetAccelerator(int id, ui::Accelerator* accel) const {
 382   return false;
 383 }
 384
 385 int Combobox::GetRowCount() {
 386   return model()->GetItemCount();
 387 }
 388
 389 int Combobox::GetSelectedRow() {
 390   return selected_index_;
 391 }
 392
 393 void Combobox::SetSelectedRow(int row) {
 394   int prev_index = selected_index_;
 395   SetSelectedIndex(row);
 396   if (selected_index_ != prev_index)
 397     OnPerformAction();
 398 }
 399
 400 base::string16 Combobox::GetTextForRow(int row) {
 401   return model()->IsItemSeparatorAt(row) ? base::string16() :
 402                                            model()->GetItemAt(row);
 403 }
 404
 405 ////////////////////////////////////////////////////////////////////////////////
 406 // Combobox, View overrides:
 407
 408 gfx::Size Combobox::GetPreferredSize() const {
 409   // The preferred size will drive the local bounds which in turn is used to set
 410   // the minimum width for the dropdown list.
 411   gfx::Insets insets = GetInsets();
 412   int total_width = std::max(kMinComboboxWidth, content_size_.width()) +
 413       insets.width() + GetDisclosureArrowLeftPadding() +
 414       ArrowSize().width() + GetDisclosureArrowRightPadding();
 415   return gfx::Size(total_width, content_size_.height() + insets.height());
 416 }
 417
 418 const char* Combobox::GetClassName() const {
 419   return kViewClassName;
 420 }
 421
 422 bool Combobox::SkipDefaultKeyEventProcessing(const ui::KeyEvent& e) {
 423   // Escape should close the drop down list when it is active, not host UI.
 424   if (e.key_code() != ui::VKEY_ESCAPE ||
 425       e.IsShiftDown() || e.IsControlDown() || e.IsAltDown()) {
 426     return false;
 427   }
 428   return dropdown_open_;
 429 }
 430
 431 bool Combobox::OnKeyPressed(const ui::KeyEvent& e) {
 432   // TODO(oshima): handle IME.
 433   DCHECK_EQ(e.type(), ui::ET_KEY_PRESSED);
 434
 435   DCHECK_GE(selected_index_, 0);
 436   DCHECK_LT(selected_index_, model()->GetItemCount());
 437   if (selected_index_ < 0 || selected_index_ > model()->GetItemCount())
 438     selected_index_ = 0;
 439
 440   bool show_menu = false;
 441   int new_index = kNoSelection;
 442   switch (e.key_code()) {
 443     // Show the menu on F4 without modifiers.
 444     case ui::VKEY_F4:
 445       if (e.IsAltDown() || e.IsAltGrDown() || e.IsControlDown())
 446         return false;
 447       show_menu = true;
 448       break;
 449
 450     // Move to the next item if any, or show the menu on Alt+Down like Windows.
 451     case ui::VKEY_DOWN:
 452       if (e.IsAltDown())
 453         show_menu = true;
 454       else
 455         new_index = GetAdjacentIndex(model(), 1, selected_index_);
 456       break;
 457
 458     // Move to the end of the list.
 459     case ui::VKEY_END:
 460     case ui::VKEY_NEXT:  // Page down.
 461       new_index = GetAdjacentIndex(model(), -1, model()->GetItemCount());
 462       break;
 463
 464     // Move to the beginning of the list.
 465     case ui::VKEY_HOME:
 466     case ui::VKEY_PRIOR:  // Page up.
 467       new_index = GetAdjacentIndex(model(), 1, -1);
 468       break;
 469
 470     // Move to the previous item if any.
 471     case ui::VKEY_UP:
 472       new_index = GetAdjacentIndex(model(), -1, selected_index_);
 473       break;
 474
 475     // Click the button only when the button style mode.
 476     case ui::VKEY_SPACE:
 477       if (style_ == STYLE_ACTION) {
 478         // When pressing space, the click event will be raised after the key is
 479         // released.
 480         text_button_->SetState(Button::STATE_PRESSED);
 481       } else {
 482         return false;
 483       }
 484       break;
 485
 486     // Click the button only when the button style mode.
 487     case ui::VKEY_RETURN:
 488       if (style_ != STYLE_ACTION)
 489         return false;
 490       OnPerformAction();
 491       break;
 492
 493     default:
 494       return false;
 495   }
 496
 497   if (show_menu) {
 498     UpdateFromModel();
 499     ShowDropDownMenu(ui::MENU_SOURCE_KEYBOARD);
 500   } else if (new_index != selected_index_ && new_index != kNoSelection &&
 501              style_ != STYLE_ACTION) {
 502     DCHECK(!model()->IsItemSeparatorAt(new_index));
 503     selected_index_ = new_index;
 504     OnPerformAction();
 505   }
 506
 507   return true;
 508 }
 509
 510 bool Combobox::OnKeyReleased(const ui::KeyEvent& e) {
 511   if (style_ != STYLE_ACTION)
 512     return false;  // crbug.com/127520
 513
 514   if (e.key_code() == ui::VKEY_SPACE && style_ == STYLE_ACTION)
 515     OnPerformAction();
 516
 517   return false;
 518 }
 519
 520 void Combobox::OnPaint(gfx::Canvas* canvas) {
 521   switch (style_) {
 522     case STYLE_NORMAL: {
 523       OnPaintBackground(canvas);
 524       PaintText(canvas);
 525       OnPaintBorder(canvas);
 526       break;
 527     }
 528     case STYLE_ACTION: {
 529       PaintButtons(canvas);
 530       PaintText(canvas);
 531       break;
 532     }
 533   }
 534 }
 535
 536 void Combobox::OnFocus() {
 537   GetInputMethod()->OnFocus();
 538   View::OnFocus();
 539   // Border renders differently when focused.
 540   SchedulePaint();
 541 }
 542
 543 void Combobox::OnBlur() {
 544   GetInputMethod()->OnBlur();
 545   if (selector_)
 546     selector_->OnViewBlur();
 547   // Border renders differently when focused.
 548   SchedulePaint();
 549 }
 550
 551 void Combobox::GetAccessibleState(ui::AXViewState* state) {
 552   state->role = ui::AX_ROLE_COMBO_BOX;
 553   state->name = accessible_name_;
 554   state->value = model_->GetItemAt(selected_index_);
 555   state->index = selected_index_;
 556   state->count = model_->GetItemCount();
 557 }
 558
 559 void Combobox::OnComboboxModelChanged(ui::ComboboxModel* model) {
 560   DCHECK_EQ(model, model_);
 561   ModelChanged();
 562 }
 563
 564 void Combobox::ButtonPressed(Button* sender, const ui::Event& event) {
 565   if (!enabled())
 566     return;
 567
 568   RequestFocus();
 569
 570   if (sender == text_button_) {
 571     OnPerformAction();
 572   } else {
 573     DCHECK_EQ(arrow_button_, sender);
 574     // TODO(hajimehoshi): Fix the problem that the arrow button blinks when
 575     // cliking this while the dropdown menu is opened.
 576     const base::TimeDelta delta = base::Time::Now() - closed_time_;
 577     if (delta.InMilliseconds() <= kMinimumMsBetweenButtonClicks)
 578       return;
 579
 580     ui::MenuSourceType source_type = ui::MENU_SOURCE_MOUSE;
 581     if (event.IsKeyEvent())
 582       source_type = ui::MENU_SOURCE_KEYBOARD;
 583     else if (event.IsGestureEvent() || event.IsTouchEvent())
 584       source_type = ui::MENU_SOURCE_TOUCH;
 585     ShowDropDownMenu(source_type);
 586   }
 587 }
 588
 589 void Combobox::UpdateFromModel() {
 590   const gfx::FontList& font_list = Combobox::GetFontList();
 591
 592   MenuItemView* menu = new MenuItemView(this);
 593   // MenuRunner owns |menu|.
 594   dropdown_list_menu_runner_.reset(new MenuRunner(menu));
 595
 596   int num_items = model()->GetItemCount();
 597   int width = 0;
 598   bool text_item_appended = false;
 599   for (int i = 0; i < num_items; ++i) {
 600     // When STYLE_ACTION is used, the first item and the following separators
 601     // are not added to the dropdown menu. It is assumed that the first item is
 602     // always selected and rendered on the top of the action button.
 603     if (model()->IsItemSeparatorAt(i)) {
 604       if (text_item_appended || style_ != STYLE_ACTION)
 605         menu->AppendSeparator();
 606       continue;
 607     }
 608
 609     base::string16 text = model()->GetItemAt(i);
 610
 611     // Inserting the Unicode formatting characters if necessary so that the
 612     // text is displayed correctly in right-to-left UIs.
 613     base::i18n::AdjustStringForLocaleDirection(&text);
 614
 615     if (style_ != STYLE_ACTION || i > 0) {
 616       menu->AppendMenuItem(i + kFirstMenuItemId, text, MenuItemView::NORMAL);
 617       text_item_appended = true;
 618     }
 619
 620     if (style_ != STYLE_ACTION || i == selected_index_)
 621       width = std::max(width, gfx::GetStringWidth(text, font_list));
 622   }
 623
 624   content_size_.SetSize(width, font_list.GetHeight());
 625 }
 626
 627 void Combobox::UpdateBorder() {
 628   scoped_ptr<FocusableBorder> border(new FocusableBorder());
 629   if (style_ == STYLE_ACTION)
 630     border->SetInsets(8, 13, 8, 13);
 631   if (invalid_)
 632     border->SetColor(kWarningColor);
 633   SetBorder(border.PassAs<Border>());
 634 }
 635
 636 void Combobox::AdjustBoundsForRTLUI(gfx::Rect* rect) const {
 637   rect->set_x(GetMirroredXForRect(*rect));
 638 }
 639
 640 void Combobox::PaintText(gfx::Canvas* canvas) {
 641   gfx::Insets insets = GetInsets();
 642
 643   gfx::ScopedCanvas scoped_canvas(canvas);
 644   canvas->ClipRect(GetContentsBounds());
 645
 646   int x = insets.left();
 647   int y = insets.top();
 648   int text_height = height() - insets.height();
 649   SkColor text_color = GetNativeTheme()->GetSystemColor(
 650       ui::NativeTheme::kColorId_LabelEnabledColor);
 651
 652   DCHECK_GE(selected_index_, 0);
 653   DCHECK_LT(selected_index_, model()->GetItemCount());
 654   if (selected_index_ < 0 || selected_index_ > model()->GetItemCount())
 655     selected_index_ = 0;
 656   base::string16 text = model()->GetItemAt(selected_index_);
 657
 658   gfx::Size arrow_size = ArrowSize();
 659   int disclosure_arrow_offset = width() - arrow_size.width() -
 660       GetDisclosureArrowLeftPadding() - GetDisclosureArrowRightPadding();
 661
 662   const gfx::FontList& font_list = Combobox::GetFontList();
 663   int text_width = gfx::GetStringWidth(text, font_list);
 664   if ((text_width + insets.width()) > disclosure_arrow_offset)
 665     text_width = disclosure_arrow_offset - insets.width();
 666
 667   gfx::Rect text_bounds(x, y, text_width, text_height);
 668   AdjustBoundsForRTLUI(&text_bounds);
 669   canvas->DrawStringRect(text, font_list, text_color, text_bounds);
 670
 671   int arrow_x = disclosure_arrow_offset + GetDisclosureArrowLeftPadding();
 672   gfx::Rect arrow_bounds(arrow_x,
 673                          height() / 2 - arrow_size.height() / 2,
 674                          arrow_size.width(),
 675                          arrow_size.height());
 676   AdjustBoundsForRTLUI(&arrow_bounds);
 677
 678   // TODO(estade): hack alert! Remove this direct call into CommonTheme. For now
 679   // STYLE_ACTION isn't properly themed so we have to override the NativeTheme
 680   // behavior. See crbug.com/384071
 681   if (style_ == STYLE_ACTION) {
 682     ui::CommonThemePaintComboboxArrow(canvas->sk_canvas(), arrow_bounds);
 683   } else {
 684     ui::NativeTheme::ExtraParams ignored;
 685     GetNativeTheme()->Paint(canvas->sk_canvas(),
 686                             ui::NativeTheme::kComboboxArrow,
 687                             ui::NativeTheme::kNormal,
 688                             arrow_bounds,
 689                             ignored);
 690   }
 691 }
 692
 693 void Combobox::PaintButtons(gfx::Canvas* canvas) {
 694   DCHECK(style_ == STYLE_ACTION);
 695
 696   gfx::ScopedCanvas scoped_canvas(canvas);
 697   if (base::i18n::IsRTL()) {
 698     canvas->Translate(gfx::Vector2d(width(), 0));
 699     canvas->Scale(-1, 1);
 700   }
 701
 702   bool focused = HasFocus();
 703   const std::vector<const gfx::ImageSkia*>& arrow_button_images =
 704       menu_button_images_[focused][
 705           arrow_button_->state() == Button::STATE_HOVERED ?
 706           Button::STATE_NORMAL : arrow_button_->state()];
 707
 708   int text_button_hover_alpha =
 709       text_button_->state() == Button::STATE_PRESSED ? 0 :
 710       static_cast<int>(static_cast<TransparentButton*>(text_button_)->
 711                        GetAnimationValue() * 255);
 712   if (text_button_hover_alpha < 255) {
 713     canvas->SaveLayerAlpha(255 - text_button_hover_alpha);
 714     Painter* text_button_painter =
 715         body_button_painters_[focused][
 716             text_button_->state() == Button::STATE_HOVERED ?
 717             Button::STATE_NORMAL : text_button_->state()].get();
 718     Painter::PaintPainterAt(canvas, text_button_painter,
 719                             gfx::Rect(0, 0, text_button_->width(), height()));
 720     canvas->Restore();
 721   }
 722   if (0 < text_button_hover_alpha) {
 723     canvas->SaveLayerAlpha(text_button_hover_alpha);
 724     Painter* text_button_hovered_painter =
 725         body_button_painters_[focused][Button::STATE_HOVERED].get();
 726     Painter::PaintPainterAt(canvas, text_button_hovered_painter,
 727                             gfx::Rect(0, 0, text_button_->width(), height()));
 728     canvas->Restore();
 729   }
 730
 731   int arrow_button_hover_alpha =
 732       arrow_button_->state() == Button::STATE_PRESSED ? 0 :
 733       static_cast<int>(static_cast<TransparentButton*>(arrow_button_)->
 734                        GetAnimationValue() * 255);
 735   if (arrow_button_hover_alpha < 255) {
 736     canvas->SaveLayerAlpha(255 - arrow_button_hover_alpha);
 737     PaintArrowButton(canvas, arrow_button_images, arrow_button_->x(), height());
 738     canvas->Restore();
 739   }
 740   if (0 < arrow_button_hover_alpha) {
 741     canvas->SaveLayerAlpha(arrow_button_hover_alpha);
 742     const std::vector<const gfx::ImageSkia*>& arrow_button_hovered_images =
 743         menu_button_images_[focused][Button::STATE_HOVERED];
 744     PaintArrowButton(canvas, arrow_button_hovered_images,
 745                      arrow_button_->x(), height());
 746     canvas->Restore();
 747   }
 748 }
 749
 750 void Combobox::ShowDropDownMenu(ui::MenuSourceType source_type) {
 751   if (!dropdown_list_menu_runner_.get())
 752     UpdateFromModel();
 753
 754   // Extend the menu to the width of the combobox.
 755   MenuItemView* menu = dropdown_list_menu_runner_->GetMenu();
 756   SubmenuView* submenu = menu->CreateSubmenu();
 757   submenu->set_minimum_preferred_width(
 758       size().width() - (kMenuBorderWidthLeft + kMenuBorderWidthRight));
 759
 760   gfx::Rect lb = GetLocalBounds();
 761   gfx::Point menu_position(lb.origin());
 762
 763   if (style_ == STYLE_NORMAL) {
 764     // Inset the menu's requested position so the border of the menu lines up
 765     // with the border of the combobox.
 766     menu_position.set_x(menu_position.x() + kMenuBorderWidthLeft);
 767     menu_position.set_y(menu_position.y() + kMenuBorderWidthTop);
 768   }
 769   lb.set_width(lb.width() - (kMenuBorderWidthLeft + kMenuBorderWidthRight));
 770
 771   View::ConvertPointToScreen(this, &menu_position);
 772   if (menu_position.x() < 0)
 773     menu_position.set_x(0);
 774
 775   gfx::Rect bounds(menu_position, lb.size());
 776
 777   Button::ButtonState original_state = Button::STATE_NORMAL;
 778   if (arrow_button_) {
 779     original_state = arrow_button_->state();
 780     arrow_button_->SetState(Button::STATE_PRESSED);
 781   }
 782   dropdown_open_ = true;
 783   MenuAnchorPosition anchor_position =
 784       style_ == STYLE_ACTION ? MENU_ANCHOR_TOPRIGHT : MENU_ANCHOR_TOPLEFT;
 785   if (dropdown_list_menu_runner_->RunMenuAt(GetWidget(), NULL, bounds,
 786                                             anchor_position, source_type,
 787                                             MenuRunner::COMBOBOX) ==
 788       MenuRunner::MENU_DELETED) {
 789     return;
 790   }
 791   dropdown_open_ = false;
 792   if (arrow_button_)
 793     arrow_button_->SetState(original_state);
 794   closed_time_ = base::Time::Now();
 795
 796   // Need to explicitly clear mouse handler so that events get sent
 797   // properly after the menu finishes running. If we don't do this, then
 798   // the first click to other parts of the UI is eaten.
 799   SetMouseHandler(NULL);
 800 }
 801
 802 void Combobox::OnPerformAction() {
 803   NotifyAccessibilityEvent(ui::AX_EVENT_VALUE_CHANGED, false);
 804   SchedulePaint();
 805
 806   // This combobox may be deleted by the listener.
 807   base::WeakPtr<Combobox> weak_ptr = weak_ptr_factory_.GetWeakPtr();
 808   if (listener_)
 809     listener_->OnPerformAction(this);
 810
 811   if (weak_ptr && style_ == STYLE_ACTION)
 812     selected_index_ = 0;
 813 }
 814
 815 int Combobox::MenuCommandToIndex(int menu_command_id) const {
 816   // (note that the id received is offset by kFirstMenuItemId)
 817   // Revert menu ID offset to map back to combobox model.
 818   int index = menu_command_id - kFirstMenuItemId;
 819   DCHECK_LT(index, model()->GetItemCount());
 820   return index;
 821 }
 822
 823 int Combobox::GetDisclosureArrowLeftPadding() const {
 824   switch (style_) {
 825     case STYLE_NORMAL:
 826       return kDisclosureArrowLeftPadding;
 827     case STYLE_ACTION:
 828       return kDisclosureArrowButtonLeftPadding;
 829   }
 830   NOTREACHED();
 831   return 0;
 832 }
 833
 834 int Combobox::GetDisclosureArrowRightPadding() const {
 835   switch (style_) {
 836     case STYLE_NORMAL:
 837       return kDisclosureArrowRightPadding;
 838     case STYLE_ACTION:
 839       return kDisclosureArrowButtonRightPadding;
 840   }
 841   NOTREACHED();
 842   return 0;
 843 }
 844
 845 gfx::Size Combobox::ArrowSize() const {
 846 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
 847   // TODO(estade): hack alert! This should always use GetNativeTheme(). For now
 848   // STYLE_ACTION isn't properly themed so we have to override the NativeTheme
 849   // behavior. See crbug.com/384071
 850   const ui::NativeTheme* native_theme_for_arrow = style_ == STYLE_ACTION ?
 851       ui::NativeTheme::instance() :
 852       GetNativeTheme();
 853 #else
 854   const ui::NativeTheme* native_theme_for_arrow = GetNativeTheme();
 855 #endif
 856
 857   ui::NativeTheme::ExtraParams ignored;
 858   return native_theme_for_arrow->GetPartSize(ui::NativeTheme::kComboboxArrow,
 859                                              ui::NativeTheme::kNormal,
 860                                              ignored);
 861 }
 862
 863 }  // namespace views