CrOS Tablet Window management - Split Screen part I

ash/wm/overview/window_selector.h

 // Copyright 2013 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 ASH_WM_OVERVIEW_WINDOW_SELECTOR_H_
 #define ASH_WM_OVERVIEW_WINDOW_SELECTOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "ash/ash_export.h"
+#include "ash/wm/splitview/split_view_controller.h"
 #include "base/macros.h"
 #include "base/time/time.h"
 #include "ui/aura/window_observer.h"
 #include "ui/display/display_observer.h"
+#include "ui/gfx/geometry/point.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/views/controls/textfield/textfield_controller.h"
 #include "ui/wm/public/activation_change_observer.h"
 
 namespace views {
 class Textfield;
 class Widget;
 }
 
 namespace ash {
 class WindowSelectorDelegate;
 class WindowSelectorItem;
 class WindowSelectorTest;
 class WindowGrid;
+class OverviewWindowDragController;
 
 // The WindowSelector shows a grid of all of your windows, allowing to select
 // one by clicking or tapping on it.
 class ASH_EXPORT WindowSelector : public display::DisplayObserver,
                                   public aura::WindowObserver,
                                   public ::wm::ActivationChangeObserver,
-                                  public views::TextfieldController {
+                                  public views::TextfieldController,
+                                  public SplitViewController::Observer {
  public:
   // Returns true if the window can be selected in overview mode.
   static bool IsSelectable(aura::Window* window);
 
   enum Direction { LEFT, UP, RIGHT, DOWN };
 
   using WindowList = std::vector<aura::Window*>;
 
   explicit WindowSelector(WindowSelectorDelegate* delegate);
   ~WindowSelector() override;
@@ skipping 17 matching lines @@
   // Accepts current selection if any. Returns true if a selection was made,
   // false otherwise.
   bool AcceptSelection();
 
   // Activates |item's| window.
   void SelectWindow(WindowSelectorItem* item);
 
   // Called when |window| is about to get closed.
   void WindowClosing(WindowSelectorItem* window);
 
+  // Called to set bounds for window grids. Used for split view.
+  void SetBoundsForWindowGridsInScreen(const gfx::Rect& bounds);
+
+  // Removes the window selector item from the overview window grid.
+  void RemoveWindowSelectorItem(WindowSelectorItem* item);
+
+  void InitiateDrag(WindowSelectorItem* item,
+                    const gfx::Point& location_in_screen);
+  void Drag(WindowSelectorItem* item, const gfx::Point& location_in_screen);
+  void CompleteDrag(WindowSelectorItem* item);
+
+  // Positions all of the windows in the overview.
+  void PositionWindows(bool animate);
+
   WindowSelectorDelegate* delegate() { return delegate_; }
 
   bool restoring_minimized_windows() const {
     return restoring_minimized_windows_;
   }
 
   int text_filter_bottom() const { return text_filter_bottom_; }
 
   bool is_shut_down() const { return is_shut_down_; }
 
+  const std::vector<std::unique_ptr<WindowGrid>>& grid_list_for_testing() {
+    return grid_list_;
+  }
+
   // display::DisplayObserver:
   void OnDisplayAdded(const display::Display& display) override;
   void OnDisplayRemoved(const display::Display& display) override;
   void OnDisplayMetricsChanged(const display::Display& display,
                                uint32_t metrics) override;
 
   // aura::WindowObserver:
   void OnWindowHierarchyChanged(const HierarchyChangeParams& params) override;
   void OnWindowDestroying(aura::Window* window) override;
 
   // wm::ActivationChangeObserver:
   void OnWindowActivated(ActivationReason reason,
                          aura::Window* gained_active,
                          aura::Window* lost_active) override;
   void OnAttemptToReactivateWindow(aura::Window* request_active,
                                    aura::Window* actual_active) override;
 
   // views::TextfieldController:
   void ContentsChanged(views::Textfield* sender,
                        const base::string16& new_contents) override;
   bool HandleKeyEvent(views::Textfield* sender,
                       const ui::KeyEvent& key_event) override;
 
+  // SplitViewController::Observer:
+  void OnSplitViewStateChanged(SplitViewController::State previous_state,
+                               SplitViewController::State state) override;
+
  private:
   friend class WindowSelectorTest;
 
   // Returns the aura::Window for |text_filter_widget_|.
   aura::Window* GetTextFilterWidgetWindow();
 
-  // Position all of the windows in the overview.
-  void PositionWindows(bool animate);
-
   // Repositions and resizes |text_filter_widget_| on
   // DisplayMetricsChanged event.
   void RepositionTextFilterOnDisplayMetricsChange();
 
   // |focus|, restores focus to the stored window.
   void ResetFocusRestoreWindow(bool focus);
 
   // Helper function that moves the selection widget to |direction| on the
   // corresponding window grid.
   void Move(Direction direction, bool animate);
@@ skipping 56 matching lines @@
   // Tracks whether minimized windows are currently being restored for overview
   // mode.
   bool restoring_minimized_windows_;
 
   // The distance between the top edge of the screen and the bottom edge of
   // the text filtering textfield.
   int text_filter_bottom_;
 
   bool is_shut_down_ = false;
 
+  // The drag controller for a window in the overview mode.
+  std::unique_ptr<OverviewWindowDragController> window_drag_controller_;
+
   DISALLOW_COPY_AND_ASSIGN(WindowSelector);
 };
 
 }  // namespace ash
 
 #endif  // ASH_WM_OVERVIEW_WINDOW_SELECTOR_H_