CrOS Tablet Window management - Split Screen part I

ash/wm/overview/window_selector.cc

 // 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.
 
 #include "ash/wm/overview/window_selector.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "ash/accessibility_delegate.h"
 #include "ash/accessibility_types.h"
 #include "ash/metrics/user_metrics_action.h"
 #include "ash/public/cpp/shell_window_ids.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_util.h"
 #include "ash/shelf/shelf.h"
 #include "ash/shell.h"
 #include "ash/shell_port.h"
 #include "ash/wm/mru_window_tracker.h"
+#include "ash/wm/overview/overview_window_drag_controller.h"
 #include "ash/wm/overview/window_grid.h"
 #include "ash/wm/overview/window_selector_delegate.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/panels/panel_layout_manager.h"
+#include "ash/wm/splitview/split_view_controller.h"
 #include "ash/wm/switchable_windows.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram_macros.h"
 #include "third_party/skia/include/core/SkPath.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
@@ skipping 94 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(RoundedContainerView);
 };
 
 // Triggers a shelf visibility update on all root window controllers.
 void UpdateShelfVisibility() {
   for (aura::Window* root : Shell::GetAllRootWindows())
     Shelf::ForWindow(root)->UpdateVisibilityState();
 }
 
+// Returns the bounds for the overview window grids according to the split view
+// state. If split view mode is active, the overview window should open on the
+// opposite side of the default snap window.

[oshima, 2017/06/16 19:39:15]

left is the default correct?

[xdai1, 2017/06/16 20:01:46]

It depends. The default position is decided by the first snapped window. If the
first window was snapped to left, then left is the default position. Otherwise,
right is the default position. 

+gfx::Rect GetGridsBoundsInScreen(aura::Window* root_window) {
+  if (Shell::Get()->IsSplitViewModeActive()) {
+    SplitViewController::State state =
+        Shell::Get()->split_view_controller()->state();
+    SplitViewController::State oppsite_state =
+        (state == SplitViewController::LEFT_SNAPPED)
+            ? SplitViewController::RIGHT_SNAPPED
+            : SplitViewController::LEFT_SNAPPED;
+    return Shell::Get()
+        ->split_view_controller()
+        ->GetSnappedWindowBoundsInScreen(root_window, oppsite_state);
+  } else {
+    return Shell::Get()
+        ->split_view_controller()
+        ->GetDisplayWorkAreaBoundsInScreen(root_window);
+  }
+}
+
 gfx::Rect GetTextFilterPosition(aura::Window* root_window) {
-  gfx::Rect total_bounds = ScreenUtil::GetDisplayWorkAreaBoundsInParent(
-      root_window->GetChildById(kShellWindowId_DefaultContainer));
-  ::wm::ConvertRectToScreen(root_window, &total_bounds);
+  gfx::Rect total_bounds = GetGridsBoundsInScreen(root_window);
   return gfx::Rect(
       0.5 * (total_bounds.width() -
-             std::min(kTextFilterWidth, total_bounds.width())),
+             std::min(kTextFilterWidth, total_bounds.width())) +
+          total_bounds.x(),
       total_bounds.y() + total_bounds.height() * kTextFilterTopScreenProportion,
       std::min(kTextFilterWidth, total_bounds.width()), kTextFilterHeight);
 }
 
 // Initializes the text filter on the top of the main root window and requests
 // focus on its textfield. Uses |image| to place an icon to the left of the text
 // field.
 views::Widget* CreateTextFilter(views::TextfieldController* controller,
                                 aura::Window* root_window,
                                 const gfx::ImageSkia& image,
@@ skipping 106 matching lines @@
       aura::Window* container =
           root->GetChildById(wm::kSwitchableWindowContainerIds[i]);
       container->AddObserver(this);
       observed_windows_.insert(container);
     }
 
     // Hide the callout widgets for panels. It is safe to call this for
     // root windows that don't contain any panel windows.
     PanelLayoutManager::Get(root)->SetShowCalloutWidgets(false);
 
-    std::unique_ptr<WindowGrid> grid(new WindowGrid(root, windows, this));
+    std::unique_ptr<WindowGrid> grid(
+        new WindowGrid(root, windows, this, GetGridsBoundsInScreen(root)));
     if (grid->empty())
       continue;
     num_items_ += grid->size();
     grid_list_.push_back(std::move(grid));
   }
 
   {
     // The calls to WindowGrid::PrepareForOverview() and CreateTextFilter(...)
     // requires some LayoutManagers (ie PanelLayoutManager) to perform layouts
     // so that windows are correctly visible and properly animated in overview
@@ skipping 16 matching lines @@
                                           kTextFilterIconColor);
     aura::Window* root_window = Shell::GetPrimaryRootWindow();
     text_filter_widget_.reset(CreateTextFilter(this, root_window, search_image_,
                                                &text_filter_bottom_));
   }
 
   DCHECK(!grid_list_.empty());
   UMA_HISTOGRAM_COUNTS_100("Ash.WindowSelector.Items", num_items_);
 
   Shell::Get()->activation_client()->AddObserver(this);
+  Shell::Get()->split_view_controller()->AddObserver(this);
 
   display::Screen::GetScreen()->AddObserver(this);
   ShellPort::Get()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW);
   // Send an a11y alert.
   Shell::Get()->accessibility_delegate()->TriggerAccessibilityAlert(
       A11Y_ALERT_WINDOW_OVERVIEW_MODE_ENTERED);
 
   UpdateShelfVisibility();
 }
 
 // NOTE: The work done in Shutdown() is not done in the destructor because it
 // may cause other, unrelated classes, (ie PanelLayoutManager) to make indirect
 // calls to restoring_minimized_windows() on a partially destructed object.
 void WindowSelector::Shutdown() {
   is_shut_down_ = true;
   // Stop observing screen metrics changes first to avoid auto-positioning
   // windows in response to work area changes from window activation.
   display::Screen::GetScreen()->RemoveObserver(this);
 
+  // Stop observing split view state changes before restoring window focus.
+  // Otherwise the activation of the window triggers OnSplitViewStateChanged()
+  // that will call into this function again.
+  Shell::Get()->split_view_controller()->RemoveObserver(this);
+
   size_t remaining_items = 0;
   for (std::unique_ptr<WindowGrid>& window_grid : grid_list_) {
     for (const auto& window_selector_item : window_grid->window_list())
       window_selector_item->RestoreWindow();
     remaining_items += window_grid->size();
   }
 
   // Setting focus after restoring windows' state avoids unnecessary animations.
   ResetFocusRestoreWindow(true);
   RemoveAllObservers();
@@ skipping 99 matching lines @@
     }
   }
   item->EnsureVisible();
   wm::GetWindowState(window)->Activate();
 }
 
 void WindowSelector::WindowClosing(WindowSelectorItem* window) {
   grid_list_[selected_grid_index_]->WindowClosing(window);
 }
 
+void WindowSelector::SetBoundsForWindowGridsInScreen(const gfx::Rect bounds) {
+  for (std::unique_ptr<WindowGrid>& grid : grid_list_)
+    grid->SetTotalBoundsInScreen(bounds);
+}
+
+void WindowSelector::RemoveWindowSelectorItem(WindowSelectorItem* item) {
+  if (item->GetWindow()->HasObserver(this)) {
+    item->GetWindow()->RemoveObserver(this);
+    observed_windows_.erase(item->GetWindow());
+    if (item->GetWindow() == restore_focus_window_)
+      restore_focus_window_ = nullptr;
+  }
+
+  // Remove |item| from the corresponding grid.
+  for (std::unique_ptr<WindowGrid>& grid : grid_list_) {
+    if (grid->Contains(item->GetWindow())) {
+      grid->RemoveItem(item);
+      break;
+    }
+  }
+}
+
+void WindowSelector::InitiateDrag(WindowSelectorItem* item,
+                                  const gfx::Point& location_in_screen) {
+  window_drag_controller_.reset(new OverviewWindowDragController(this));
+  window_drag_controller_->InitiateDrag(item, location_in_screen);
+}
+
+void WindowSelector::Drag(WindowSelectorItem* item,
+                          const gfx::Point& location_in_screen) {
+  DCHECK(window_drag_controller_.get());
+  DCHECK_EQ(item, window_drag_controller_->item());
+  window_drag_controller_->Drag(location_in_screen);
+}
+
+void WindowSelector::CompleteDrag(WindowSelectorItem* item) {
+  DCHECK(window_drag_controller_.get());
+  DCHECK_EQ(item, window_drag_controller_->item());
+  window_drag_controller_->CompleteDrag();
+}
+
 bool WindowSelector::HandleKeyEvent(views::Textfield* sender,
                                     const ui::KeyEvent& key_event) {
   if (key_event.type() != ui::ET_KEY_PRESSED)
     return false;
 
   switch (key_event.key_code()) {
     case ui::VKEY_ESCAPE:
       CancelSelection();
       break;
     case ui::VKEY_UP:
@@ skipping 46 matching lines @@
 
 void WindowSelector::OnDisplayAdded(const display::Display& display) {}
 
 void WindowSelector::OnDisplayRemoved(const display::Display& display) {
   // TODO(flackr): Keep window selection active on remaining displays.
   CancelSelection();
 }
 
 void WindowSelector::OnDisplayMetricsChanged(const display::Display& display,
                                              uint32_t metrics) {
+  // Re-calculate the bounds for the window grids and position all the windows.
+  for (std::unique_ptr<WindowGrid>& grid : grid_list_) {
+    SetBoundsForWindowGridsInScreen(
+        GetGridsBoundsInScreen(const_cast<aura::Window*>(grid->root_window())));
+  }
   PositionWindows(/* animate */ false);
   RepositionTextFilterOnDisplayMetricsChange();
 }
 
 void WindowSelector::OnWindowHierarchyChanged(
     const HierarchyChangeParams& params) {
   // Only care about newly added children of |observed_windows_|.
   if (!observed_windows_.count(params.receiver) ||
       !observed_windows_.count(params.new_parent)) {
     return;
@@ skipping 42 matching lines @@
       windows.begin(), windows.end(),
       [gained_active](const std::unique_ptr<WindowSelectorItem>& window) {
         return window->Contains(gained_active);
       });
 
   if (iter == windows.end() && showing_text_filter_ &&
       lost_active == GetTextFilterWidgetWindow()) {
     return;
   }
 
+  // Do not cancel the overview mode if the window activation was caused by
+  // snapping window to one side of the screen.
+  if (Shell::Get()->IsSplitViewModeActive())
+    return;
+
   // Don't restore focus on exit if a window was just activated.
   ResetFocusRestoreWindow(false);
   CancelSelection();
 }
 
 void WindowSelector::OnAttemptToReactivateWindow(aura::Window* request_active,
                                                  aura::Window* actual_active) {
   OnWindowActivated(ActivationReason::ACTIVATION_CLIENT, request_active,
                     actual_active);
 }
@@ skipping 30 matching lines @@
   for (auto iter = grid_list_.begin(); iter != grid_list_.end(); iter++)
     (*iter)->FilterItems(new_contents);
 
   // If the selection widget is not active, execute a Move() command so that it
   // shows up on the first undimmed item.
   if (grid_list_[selected_grid_index_]->is_selecting())
     return;
   Move(WindowSelector::RIGHT, false);
 }
 
-aura::Window* WindowSelector::GetTextFilterWidgetWindow() {
-  return text_filter_widget_->GetNativeWindow();
+void WindowSelector::OnSplitViewStateChanged(
+    SplitViewController::State previous_state,
+    SplitViewController::State state) {
+  if (state != SplitViewController::NOSNAP) {
+    // Do not restore focus if a window was just snapped and activated.
+    ResetFocusRestoreWindow(false);
+  }
+
+  if (state == SplitViewController::LEFT_SNAPPED) {
+    aura::Window* snapped_window =
+        Shell::Get()->split_view_controller()->left_window();
+    const gfx::Rect bounds_in_screen =
+        Shell::Get()->split_view_controller()->GetSnappedWindowBoundsInScreen(
+            snapped_window, SplitViewController::RIGHT_SNAPPED);
+    SetBoundsForWindowGridsInScreen(bounds_in_screen);
+  } else if (state == SplitViewController::RIGHT_SNAPPED) {
+    aura::Window* snapped_window =
+        Shell::Get()->split_view_controller()->right_window();
+    const gfx::Rect bounds_in_screen =
+        Shell::Get()->split_view_controller()->GetSnappedWindowBoundsInScreen(
+            snapped_window, SplitViewController::LEFT_SNAPPED);
+    SetBoundsForWindowGridsInScreen(bounds_in_screen);
+  } else if (state == SplitViewController::BOTH_SNAPPED) {
+    CancelSelection();
+  } else {
+    DCHECK(state == SplitViewController::BOTH_SNAPPED ||
+           state == SplitViewController::NOSNAP);
+    // If two windows were snapped to both sides of the screen, end overview
+    // mode. If split view mode was ended (e.g., one of the snapped window was
+    // closed or minimized / fullscreened / maximized), also end overview mode
+    // if overview mode is active.
+    CancelSelection();
+  }
 }
 
 void WindowSelector::PositionWindows(bool animate) {
   for (std::unique_ptr<WindowGrid>& grid : grid_list_)
     grid->PositionWindows(animate);
 }
 
+aura::Window* WindowSelector::GetTextFilterWidgetWindow() {
+  return text_filter_widget_->GetNativeWindow();
+}
+
 void WindowSelector::RepositionTextFilterOnDisplayMetricsChange() {
   const gfx::Rect rect = GetTextFilterPosition(Shell::GetPrimaryRootWindow());
   text_filter_bottom_ = rect.bottom() + kTextFieldBottomMargin;
   text_filter_widget_->SetBounds(rect);
 
   gfx::Transform transform;
   transform.Translate(
       0, text_filter_string_length_ == 0 ? -text_filter_bottom_ : 0);
   aura::Window* text_filter_window = GetTextFilterWidgetWindow();
   text_filter_window->layer()->SetOpacity(text_filter_string_length_ == 0 ? 0
@@ skipping 33 matching lines @@
   for (size_t i = 0; i <= grid_list_.size() &&
                      grid_list_[selected_grid_index_]->Move(direction, animate);
        i++) {
     selected_grid_index_ =
         (selected_grid_index_ + display_direction + grid_list_.size()) %
         grid_list_.size();
   }
 }
 
 }  // namespace ash