| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "services/window_manager/view_targeter.h" | |
| 6 | |
| 7 #include "services/window_manager/capture_controller.h" | |
| 8 #include "services/window_manager/focus_controller.h" | |
| 9 #include "services/window_manager/view_target.h" | |
| 10 #include "ui/events/event_target_iterator.h" | |
| 11 | |
| 12 namespace window_manager { | |
| 13 | |
| 14 ViewTargeter::ViewTargeter() {} | |
| 15 | |
| 16 ViewTargeter::~ViewTargeter() {} | |
| 17 | |
| 18 ui::EventTarget* ViewTargeter::FindTargetForEvent(ui::EventTarget* root, | |
| 19 ui::Event* event) { | |
| 20 ViewTarget* view = static_cast<ViewTarget*>(root); | |
| 21 ViewTarget* target; | |
| 22 if (event->IsKeyEvent()) { | |
| 23 target = FindTargetForKeyEvent(view, *static_cast<ui::KeyEvent*>(event)); | |
| 24 } else if (event->IsMouseEvent() || | |
| 25 event->IsScrollEvent() || | |
| 26 event->IsTouchEvent() || | |
| 27 event->IsGestureEvent()) { | |
| 28 target = static_cast<ViewTarget*>(FindTargetForLocatedEvent( | |
| 29 root, static_cast<ui::LocatedEvent*>(event))); | |
| 30 } else { | |
| 31 target = static_cast<ViewTarget*>(root); | |
| 32 } | |
| 33 | |
| 34 // TODO(erg): The aura version of this method does a lot of work to handle | |
| 35 // dispatching to a target that isn't a child of |view|. For now, punt on | |
| 36 // this. | |
| 37 DCHECK_EQ(view->GetRoot(), target->GetRoot()); | |
| 38 | |
| 39 return target; | |
| 40 } | |
| 41 | |
| 42 ui::EventTarget* ViewTargeter::FindNextBestTarget( | |
| 43 ui::EventTarget* previous_target, ui::Event* event) { | |
| 44 return nullptr; | |
| 45 } | |
| 46 | |
| 47 ui::EventTarget* ViewTargeter::FindTargetForLocatedEvent( | |
| 48 ui::EventTarget* root, | |
| 49 ui::LocatedEvent* event) { | |
| 50 ViewTarget* view = static_cast<ViewTarget*>(root); | |
| 51 if (!view->HasParent()) { | |
| 52 ViewTarget* target = FindTargetInRootView(view, *event); | |
| 53 if (target) { | |
| 54 view->ConvertEventToTarget(target, event); | |
| 55 return target; | |
| 56 } | |
| 57 } | |
| 58 scoped_ptr<ui::EventTargetIterator> iter = root->GetChildIterator(); | |
| 59 if (iter) { | |
| 60 ui::EventTarget* target = root; | |
| 61 for (ui::EventTarget* child = iter->GetNextTarget(); child; | |
| 62 child = iter->GetNextTarget()) { | |
| 63 ViewTargeter* targeter = static_cast<ViewTargeter*>( | |
| 64 child->GetEventTargeter()); | |
| 65 if (!targeter) | |
| 66 targeter = this; | |
| 67 if (!targeter->SubtreeShouldBeExploredForEvent(child, *event)) | |
| 68 continue; | |
| 69 target->ConvertEventToTarget(child, event); | |
| 70 target = child; | |
| 71 ui::EventTarget* child_target = | |
| 72 targeter->FindTargetForLocatedEvent(child, event); | |
| 73 if (child_target) | |
| 74 return child_target; | |
| 75 } | |
| 76 target->ConvertEventToTarget(root, event); | |
| 77 } | |
| 78 return root->CanAcceptEvent(*event) ? root : NULL; | |
| 79 } | |
| 80 | |
| 81 bool ViewTargeter::SubtreeShouldBeExploredForEvent( | |
| 82 ui::EventTarget* target, const ui::LocatedEvent& event) { | |
| 83 return SubtreeCanAcceptEvent(target, event) && | |
| 84 EventLocationInsideBounds(target, event); | |
| 85 } | |
| 86 | |
| 87 bool ViewTargeter::SubtreeCanAcceptEvent(ui::EventTarget* target, | |
| 88 const ui::LocatedEvent& event) const { | |
| 89 ViewTarget* view = static_cast<ViewTarget*>(target); | |
| 90 | |
| 91 if (!view->IsVisible()) | |
| 92 return false; | |
| 93 | |
| 94 // TODO(erg): We may need to keep track of the parent on ViewTarget, because | |
| 95 // we have a check here about | |
| 96 // WindowDelegate::ShouldDescendIntoChildForEventHandling(). | |
| 97 | |
| 98 // TODO(sky): decide if we really want this. If we do, it should be a public | |
| 99 // constant and documented. | |
| 100 if (view->view()->shared_properties().count("deliver-events-to-parent")) | |
| 101 return false; | |
| 102 | |
| 103 return true; | |
| 104 } | |
| 105 | |
| 106 bool ViewTargeter::EventLocationInsideBounds( | |
| 107 ui::EventTarget* target, | |
| 108 const ui::LocatedEvent& event) const { | |
| 109 ViewTarget* view = static_cast<ViewTarget*>(target); | |
| 110 gfx::Point point = event.location(); | |
| 111 const ViewTarget* parent = view->GetParent(); | |
| 112 if (parent) | |
| 113 ViewTarget::ConvertPointToTarget(parent, view, &point); | |
| 114 return gfx::Rect(view->GetBounds().size()).Contains(point); | |
| 115 } | |
| 116 | |
| 117 ViewTarget* ViewTargeter::FindTargetForKeyEvent(ViewTarget* view_target, | |
| 118 const ui::KeyEvent& key) { | |
| 119 FocusController* focus_controller = GetFocusController(view_target->view()); | |
| 120 if (focus_controller) { | |
| 121 mojo::View* focused_view = focus_controller->GetFocusedView(); | |
| 122 if (focused_view) | |
| 123 return ViewTarget::TargetFromView(focused_view); | |
| 124 } | |
| 125 return view_target; | |
| 126 } | |
| 127 | |
| 128 ViewTarget* ViewTargeter::FindTargetInRootView(ViewTarget* root_view, | |
| 129 const ui::LocatedEvent& event) { | |
| 130 // TODO(erg): This here is important because it resolves | |
| 131 // mouse_pressed_handler() in the aura version. This is what makes sure | |
| 132 // that a view gets both the mouse down and up. | |
| 133 | |
| 134 CaptureController* capture_controller = | |
| 135 GetCaptureController(root_view->view()); | |
| 136 if (capture_controller) { | |
| 137 mojo::View* capture_view = capture_controller->GetCapture(); | |
| 138 if (capture_view) | |
| 139 return ViewTarget::TargetFromView(capture_view); | |
| 140 } | |
| 141 | |
| 142 // TODO(erg): There's a whole bunch of junk about handling touch events | |
| 143 // here. Handle later. | |
| 144 | |
| 145 return nullptr; | |
| 146 } | |
| 147 | |
| 148 } // namespace window_manager | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1531403003:
Delete the ViewManager and WindowManager services. (Closed)
Base URL: git@github.com:domokit/mojo.git@moz-3