Move bezel event routing for the shelf into ShelfLayoutManager

ash/shelf/shelf_layout_manager.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_layout_manager.h"
 
 #include <algorithm>
 #include <cmath>
+#include <cstring>
+#include <string>
+#include <vector>
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/launcher/launcher_types.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.h"
 #include "ash/session_state_delegate.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/system/status_area_widget.h"
 #include "ash/wm/gestures/shelf_gesture_handler.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/window_cycle_controller.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_util.h"
+#include "ash/wm/workspace/workspace_animations.h"
 #include "ash/wm/workspace_controller.h"
-#include "ash/wm/workspace/workspace_animations.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
+#include "base/command_line.h"
 #include "base/i18n/rtl.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/base/events/event.h"
 #include "ui/base/events/event_handler.h"
+#include "ui/base/ui_base_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_observer.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace internal {
 
@@ skipping 40 matching lines @@
   bool in_mouse_drag() const { return in_mouse_drag_; }
 
   // Overridden from ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
   virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
 
  private:
   ShelfLayoutManager* shelf_;
   bool in_mouse_drag_;
   ShelfGestureHandler gesture_handler_;
-
   DISALLOW_COPY_AND_ASSIGN(AutoHideEventFilter);
 };
 
 ShelfLayoutManager::AutoHideEventFilter::AutoHideEventFilter(
     ShelfLayoutManager* shelf)
     : shelf_(shelf),
       in_mouse_drag_(false) {
   Shell::GetInstance()->AddPreTargetHandler(this);
 }
 
@@ skipping 15 matching lines @@
 }
 
 void ShelfLayoutManager::AutoHideEventFilter::OnGestureEvent(
     ui::GestureEvent* event) {
   if (shelf_->IsShelfWindow(static_cast<aura::Window*>(event->target()))) {
     if (gesture_handler_.ProcessGestureEvent(*event))
       event->StopPropagation();
   }
 }
 
+// ShelfLayoutManager::BezelEventFilter -------------------------------------
+
+// Notifies ShelfLayoutManager any time the mouse moves.
+class ShelfLayoutManager::BezelEventFilter : public ui::EventHandler {
+ public:
+  explicit BezelEventFilter(ShelfLayoutManager* shelf);
+  virtual ~BezelEventFilter();
+
+  // Overridden from ui::EventHandler:
+  virtual void OnGestureEvent(ui::GestureEvent* event) OVERRIDE;
+
+ private:
+  bool IsShelfOnBezel(const gfx::Rect& screen,
+                      const gfx::Point& point) const;
+
+  ShelfLayoutManager* shelf_;  // non-owned
+  bool in_touch_drag_;
+  ShelfGestureHandler gesture_handler_;
+  DISALLOW_COPY_AND_ASSIGN(BezelEventFilter);
+};
+
+ShelfLayoutManager::BezelEventFilter::BezelEventFilter(
+    ShelfLayoutManager* shelf)
+    : shelf_(shelf),
+      in_touch_drag_(false) {
+  Shell::GetInstance()->AddPreTargetHandler(this);
+}
+
+ShelfLayoutManager::BezelEventFilter::~BezelEventFilter() {
+  Shell::GetInstance()->RemovePreTargetHandler(this);
+}
+
+void ShelfLayoutManager::BezelEventFilter::OnGestureEvent(
+    ui::GestureEvent* event) {
+  gfx::Rect screen =
+      Shell::GetScreen()->GetDisplayNearestPoint(event->location()).bounds();
+  if ((!screen.Contains(event->location()) &&
+       IsShelfOnBezel(screen, event->location())) ||
+      in_touch_drag_) {
+    if (gesture_handler_.ProcessGestureEvent(*event)) {
+      switch (event->type()) {
+        case ui::ET_GESTURE_SCROLL_BEGIN:
+          in_touch_drag_ = true;
+          break;
+        case ui::ET_GESTURE_SCROLL_END:
+        case ui::ET_SCROLL_FLING_START:
+          in_touch_drag_ = false;
+          break;
+        default:
+          break;
+      }
+      event->StopPropagation();
+    }
+  }
+}
+
+bool ShelfLayoutManager::BezelEventFilter::IsShelfOnBezel(
+    const gfx::Rect& screen,
+    const gfx::Point& point) const{
+  switch (shelf_->GetAlignment()) {
+    case SHELF_ALIGNMENT_BOTTOM:
+      if (point.y() >= screen.bottom())
+        return true;
+      break;
+    case SHELF_ALIGNMENT_LEFT:
+      if (point.x() <= screen.x())
+        return true;
+      break;
+    case SHELF_ALIGNMENT_TOP:
+      if (point.y() <= screen.y())
+        return true;
+      break;
+    case SHELF_ALIGNMENT_RIGHT:
+      if (point.x() >= screen.right())
+        return true;
+      break;
+  }
+  return false;
+}
+
 // ShelfLayoutManager:UpdateShelfObserver --------------------------------------
 
 // UpdateShelfObserver is used to delay updating the background until the
 // animation completes.
 class ShelfLayoutManager::UpdateShelfObserver
     : public ui::ImplicitAnimationObserver {
  public:
   explicit UpdateShelfObserver(ShelfLayoutManager* shelf) : shelf_(shelf) {
     shelf_->update_shelf_observer_ = this;
   }
@@ skipping 24 matching lines @@
 // ShelfLayoutManager ----------------------------------------------------------
 
 ShelfLayoutManager::ShelfLayoutManager(ShelfWidget* shelf)
     : root_window_(shelf->GetNativeView()->GetRootWindow()),
       in_layout_(false),
       auto_hide_behavior_(SHELF_AUTO_HIDE_BEHAVIOR_NEVER),
       alignment_(SHELF_ALIGNMENT_BOTTOM),
       shelf_(shelf),
       workspace_controller_(NULL),
       window_overlaps_shelf_(false),
+      bezel_event_filter_(new BezelEventFilter(this)),
       gesture_drag_status_(GESTURE_DRAG_NONE),
       gesture_drag_amount_(0.f),
       gesture_drag_auto_hide_state_(SHELF_AUTO_HIDE_SHOWN),
       update_shelf_observer_(NULL) {
   Shell::GetInstance()->AddShellObserver(this);
   aura::client::GetActivationClient(root_window_)->AddObserver(this);
 }
 
 ShelfLayoutManager::~ShelfLayoutManager() {
   if (update_shelf_observer_)
@@ skipping 375 matching lines @@
 
   if (state_.Equals(state))
     return;  // Nothing changed.
 
   FOR_EACH_OBSERVER(ShelfLayoutManagerObserver, observers_,
                     WillChangeVisibilityState(visibility_state));
 
   if (state.visibility_state == SHELF_AUTO_HIDE) {
     // When state is SHELF_AUTO_HIDE we need to track when the mouse is over the
     // launcher to unhide the shelf. AutoHideEventFilter does that for us.
-    if (!event_filter_)
-      event_filter_.reset(new AutoHideEventFilter(this));
+    if (!auto_hide_event_filter_)
+      auto_hide_event_filter_.reset(new AutoHideEventFilter(this));
   } else {
-    event_filter_.reset(NULL);
+    auto_hide_event_filter_.reset(NULL);
   }
 
   auto_hide_timer_.Stop();
 
   // Animating the background when transitioning from auto-hide & hidden to
   // visible is janky. Update the background immediately in this case.
   BackgroundAnimator::ChangeType change_type =
       (state_.visibility_state == SHELF_AUTO_HIDE &&
        state_.auto_hide_state == SHELF_AUTO_HIDE_HIDDEN &&
        state.visibility_state == SHELF_VISIBLE) ?
@@ skipping 283 matching lines @@
   if (shelf_->launcher() && shelf_->launcher()->IsShowingMenu())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->launcher() && shelf_->launcher()->IsShowingOverflowBubble())
     return SHELF_AUTO_HIDE_SHOWN;
 
   if (shelf_->IsActive() || shelf_->status_area_widget()->IsActive())
     return SHELF_AUTO_HIDE_SHOWN;
 
   // Don't show if the user is dragging the mouse.
-  if (event_filter_.get() && event_filter_->in_mouse_drag())
+  if (auto_hide_event_filter_.get() && auto_hide_event_filter_->in_mouse_drag())
     return SHELF_AUTO_HIDE_HIDDEN;
 
   gfx::Rect shelf_region = shelf_->GetWindowBoundsInScreen();
   if (shelf_->status_area_widget() &&
       shelf_->status_area_widget()->IsMessageBubbleShown() &&
       IsVisible()) {
     // Increase the the hit test area to prevent the shelf from disappearing
     // when the mouse is over the bubble gap.
     shelf_region.Inset(alignment_ == SHELF_ALIGNMENT_RIGHT ?
                            -kNotificationBubbleGapHeight : 0,
@@ skipping 81 matching lines @@
       return gfx::Insets(0, distance, 0, 0);
     case SHELF_ALIGNMENT_TOP:
       return gfx::Insets(0, 0, distance, 0);
   }
   NOTREACHED();
   return gfx::Insets();
 }
 
 }  // namespace internal
 }  // namespace ash