MenuButton: support Mac look & feel

ui/views/controls/combobox/combobox.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/combobox/combobox.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 36 matching lines @@
 namespace {
 
 // Menu border widths
 const int kMenuBorderWidthLeft = 1;
 const int kMenuBorderWidthTop = 1;
 const int kMenuBorderWidthRight = 1;
 
 // Limit how small a combobox can be.
 const int kMinComboboxWidth = 25;
 
-// Size of the combobox arrow margins
-const int kDisclosureArrowLeftPadding = 7;
-const int kDisclosureArrowRightPadding = 7;
-const int kDisclosureArrowButtonLeftPadding = 11;
-const int kDisclosureArrowButtonRightPadding = 12;
-
 // Define the id of the first item in the menu (since it needs to be > 0)
 const int kFirstMenuItemId = 1000;
 
 // Used to indicate that no item is currently selected by the user.
 const int kNoSelection = -1;
 
 const int kBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON);
 const int kHoveredBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON_H);
 const int kPressedBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON_P);
 const int kFocusedBodyButtonImages[] = IMAGE_GRID(IDR_COMBOBOX_BUTTON_F);
@@ skipping 382 matching lines @@
   if (invalid == invalid_)
     return;
 
   invalid_ = invalid;
 
   UpdateBorder();
   SchedulePaint();
 }
 
 int Combobox::GetArrowButtonWidth() const {
-  return GetDisclosureArrowLeftPadding() +
-         ArrowSize().width() +
-         GetDisclosureArrowRightPadding();
+  return PlatformStyle::GetComboboxArrowWidth(style_);

[tapted, 2016/04/21 06:06:46]

Maybe "ShoulderWidth"

[Elly Fong-Jones, 2016/04/21 15:30:26]

Done.

 }
 
 void Combobox::Layout() {
   PrefixDelegate::Layout();
 
   gfx::Insets insets = GetInsets();
   int text_button_width = 0;
   int arrow_button_width = 0;
 
   switch (style_) {
     case STYLE_NORMAL: {
       arrow_button_width = width();
       break;
     }
     case STYLE_ACTION: {
-      arrow_button_width = GetDisclosureArrowLeftPadding() +
-          ArrowSize().width() +
-          GetDisclosureArrowRightPadding();
+      arrow_button_width = GetArrowButtonWidth();
       text_button_width = width() - arrow_button_width;
       break;
     }
   }
 
   int arrow_button_x = std::max(0, text_button_width);
   text_button_->SetBounds(0, 0, std::max(0, text_button_width), height());
   arrow_button_->SetBounds(arrow_button_x, 0, arrow_button_width, height());
 }
 
@@ skipping 22 matching lines @@
 
 gfx::Size Combobox::GetPreferredSize() const {
   // The preferred size will drive the local bounds which in turn is used to set
   // the minimum width for the dropdown list.
   gfx::Insets insets = GetInsets();
   insets += gfx::Insets(Textfield::kTextPadding,
                         Textfield::kTextPadding,
                         Textfield::kTextPadding,
                         Textfield::kTextPadding);
   int total_width = std::max(kMinComboboxWidth, content_size_.width()) +
-                    insets.width() + GetDisclosureArrowLeftPadding() +
-                    ArrowSize().width() + GetDisclosureArrowRightPadding();
+                    insets.width() + GetArrowButtonWidth();
   return gfx::Size(total_width, content_size_.height() + insets.height());
 }
 
 const char* Combobox::GetClassName() const {
   return kViewClassName;
 }
 
 bool Combobox::SkipDefaultKeyEventProcessing(const ui::KeyEvent& e) {
   // Escape should close the drop down list when it is active, not host UI.
   if (e.key_code() != ui::VKEY_ESCAPE ||
@@ skipping 186 matching lines @@
   SkColor text_color = GetNativeTheme()->GetSystemColor(
       enabled() ? ui::NativeTheme::kColorId_LabelEnabledColor :
                   ui::NativeTheme::kColorId_LabelDisabledColor);
 
   DCHECK_GE(selected_index_, 0);
   DCHECK_LT(selected_index_, model()->GetItemCount());
   if (selected_index_ < 0 || selected_index_ > model()->GetItemCount())
     selected_index_ = 0;
   base::string16 text = model()->GetItemAt(selected_index_);
 
-  gfx::Size arrow_size = ArrowSize();
-  int disclosure_arrow_offset = width() - arrow_size.width() -
-      GetDisclosureArrowLeftPadding() - GetDisclosureArrowRightPadding();
+  int disclosure_arrow_offset = width() - GetArrowButtonWidth();
 
   const gfx::FontList& font_list = Combobox::GetFontList();
   int text_width = gfx::GetStringWidth(text, font_list);
   if ((text_width + insets.width()) > disclosure_arrow_offset)
     text_width = disclosure_arrow_offset - insets.width();
 
   gfx::Rect text_bounds(x, y, text_width, text_height);
   AdjustBoundsForRTLUI(&text_bounds);
   canvas->DrawStringRect(text, font_list, text_color, text_bounds);
 
-  int arrow_x = disclosure_arrow_offset + GetDisclosureArrowLeftPadding();
-  gfx::Rect arrow_bounds(arrow_x,
-                         height() / 2 - arrow_size.height() / 2,
-                         arrow_size.width(),
-                         arrow_size.height());
+  gfx::ImageSkia arrow_image = PlatformStyle::CreateComboboxArrow(
+      enabled(), style_);
+  gfx::Rect arrow_bounds(disclosure_arrow_offset, 0, GetArrowButtonWidth(),
+                         height());
+  arrow_bounds.ClampToCenteredSize(ArrowSize());
   AdjustBoundsForRTLUI(&arrow_bounds);
 
-  gfx::ImageSkia arrow_image = PlatformStyle::CreateComboboxArrow(
-      enabled(), style_);
   canvas->DrawImageInt(arrow_image, arrow_bounds.x(), arrow_bounds.y());
 }
 
 void Combobox::PaintButtons(gfx::Canvas* canvas) {
   DCHECK(style_ == STYLE_ACTION);
 
   gfx::ScopedCanvas scoped_canvas(canvas);
   if (base::i18n::IsRTL()) {
     canvas->Translate(gfx::Vector2d(width(), 0));
     canvas->Scale(-1, 1);
@@ skipping 98 matching lines @@
 
   // This combobox may be deleted by the listener.
   base::WeakPtr<Combobox> weak_ptr = weak_ptr_factory_.GetWeakPtr();
   if (listener_)
     listener_->OnPerformAction(this);
 
   if (weak_ptr && style_ == STYLE_ACTION)
     selected_index_ = 0;
 }
 
-int Combobox::GetDisclosureArrowLeftPadding() const {
-  switch (style_) {
-    case STYLE_NORMAL:
-      return kDisclosureArrowLeftPadding;
-    case STYLE_ACTION:
-      return kDisclosureArrowButtonLeftPadding;
-  }
-  NOTREACHED();
-  return 0;
-}
-
-int Combobox::GetDisclosureArrowRightPadding() const {
-  switch (style_) {
-    case STYLE_NORMAL:
-      return kDisclosureArrowRightPadding;
-    case STYLE_ACTION:
-      return kDisclosureArrowButtonRightPadding;
-  }
-  NOTREACHED();
-  return 0;
-}
-
 gfx::Size Combobox::ArrowSize() const {
   return PlatformStyle::CreateComboboxArrow(enabled(), style_).size();
 }
 
 gfx::Size Combobox::GetContentSize() const {
   const gfx::FontList& font_list = GetFontList();
 
   int width = 0;
   for (int i = 0; i < model()->GetItemCount(); ++i) {
     if (model_->IsItemSeparatorAt(i))
       continue;
 
     if (style_ != STYLE_ACTION || i == selected_index_) {
       width = std::max(
           width,
           gfx::GetStringWidth(menu_model_adapter_->GetLabelAt(i), font_list));
     }
   }
   return gfx::Size(width, font_list.GetHeight());
 }
 
 PrefixSelector* Combobox::GetPrefixSelector() {
   if (!selector_)
     selector_.reset(new PrefixSelector(this));
   return selector_.get();
 }
 
 }  // namespace views