CrOS Tablet Window management - Split Screen part I

ash/wm/overview/window_selector_item.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_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/metrics/user_metrics_action.h"
@@ skipping 81 matching lines @@
 // Duration of background opacity transition for the selected label.
 static const int kSelectorFadeInMilliseconds = 350;
 
 // Duration of background opacity transition when exiting overview mode.
 static const int kExitFadeInMilliseconds = 30;
 
 // Before closing a window animate both the window and the caption to shrink by
 // this fraction of size.
 static const float kPreCloseScale = 0.02f;
 
+// Before dragging an overview window, the window will scale up |kPreDragScale|
+// to indicate its selection.
+static const float kDragWindowScale = 0.04f;
+
 // Convenience method to fade in a Window with predefined animation settings.
 // Note: The fade in animation will occur after a delay where the delay is how
 // long the lay out animations take.
 void SetupFadeInAfterLayout(views::Widget* widget) {
   aura::Window* window = widget->GetNativeWindow();
   window->layer()->SetOpacity(0.0f);
   ScopedOverviewAnimationSettings scoped_overview_animation_settings(
       OverviewAnimationType::OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN,
       window);
   window->layer()->SetOpacity(1.0f);
 }
 
-// A Button that has a listener and listens to mouse clicks on the visible part
-// of an overview window.
+// A Button that has a listener and listens to mouse / gesture events on the
+// visible part of an overview window. Note the drag events are only handled in

[varkha, 2017/06/21 01:51:53]

nit: "Note:" or "Note that"

[xdai1, 2017/06/22 21:46:34]

Done.

+// maximized mode.
 class ShieldButton : public views::CustomButton {
  public:
   ShieldButton(views::ButtonListener* listener, const base::string16& name)
       : views::CustomButton(listener) {
     SetAccessibleName(name);
   }
   ~ShieldButton() override {}
 
   // When WindowSelectorItem (which is a ButtonListener) is destroyed, its
   // |item_widget_| is allowed to stay around to complete any animations.
   // Resetting the listener in all views that are targeted by events is
   // necessary to prevent a crash when a user clicks on the fading out widget
   // after the WindowSelectorItem has been destroyed.
   void ResetListener() { listener_ = nullptr; }
 
+  // views::CustomButton overrides:

[varkha, 2017/06/21 01:51:53]

nit: "// views::CustomButton:" for consistency.

[xdai1, 2017/06/22 21:46:34]

Done.

+  bool OnMousePressed(const ui::MouseEvent& event) override {
+    if (listener() && SplitViewController::ShouldAllowSplitView()) {
+      gfx::Point location(event.location());
+      views::View::ConvertPointToScreen(this, &location);
+      listener()->HandlePressEvent(location);
+      return true;
+    }
+    return views::CustomButton::OnMousePressed(event);
+  }
+
+  void OnMouseReleased(const ui::MouseEvent& event) override {
+    if (listener() && SplitViewController::ShouldAllowSplitView()) {
+      gfx::Point location(event.location());
+      views::View::ConvertPointToScreen(this, &location);
+      listener()->HandleReleaseEvent(location);
+      return;
+    }
+    views::CustomButton::OnMouseReleased(event);
+  }
+
+  bool OnMouseDragged(const ui::MouseEvent& event) override {
+    if (listener() && SplitViewController::ShouldAllowSplitView()) {
+      gfx::Point location(event.location());
+      views::View::ConvertPointToScreen(this, &location);
+      listener()->HandleDragEvent(location);
+      return true;
+    }
+    return views::CustomButton::OnMouseDragged(event);
+  }
+
+  void OnGestureEvent(ui::GestureEvent* event) override {
+    if (listener() && SplitViewController::ShouldAllowSplitView()) {
+      gfx::Point location(event->location());
+      views::View::ConvertPointToScreen(this, &location);
+      switch (event->type()) {
+        case ui::ET_GESTURE_SCROLL_BEGIN:
+        case ui::ET_GESTURE_TAP_DOWN:
+          listener()->HandlePressEvent(location);
+          break;
+        case ui::ET_GESTURE_SCROLL_UPDATE:
+          listener()->HandleDragEvent(location);
+          break;
+        case ui::ET_GESTURE_END:
+          listener()->HandleReleaseEvent(location);
+          break;
+        default:
+          break;
+      }
+      event->SetHandled();
+      return;
+    }
+    views::CustomButton::OnGestureEvent(event);
+  }
+
+  WindowSelectorItem* listener() {
+    return static_cast<WindowSelectorItem*>(listener_);

[varkha, 2017/06/21 01:51:53]

Since this is a local class, I think it would look better if we simply store a
pointer to WindowSlsectorItem instead of ButtonListener and rename the variable
to selector_item_. This way you would not need the cast and using it as a
ButtonListener should still work.

[xdai1, 2017/06/22 21:46:34]

|listener_| is a class member variable from the base class Button. So we still
need the cast here.

[varkha, 2017/06/26 16:40:07]

Acknowledged.

+  }
+
  protected:
   // views::View:
   const char* GetClassName() const override { return "ShieldButton"; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ShieldButton);
 };
 
 }  // namespace
 
@@ skipping 250 matching lines @@
   views::Label* label_;
   views::ImageButton* close_button_;
 
   DISALLOW_COPY_AND_ASSIGN(CaptionContainerView);
 };
 
 WindowSelectorItem::WindowSelectorItem(aura::Window* window,
                                        WindowSelector* window_selector)
     : dimmed_(false),
       root_window_(window->GetRootWindow()),
-      transform_window_(window),
+      transform_window_(this, window),
       in_bounds_update_(false),
       selected_(false),
       caption_container_view_(nullptr),
       label_view_(nullptr),
       close_button_(new OverviewCloseButton(this)),
       window_selector_(window_selector),
       background_view_(nullptr) {
   CreateWindowLabel(window->GetTitle());
   GetWindow()->AddObserver(this);
 }
@@ skipping 115 matching lines @@
 }
 
 void WindowSelectorItem::ButtonPressed(views::Button* sender,
                                        const ui::Event& event) {
   if (sender == close_button_) {
     ShellPort::Get()->RecordUserMetricsAction(UMA_WINDOW_OVERVIEW_CLOSE_BUTTON);
     CloseWindow();
     return;
   }
   CHECK(sender == caption_container_view_->listener_button());
-  window_selector_->SelectWindow(this);
+
+  // For other cases, the event is handled in OverviewWindowDragController.
+  if (!SplitViewController::ShouldAllowSplitView()) {

[varkha, 2017/06/21 01:51:53]

nit: no {}

[xdai1, 2017/06/22 21:46:34]

Done.

+    window_selector_->SelectWindow(this);
+  }
 }
 
 void WindowSelectorItem::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
   transform_window_.OnWindowDestroyed();
 }
 
 void WindowSelectorItem::OnWindowTitleChanged(aura::Window* window) {
   // TODO(flackr): Maybe add the new title to a vector of titles so that we can
   // filter any of the titles the window had while in the overview session.
   label_view_->SetText(window->GetTitle());
   UpdateAccessibilityName();
 }
 
 float WindowSelectorItem::GetItemScale(const gfx::Size& size) {
   gfx::Size inset_size(size.width(), size.height() - 2 * kWindowMargin);
   return ScopedTransformOverviewWindow::GetItemScale(
       transform_window_.GetTargetBoundsInScreen().size(), inset_size,
       transform_window_.GetTopInset(),
       close_button_->GetPreferredSize().height());
 }
 
+void WindowSelectorItem::HandlePressEvent(
+    const gfx::Point& location_in_screen) {
+  PrepareDrag();
+  window_selector_->InitiateDrag(this, location_in_screen);
+}
+
+void WindowSelectorItem::HandleReleaseEvent(
+    const gfx::Point& location_in_screen) {
+  EndDrag();
+  window_selector_->CompleteDrag(this);
+}
+
+void WindowSelectorItem::HandleDragEvent(const gfx::Point& location_in_screen) {
+  window_selector_->Drag(this, location_in_screen);
+}
+
 gfx::Rect WindowSelectorItem::GetTargetBoundsInScreen() const {
   return transform_window_.GetTargetBoundsInScreen();
 }
 
 void WindowSelectorItem::SetItemBounds(const gfx::Rect& target_bounds,
                                        OverviewAnimationType animation_type) {
   DCHECK(root_window_ == GetWindow()->GetRootWindow());
   gfx::Rect screen_rect = transform_window_.GetTargetBoundsInScreen();
 
   // Avoid division by zero by ensuring screen bounds is not empty.
@@ skipping 170 matching lines @@
 }
 
 gfx::SlideAnimation* WindowSelectorItem::GetBackgroundViewAnimation() {
   return background_view_ ? background_view_->animation() : nullptr;
 }
 
 aura::Window* WindowSelectorItem::GetOverviewWindowForMinimizedStateForTest() {
   return transform_window_.GetOverviewWindowForMinimizedState();
 }
 
+void WindowSelectorItem::PrepareDrag() {
+  gfx::Rect scaled_bounds(target_bounds_);
+  scaled_bounds.Inset(-target_bounds_.width() * kDragWindowScale,
+                      -target_bounds_.height() * kDragWindowScale);
+  OverviewAnimationType animation_type =
+      OverviewAnimationType::OVERVIEW_ANIMATION_CLOSING_SELECTOR_ITEM;
+  SetBounds(scaled_bounds, animation_type);

[varkha, 2017/06/21 01:51:53]

Don't you need to revert this somewhere?

[xdai1, 2017/06/22 21:46:34]

I don't think it's necessary since if the window was snapped, the selector item
will be deleted, and if the window was moved back to the overview grid, we
called WindowSelector::PositionWindows() in
OverviewWindowDragController::CompleteDrag() to recalculate all window selector
items' bounds.

[varkha, 2017/06/26 16:40:07]

Acknowledged.

+
+  aura::Window* widget_window = item_widget_->GetNativeWindow();
+  if (widget_window && widget_window->parent() == GetWindow()->parent()) {
+    // TODO(xdai): This might not work if there is an always on top window.
+    // See crbug.com/733760.
+    widget_window->parent()->StackChildAtTop(widget_window);
+    widget_window->parent()->StackChildBelow(GetWindow(), widget_window);
+  }
+}
+
+void WindowSelectorItem::EndDrag() {
+  aura::Window* widget_window = item_widget_->GetNativeWindow();
+  if (widget_window && widget_window->parent() == GetWindow()->parent()) {
+    widget_window->parent()->StackChildAtBottom(widget_window);

[varkha, 2017/06/21 01:51:53]

I don't think we should be changing the order relative to what it was at the
beginning of the drag. This seems to be changing that order so entering
overview, dragging an item and releasing could be changing state. Not sure if
the window would also get activated as a result of a drag but this will probably
change the stacking of windows while they are animated back to their original
positions.

[xdai1, 2017/06/22 21:46:34]

I changed the animation time and confirmed that the windows stack does change. I
modified the function so that the windows stack remains the same after dragging.

+    widget_window->parent()->StackChildBelow(GetWindow(), widget_window);
+  }
+}
+
 }  // namespace ash