Adding split view divider widget.

athena/wm/bezel_controller.cc

 // Copyright 2014 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 "athena/wm/bezel_controller.h"
 
 #include "ui/aura/window.h"
 #include "ui/events/event_handler.h"
 #include "ui/gfx/display.h"
 #include "ui/gfx/geometry/point_conversions.h"
@@ skipping 28 matching lines @@
   DCHECK(bezel == BezelController::BEZEL_LEFT ||
          bezel == BezelController::BEZEL_RIGHT);
   // Convert location from window coordinates to screen coordinates.
   gfx::Point point_in_screen(gfx::ToRoundedPoint(location));
   wm::ConvertPointToScreen(window, &point_in_screen);
   return bezel == BezelController::BEZEL_LEFT
              ? point_in_screen.x()
              : point_in_screen.x() - GetDisplay(window).bounds().width();
 }
 
+// Returns the bezel corresponding to the |location| in |window| or BEZEL_NONE
+// if the location is outside of the bezel area.
+// Only implemented for LEFT and RIGHT bezels ATM.

[pkotwicz, 2014/09/23 05:13:40]

Nit: Remove 'ATM'

[mfomitchev, 2014/09/23 15:46:02]

Done.

+BezelController::Bezel GetBezel(const gfx::PointF& location,
+                                aura::Window* window) {
+  int screen_width = GetDisplay(window).bounds().width();
+  gfx::Point point_in_screen(gfx::ToRoundedPoint(location));
+  wm::ConvertPointToScreen(window, &point_in_screen);
+  if (point_in_screen.x() < kBezelWidth)
+    return BezelController::BEZEL_LEFT;
+  if (point_in_screen.x() > screen_width - kBezelWidth)
+    return BezelController::BEZEL_RIGHT;
+  return BezelController::BEZEL_NONE;
+}
+
 }  // namespace
 
 BezelController::BezelController(aura::Window* container)
     : container_(container),
       state_(NONE),
       scroll_bezel_(BEZEL_NONE),
       scroll_target_(NULL),
       left_right_delegate_(NULL) {
 }
 
 void BezelController::SetState(BezelController::State state) {
   // Use SetState(State, float) if |state| is one of the BEZEL_SCROLLING states.
   DCHECK_NE(state, BEZEL_SCROLLING_TWO_FINGERS);
   DCHECK_NE(state, BEZEL_SCROLLING_ONE_FINGER);
   SetState(state, kScrollDeltaNone);
 }
 
 void BezelController::SetState(BezelController::State state,
                                float scroll_delta) {
   if (!left_right_delegate_ || state == state_)
     return;
 
   if (state == BEZEL_SCROLLING_TWO_FINGERS)
-    left_right_delegate_->ScrollBegin(scroll_bezel_, scroll_delta);
+    left_right_delegate_->BezelScrollBegin(scroll_bezel_, scroll_delta);
   else if (state_ == BEZEL_SCROLLING_TWO_FINGERS)
-    left_right_delegate_->ScrollEnd();
+    left_right_delegate_->BezelScrollEnd();
   state_ = state;
   if (state == NONE) {
     scroll_bezel_ = BEZEL_NONE;
     scroll_target_ = NULL;
   }
 }
 
-// Only implemented for LEFT and RIGHT bezels ATM.
-BezelController::Bezel BezelController::GetBezel(const gfx::PointF& location) {
-  int screen_width = GetDisplay(container_).bounds().width();
-  if (location.x() < kBezelWidth) {
-    return BEZEL_LEFT;
-  } else if (location.x() > screen_width - kBezelWidth) {
-    return BEZEL_RIGHT;
-  } else {
-    return BEZEL_NONE;
-  }
-}
-
 void BezelController::OnGestureEvent(ui::GestureEvent* event) {
   // TODO(mfomitchev): Currently we aren't retargetting or consuming any of the
   // touch events. This means that content can prevent the generation of gesture
   // events and two-finger scroll won't work. Possible solution to this problem
   // is hosting our own gesture recognizer or retargetting touch events at the
   // bezel.
 
   if (!left_right_delegate_)
     return;
 
   ui::EventType type = event->type();
   if (!ShouldProcessGesture(type))
     return;
 
+  const ui::GestureEventDetails& event_details = event->details();
+  int num_touch_points = event_details.touch_points();
+  if (num_touch_points == 1 && type == ui::ET_GESTURE_BEGIN) {
+    // Reset the state if needed.
+    // Normally, the state would be reset when ET_GESTURE_END is dispatched,
+    // however ET_GESTURE_END may not be dispatched if the gesture target is
+    // hidden or deleted before the gesture ends.
+    SetState(NONE);

[pkotwicz, 2014/09/23 05:13:40]

I am sure that I am missing something. Can you explain why this is needed? I
initially thought that this was to make the unit tests pass but that's not the
case.

Based on the description, it sounds like the changes that I am making in
BezelController in https://codereview.chromium.org/574113004/ accomplish the
same task (If the two do the same thing I think my implementation is slightly
better)

[mfomitchev, 2014/09/23 15:46:02]

When you drag the divider handle, it becomes the target of the gesture event
sequence. The handle is hidden on ET_GESTURE_SCROLL_END. This prevents
ET_GESTURE_END from being dispatched (because the target is hidden). Thus the
bezel controller never receives ET_GESTURE_END and it doesn't change its state
to NONE.

More generally, we can't rely on receiving ET_GESTURE_END for every
ET_GESTURE_BEGIN because the target can be hidden or even deleted mid-gesture.

Thus we do a state sanity check on every ET_GESTURE_BEGIN.

I've updated the comment to make it a bit more clear/detailed.

[pkotwicz, 2014/09/23 19:44:46]

From talking to tdresser@ we are supposed to get ET_GESTURE_END. However, I
cannot get ET_GESTURE_END to be sent

This is ok for now for the sake of this CL. However, it would be useful to
figure out why ET_GESTURE_END is not received

[mfomitchev, 2014/09/23 21:02:09]

I started a thread with sadrul on this, but it didn't get anywhere. I'll add
you. Also, if the target was deleted (which could happen)I understand it is
expected that ET_GESTURE_END won't be send.

+  }
+
   if (scroll_target_ && event->target() != scroll_target_)
     return;
 
   const gfx::PointF& event_location = event->location_f();
-  const ui::GestureEventDetails& event_details = event->details();
-  int num_touch_points = event_details.touch_points();
   float scroll_delta = kScrollDeltaNone;
-  if (scroll_bezel_ != BEZEL_NONE) {
-    aura::Window* target_window = static_cast<aura::Window*>(event->target());
+  aura::Window* target_window = static_cast<aura::Window*>(event->target());
+  if (scroll_bezel_ != BEZEL_NONE)
     scroll_delta = GetDistance(event_location, target_window, scroll_bezel_);
-  }
 
   if (type == ui::ET_GESTURE_BEGIN) {
     if (num_touch_points > 2) {
       SetState(IGNORE_CURRENT_SCROLL);
       return;
     }
-    BezelController::Bezel event_bezel = GetBezel(event->location_f());
+    BezelController::Bezel event_bezel =
+        GetBezel(event->location_f(), target_window);
     switch (state_) {
       case NONE:
         scroll_bezel_ = event_bezel;
         scroll_target_ = event->target();
         if (event_bezel != BEZEL_LEFT && event_bezel != BEZEL_RIGHT)
           SetState(IGNORE_CURRENT_SCROLL);
         else
           SetState(BEZEL_GESTURE_STARTED);
         break;
       case IGNORE_CURRENT_SCROLL:
@@ skipping 31 matching lines @@
     if (state_ != BEZEL_GESTURE_STARTED)
       return;
 
     if (num_touch_points == 1) {
       SetState(BEZEL_SCROLLING_ONE_FINGER, scroll_delta);
       return;
     }
 
     DCHECK_EQ(num_touch_points, 2);
     SetState(BEZEL_SCROLLING_TWO_FINGERS, scroll_delta);
-    if (left_right_delegate_->CanScroll())
+    if (left_right_delegate_->BezelCanScroll())
       event->SetHandled();
   } else if (type == ui::ET_GESTURE_SCROLL_UPDATE) {
     if (state_ != BEZEL_SCROLLING_TWO_FINGERS)
       return;
 
-    left_right_delegate_->ScrollUpdate(scroll_delta);
-    if (left_right_delegate_->CanScroll())
+    left_right_delegate_->BezelScrollUpdate(scroll_delta);
+    if (left_right_delegate_->BezelCanScroll())
       event->SetHandled();
   }
 }
 
 }  // namespace athena