Disambiguate OnMouseCaptureLost from OnMouseReleased, etc.

views/controls/scrollbar/bitmap_scroll_bar.cc

 // Copyright (c) 2011 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 "views/controls/scrollbar/bitmap_scroll_bar.h"
 
 #if defined(OS_LINUX)
 #include "views/screen.h"
 #endif
 
@@ skipping 35 matching lines @@
 class AutorepeatButton : public ImageButton {
  public:
   AutorepeatButton(ButtonListener* listener)
       : ImageButton(listener),
         ALLOW_THIS_IN_INITIALIZER_LIST(repeater_(
             NewCallback<AutorepeatButton>(this,
                                           &AutorepeatButton::NotifyClick))) {
   }
   virtual ~AutorepeatButton() {}
 
- protected:
-  virtual bool OnMousePressed(const MouseEvent& event) {
+  virtual bool OnMousePressed(const MouseEvent& event) OVERRIDE {
     Button::NotifyClick(event);
     repeater_.Start();
     return true;
   }
 
-  virtual void OnMouseReleased(const MouseEvent& event, bool canceled) {
+  virtual void OnMouseReleased(const MouseEvent& event) OVERRIDE {
     repeater_.Stop();
-    View::OnMouseReleased(event, canceled);
+    View::OnMouseReleased(event);
+  }
+
+  virtual void OnMouseCaptureLost() OVERRIDE {
+    repeater_.Stop();
+    View::OnMouseCaptureLost();
   }
 
  private:
   void NotifyClick() {
 #if defined(OS_WIN)
     DWORD pos = GetMessagePos();
     POINTS points = MAKEPOINTS(pos);
     gfx::Point cursor_point(points.x, points.y);
 #elif defined(OS_LINUX)
     gfx::Point cursor_point = Screen::GetCursorScreenPoint();
@@ skipping 66 matching lines @@
 
   // Gets the position of the thumb on the x or y axis.
   int GetPosition() const {
     gfx::Rect track_bounds = scroll_bar_->GetTrackBounds();
     if (scroll_bar_->IsHorizontal())
       return x() - track_bounds.x();
     return y() - track_bounds.y();
   }
 
   // View overrides:
-  virtual gfx::Size GetPreferredSize() {
+  virtual gfx::Size GetPreferredSize() OVERRIDE {
     return gfx::Size(background_bitmap()->width(),
                      start_cap_bitmap()->height() +
                          end_cap_bitmap()->height() +
                          grippy_bitmap()->height());
   }
 
- protected:
-  // View overrides:
-  virtual void Paint(gfx::Canvas* canvas) {
-    canvas->DrawBitmapInt(*start_cap_bitmap(), 0, 0);
-    int top_cap_height = start_cap_bitmap()->height();
-    int bottom_cap_height = end_cap_bitmap()->height();
-    int thumb_body_height = height() - top_cap_height - bottom_cap_height;
-    canvas->TileImageInt(*background_bitmap(), 0, top_cap_height,
-                         background_bitmap()->width(), thumb_body_height);
-    canvas->DrawBitmapInt(*end_cap_bitmap(), 0,
-                          height() - bottom_cap_height);
-
-    // Paint the grippy over the track.
-    int grippy_x = (width() - grippy_bitmap()->width()) / 2;
-    int grippy_y = (thumb_body_height - grippy_bitmap()->height()) / 2;
-    canvas->DrawBitmapInt(*grippy_bitmap(), grippy_x, grippy_y);
-  }
-
-  virtual void OnMouseEntered(const MouseEvent& event) {
+  virtual void OnMouseEntered(const MouseEvent& event) OVERRIDE {
     SetState(CustomButton::BS_HOT);
   }
 
-  virtual void OnMouseExited(const MouseEvent& event) {
+  virtual void OnMouseExited(const MouseEvent& event) OVERRIDE {
     SetState(CustomButton::BS_NORMAL);
   }
 
-  virtual bool OnMousePressed(const MouseEvent& event) {
+  virtual bool OnMousePressed(const MouseEvent& event) OVERRIDE {
     mouse_offset_ = scroll_bar_->IsHorizontal() ? event.x() : event.y();
     drag_start_position_ = GetPosition();
     SetState(CustomButton::BS_PUSHED);
     return true;
   }
 
-  virtual bool OnMouseDragged(const MouseEvent& event) {
+  virtual bool OnMouseDragged(const MouseEvent& event) OVERRIDE {
     // If the user moves the mouse more than |kScrollThumbDragOutSnap| outside
     // the bounds of the thumb, the scrollbar will snap the scroll back to the
     // point it was at before the drag began.
     if (scroll_bar_->IsHorizontal()) {
       if ((event.y() < y() - kScrollThumbDragOutSnap) ||
           (event.y() > (y() + height() + kScrollThumbDragOutSnap))) {
         scroll_bar_->ScrollToThumbPosition(drag_start_position_, false);
         return true;
       }
     } else {
       if ((event.x() < x() - kScrollThumbDragOutSnap) ||
           (event.x() > (x() + width() + kScrollThumbDragOutSnap))) {
         scroll_bar_->ScrollToThumbPosition(drag_start_position_, false);
         return true;
       }
     }
     if (scroll_bar_->IsHorizontal()) {
       int thumb_x = event.x() - mouse_offset_;
       scroll_bar_->ScrollToThumbPosition(x() + thumb_x, false);
     } else {
       int thumb_y = event.y() - mouse_offset_;
       scroll_bar_->ScrollToThumbPosition(y() + thumb_y, false);
     }
     return true;
   }
 
-  virtual void OnMouseReleased(const MouseEvent& event,
-                               bool canceled) {
+  virtual void OnMouseReleased(const MouseEvent& event) OVERRIDE {
     SetState(CustomButton::BS_HOT);
-    View::OnMouseReleased(event, canceled);
+    View::OnMouseReleased(event);
+  }
+
+  virtual void OnMouseCaptureLost() OVERRIDE {
+    SetState(CustomButton::BS_HOT);
+    View::OnMouseCaptureLost();
+  }
+
+ protected:
+  // View overrides:
+  virtual void Paint(gfx::Canvas* canvas) OVERRIDE {
+    canvas->DrawBitmapInt(*start_cap_bitmap(), 0, 0);
+    int top_cap_height = start_cap_bitmap()->height();
+    int bottom_cap_height = end_cap_bitmap()->height();
+    int thumb_body_height = height() - top_cap_height - bottom_cap_height;
+    canvas->TileImageInt(*background_bitmap(), 0, top_cap_height,
+                         background_bitmap()->width(), thumb_body_height);
+    canvas->DrawBitmapInt(*end_cap_bitmap(), 0,
+                          height() - bottom_cap_height);
+
+    // Paint the grippy over the track.
+    int grippy_x = (width() - grippy_bitmap()->width()) / 2;
+    int grippy_y = (thumb_body_height - grippy_bitmap()->height()) / 2;
+    canvas->DrawBitmapInt(*grippy_bitmap(), grippy_x, grippy_y);
   }
 
  private:
   // Returns the bitmap rendered at the start of the thumb.
   SkBitmap* start_cap_bitmap() const {
     return scroll_bar_->images_[BitmapScrollBar::THUMB_START_CAP][state_];
   }
 
   // Returns the bitmap rendered at the end of the thumb.
   SkBitmap* end_cap_bitmap() const {
@@ skipping 231 matching lines @@
       } else if (event.y() > thumb_bounds.bottom()) {
         last_scroll_amount_ = SCROLL_NEXT_PAGE;
       }
     }
     TrackClicked();
     repeater_.Start();
   }
   return true;
 }
 
-void BitmapScrollBar::OnMouseReleased(const MouseEvent& event, bool canceled) {
+void BitmapScrollBar::OnMouseReleased(const MouseEvent& event) {
   SetThumbTrackState(CustomButton::BS_NORMAL);
   repeater_.Stop();
-  View::OnMouseReleased(event, canceled);
+  View::OnMouseReleased(event);
+}
+
+void BitmapScrollBar::OnMouseCaptureLost() {
+  SetThumbTrackState(CustomButton::BS_NORMAL);
+  repeater_.Stop();
+  View::OnMouseCaptureLost();
 }
 
 bool BitmapScrollBar::OnKeyPressed(const KeyEvent& event) {
   ScrollAmount amount = SCROLL_NONE;
   switch (event.key_code()) {
     case ui::VKEY_UP:
       if (!IsHorizontal())
         amount = SCROLL_PREV_LINE;
       break;
     case ui::VKEY_DOWN:
@@ skipping 231 matching lines @@
     thumb_position = thumb_position - (thumb_->GetSize() / 2);
   return (thumb_position * contents_size_) / GetTrackSize();
 }
 
 void BitmapScrollBar::SetThumbTrackState(CustomButton::ButtonState state) {
   thumb_track_state_ = state;
   SchedulePaint();
 }
 
 }  // namespace views