#include "ui/base/cursor/cursor.h"
#include "ui/base/hit_test.h"
#include "ui/base/ui_base_types.h"
-#include "ui/compositor/layer.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
#include "ui/events/event.h"
#include "ui/events/event_utils.h"
#include "ui/events/gestures/gesture_recognizer.h"
+#include "ui/gfx/geometry/point_conversions.h"
#include "ui/gfx/screen.h"
namespace {
namespace {
+// Returns whether |window| can be moved via a two finger drag given
+// the hittest results of the two fingers.
+bool CanStartTwoFingerMove(aura::Window* window,
+ int window_component1,
+ int window_component2) {
+ // We allow moving a window via two fingers when the hittest components are
+ // HTCLIENT. This is done so that a window can be dragged via two fingers when
+ // the tab strip is full and hitting the caption area is difficult. We check
+ // the window type and the show state so that we do not steal touches from the
+ // web contents.
+ if (!ash::wm::GetWindowState(window)->IsNormalShowState() ||
+ window->type() != ui::wm::WINDOW_TYPE_NORMAL) {
+ return false;
+ }
+ int component1_behavior =
+ WindowResizer::GetBoundsChangeForWindowComponent(window_component1);
+ int component2_behavior =
+ WindowResizer::GetBoundsChangeForWindowComponent(window_component2);
+ return (component1_behavior & WindowResizer::kBoundsChange_Resizes) == 0 &&
+ (component2_behavior & WindowResizer::kBoundsChange_Resizes) == 0;
+}
+
+// Returns whether |window| can be moved or resized via one finger given
+// |window_component|.
+bool CanStartOneFingerDrag(int window_component) {
+ return WindowResizer::GetBoundsChangeForWindowComponent(
+ window_component) != 0;
+}
+
gfx::Point ConvertPointToParent(aura::Window* window,
const gfx::Point& point) {
gfx::Point result(point);
return result;
}
+// Returns the window component containing |event|'s location.
+int GetWindowComponent(aura::Window* window, const ui::LocatedEvent& event) {
+ return window->delegate()->GetNonClientComponent(event.location());
+}
+
} // namespace
// ScopedWindowResizer ---------------------------------------------------------
WindowResizer* resizer);
virtual ~ScopedWindowResizer();
+ // Returns true if the drag moves the window and does not resize.
+ bool IsMove() const;
+
WindowResizer* resizer() { return resizer_.get(); }
// WindowObserver overrides:
virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
// WindowStateObserver overrides:
- virtual void OnWindowShowTypeChanged(wm::WindowState* window_state,
- wm::WindowShowType type) OVERRIDE;
+ virtual void OnPreWindowShowTypeChange(wm::WindowState* window_state,
+ wm::WindowShowType type) OVERRIDE;
private:
- void AddHandlers(aura::Window* container);
- void RemoveHandlers();
-
ToplevelWindowEventHandler* handler_;
scoped_ptr<WindowResizer> resizer_;
- // If not NULL, this is an additional container that the dragged window has
- // moved to which ScopedWindowResizer has temporarily added observers on.
- aura::Window* target_container_;
-
DISALLOW_COPY_AND_ASSIGN(ScopedWindowResizer);
};
ToplevelWindowEventHandler* handler,
WindowResizer* resizer)
: handler_(handler),
- resizer_(resizer),
- target_container_(NULL) {
- if (resizer_) {
- resizer_->GetTarget()->AddObserver(this);
- wm::GetWindowState(resizer_->GetTarget())->AddObserver(this);
- }
+ resizer_(resizer) {
+ resizer_->GetTarget()->AddObserver(this);
+ wm::GetWindowState(resizer_->GetTarget())->AddObserver(this);
}
ToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
- RemoveHandlers();
- if (resizer_) {
- resizer_->GetTarget()->RemoveObserver(this);
- wm::GetWindowState(resizer_->GetTarget())->RemoveObserver(this);
- }
+ resizer_->GetTarget()->RemoveObserver(this);
+ wm::GetWindowState(resizer_->GetTarget())->RemoveObserver(this);
+}
+
+bool ToplevelWindowEventHandler::ScopedWindowResizer::IsMove() const {
+ return resizer_->details().bounds_change ==
+ WindowResizer::kBoundsChange_Repositions;
}
void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowHierarchyChanging(
if (params.receiver != resizer_->GetTarget())
return;
wm::WindowState* state = wm::GetWindowState(params.receiver);
- if (state->continue_drag_after_reparent()) {
+ if (state->continue_drag_after_reparent())
state->set_continue_drag_after_reparent(false);
- AddHandlers(params.new_parent);
- } else {
- handler_->CompleteDrag(DRAG_COMPLETE, 0);
- }
+ else
+ handler_->CompleteDrag(DRAG_COMPLETE);
}
-void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowShowTypeChanged(
+void
+ToplevelWindowEventHandler::ScopedWindowResizer::OnPreWindowShowTypeChange(
wm::WindowState* window_state,
wm::WindowShowType old) {
- if (!window_state->IsNormalShowState())
- handler_->CompleteDrag(DRAG_COMPLETE, 0);
+ handler_->CompleteDrag(DRAG_COMPLETE);
}
void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowDestroying(
aura::Window* window) {
- DCHECK(resizer_.get());
DCHECK_EQ(resizer_->GetTarget(), window);
handler_->ResizerWindowDestroyed();
}
-void ToplevelWindowEventHandler::ScopedWindowResizer::AddHandlers(
- aura::Window* container) {
- RemoveHandlers();
- if (!handler_->owner()->Contains(container)) {
- container->AddPreTargetHandler(handler_);
- container->AddPostTargetHandler(handler_);
- target_container_ = container;
- }
-}
-
-void ToplevelWindowEventHandler::ScopedWindowResizer::RemoveHandlers() {
- if (target_container_) {
- target_container_->RemovePreTargetHandler(handler_);
- target_container_->RemovePostTargetHandler(handler_);
- target_container_ = NULL;
- }
-}
-
-
// ToplevelWindowEventHandler --------------------------------------------------
-ToplevelWindowEventHandler::ToplevelWindowEventHandler(aura::Window* owner)
- : owner_(owner),
+ToplevelWindowEventHandler::ToplevelWindowEventHandler()
+ : first_finger_hittest_(HTNOWHERE),
in_move_loop_(false),
- move_cancelled_(false),
in_gesture_drag_(false),
+ drag_reverted_(false),
destroyed_(NULL) {
- aura::client::SetWindowMoveClient(owner, this);
Shell::GetInstance()->display_controller()->AddObserver(this);
- owner->AddPreTargetHandler(this);
- owner->AddPostTargetHandler(this);
}
ToplevelWindowEventHandler::~ToplevelWindowEventHandler() {
void ToplevelWindowEventHandler::OnKeyEvent(ui::KeyEvent* event) {
if (window_resizer_.get() && event->type() == ui::ET_KEY_PRESSED &&
event->key_code() == ui::VKEY_ESCAPE) {
- CompleteDrag(DRAG_REVERT, event->flags());
+ CompleteDrag(DRAG_REVERT);
}
}
void ToplevelWindowEventHandler::OnMouseEvent(
ui::MouseEvent* event) {
+ if (event->handled())
+ return;
if ((event->flags() &
(ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON)) != 0)
return;
}
void ToplevelWindowEventHandler::OnGestureEvent(ui::GestureEvent* event) {
+ if (event->handled())
+ return;
aura::Window* target = static_cast<aura::Window*>(event->target());
if (!target->delegate())
return;
- if (in_move_loop_ && !in_gesture_drag_)
+ if (window_resizer_.get() && !in_gesture_drag_)
return;
+ if (window_resizer_.get() &&
+ window_resizer_->resizer()->GetTarget() != target) {
+ return;
+ }
+
+ if (event->details().touch_points() > 2) {
+ if (window_resizer_.get()) {
+ CompleteDrag(DRAG_COMPLETE);
+ event->StopPropagation();
+ }
+ return;
+ }
+
switch (event->type()) {
case ui::ET_GESTURE_TAP_DOWN: {
- int component =
- target->delegate()->GetNonClientComponent(event->location());
+ int component = GetWindowComponent(target, *event);
if (!(WindowResizer::GetBoundsChangeForWindowComponent(component) &
WindowResizer::kBoundsChange_Resizes))
return;
Shell::GetInstance()->resize_shadow_controller();
if (controller)
controller->HideShadow(target);
+
+ if (window_resizer_.get() &&
+ (event->details().touch_points() == 1 ||
+ !CanStartOneFingerDrag(first_finger_hittest_))) {
+ CompleteDrag(DRAG_COMPLETE);
+ event->StopPropagation();
+ }
+ return;
+ }
+ case ui::ET_GESTURE_BEGIN: {
+ if (event->details().touch_points() == 1) {
+ first_finger_hittest_ = GetWindowComponent(target, *event);
+ } else if (window_resizer_.get()) {
+ if (!window_resizer_->IsMove()) {
+ // The transition from resizing with one finger to resizing with two
+ // fingers causes unintended resizing because the location of
+ // ET_GESTURE_SCROLL_UPDATE jumps from the position of the first
+ // finger to the position in the middle of the two fingers. For this
+ // reason two finger resizing is not supported.
+ CompleteDrag(DRAG_COMPLETE);
+ event->StopPropagation();
+ }
+ } else {
+ int second_finger_hittest = GetWindowComponent(target, *event);
+ if (CanStartTwoFingerMove(
+ target, first_finger_hittest_, second_finger_hittest)) {
+ gfx::Point location_in_parent =
+ event->details().bounding_box().CenterPoint();
+ AttemptToStartDrag(target, location_in_parent, HTCAPTION,
+ aura::client::WINDOW_MOVE_SOURCE_TOUCH);
+ event->StopPropagation();
+ }
+ }
return;
}
case ui::ET_GESTURE_SCROLL_BEGIN: {
- if (in_gesture_drag_)
+ // The one finger drag is not started in ET_GESTURE_BEGIN to avoid the
+ // window jumping upon initiating a two finger drag. When a one finger
+ // drag is converted to a two finger drag, a jump occurs because the
+ // location of the ET_GESTURE_SCROLL_UPDATE event switches from the single
+ // finger's position to the position in the middle of the two fingers.
+ if (window_resizer_.get())
return;
- int component =
- target->delegate()->GetNonClientComponent(event->location());
- if (WindowResizer::GetBoundsChangeForWindowComponent(component) == 0) {
- window_resizer_.reset();
+ int component = GetWindowComponent(target, *event);
+ if (!CanStartOneFingerDrag(component))
return;
- }
- in_gesture_drag_ = true;
- pre_drag_window_bounds_ = target->bounds();
gfx::Point location_in_parent(
ConvertPointToParent(target, event->location()));
- CreateScopedWindowResizer(target, location_in_parent, component,
- aura::client::WINDOW_MOVE_SOURCE_TOUCH);
- break;
+ AttemptToStartDrag(target, location_in_parent, component,
+ aura::client::WINDOW_MOVE_SOURCE_TOUCH);
+ event->StopPropagation();
+ return;
}
- case ui::ET_GESTURE_SCROLL_UPDATE: {
- if (!in_gesture_drag_)
- return;
- if (window_resizer_.get() &&
- window_resizer_->resizer()->GetTarget() != target) {
- return;
- }
- HandleDrag(target, event);
+ default:
break;
- }
- case ui::ET_GESTURE_SCROLL_END:
- case ui::ET_SCROLL_FLING_START: {
- if (!in_gesture_drag_)
- return;
- if (window_resizer_.get() &&
- window_resizer_->resizer()->GetTarget() != target) {
- return;
- }
+ }
- CompleteDrag(DRAG_COMPLETE, event->flags());
- if (in_move_loop_) {
- quit_closure_.Run();
- in_move_loop_ = false;
- }
- in_gesture_drag_ = false;
+ if (!window_resizer_.get())
+ return;
- if (event->type() == ui::ET_GESTURE_SCROLL_END) {
- event->StopPropagation();
+ switch (event->type()) {
+ case ui::ET_GESTURE_SCROLL_UPDATE:
+ HandleDrag(target, event);
+ event->StopPropagation();
+ return;
+ case ui::ET_GESTURE_SCROLL_END:
+ // We must complete the drag here instead of as a result of ET_GESTURE_END
+ // because otherwise the drag will be reverted when EndMoveLoop() is
+ // called.
+ // TODO(pkotwicz): Pass drag completion status to
+ // WindowMoveClient::EndMoveLoop().
+ CompleteDrag(DRAG_COMPLETE);
+ event->StopPropagation();
+ return;
+ case ui::ET_SCROLL_FLING_START:
+ CompleteDrag(DRAG_COMPLETE);
+
+ // TODO(pkotwicz): Fix tests which inadvertantly start flings and check
+ // window_resizer_->IsMove() instead of the hittest component at |event|'s
+ // location.
+ if (GetWindowComponent(target, *event) != HTCAPTION ||
+ !wm::GetWindowState(target)->IsNormalShowState()) {
return;
}
- int component =
- target->delegate()->GetNonClientComponent(event->location());
- if (WindowResizer::GetBoundsChangeForWindowComponent(component) == 0)
- return;
-
- wm::WindowState* window_state = wm::GetWindowState(target);
- if (!window_state->IsNormalShowState())
- return;
-
- if (fabs(event->details().velocity_y()) >
- kMinVertVelocityForWindowMinimize) {
- // Minimize/maximize.
- if (event->details().velocity_y() > 0 &&
- window_state->CanMinimize()) {
- window_state->Minimize();
- window_state->set_always_restores_to_restore_bounds(true);
- window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
- } else if (window_state->CanMaximize()) {
- window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
- window_state->Maximize();
- }
- } else if (window_state->CanSnap() &&
- fabs(event->details().velocity_x()) >
+ if (event->details().velocity_y() > kMinVertVelocityForWindowMinimize) {
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_MINIMIZED);
+ } else if (event->details().velocity_y() <
+ -kMinVertVelocityForWindowMinimize) {
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_MAXIMIZED);
+ } else if (event->details().velocity_x() >
kMinHorizVelocityForWindowSwipe) {
- // Snap left/right.
- ui::ScopedLayerAnimationSettings scoped_setter(
- target->layer()->GetAnimator());
- scoped_setter.SetPreemptionStrategy(
- ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
- internal::SnapSizer::SnapWindow(window_state,
- event->details().velocity_x() < 0 ?
- internal::SnapSizer::LEFT_EDGE : internal::SnapSizer::RIGHT_EDGE);
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_RIGHT_SNAPPED);
+ } else if (event->details().velocity_x() <
+ -kMinHorizVelocityForWindowSwipe) {
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_LEFT_SNAPPED);
}
- break;
- }
+ event->StopPropagation();
+ return;
+ case ui::ET_GESTURE_MULTIFINGER_SWIPE:
+ if (!wm::GetWindowState(target)->IsNormalShowState())
+ return;
+
+ CompleteDrag(DRAG_COMPLETE);
+
+ if (event->details().swipe_down())
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_MINIMIZED);
+ else if (event->details().swipe_up())
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_MAXIMIZED);
+ else if (event->details().swipe_right())
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_RIGHT_SNAPPED);
+ else
+ SetWindowShowTypeFromGesture(target, wm::SHOW_TYPE_LEFT_SNAPPED);
+ event->StopPropagation();
+ return;
default:
return;
}
-
- event->StopPropagation();
}
aura::client::WindowMoveResult ToplevelWindowEventHandler::RunMoveLoop(
const gfx::Vector2d& drag_offset,
aura::client::WindowMoveSource move_source) {
DCHECK(!in_move_loop_); // Can only handle one nested loop at a time.
- in_move_loop_ = true;
- move_cancelled_ = false;
aura::Window* root_window = source->GetRootWindow();
DCHECK(root_window);
+ // TODO(tdresser): Use gfx::PointF. See crbug.com/337824.
gfx::Point drag_location;
if (move_source == aura::client::WINDOW_MOVE_SOURCE_TOUCH &&
aura::Env::GetInstance()->is_touch_down()) {
- in_gesture_drag_ = true;
+ gfx::PointF drag_location_f;
bool has_point = ui::GestureRecognizer::Get()->
- GetLastTouchPointForTarget(source, &drag_location);
+ GetLastTouchPointForTarget(source, &drag_location_f);
+ drag_location = gfx::ToFlooredPoint(drag_location_f);
DCHECK(has_point);
} else {
drag_location = root_window->GetDispatcher()->GetLastMouseLocationInRoot();
aura::Window::ConvertPointToTarget(
root_window, source->parent(), &drag_location);
}
- // Set the cursor before calling CreateScopedWindowResizer(), as that will
+ // Set the cursor before calling AttemptToStartDrag(), as that will
// eventually call LockCursor() and prevent the cursor from changing.
aura::client::CursorClient* cursor_client =
aura::client::GetCursorClient(root_window);
if (cursor_client)
cursor_client->SetCursor(ui::kCursorPointer);
- CreateScopedWindowResizer(source, drag_location, HTCAPTION, move_source);
+ if (!AttemptToStartDrag(source, drag_location, HTCAPTION, move_source))
+ return aura::client::MOVE_CANCELED;
+
+ in_move_loop_ = true;
bool destroyed = false;
destroyed_ = &destroyed;
base::MessageLoopForUI* loop = base::MessageLoopForUI::current();
base::MessageLoop::ScopedNestableTaskAllower allow_nested(loop);
- base::RunLoop run_loop(aura::Env::GetInstance()->GetDispatcher());
+ base::RunLoop run_loop;
quit_closure_ = run_loop.QuitClosure();
run_loop.Run();
if (destroyed)
return aura::client::MOVE_CANCELED;
destroyed_ = NULL;
- in_gesture_drag_ = in_move_loop_ = false;
- return move_cancelled_ ? aura::client::MOVE_CANCELED :
+ in_move_loop_ = false;
+ return drag_reverted_ ? aura::client::MOVE_CANCELED :
aura::client::MOVE_SUCCESSFUL;
}
void ToplevelWindowEventHandler::EndMoveLoop() {
- if (!in_move_loop_)
- return;
-
- in_move_loop_ = false;
- if (window_resizer_) {
- window_resizer_->resizer()->RevertDrag();
- window_resizer_.reset();
- }
- quit_closure_.Run();
+ if (in_move_loop_)
+ CompleteDrag(DRAG_REVERT);
}
void ToplevelWindowEventHandler::OnDisplayConfigurationChanging() {
- if (in_move_loop_) {
- move_cancelled_ = true;
- EndMoveLoop();
- } else if (window_resizer_) {
- window_resizer_->resizer()->RevertDrag();
- window_resizer_.reset();
- }
+ CompleteDrag(DRAG_REVERT);
}
-void ToplevelWindowEventHandler::CreateScopedWindowResizer(
+bool ToplevelWindowEventHandler::AttemptToStartDrag(
aura::Window* window,
const gfx::Point& point_in_parent,
int window_component,
aura::client::WindowMoveSource source) {
- window_resizer_.reset();
- WindowResizer* resizer =
- CreateWindowResizer(window, point_in_parent, window_component,
- source).release();
- if (resizer)
- window_resizer_.reset(new ScopedWindowResizer(this, resizer));
+ if (window_resizer_.get())
+ return false;
+ WindowResizer* resizer = CreateWindowResizer(window, point_in_parent,
+ window_component, source).release();
+ if (!resizer)
+ return false;
+
+ window_resizer_.reset(new ScopedWindowResizer(this, resizer));
+
+ pre_drag_window_bounds_ = window->bounds();
+ in_gesture_drag_ = (source == aura::client::WINDOW_MOVE_SOURCE_TOUCH);
+ return true;
}
-void ToplevelWindowEventHandler::CompleteDrag(DragCompletionStatus status,
- int event_flags) {
+void ToplevelWindowEventHandler::CompleteDrag(DragCompletionStatus status) {
scoped_ptr<ScopedWindowResizer> resizer(window_resizer_.release());
if (resizer) {
if (status == DRAG_COMPLETE)
- resizer->resizer()->CompleteDrag(event_flags);
+ resizer->resizer()->CompleteDrag();
else
resizer->resizer()->RevertDrag();
}
+ drag_reverted_ = (status == DRAG_REVERT);
+
+ first_finger_hittest_ = HTNOWHERE;
+ in_gesture_drag_ = false;
+ if (in_move_loop_)
+ quit_closure_.Run();
}
void ToplevelWindowEventHandler::HandleMousePressed(
aura::Window* target,
ui::MouseEvent* event) {
- // Move/size operations are initiated post-target handling to give the target
- // an opportunity to cancel this default behavior by returning ER_HANDLED.
- if (ui::EventCanceledDefaultHandling(*event))
+ if (event->phase() != ui::EP_PRETARGET || !target->delegate())
return;
// We also update the current window component here because for the
// mouse-drag-release-press case, where the mouse is released and
// pressed without mouse move event.
- int component =
- target->delegate()->GetNonClientComponent(event->location());
+ int component = GetWindowComponent(target, *event);
if ((event->flags() &
(ui::EF_IS_DOUBLE_CLICK | ui::EF_IS_TRIPLE_CLICK)) == 0 &&
WindowResizer::GetBoundsChangeForWindowComponent(component)) {
gfx::Point location_in_parent(
ConvertPointToParent(target, event->location()));
- CreateScopedWindowResizer(target, location_in_parent, component,
- aura::client::WINDOW_MOVE_SOURCE_MOUSE);
+ AttemptToStartDrag(target, location_in_parent, component,
+ aura::client::WINDOW_MOVE_SOURCE_MOUSE);
+ event->StopPropagation();
} else {
- window_resizer_.reset();
+ CompleteDrag(DRAG_COMPLETE);
}
- if (WindowResizer::GetBoundsChangeForWindowComponent(component) != 0)
- event->StopPropagation();
}
void ToplevelWindowEventHandler::HandleMouseReleased(
return;
CompleteDrag(event->type() == ui::ET_MOUSE_RELEASED ?
- DRAG_COMPLETE : DRAG_REVERT,
- event->flags());
- if (in_move_loop_) {
- quit_closure_.Run();
- in_move_loop_ = false;
- }
+ DRAG_COMPLETE : DRAG_REVERT);
// Completing the drag may result in hiding the window. If this happens
// return true so no other handlers/observers see the event. Otherwise
// they see the event on a hidden window.
- if (event->type() == ui::ET_MOUSE_CAPTURE_CHANGED &&
+ if (window_resizer_ &&
+ event->type() == ui::ET_MOUSE_CAPTURE_CHANGED &&
!target->IsVisible()) {
event->StopPropagation();
}
// Shadow effects are applied after target handling. Note that we don't
// respect ER_HANDLED here right now since we have not had a reason to allow
// the target to cancel shadow rendering.
- if (event->phase() != ui::EP_POSTTARGET)
+ if (event->phase() != ui::EP_POSTTARGET || !target->delegate())
return;
// TODO(jamescook): Move the resize cursor update code into here from
controller->HideShadow(target);
}
+void ToplevelWindowEventHandler::SetWindowShowTypeFromGesture(
+ aura::Window* window,
+ wm::WindowShowType new_show_type) {
+ wm::WindowState* window_state = ash::wm::GetWindowState(window);
+ switch (new_show_type) {
+ case wm::SHOW_TYPE_MINIMIZED:
+ if (window_state->CanMinimize()) {
+ window_state->Minimize();
+ window_state->set_unminimize_to_restore_bounds(true);
+ window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
+ }
+ break;
+ case wm::SHOW_TYPE_MAXIMIZED:
+ if (window_state->CanMaximize()) {
+ window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
+ window_state->Maximize();
+ }
+ break;
+ case wm::SHOW_TYPE_LEFT_SNAPPED:
+ if (window_state->CanSnap()) {
+ window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
+ internal::SnapSizer::SnapWindow(window_state,
+ internal::SnapSizer::LEFT_EDGE);
+ }
+ break;
+ case wm::SHOW_TYPE_RIGHT_SNAPPED:
+ if (window_state->CanSnap()) {
+ window_state->SetRestoreBoundsInParent(pre_drag_window_bounds_);
+ internal::SnapSizer::SnapWindow(window_state,
+ internal::SnapSizer::RIGHT_EDGE);
+ }
+ break;
+ default:
+ NOTREACHED();
+ }
+}
+
void ToplevelWindowEventHandler::ResizerWindowDestroyed() {
// We explicitly don't invoke RevertDrag() since that may do things to window.
// Instead we destroy the resizer.
window_resizer_.reset();
- // End the move loop. This does nothing if we're not in a move loop.
- EndMoveLoop();
+ CompleteDrag(DRAG_REVERT);
}
} // namespace ash
projects / platform / framework / web / crosswalk.git / blobdiff