aura: Add an EasyResizeWindowTargeter.

ash/shelf/shelf_widget.cc

 // Copyright (c) 2012 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/shelf/shelf_widget.h"
 
 #include "ash/ash_switches.h"
 #include "ash/focus_cycler.h"
 #include "ash/root_window_controller.h"
 #include "ash/session_state_delegate.h"
@@ skipping 19 matching lines @@
 #include "ui/compositor/layer.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_constants.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skbitmap_operations.h"
 #include "ui/views/accessible_pane_view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/views/widget/widget_delegate.h"
+#include "ui/wm/public/easy_resize_window_targeter.h"
 
 namespace {
 // Size of black border at bottom (or side) of shelf.
 const int kNumBlackPixels = 3;
 // Alpha to paint dimming image with.
 const int kDimAlpha = 128;
 
 // The time to dim and un-dim.
 const int kTimeToDimMs = 3000;  // Slow in dimming.
 const int kTimeToUnDimMs = 200;  // Fast in activating.
@@ skipping 176 matching lines @@
   bool touch_inside = false;
   if (event->type() != ui::ET_TOUCH_RELEASED &&
       event->type() != ui::ET_TOUCH_CANCELLED)
     touch_inside = owner_->GetBoundsInScreen().Contains(event->root_location());
 
   if (mouse_inside_ || touch_inside_ != mouse_inside_ || touch_inside)
     owner_->SetHovered(mouse_inside_ || touch_inside);
   touch_inside_ = touch_inside;
 }
 
+using ash::internal::ShelfLayoutManager;
+
+// ShelfWindowTargeter makes it easier to resize windows with the mouse when the
+// window-edge slightly overlaps with the shelf edge. The targeter also makes it
+// easier to drag the shelf out with touch while it is hidden.
+class ShelfWindowTargeter : public wm::EasyResizeWindowTargeter,
+                            public ash::ShelfLayoutManagerObserver {
+ public:
+  ShelfWindowTargeter(aura::Window* container,
+                      ShelfLayoutManager* shelf)
+      : wm::EasyResizeWindowTargeter(container, gfx::Insets(), gfx::Insets()),
+        shelf_(shelf) {
+    WillChangeVisibilityState(shelf_->visibility_state());
+    shelf_->AddObserver(this);
+  }
+
+  virtual ~ShelfWindowTargeter() {
+    // |shelf_| may have been destroyed by this time.
+    if (shelf_)
+      shelf_->RemoveObserver(this);
+  }
+
+ private:
+  gfx::Insets GetInsetsForAlignment(int distance,
+                                    ash::ShelfAlignment alignment) {
+    switch (alignment) {
+      case ash::SHELF_ALIGNMENT_BOTTOM:
+        return gfx::Insets(distance, 0, 0, 0);
+      case ash::SHELF_ALIGNMENT_LEFT:
+        return gfx::Insets(0, 0, 0, distance);
+      case ash::SHELF_ALIGNMENT_RIGHT:
+        return gfx::Insets(0, distance, 0, 0);
+      case ash::SHELF_ALIGNMENT_TOP:
+        return gfx::Insets(0, 0, distance, 0);
+    }
+    NOTREACHED();
+    return gfx::Insets();
+  }
+
+  // ash::ShelfLayoutManagerObserver:
+  virtual void WillDeleteShelf() OVERRIDE {
+    shelf_ = NULL;
+  }
+
+  virtual void WillChangeVisibilityState(
+      ash::ShelfVisibilityState new_state) OVERRIDE {
+    gfx::Insets mouse_insets;
+    gfx::Insets touch_insets;
+    if (new_state == ash::SHELF_VISIBLE) {
+      // Let clicks at the very top of the shelf through so windows can be
+      // resized with the bottom-right corner and bottom edge.
+      mouse_insets = GetInsetsForAlignment(
+          ShelfLayoutManager::kWorkspaceAreaVisibleInset,
+          shelf_->GetAlignment());
+    } else if (new_state == ash::SHELF_AUTO_HIDE) {
+      // Extend the touch hit target out a bit to allow users to drag shelf out
+      // while hidden.
+      touch_insets = GetInsetsForAlignment(
+          -ShelfLayoutManager::kWorkspaceAreaAutoHideInset,
+          shelf_->GetAlignment());
+    }
+
+    set_mouse_extend(mouse_insets);
+    set_touch_extend(touch_insets);
+  }
+
+  ShelfLayoutManager* shelf_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShelfWindowTargeter);
+};
+
 }  // namespace
 
 namespace ash {
 
 // The contents view of the Shelf. This view contains ShelfView and
 // sizes it to the width of the shelf minus the size of the status area.
 class ShelfWidget::DelegateView : public views::WidgetDelegate,
                                   public views::AccessiblePaneView,
                                   public internal::BackgroundAnimatorDelegate,
                                   public aura::WindowObserver {
@@ skipping 311 matching lines @@
 
   shelf_layout_manager_ = new internal::ShelfLayoutManager(this);
   shelf_layout_manager_->AddObserver(this);
   shelf_container->SetLayoutManager(shelf_layout_manager_);
   shelf_layout_manager_->set_workspace_controller(workspace_controller);
   workspace_controller->SetShelf(shelf_layout_manager_);
 
   status_container->SetLayoutManager(
       new internal::StatusAreaLayoutManager(this));
 
+  shelf_container->set_event_targeter(scoped_ptr<ui::EventTargeter>(new
+      ShelfWindowTargeter(shelf_container, shelf_layout_manager_)));
+  status_container->set_event_targeter(scoped_ptr<ui::EventTargeter>(new
+      ShelfWindowTargeter(status_container, shelf_layout_manager_)));
+
   views::Widget::AddObserver(this);
 }
 
 ShelfWidget::~ShelfWidget() {
   RemoveObserver(this);
 }
 
 void ShelfWidget::SetPaintsBackground(
     ShelfBackgroundType background_type,
     BackgroundAnimatorChangeType change_type) {
@@ skipping 154 matching lines @@
   DCHECK(delegate_view_);
   return delegate_view_->disable_dimming_animations_for_test();
 }
 
 void ShelfWidget::WillDeleteShelf() {
   shelf_layout_manager_->RemoveObserver(this);
   shelf_layout_manager_ = NULL;
 }
 
 }  // namespace ash