Scrolling through tabs by using mouse-wheel on tab bar

chrome/browser/views/tabs/tab_strip.cc

 // Copyright (c) 2006-2008 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/views/tabs/tab_strip.h"
 
 #include "base/gfx/size.h"
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents.h"
@@ skipping 424 matching lines @@
       : TabAnimation(tabstrip, RESIZE) {
     int tab_count = tabstrip->GetTabCount();
     GenerateStartAndEndWidths(tab_count, tab_count);
     InitStartState();
   }
   virtual ~ResizeLayoutAnimation() {
   }
 
   // Overridden from AnimationDelegate:
   virtual void AnimationEnded(const Animation* animation) {
-    tabstrip_->resize_layout_scheduled_ = false;
+    tabstrip_->needs_resize_layout_ = false;
     TabStrip::TabAnimation::AnimationEnded(animation);
   }
 
  protected:
   // Overridden from TabStrip::TabAnimation:
   virtual int GetDuration() const {
     return kResizeLayoutAnimationDurationMs;
   }
 
   virtual double GetWidthForTab(int index) const {
@@ skipping 24 matching lines @@
   DISALLOW_EVIL_CONSTRUCTORS(ResizeLayoutAnimation);
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, public:
 
 TabStrip::TabStrip(TabStripModel* model)
     : model_(model),
       resize_layout_factory_(this),
       added_as_message_loop_observer_(false),
-      resize_layout_scheduled_(false),
+      needs_resize_layout_(false),
       current_unselected_width_(Tab::GetStandardSize().width()),
       current_selected_width_(Tab::GetStandardSize().width()),
       available_width_for_tabs_(-1) {
   Init();
 }
 
 TabStrip::~TabStrip() {
   // TODO(beng): (1031854) Restore this line once XPFrame/VistaFrame are dead.
   //model_->RemoveObserver(this);
 
@@ skipping 361 matching lines @@
 
 void TabStrip::TabSelectedAt(TabContents* old_contents,
                              TabContents* new_contents,
                              int index,
                              bool user_gesture) {
   DCHECK(index >= 0 && index < GetTabCount());
   if (CanUpdateDisplay()) {
     // We have "tiny tabs" if the tabs are so tiny that the unselected ones are
     // a different size to the selected ones.
     bool tiny_tabs = current_unselected_width_ != current_selected_width_;
-    if (!IsAnimating() && (!resize_layout_scheduled_ || tiny_tabs)) {
+    if (!IsAnimating() && (!needs_resize_layout_ || tiny_tabs)) {
       Layout();
     } else {
       SchedulePaint();
     }
   }
 }
 
 void TabStrip::TabMoved(TabContents* contents, int from_index, int to_index) {
   Tab* tab = GetTabAt(from_index);
   Tab* other_tab = GetTabAt(to_index);
@@ skipping 57 matching lines @@
   int tab_index = GetIndexOfTab(tab);
   if (model_->ContainsIndex(tab_index)) {
     TabContents* contents = model_->GetTabContentsAt(tab_index);
     if (contents)
       UserMetrics::RecordAction(L"CloseTab_Mouse", contents->profile());
     Tab* last_tab = GetTabAt(GetTabCount() - 1);
     // Limit the width available to the TabStrip for laying out Tabs, so that
     // Tabs are not resized until a later time (when the mouse pointer leaves
     // the TabStrip).
     available_width_for_tabs_ = GetAvailableWidthForTabs(last_tab);
-    resize_layout_scheduled_ = true;
-    AddMessageLoopObserver();
+    needs_resize_layout_ = true;
     model_->CloseTabContentsAt(tab_index);
   }
 }
 
 bool TabStrip::IsCommandEnabledForTab(
     TabStripModel::ContextMenuCommand command_id, const Tab* tab) const {
   int index = GetIndexOfTab(tab);
   if (model_->ContainsIndex(index))
     return model_->IsContextMenuCommandEnabled(index, command_id);
   return false;
@@ skipping 84 matching lines @@
     model_->AddBlankTab(true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, MessageLoop::Observer implementation:
 
 void TabStrip::WillProcessMessage(const MSG& msg) {
 }
 
 void TabStrip::DidProcessMessage(const MSG& msg) {
-  // We spy on three different Windows messages here to see if the mouse has
-  // moved out of the bounds of the tabstrip, which we use as our cue to kick
-  // of the resize animation. The messages are:
-  //
-  // WM_MOUSEMOVE:
-  //   For when the mouse moves from the tabstrip over into the rest of the
-  //   browser UI, i.e. within the bounds of the same windows HWND.
-  // WM_MOUSELEAVE:
-  //   For when the mouse moves very rapidly from a tab closed in the middle of
-  //   the tabstrip (_not_ the end) out of the bounds of the browser's HWND and
-  //   over some other HWND.
-  // WM_NCMOUSELEAVE:
-  //   For when the mouse moves very rapidly from the end of the tabstrip (when
-  //   the last tab is closed and the mouse is left floating over the title
-  //   bar). Because the empty area of the tabstrip at the end of the title bar
-  //   is registered by the ChromeFrame as part of the "caption" area of the
-  //   window (the frame's OnNCHitTest method returns HTCAPTION for this
-  //   region), the frame's HWND receives a WM_MOUSEMOVE message immediately,
-  //   because as far as it is concerned the mouse has _left_ the client area
-  //   of the window (and is now over the non-client area). To be notified
-  //   again when the mouse leaves the _non-client_ area, we use the
-  //   WM_NCMOUSELEAVE message, which causes us to re-evaluate the cursor
-  //   position and correctly resize the tabstrip.
-  //
   switch (msg.message) {
+    // We spy on three different Windows messages here to see if the mouse has
+    // moved out of the bounds of the tabstrip, which we use as our cue to kick
+    // of the resize animation. The messages are:
+    //
+    // WM_MOUSEMOVE:
+    //   For when the mouse moves from the tabstrip over into the rest of the
+    //   browser UI, i.e. within the bounds of the same windows HWND.
+    // WM_MOUSELEAVE:
+    //   For when the mouse moves very rapidly from a tab closed in the middle
+    //   of the tabstrip (_not_ the end) out of the bounds of the browser's
+    //   HWND and over some other HWND.
+    // WM_NCMOUSELEAVE:
+    //   For when the mouse moves very rapidly from the end of the tabstrip
+    //   (when the last tab is closed and the mouse is left floating over the
+    //   title bar). Because the empty area of the tabstrip at the end of the
+    //   title bar is registered by the ChromeFrame as part of the "caption"
+    //   area of the window (the frame's OnNCHitTest method returns HTCAPTION
+    //   for this region), the frame's HWND receives a WM_MOUSEMOVE message
+    //   immediately, because as far as it is concerned the mouse has _left_
+    //   the client area of the window (and is now over the non-client area).
+    //   To be notified again when the mouse leaves the _non-client_ area, we
+    //   use the WM_NCMOUSELEAVE message, which causes us to re-evaluate the
+    //   cursor position and correctly resize the tabstrip.
+    //
     case WM_MOUSEMOVE:
     case WM_MOUSELEAVE:
     case WM_NCMOUSELEAVE:
+      if (!needs_resize_layout_)
+        break;
       if (!IsCursorInTabStripZone()) {
         // Mouse moved outside the tab slop zone, start a timer to do a resize
         // layout after a short while...
         if (resize_layout_factory_.empty()) {
           MessageLoop::current()->PostDelayedTask(FROM_HERE,
               resize_layout_factory_.NewRunnableMethod(
                   &TabStrip::ResizeLayoutTabs),
               kResizeTabsTimeMs);
         }
       } else {
         // Mouse moved quickly out of the tab strip and then into it again, so
         // cancel the timer so that the strip doesn't move when the mouse moves
         // back over it.
         resize_layout_factory_.RevokeAll();
       }
       break;
+    // We also watch out for mouse-wheel messages here to allow the user to
+    // leaf through the tabs by scrolling while the mouse cursor is in the tab
+    // strip zone.
+    case WM_MOUSEWHEEL:
+      if (!IsCursorInTabStripZone())
+        break;
+      CHECK(model_);
+      // A positive value indicates that the wheel was rotated away from the
+      // user; a negative value indicates rotation toward the user.
+      if (GET_WHEEL_DELTA_WPARAM(msg.wParam) > 0)
+        model_->SelectPreviousTab();
+      else
+        model_->SelectNextTab();
+      break;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStrip, private:
 
 void TabStrip::Init() {
   model_->AddObserver(this);
   newtab_button_ = new NewTabButton;
   newtab_button_->SetListener(this, TabStripModel::kNoTab);
@@ skipping 12 matching lines @@
 
   newtab_button_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_NEWTAB));
   AddChildView(newtab_button_);
 
   if (drop_indicator_width == 0) {
     // Direction doesn't matter, both images are the same size.
     SkBitmap* drop_image = GetDropArrowImage(true);
     drop_indicator_width = drop_image->width();
     drop_indicator_height = drop_image->height();
   }
+
+  AddMessageLoopObserver();
 }
 
 Tab* TabStrip::GetTabAt(int index) const {
   DCHECK(index >= 0 && index < GetTabCount());
   return tab_data_.at(index).tab;
 }
 
 Tab* TabStrip::GetTabAtAdjustForAnimation(int index) const {
   if (active_animation_.get() &&
       active_animation_->type() == TabAnimation::REMOVE &&
@@ skipping 75 matching lines @@
       // Selected width = (total width - (unselected width * (num_tabs - 1)))
       *selected_width = std::max(available_width - total_offset -
           (min_unselected_width * (tab_count - 1)), min_selected_width);
     }
   }
 }
 
 void TabStrip::ResizeLayoutTabs() {
   resize_layout_factory_.RevokeAll();
 
-  // It is critically important that this is unhooked here, otherwise we will
-  // keep spying on messages forever.
-  RemoveMessageLoopObserver();
-
   available_width_for_tabs_ = -1;
   double unselected, selected;
   GetDesiredTabWidths(GetTabCount(), &unselected, &selected);
   Tab* first_tab = GetTabAt(0);
   int w = Round(first_tab->IsSelected() ? selected : selected);
 
   // We only want to run the animation if we're not already at the desired
   // size.
   if (abs(first_tab->width() - w) > 1)
     StartResizeLayoutAnimation();
@@ skipping 213 matching lines @@
     gfx::Rect state(rounded_tab_x, 0, Round(end_of_tab) - rounded_tab_x,
                     tab_height);
     tab_data_.at(i).ideal_bounds = state;
     tab_x = end_of_tab + kTabHOffset;
   }
 }
 
 void TabStrip::LayoutNewTabButton(double last_tab_right,
                                   double unselected_width) {
   int delta = abs(Round(unselected_width) - Tab::GetStandardSize().width());
-  if (delta > 1 && !resize_layout_scheduled_) {
+  if (delta > 1 && !needs_resize_layout_) {
     // We're shrinking tabs, so we need to anchor the New Tab button to the
     // right edge of the TabStrip's bounds, rather than the right edge of the
     // right-most Tab, otherwise it'll bounce when animating.
     newtab_button_->SetBounds(width() - newtab_button_size_.width(),
                               kNewTabButtonVOffset,
                               newtab_button_size_.width(),
                               newtab_button_size_.height());
   } else {
     newtab_button_->SetBounds(
         Round(last_tab_right - kTabHOffset) + kNewTabButtonHOffset,
@@ skipping 91 matching lines @@
 int TabStrip::GetAvailableWidthForTabs(Tab* last_tab) const {
   return last_tab->x() + last_tab->width();
 }
 
 bool TabStrip::IsPointInTab(Tab* tab, const CPoint& point_in_tabstrip_coords) {
   CPoint point_in_tab_coords(point_in_tabstrip_coords);
   View::ConvertPointToView(this, tab, &point_in_tab_coords);
   return tab->HitTest(point_in_tab_coords);
 }