Attempt 3 at a better touch tabstrip. There is still a bunch to do,

chrome/browser/ui/views/tabs/tab_strip.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_VIEWS_TABS_TAB_STRIP_H_
 #define CHROME_BROWSER_UI_VIEWS_TABS_TAB_STRIP_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 10 matching lines @@
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/mouse_watcher.h"
 #include "ui/views/view_model.h"
 
 class BaseTab;
 class NewTabButton;
 class Tab;
 class TabDragController;
 class TabStripController;
 class TabStripSelectionModel;
+class TouchTabStripLayout;
 
 namespace views {
 class ImageView;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // TabStrip
 //
 //  A View that represents the TabStripModel. The TabStrip has the
@@ skipping 22 matching lines @@
   // strip.
   bool SizeTabButtonToTopOfTabStrip();
 
   // Starts highlighting the tab at the specified index.
   void StartHighlight(int model_index);
 
   // Stops all tab higlighting.
   void StopAllHighlighting();
 
   // Adds a tab at the specified index.
-  void AddTabAt(int model_index, const TabRendererData& data);
+  void AddTabAt(int model_index, const TabRendererData& data, bool is_active);
 
   // Moves a tab.
-  void MoveTab(int from_model_index, int to_model_index);
+  void MoveTab(int from_model_index,
+               int to_model_index,
+               const TabRendererData& data);
 
   // Removes a tab at the specified index.
   void RemoveTabAt(int model_index);
 
   // Sets the tab data at the specified model index.
   void SetTabData(int model_index, const TabRendererData& data);
 
   // Invoked from the controller when the close initiates from the TabController
   // (the user clicked the tab close button or middle clicked the tab). This is
   // invoked from Close. Because of unload handlers Close is not always
@@ skipping 34 matching lines @@
   // Creates and returns a tab that can be used for dragging. Ownership passes
   // to the caller.
   BaseTab* CreateTabForDragging();
 
   // Returns true if a drag session is currently active.
   bool IsDragSessionActive() const;
 
   // Returns true if a tab is being dragged into this tab strip.
   bool IsActiveDropTarget() const;
 
-  // Returns true if this tab strip is in stacking mode.
-  bool IsStacking() const;
-
   // TabController overrides:
   virtual const TabStripSelectionModel& GetSelectionModel() OVERRIDE;
+  virtual bool SupportsMultipleSelection() OVERRIDE;
   virtual void SelectTab(BaseTab* tab) OVERRIDE;
   virtual void ExtendSelectionTo(BaseTab* tab) OVERRIDE;
   virtual void ToggleSelected(BaseTab* tab) OVERRIDE;
   virtual void AddSelectionFromAnchorTo(BaseTab* tab) OVERRIDE;
   virtual void CloseTab(BaseTab* tab) OVERRIDE;
   virtual void ShowContextMenuForTab(BaseTab* tab,
                                      const gfx::Point& p) OVERRIDE;
   virtual bool IsActiveTab(const BaseTab* tab) const OVERRIDE;
   virtual bool IsTabSelected(const BaseTab* tab) const OVERRIDE;
   virtual bool IsTabPinned(const BaseTab* tab) const OVERRIDE;
@@ skipping 43 matching lines @@
   }
 
   // Returns the number of mini-tabs.
   int GetMiniTabCount() const;
 
   // views::ButtonListener implementation:
   virtual void ButtonPressed(views::Button* sender,
                              const views::Event& event) OVERRIDE;
 
   // View overrides.
-  virtual void ViewHierarchyChanged(bool is_add,
-                                    views::View* parent,
-                                    views::View* child) OVERRIDE;
   virtual const views::View* GetViewByID(int id) const OVERRIDE;
   virtual bool OnMouseDragged(const views::MouseEvent& event) OVERRIDE;
   virtual void OnMouseReleased(const views::MouseEvent& event) OVERRIDE;
   virtual void OnMouseCaptureLost() OVERRIDE;
 
  private:
   typedef std::map<int, std::vector<BaseTab*> > TabsClosingMap;
 
   class RemoveTabDelegate;
 
@@ skipping 22 matching lines @@
     // Renders the drop indicator.
     views::Widget* arrow_window;
     views::ImageView* arrow_view;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(DropInfo);
   };
 
   void Init();
 
-  // Creates the new tab button.
-  void InitTabStripButtons();
-
   // Creates and returns a new tab. The caller owners the returned tab.
   BaseTab* CreateTab();
 
   // Invoked from |AddTabAt| after the newly created tab has been inserted.
   void StartInsertTabAnimation(int model_index);
 
   // Invoked from |MoveTab| after |tab_data_| has been updated to animate the
   // move.
   void StartMoveTabAnimation();
 
   // Starts the remove tab animation.
   void StartRemoveTabAnimation(int model_index);
 
+  // Schedules the animations and bounds changes necessary for a remove tab
+  // animation.
+  void ScheduleRemoveTabAnimation(BaseTab* tab);
+
   // Stops any ongoing animations. If |layout| is true and an animation is
   // ongoing this does a layout.
   void StopAnimating(bool layout);
 
   // Animates all the views to their ideal bounds.
   // NOTE: this does *not* invoke GenerateIdealBounds, it uses the bounds
   // currently set in ideal_bounds.
   void AnimateToIdealBounds();
 
   // Returns whether the highlight button should be highlighted after a remove.
   bool ShouldHighlightCloseButtonAfterRemove();
 
   // Invoked from Layout if the size changes or layout is really needed.
   void DoLayout();
 
   // Invoked during drag to layout the tabs being dragged in |tabs| at
   // |location|. If |initial_drag| is true, this is the initial layout after the
   // user moved the mouse far enough to trigger a drag.
   void LayoutDraggedTabsAt(const std::vector<BaseTab*>& tabs,
                            BaseTab* active_tab,
                            const gfx::Point& location,
                            bool initial_drag);
 
-  // Invoked during drag to layout all tabs when in stacking mode, with
-  // |active_tab| positioned at |location|.
-  void LayoutDraggedTabsAtWithStacking(BaseTab* active_tab,
-                                       const gfx::Point& location);
-
   // Calculates the bounds needed for each of the tabs, placing the result in
   // |bounds|.
   void CalculateBoundsForDraggedTabs(
       const std::vector<BaseTab*>& tabs,
       std::vector<gfx::Rect>* bounds);
 
   // Returns the size needed for the specified tabs. This is invoked during drag
   // and drop to calculate offsets and positioning.
   int GetSizeNeededForTabs(const std::vector<BaseTab*>& tabs);
 
@@ skipping 28 matching lines @@
   // Takes ownership of |controller|.
   void OwnDragController(TabDragController* controller);
 
   // Destroys the current TabDragController. This cancel the existing drag
   // operation.
   void DestroyDragController();
 
   // Releases ownership of the current TabDragController.
   TabDragController* ReleaseDragController();
 
-  // Returns the number of non-closing tabs between |index1| and |index2|.
-  int NumNonClosingTabs(int index1, int index2) const;
-
-  // Updates |num_visible_tabs_| based on |width| and the specified tab size.
-  // Additionally updates |first_visible_tab_index_|.
-  void UpdateNumVisibleTabs(int non_closing_tab_count,
-                            int width,
-                            double tab_size);
-
-  // Makes sure |model_index| is within the set of visible tabs. Only does
-  // something if stacking.
-  void EnsureModelIndexIsVisible(int model_index);
-
   // Paints all the tabs in |tabs_closing_map_[index]|.
   void PaintClosingTabs(gfx::Canvas* canvas, int index);
 
   // -- Tab Resize Layout -----------------------------------------------------
 
   // Returns the exact (unrounded) current width of each tab.
   void GetCurrentTabWidths(double* unselected_width,
                            double* selected_width) const;
 
   // Returns the exact (unrounded) desired width of each tab, based on the
@@ skipping 45 matching lines @@
   // position.
   bool IsAnimating() const;
 
   // Invoked prior to starting a new animation.
   void PrepareForAnimation();
 
   // Generates the ideal bounds for each of the tabs as well as the new tab
   // button.
   void GenerateIdealBounds();
 
-  // Same as GenerateIdealBounds, except used with in stacking mode. Only
-  // intended to be called by GenerateIdealBounds. Returns location for
-  // new tab button.
-  double GenerateIdealBoundsWithStacking(int mini_tab_count,
-                                         int non_closing_tab_count,
-                                         double new_tab_x,
-                                         double selected_size);
+  // Generates the ideal bounds for the mini tabs. Returns the index to position
+  // the first non-mini tab and sets |first_non_mini_index| to the index of the
+  // first non-mini tab.
+  int GenerateIdealBoundsForMiniTabs(int* first_non_mini_index);
+
+  // Returns the width needed for the new tab button (and padding).
+  int new_tab_button_width() const;
 
   // Starts various types of TabStrip animations.
   void StartResizeLayoutAnimation();
   void StartMiniTabAnimation();
   void StartMouseInitiatedRemoveTabAnimation(int model_index);
 
   // Returns true if the specified point in TabStrip coords is within the
   // hit-test region of the specified Tab.
   bool IsPointInTab(Tab* tab, const gfx::Point& point_in_tabstrip_coords);
 
+  // -- Touch Layout ----------------------------------------------------------
+
+  // Returns the position normal tabs start at.
+  int GetStartXForNormalTabs() const;
+
+  // Returns the tab to use for event handling starting at index |start| and
+  // iterating by |delta|.
+  Tab* FindTabForEvent(const gfx::Point& point, int start, int delta);
+
   // -- Member Variables ------------------------------------------------------
 
   // There is a one-to-one mapping between each of the tabs in the
   // TabStripController (TabStripModel) and |tabs_|. Because we animate tab
   // removal there exists a period of time where a tab is displayed but not in
   // the model. When this occurs the tab is removed from |tabs_| and placed in
   // |tabs_closing_map_|. When the animation completes the tab is removed from
   // |tabs_closing_map_|. The painting code ensures both sets of tabs are
   // painted, and the event handling code ensures only tabs in |tabs_| are used.
   views::ViewModel tabs_;
@@ skipping 57 matching lines @@
 
   // The controller for a drag initiated from a Tab. Valid for the lifetime of
   // the drag session.
   scoped_ptr<TabDragController> drag_controller_;
 
   views::BoundsAnimator bounds_animator_;
 
   // Size we last layed out at.
   gfx::Size last_layout_size_;
 
-  // If |stacking_| is true this is the index (into tab_data_) of the first
-  // tab completely shown.
-  int first_visible_tab_index_;
-
-  // If |stacking_| is true this is the number of tabs totally visible, the
-  // rest are compresses on the left/right edge.
-  int num_visible_tabs_;
-
-  // Are we in stacking/scrolling mode?
-  bool stacking_;
+  // Only used while in touch mode.
+  scoped_ptr<TouchTabStripLayout> touch_layout_;
 
   DISALLOW_COPY_AND_ASSIGN(TabStrip);
 };
 
 #endif  // CHROME_BROWSER_UI_VIEWS_TABS_TAB_STRIP_H_