views: Fix gesture event propagation in menus.

chrome/browser/ui/views/wrench_menu.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 "chrome/browser/ui/views/wrench_menu.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 
@@ skipping 75 matching lines @@
 
 // For touch menu items we want to have this height in pixels.
 const int kTouchItemHeight = 47;
 
 // Subclass of ImageButton whose preferred size includes the size of the border.
 class FullscreenButton : public ImageButton {
  public:
   explicit FullscreenButton(views::ButtonListener* listener)
       : ImageButton(listener) { }
 
-  virtual gfx::Size GetPreferredSize() {
+  // Overridden from ImageButton.
+  virtual gfx::Size GetPreferredSize() OVERRIDE {
     gfx::Size pref = ImageButton::GetPreferredSize();
     gfx::Insets insets;
     if (border())
       border()->GetInsets(&insets);
     pref.Enlarge(insets.width(), insets.height());
     return pref;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FullscreenButton);
 };
 
 // Border for buttons contained in the menu. This is only used for getting the
 // insets, the actual painting is done in MenuButtonBackground.
 class MenuButtonBorder : public views::Border {
  public:
   MenuButtonBorder()
     : horizontal_padding_(ui::GetDisplayLayout() == ui::LAYOUT_TOUCH ?
                               kHorizontalTouchPadding :
                               kHorizontalPadding) {}
 
-  virtual void Paint(const View& view, gfx::Canvas* canvas) const {
+  // Overridden from views::Border.
+  virtual void Paint(const View& view, gfx::Canvas* canvas) const OVERRIDE {
     // Painting of border is done in MenuButtonBackground.
   }
 
-  virtual void GetInsets(gfx::Insets* insets) const {
+  virtual void GetInsets(gfx::Insets* insets) const OVERRIDE {
     insets->Set(MenuConfig::instance().item_top_margin,
                 horizontal_padding_,
                 MenuConfig::instance().item_bottom_margin,
                 horizontal_padding_);
   }
 
  private:
   // The horizontal padding dependent on the layout.
   const int horizontal_padding_;
 
@@ skipping 22 matching lines @@
   void SetOtherButtons(CustomButton* left_button, CustomButton* right_button) {
     if (base::i18n::IsRTL()) {
       left_button_ = right_button;
       right_button_ = left_button;
     } else {
       left_button_ = left_button;
       right_button_ = right_button;
     }
   }
 
-  virtual void Paint(gfx::Canvas* canvas, View* view) const {
+  // Overridden from views::Background.
+  virtual void Paint(gfx::Canvas* canvas, View* view) const OVERRIDE {
     CustomButton::ButtonState state =
         (view->GetClassName() == views::Label::kViewClassName) ?
         CustomButton::BS_NORMAL : static_cast<CustomButton*>(view)->state();
     int w = view->width();
     int h = view->height();
     // Windows is drawing its own separators and we cannot use the touch button
     // for that.
 #if !defined(OS_WIN)
     if (ui::GetDisplayLayout() == ui::LAYOUT_TOUCH) {
       // Normal buttons get a border drawn on the right side and the rest gets
@@ skipping 111 matching lines @@
 
 // A View subclass that forces SchedulePaint to paint all. Normally when the
 // mouse enters/exits a button the buttons invokes SchedulePaint. As part of the
 // button border (MenuButtonBackground) is rendered by the button to the
 // left/right of it SchedulePaint on the the button may not be enough, so this
 // forces a paint all.
 class ScheduleAllView : public views::View {
  public:
   ScheduleAllView() {}
 
-  virtual void SchedulePaintInRect(const gfx::Rect& r) {
+  // Overridden from views::View.
+  virtual void SchedulePaintInRect(const gfx::Rect& r) OVERRIDE {
     View::SchedulePaintInRect(gfx::Rect(0, 0, width(), height()));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ScheduleAllView);
 };
 
 string16 GetAccessibleNameForWrenchMenuItem(
       MenuModel* model, int item_index, int accessible_string_id) {
   string16 accessible_name = l10n_util::GetStringUTF16(accessible_string_id);
@@ skipping 59 matching lines @@
   MenuModel* menu_model_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WrenchMenuView);
 };
 
 class ButtonContainerMenuItemView : public MenuItemView {
  public:
   // Constructor for use with button containing menu items which have a
   // different height then .
-  explicit ButtonContainerMenuItemView(MenuItemView* parent,
-                                       int id,
-                                       int height)
+  ButtonContainerMenuItemView(MenuItemView* parent, int id, int height)
       : MenuItemView(parent, id, MenuItemView::NORMAL),
         height_(height) {
   };
 
-  gfx::Size GetChildPreferredSize() OVERRIDE {
+  // Overridden from MenuItemView.
+  virtual gfx::Size GetChildPreferredSize() OVERRIDE {
     gfx::Size size = MenuItemView::GetChildPreferredSize();
     // When there is a height override given, we need to deduct our spacing
     // above and below to get to the correct height to return here for the
     // child item.
     int height = height_ - GetTopMargin() - GetBottomMargin();
     if (height > size.height())
       size.set_height(height);
     return size;
   }
 
  private:
   int height_;
 
   DISALLOW_COPY_AND_ASSIGN(ButtonContainerMenuItemView);
 };
 
 class TintedImageSource: public gfx::CanvasImageSource {
  public:
   TintedImageSource(gfx::ImageSkia& image, SkColor tint_value)
       : CanvasImageSource(image.size(), false),
         image_(image),
         tint_value_(tint_value) {
   }
 
   virtual ~TintedImageSource() {
   }
 
-  void Draw(gfx::Canvas* canvas) OVERRIDE {
+  // Overridden from gfx::CanvasImageSource.
+  virtual void Draw(gfx::Canvas* canvas) OVERRIDE {
     canvas->DrawImageInt(image_, 0, 0);
     SkPaint paint;
     // We leave the old alpha alone and add the new color multiplied
     // with the source alpha to the existing alpha. Thus: We brighten
     // the image up - but only the non transparent pixels.
     paint.setXfermodeMode(SkXfermode::kDstATop_Mode);
     paint.setColor(tint_value_);
     canvas->sk_canvas()->drawPaint(paint);
   }
 
@@ skipping 36 matching lines @@
         paste_index,
         NULL);
     if (is_touch) {
       cut->SetEnabledColor(kTouchButtonText);
       copy->SetEnabledColor(kTouchButtonText);
       paste->SetEnabledColor(kTouchButtonText);
     }
     copy_background->SetOtherButtons(cut, paste);
   }
 
-  gfx::Size GetPreferredSize() {
+  // Overridden from View.
+  virtual gfx::Size GetPreferredSize() OVERRIDE {
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview.
     return gfx::Size(GetMaxChildViewPreferredWidth() * child_count(), 0);
   }
 
-  void Layout() {
+  virtual void Layout() OVERRIDE {
     // All buttons are given the same width.
     int width = GetMaxChildViewPreferredWidth();
     for (int i = 0; i < child_count(); ++i)
       child_at(i)->SetBounds(i * width, 0, width, height());
   }
 
-  // ButtonListener
-  virtual void ButtonPressed(views::Button* sender, const views::Event& event) {
+  // Overridden from ButtonListener.
+  virtual void ButtonPressed(views::Button* sender,
+                             const views::Event& event) OVERRIDE {
     menu_->CancelAndEvaluate(menu_model_, sender->tag());
   }
 
  private:
   // Returns the max preferred width of all the children.
   int GetMaxChildViewPreferredWidth() {
     int width = 0;
     for (int i = 0; i < child_count(); ++i)
       width = std::max(width, child_at(i)->GetPreferredSize().width());
     return width;
@@ skipping 95 matching lines @@
     AddChildView(fullscreen_button_);
 
     UpdateZoomControls();
 
     registrar_.Add(
         this, content::NOTIFICATION_ZOOM_LEVEL_CHANGED,
         content::Source<HostZoomMap>(
             HostZoomMap::GetForBrowserContext(menu->browser_->profile())));
   }
 
-  gfx::Size GetPreferredSize() {
+  // Overridden from View.
+  virtual gfx::Size GetPreferredSize() OVERRIDE {
     // The increment/decrement button are forced to the same width.
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
     int zoom_padding = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH ?
                            kTouchZoomPadding : kZoomPadding;
     int fullscreen_width = fullscreen_button_->GetPreferredSize().width() +
                            zoom_padding;
     // Returned height doesn't matter as MenuItemView forces everything to the
     // height of the menuitemview. Note that we have overridden the height when
     // constructing the menu.
     return gfx::Size(button_width + zoom_label_width_ + button_width +
                      fullscreen_width, 0);
   }
 
-  void Layout() {
+  virtual void Layout() OVERRIDE {
     int x = 0;
     int button_width = std::max(increment_button_->GetPreferredSize().width(),
                                 decrement_button_->GetPreferredSize().width());
     gfx::Rect bounds(0, 0, button_width, height());
 
     decrement_button_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(zoom_label_width_);
     zoom_label_->SetBoundsRect(bounds);
 
     x += bounds.width();
     bounds.set_x(x);
     bounds.set_width(button_width);
     increment_button_->SetBoundsRect(bounds);
 
     bool is_touch = ui::GetDisplayLayout() == ui::LAYOUT_TOUCH;
     x += bounds.width() + (is_touch ? 0 : kZoomPadding);
     bounds.set_x(x);
     bounds.set_width(fullscreen_button_->GetPreferredSize().width() +
                      (is_touch ? kTouchZoomPadding : 0));
     fullscreen_button_->SetBoundsRect(bounds);
   }
 
-  // ButtonListener:
-  virtual void ButtonPressed(views::Button* sender, const views::Event& event) {
+  // Overridden from ButtonListener.
+  virtual void ButtonPressed(views::Button* sender,
+                             const views::Event& event) OVERRIDE {
     if (sender->tag() == fullscreen_index_) {
       menu_->CancelAndEvaluate(menu_model_, sender->tag());
     } else {
       // Zoom buttons don't close the menu.
       menu_model_->ActivatedAt(sender->tag());
     }
   }
 
-  // content::NotificationObserver:
+  // Overridden from content::NotificationObserver.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
-                       const content::NotificationDetails& details) {
+                       const content::NotificationDetails& details) OVERRIDE {
     DCHECK_EQ(content::NOTIFICATION_ZOOM_LEVEL_CHANGED, type);
     UpdateZoomControls();
   }
 
  private:
   void UpdateZoomControls() {
     int zoom = 100;
     // Don't override initial states of increment and decrement buttons when
     // instant extended API is enabled and mode is NTP; they are properly
     // updated in ToolbarView::ModeChanged() via CommandUpdater, and queried
@@ skipping 441 matching lines @@
   bookmark_menu_delegate_.reset(
       new BookmarkMenuDelegate(browser_,
                                browser_,
                                parent,
                                first_bookmark_command_id_));
   bookmark_menu_delegate_->Init(
       this, bookmark_menu_, model->bookmark_bar_node(), 0,
       BookmarkMenuDelegate::SHOW_PERMANENT_FOLDERS,
       bookmark_utils::LAUNCH_WRENCH_MENU);
 }