More TabStrip refactoring.

chrome/browser/views/tabs/dragged_tab_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_VIEWS_TABS_DRAGGED_TAB_CONTROLLER_H_
 #define CHROME_BROWSER_VIEWS_TABS_DRAGGED_TAB_CONTROLLER_H_
 
 #include "base/message_loop.h"
 #include "base/timer.h"
 #include "chrome/browser/dock_info.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/common/notification_registrar.h"
 #include "gfx/rect.h"
 
 namespace views {
 class View;
 }
+class BaseTabRenderer;
 class BaseTabStrip;
 class DraggedTabView;
 class NativeViewPhotobooth;
-class Tab;
-class TabStrip;
 class TabStripModel;
 
 struct TabRendererData;
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // DraggedTabController
 //
 //  An object that handles a drag session for an individual Tab within a
 //  TabStrip. This object is created whenever the mouse is pressed down on a
 //  Tab and destroyed when the mouse is released or the drag operation is
 //  aborted. The Tab that the user dragged (the "source tab") owns this object
 //  and must be the only one to destroy it (via |DestroyDragController|).
 //
 ///////////////////////////////////////////////////////////////////////////////
 class DraggedTabController : public TabContentsDelegate,
                              public NotificationObserver,
                              public MessageLoopForUI::Observer {
  public:
-  DraggedTabController(Tab* source_tab, TabStrip* source_tabstrip);
+  DraggedTabController(BaseTabRenderer* source_tab,
+                       BaseTabStrip* source_tabstrip);
   virtual ~DraggedTabController();
 
   // Capture information needed to be used during a drag session for this
-  // controller's associated source Tab and TabStrip. |mouse_offset| is the
-  // distance of the mouse pointer from the Tab's origin.
-  void CaptureDragInfo(Tab* tab, const gfx::Point& mouse_offset);
+  // controller's associated source tab and BaseTabStrip. |mouse_offset| is the
+  // distance of the mouse pointer from the tab's origin.
+  void CaptureDragInfo(views::View* tab, const gfx::Point& mouse_offset);
 
   // Responds to drag events subsequent to StartDrag. If the mouse moves a
   // sufficient distance before the mouse is released, a drag session is
   // initiated.
   void Drag();
 
   // Complete the current drag session. If the drag session was canceled
   // because the user pressed Escape or something interrupted it, |canceled|
   // is true so the helper can revert the state to the world before the drag
   // begun.
@@ skipping 87 matching lines @@
   // threshold required to start a drag.
   bool CanStartDrag() const;
 
   // Move the DraggedTabView according to the current mouse screen position,
   // potentially updating the source and other TabStrips.
   void ContinueDragging();
 
   // Handles dragging a tab while the tab is attached.
   void MoveAttachedTab(const gfx::Point& screen_point);
 
+  // Adjusts the model as necessary for a move when the attached tab strip is
+  // horizontal.
+  void MoveAttachedTabHorizontalTabStrip(const gfx::Point& screen_point,
+                                         TabStripModel* model,
+                                         const gfx::Point& dragged_view_point,
+                                         int from_index);
+
+  // Adjusts the model as necessary for a move when the attached tab strip is
+  // vertical.
+  void MoveAttachedTabVerticalTabStrip(const gfx::Point& screen_point,
+                                       TabStripModel* model,
+                                       const gfx::Point& dragged_view_point,
+                                       int from_index);
+
   // Handles dragging while the tab is detached.
   void MoveDetachedTab(const gfx::Point& screen_point);
 
   // Returns the compatible TabStrip that is under the specified point (screen
   // coordinates), or NULL if there is none.
-  TabStrip* GetTabStripForPoint(const gfx::Point& screen_point);
+  BaseTabStrip* GetTabStripForPoint(const gfx::Point& screen_point);
 
   DockInfo GetDockInfoAtPoint(const gfx::Point& screen_point);
 
   // Returns the specified |tabstrip| if it contains the specified point
   // (screen coordinates), NULL if it does not.
-  TabStrip* GetTabStripIfItContains(TabStrip* tabstrip,
-                                    const gfx::Point& screen_point) const;
+  BaseTabStrip* GetTabStripIfItContains(BaseTabStrip* tabstrip,
+                                        const gfx::Point& screen_point) const;
 
   // Attach the dragged Tab to the specified TabStrip.
-  void Attach(TabStrip* attached_tabstrip, const gfx::Point& screen_point);
+  void Attach(BaseTabStrip* attached_tabstrip, const gfx::Point& screen_point);
 
   // Detach the dragged Tab from the current TabStrip.
   void Detach();
 
   // Returns the index where the dragged TabContents should be inserted into
   // the attached TabStripModel given the DraggedTabView's bounds
   // |dragged_bounds| in coordinates relative to the attached TabStrip.
   // |is_tab_attached| is true if the tab has already been added.
   int GetInsertionIndexForDraggedBounds(const gfx::Rect& dragged_bounds,
                                         bool is_tab_attached) const;
 
   // Retrieve the bounds of the DraggedTabView, relative to the attached
   // TabStrip, given location of the dragged tab in screen coordinates.
   gfx::Rect GetDraggedViewTabStripBounds(const gfx::Point& screen_point);
 
   // Get the position of the dragged tab view relative to the attached tab
   // strip.
   gfx::Point GetAttachedTabDragPoint(const gfx::Point& screen_point);
 
   // Finds the Tab within the specified TabStrip that corresponds to the
   // dragged TabContents.
-  Tab* GetTabMatchingDraggedContents(TabStrip* tabstrip) const;
+  BaseTabRenderer* GetTabMatchingDraggedContents(BaseTabStrip* tabstrip) const;
 
   // Does the work for EndDrag. If we actually started a drag and |how_end| is
   // not TAB_DESTROYED then one of EndDrag or RevertDrag is invoked.
   void EndDragImpl(EndDragType how_end);
 
   // Reverts a cancelled drag operation.
   void RevertDrag();
 
   // Finishes a succesful drag operation.
   void CompleteDrag();
@@ skipping 30 matching lines @@
 
   // The TabContents being dragged.
   TabContents* dragged_contents_;
 
   // The original TabContentsDelegate of |dragged_contents_|, before it was
   // detached from the browser window. We store this so that we can forward
   // certain delegate notifications back to it if we can't handle them locally.
   TabContentsDelegate* original_delegate_;
 
   // The TabStrip |source_tab_| originated from.
-  TabStrip* source_tabstrip_;
+  BaseTabStrip* source_tabstrip_;
 
   // This is the index of the |source_tab_| in |source_tabstrip_| when the drag
   // began. This is used to restore the previous state if the drag is aborted.
   int source_model_index_;
 
   // The TabStrip the dragged Tab is currently attached to, or NULL if the
   // dragged Tab is detached.
-  TabStrip* attached_tabstrip_;
+  BaseTabStrip* attached_tabstrip_;
 
   // If attached this is the tab we're dragging.
-  Tab* attached_tab_;
+  BaseTabRenderer* attached_tab_;
 
   // The visual representation of the dragged Tab.
   scoped_ptr<DraggedTabView> view_;
 
   // The photo-booth the TabContents sits in when the Tab is detached, to
   // obtain screen shots.
   scoped_ptr<NativeViewPhotobooth> photobooth_;
 
   // The position of the mouse (in screen coordinates) at the start of the drag
   // operation. This is used to calculate minimum elasticity before a
@@ skipping 54 matching lines @@
   // brought to front.
   base::OneShotTimer<DraggedTabController> bring_to_front_timer_;
 
   // Did the mouse move enough that we started a drag?
   bool started_drag_;
 
   DISALLOW_COPY_AND_ASSIGN(DraggedTabController);
 };
 
 #endif  // CHROME_BROWSER_VIEWS_TABS_DRAGGED_TAB_CONTROLLER_H_