Home | History | Annotate | Download | only in menu 
      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/submenu_view.h"
      6 
      7 #include <algorithm>
      8 
      9 #include "base/compiler_specific.h"
     10 #include "ui/accessibility/ax_view_state.h"
     11 #include "ui/events/event.h"
     12 #include "ui/gfx/canvas.h"
     13 #include "ui/gfx/geometry/safe_integer_conversions.h"
     14 #include "ui/views/controls/menu/menu_config.h"
     15 #include "ui/views/controls/menu/menu_controller.h"
     16 #include "ui/views/controls/menu/menu_host.h"
     17 #include "ui/views/controls/menu/menu_item_view.h"
     18 #include "ui/views/controls/menu/menu_scroll_view_container.h"
     19 #include "ui/views/widget/root_view.h"
     20 #include "ui/views/widget/widget.h"
     21 
     22 namespace {
     23 
     24 // Height of the drop indicator. This should be an even number.
     25 const int kDropIndicatorHeight = 2;
     26 
     27 // Color of the drop indicator.
     28 const SkColor kDropIndicatorColor = SK_ColorBLACK;
     29 
     30 }  // namespace
     31 
     32 namespace views {
     33 
     34 // static
     35 const char SubmenuView::kViewClassName[] = "SubmenuView";
     36 
     37 SubmenuView::SubmenuView(MenuItemView* parent)
     38     : parent_menu_item_(parent),
     39       host_(NULL),
     40       drop_item_(NULL),
     41       drop_position_(MenuDelegate::DROP_NONE),
     42       scroll_view_container_(NULL),
     43       max_minor_text_width_(0),
     44       minimum_preferred_width_(0),
     45       resize_open_menu_(false),
     46       scroll_animator_(new ScrollAnimator(this)),
     47       roundoff_error_(0),
     48       prefix_selector_(this) {
     49   DCHECK(parent);
     50   // We'll delete ourselves, otherwise the ScrollView would delete us on close.
     51   set_owned_by_client();
     52 }
     53 
     54 SubmenuView::~SubmenuView() {
     55   // The menu may not have been closed yet (it will be hidden, but not
     56   // necessarily closed).
     57   Close();
     58 
     59   delete scroll_view_container_;
     60 }
     61 
     62 int SubmenuView::GetMenuItemCount() {
     63   int count = 0;
     64   for (int i = 0; i < child_count(); ++i) {
     65     if (child_at(i)->id() == MenuItemView::kMenuItemViewID)
     66       count++;
     67   }
     68   return count;
     69 }
     70 
     71 MenuItemView* SubmenuView::GetMenuItemAt(int index) {
     72   for (int i = 0, count = 0; i < child_count(); ++i) {
     73     if (child_at(i)->id() == MenuItemView::kMenuItemViewID &&
     74         count++ == index) {
     75       return static_cast<MenuItemView*>(child_at(i));
     76     }
     77   }
     78   NOTREACHED();
     79   return NULL;
     80 }
     81 
     82 void SubmenuView::ChildPreferredSizeChanged(View* child) {
     83   if (!resize_open_menu_)
     84     return;
     85 
     86   MenuItemView *item = GetMenuItem();
     87   MenuController* controller = item->GetMenuController();
     88 
     89   if (controller) {
     90     bool dir;
     91     gfx::Rect bounds = controller->CalculateMenuBounds(item, false, &dir);
     92     Reposition(bounds);
     93   }
     94 }
     95 
     96 void SubmenuView::Layout() {
     97   // We're in a ScrollView, and need to set our width/height ourselves.
     98   if (!parent())
     99     return;
    100 
    101   // Use our current y, unless it means part of the menu isn't visible anymore.
    102   int pref_height = GetPreferredSize().height();
    103   int new_y;
    104   if (pref_height > parent()->height())
    105     new_y = std::max(parent()->height() - pref_height, y());
    106   else
    107     new_y = 0;
    108   SetBounds(x(), new_y, parent()->width(), pref_height);
    109 
    110   gfx::Insets insets = GetInsets();
    111   int x = insets.left();
    112   int y = insets.top();
    113   int menu_item_width = width() - insets.width();
    114   for (int i = 0; i < child_count(); ++i) {
    115     View* child = child_at(i);
    116     if (child->visible()) {
    117       int child_height = child->GetHeightForWidth(menu_item_width);
    118       child->SetBounds(x, y, menu_item_width, child_height);
    119       y += child_height;
    120     }
    121   }
    122 }
    123 
    124 gfx::Size SubmenuView::GetPreferredSize() const {
    125   if (!has_children())
    126     return gfx::Size();
    127 
    128   max_minor_text_width_ = 0;
    129   // The maximum width of items which contain maybe a label and multiple views.
    130   int max_complex_width = 0;
    131   // The max. width of items which contain a label and maybe an accelerator.
    132   int max_simple_width = 0;
    133 
    134   // We perform the size calculation in two passes. In the first pass, we
    135   // calculate the width of the menu. In the second, we calculate the height
    136   // using that width. This allows views that have flexible widths to adjust
    137   // accordingly.
    138   for (int i = 0; i < child_count(); ++i) {
    139     const View* child = child_at(i);
    140     if (!child->visible())
    141       continue;
    142     if (child->id() == MenuItemView::kMenuItemViewID) {
    143       const MenuItemView* menu = static_cast<const MenuItemView*>(child);
    144       const MenuItemView::MenuItemDimensions& dimensions =
    145           menu->GetDimensions();
    146       max_simple_width = std::max(
    147           max_simple_width, dimensions.standard_width);
    148       max_minor_text_width_ =
    149           std::max(max_minor_text_width_, dimensions.minor_text_width);
    150       max_complex_width = std::max(max_complex_width,
    151           dimensions.standard_width + dimensions.children_width);
    152     } else {
    153       max_complex_width = std::max(max_complex_width,
    154                                    child->GetPreferredSize().width());
    155     }
    156   }
    157   if (max_minor_text_width_ > 0) {
    158     max_minor_text_width_ +=
    159         GetMenuItem()->GetMenuConfig().label_to_minor_text_padding;
    160   }
    161   // Finish calculating our optimum width.
    162   gfx::Insets insets = GetInsets();
    163   int width = std::max(max_complex_width,
    164                        std::max(max_simple_width + max_minor_text_width_ +
    165                                     insets.width(),
    166                                 minimum_preferred_width_ - 2 * insets.width()));
    167 
    168   // Then, the height for that width.
    169   int height = 0;
    170   int menu_item_width = width - insets.width();
    171   for (int i = 0; i < child_count(); ++i) {
    172     const View* child = child_at(i);
    173     height += child->visible() ? child->GetHeightForWidth(menu_item_width) : 0;
    174   }
    175 
    176   return gfx::Size(width, height + insets.height());
    177 }
    178 
    179 void SubmenuView::GetAccessibleState(ui::AXViewState* state) {
    180   // Inherit most of the state from the parent menu item, except the role.
    181   if (GetMenuItem())
    182     GetMenuItem()->GetAccessibleState(state);
    183   state->role = ui::AX_ROLE_MENU_LIST_POPUP;
    184 }
    185 
    186 ui::TextInputClient* SubmenuView::GetTextInputClient() {
    187   return &prefix_selector_;
    188 }
    189 
    190 void SubmenuView::PaintChildren(gfx::Canvas* canvas,
    191                                 const views::CullSet& cull_set) {
    192   View::PaintChildren(canvas, cull_set);
    193 
    194   if (drop_item_ && drop_position_ != MenuDelegate::DROP_ON)
    195     PaintDropIndicator(canvas, drop_item_, drop_position_);
    196 }
    197 
    198 bool SubmenuView::GetDropFormats(
    199       int* formats,
    200       std::set<OSExchangeData::CustomFormat>* custom_formats) {
    201   DCHECK(GetMenuItem()->GetMenuController());
    202   return GetMenuItem()->GetMenuController()->GetDropFormats(this, formats,
    203                                                             custom_formats);
    204 }
    205 
    206 bool SubmenuView::AreDropTypesRequired() {
    207   DCHECK(GetMenuItem()->GetMenuController());
    208   return GetMenuItem()->GetMenuController()->AreDropTypesRequired(this);
    209 }
    210 
    211 bool SubmenuView::CanDrop(const OSExchangeData& data) {
    212   DCHECK(GetMenuItem()->GetMenuController());
    213   return GetMenuItem()->GetMenuController()->CanDrop(this, data);
    214 }
    215 
    216 void SubmenuView::OnDragEntered(const ui::DropTargetEvent& event) {
    217   DCHECK(GetMenuItem()->GetMenuController());
    218   GetMenuItem()->GetMenuController()->OnDragEntered(this, event);
    219 }
    220 
    221 int SubmenuView::OnDragUpdated(const ui::DropTargetEvent& event) {
    222   DCHECK(GetMenuItem()->GetMenuController());
    223   return GetMenuItem()->GetMenuController()->OnDragUpdated(this, event);
    224 }
    225 
    226 void SubmenuView::OnDragExited() {
    227   DCHECK(GetMenuItem()->GetMenuController());
    228   GetMenuItem()->GetMenuController()->OnDragExited(this);
    229 }
    230 
    231 int SubmenuView::OnPerformDrop(const ui::DropTargetEvent& event) {
    232   DCHECK(GetMenuItem()->GetMenuController());
    233   return GetMenuItem()->GetMenuController()->OnPerformDrop(this, event);
    234 }
    235 
    236 bool SubmenuView::OnMouseWheel(const ui::MouseWheelEvent& e) {
    237   gfx::Rect vis_bounds = GetVisibleBounds();
    238   int menu_item_count = GetMenuItemCount();
    239   if (vis_bounds.height() == height() || !menu_item_count) {
    240     // All menu items are visible, nothing to scroll.
    241     return true;
    242   }
    243 
    244   // Find the index of the first menu item whose y-coordinate is >= visible
    245   // y-coordinate.
    246   int i = 0;
    247   while ((i < menu_item_count) && (GetMenuItemAt(i)->y() < vis_bounds.y()))
    248     ++i;
    249   if (i == menu_item_count)
    250     return true;
    251   int first_vis_index = std::max(0,
    252       (GetMenuItemAt(i)->y() == vis_bounds.y()) ? i : i - 1);
    253 
    254   // If the first item isn't entirely visible, make it visible, otherwise make
    255   // the next/previous one entirely visible. If enough wasn't scrolled to show
    256   // any new rows, then just scroll the amount so that smooth scrolling using
    257   // the trackpad is possible.
    258   int delta = abs(e.y_offset() / ui::MouseWheelEvent::kWheelDelta);
    259   if (delta == 0)
    260     return OnScroll(0, e.y_offset());
    261   for (bool scroll_up = (e.y_offset() > 0); delta != 0; --delta) {
    262     int scroll_target;
    263     if (scroll_up) {
    264       if (GetMenuItemAt(first_vis_index)->y() == vis_bounds.y()) {
    265         if (first_vis_index == 0)
    266           break;
    267         first_vis_index--;
    268       }
    269       scroll_target = GetMenuItemAt(first_vis_index)->y();
    270     } else {
    271       if (first_vis_index + 1 == menu_item_count)
    272         break;
    273       scroll_target = GetMenuItemAt(first_vis_index + 1)->y();
    274       if (GetMenuItemAt(first_vis_index)->y() == vis_bounds.y())
    275         first_vis_index++;
    276     }
    277     ScrollRectToVisible(gfx::Rect(gfx::Point(0, scroll_target),
    278                                   vis_bounds.size()));
    279     vis_bounds = GetVisibleBounds();
    280   }
    281 
    282   return true;
    283 }
    284 
    285 void SubmenuView::OnGestureEvent(ui::GestureEvent* event) {
    286   bool handled = true;
    287   switch (event->type()) {
    288     case ui::ET_GESTURE_SCROLL_BEGIN:
    289       scroll_animator_->Stop();
    290       break;
    291     case ui::ET_GESTURE_SCROLL_UPDATE:
    292       handled = OnScroll(0, event->details().scroll_y());
    293       break;
    294     case ui::ET_GESTURE_SCROLL_END:
    295       break;
    296     case ui::ET_SCROLL_FLING_START:
    297       if (event->details().velocity_y() != 0.0f)
    298         scroll_animator_->Start(0, event->details().velocity_y());
    299       break;
    300     case ui::ET_GESTURE_TAP_DOWN:
    301     case ui::ET_SCROLL_FLING_CANCEL:
    302       if (scroll_animator_->is_scrolling())
    303         scroll_animator_->Stop();
    304       else
    305         handled = false;
    306       break;
    307     default:
    308       handled = false;
    309       break;
    310   }
    311   if (handled)
    312     event->SetHandled();
    313 }
    314 
    315 int SubmenuView::GetRowCount() {
    316   return GetMenuItemCount();
    317 }
    318 
    319 int SubmenuView::GetSelectedRow() {
    320   int row = 0;
    321   for (int i = 0; i < child_count(); ++i) {
    322     if (child_at(i)->id() != MenuItemView::kMenuItemViewID)
    323       continue;
    324 
    325     if (static_cast<MenuItemView*>(child_at(i))->IsSelected())
    326       return row;
    327 
    328     row++;
    329   }
    330 
    331   return -1;
    332 }
    333 
    334 void SubmenuView::SetSelectedRow(int row) {
    335   GetMenuItem()->GetMenuController()->SetSelection(
    336       GetMenuItemAt(row),
    337       MenuController::SELECTION_DEFAULT);
    338 }
    339 
    340 base::string16 SubmenuView::GetTextForRow(int row) {
    341   return GetMenuItemAt(row)->title();
    342 }
    343 
    344 bool SubmenuView::IsShowing() {
    345   return host_ && host_->IsMenuHostVisible();
    346 }
    347 
    348 void SubmenuView::ShowAt(Widget* parent,
    349                          const gfx::Rect& bounds,
    350                          bool do_capture) {
    351   if (host_) {
    352     host_->ShowMenuHost(do_capture);
    353   } else {
    354     host_ = new MenuHost(this);
    355     // Force construction of the scroll view container.
    356     GetScrollViewContainer();
    357     // Force a layout since our preferred size may not have changed but our
    358     // content may have.
    359     InvalidateLayout();
    360     host_->InitMenuHost(parent, bounds, scroll_view_container_, do_capture);
    361   }
    362 
    363   GetScrollViewContainer()->NotifyAccessibilityEvent(
    364       ui::AX_EVENT_MENU_START,
    365       true);
    366   NotifyAccessibilityEvent(
    367       ui::AX_EVENT_MENU_POPUP_START,
    368       true);
    369 }
    370 
    371 void SubmenuView::Reposition(const gfx::Rect& bounds) {
    372   if (host_)
    373     host_->SetMenuHostBounds(bounds);
    374 }
    375 
    376 void SubmenuView::Close() {
    377   if (host_) {
    378     NotifyAccessibilityEvent(ui::AX_EVENT_MENU_POPUP_END, true);
    379     GetScrollViewContainer()->NotifyAccessibilityEvent(
    380         ui::AX_EVENT_MENU_END, true);
    381 
    382     host_->DestroyMenuHost();
    383     host_ = NULL;
    384   }
    385 }
    386 
    387 void SubmenuView::Hide() {
    388   if (host_)
    389     host_->HideMenuHost();
    390   if (scroll_animator_->is_scrolling())
    391     scroll_animator_->Stop();
    392 }
    393 
    394 void SubmenuView::ReleaseCapture() {
    395   if (host_)
    396     host_->ReleaseMenuHostCapture();
    397 }
    398 
    399 bool SubmenuView::SkipDefaultKeyEventProcessing(const ui::KeyEvent& e) {
    400   return views::FocusManager::IsTabTraversalKeyEvent(e);
    401 }
    402 
    403 MenuItemView* SubmenuView::GetMenuItem() const {
    404   return parent_menu_item_;
    405 }
    406 
    407 void SubmenuView::SetDropMenuItem(MenuItemView* item,
    408                                   MenuDelegate::DropPosition position) {
    409   if (drop_item_ == item && drop_position_ == position)
    410     return;
    411   SchedulePaintForDropIndicator(drop_item_, drop_position_);
    412   drop_item_ = item;
    413   drop_position_ = position;
    414   SchedulePaintForDropIndicator(drop_item_, drop_position_);
    415 }
    416 
    417 bool SubmenuView::GetShowSelection(MenuItemView* item) {
    418   if (drop_item_ == NULL)
    419     return true;
    420   // Something is being dropped on one of this menus items. Show the
    421   // selection if the drop is on the passed in item and the drop position is
    422   // ON.
    423   return (drop_item_ == item && drop_position_ == MenuDelegate::DROP_ON);
    424 }
    425 
    426 MenuScrollViewContainer* SubmenuView::GetScrollViewContainer() {
    427   if (!scroll_view_container_) {
    428     scroll_view_container_ = new MenuScrollViewContainer(this);
    429     // Otherwise MenuHost would delete us.
    430     scroll_view_container_->set_owned_by_client();
    431   }
    432   return scroll_view_container_;
    433 }
    434 
    435 void SubmenuView::MenuHostDestroyed() {
    436   host_ = NULL;
    437   GetMenuItem()->GetMenuController()->Cancel(MenuController::EXIT_DESTROYED);
    438 }
    439 
    440 const char* SubmenuView::GetClassName() const {
    441   return kViewClassName;
    442 }
    443 
    444 void SubmenuView::OnBoundsChanged(const gfx::Rect& previous_bounds) {
    445   SchedulePaint();
    446 }
    447 
    448 void SubmenuView::PaintDropIndicator(gfx::Canvas* canvas,
    449                                      MenuItemView* item,
    450                                      MenuDelegate::DropPosition position) {
    451   if (position == MenuDelegate::DROP_NONE)
    452     return;
    453 
    454   gfx::Rect bounds = CalculateDropIndicatorBounds(item, position);
    455   canvas->FillRect(bounds, kDropIndicatorColor);
    456 }
    457 
    458 void SubmenuView::SchedulePaintForDropIndicator(
    459     MenuItemView* item,
    460     MenuDelegate::DropPosition position) {
    461   if (item == NULL)
    462     return;
    463 
    464   if (position == MenuDelegate::DROP_ON) {
    465     item->SchedulePaint();
    466   } else if (position != MenuDelegate::DROP_NONE) {
    467     SchedulePaintInRect(CalculateDropIndicatorBounds(item, position));
    468   }
    469 }
    470 
    471 gfx::Rect SubmenuView::CalculateDropIndicatorBounds(
    472     MenuItemView* item,
    473     MenuDelegate::DropPosition position) {
    474   DCHECK(position != MenuDelegate::DROP_NONE);
    475   gfx::Rect item_bounds = item->bounds();
    476   switch (position) {
    477     case MenuDelegate::DROP_BEFORE:
    478       item_bounds.Offset(0, -kDropIndicatorHeight / 2);
    479       item_bounds.set_height(kDropIndicatorHeight);
    480       return item_bounds;
    481 
    482     case MenuDelegate::DROP_AFTER:
    483       item_bounds.Offset(0, item_bounds.height() - kDropIndicatorHeight / 2);
    484       item_bounds.set_height(kDropIndicatorHeight);
    485       return item_bounds;
    486 
    487     default:
    488       // Don't render anything for on.
    489       return gfx::Rect();
    490   }
    491 }
    492 
    493 bool SubmenuView::OnScroll(float dx, float dy) {
    494   const gfx::Rect& vis_bounds = GetVisibleBounds();
    495   const gfx::Rect& full_bounds = bounds();
    496   int x = vis_bounds.x();
    497   float y_f = vis_bounds.y() - dy - roundoff_error_;
    498   int y = gfx::ToRoundedInt(y_f);
    499   roundoff_error_ = y - y_f;
    500   // clamp y to [0, full_height - vis_height)
    501   y = std::min(y, full_bounds.height() - vis_bounds.height() - 1);
    502   y = std::max(y, 0);
    503   gfx::Rect new_vis_bounds(x, y, vis_bounds.width(), vis_bounds.height());
    504   if (new_vis_bounds != vis_bounds) {
    505     ScrollRectToVisible(new_vis_bounds);
    506     return true;
    507   }
    508   return false;
    509 }
    510 
    511 }  // namespace views
    512