// Copyright 2015 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 "services/ui/ws/event_processor.h" #include #include "base/time/time.h" #include "services/ui/ws/accelerator.h" #include "services/ui/ws/drag_controller.h" #include "services/ui/ws/drag_source.h" #include "services/ui/ws/event_dispatcher.h" #include "services/ui/ws/event_location.h" #include "services/ui/ws/event_processor_delegate.h" #include "services/ui/ws/server_window.h" #include "services/ui/ws/server_window_delegate.h" #include "services/ui/ws/server_window_drawn_tracker.h" #include "services/ui/ws/window_coordinate_conversions.h" #include "services/ui/ws/window_finder.h" #include "ui/base/cursor/cursor.h" #include "ui/events/event_utils.h" #include "ui/gfx/geometry/point.h" #include "ui/gfx/geometry/point_conversions.h" namespace ui { namespace ws { using Entry = std::pair>; namespace { bool IsOnlyOneMouseButtonDown(int flags) { const uint32_t button_only_flags = flags & (ui::EF_LEFT_MOUSE_BUTTON | ui::EF_MIDDLE_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON); return button_only_flags == ui::EF_LEFT_MOUSE_BUTTON || button_only_flags == ui::EF_MIDDLE_MOUSE_BUTTON || button_only_flags == ui::EF_RIGHT_MOUSE_BUTTON; } // This is meant to mirror when implicit capture stops. Specifically non-mouse // pointer up, or mouse and no more buttons down. bool IsPointerGoingUp(const Event& event) { return event.IsPointerEvent() && (event.type() == ui::ET_POINTER_UP || event.type() == ui::ET_POINTER_CANCELLED) && (!event.IsMousePointerEvent() || IsOnlyOneMouseButtonDown(event.flags())); } // Get the pointer id from an event, only supports PointerEvents for now. int32_t GetPointerId(const Event& event) { if (event.IsPointerEvent()) return event.AsPointerEvent()->pointer_details().id; return PointerDetails::kUnknownPointerId; } } // namespace //////////////////////////////////////////////////////////////////////////////// EventProcessor::ObservedWindow::ObservedWindow() = default; EventProcessor::ObservedWindow::~ObservedWindow() = default; EventProcessor::EventProcessor(EventProcessorDelegate* delegate, EventDispatcher* event_dispatcher) : delegate_(delegate), event_dispatcher_(event_dispatcher), capture_window_(nullptr), capture_window_client_id_(kInvalidClientId), event_targeter_(std::make_unique(this)), mouse_button_down_(false), mouse_cursor_source_window_(nullptr), mouse_cursor_in_non_client_area_(false) {} EventProcessor::~EventProcessor() { SetMouseCursorSourceWindow(nullptr); if (capture_window_) { UnobserveWindow(capture_window_); capture_window_ = nullptr; capture_window_client_id_ = kInvalidClientId; } for (const auto& pair : pointer_targets_) { if (pair.second.window) UnobserveWindow(pair.second.window); } pointer_targets_.clear(); } void EventProcessor::Reset() { if (capture_window_) { CancelPointerEventsToTarget(capture_window_); DCHECK(capture_window_ == nullptr); } while (!pointer_targets_.empty()) StopTrackingPointer(pointer_targets_.begin()->first); mouse_button_down_ = false; } ui::CursorData EventProcessor::GetCurrentMouseCursor() const { if (drag_controller_) return drag_controller_->current_cursor(); if (!mouse_cursor_source_window_) return ui::CursorData(ui::CursorType::kPointer); if (mouse_cursor_in_non_client_area_) return mouse_cursor_source_window_->non_client_cursor(); const ServerWindow* window = GetWindowForMouseCursor(); return window ? window->cursor() : ui::CursorData(ui::CursorType::kPointer); } bool EventProcessor::SetCaptureWindow(ServerWindow* window, ClientSpecificId client_id) { if (!window) client_id = kInvalidClientId; if (window == capture_window_ && client_id == capture_window_client_id_) return true; // A window that is blocked by a modal window cannot gain capture. if (window && modal_window_controller_.IsWindowBlocked(window)) return false; // If we're currently performing a drag and drop, reject setting the capture // window. if (drag_controller_) return false; if (capture_window_) { // Stop observing old capture window. |pointer_targets_| are cleared on // initial setting of a capture window. UnobserveWindow(capture_window_); } else { CancelImplicitCaptureExcept(window, client_id); } // Set the capture before changing native capture; otherwise, the callback // from native platform might try to set the capture again. const bool had_capture_window = capture_window_ != nullptr; ServerWindow* old_capture_window = capture_window_; capture_window_ = window; capture_window_client_id_ = client_id; delegate_->OnCaptureChanged(capture_window_, old_capture_window); // Begin tracking the capture window if it is not yet being observed. if (window) { ObserveWindow(window); // TODO(sky): this conditional is problematic for the case of capture moving // to a different display. if (!had_capture_window) delegate_->SetNativeCapture(window); } else { delegate_->ReleaseNativeCapture(); if (!mouse_button_down_) UpdateCursorProviderByLastKnownLocation(); } return true; } void EventProcessor::SetDragDropSourceWindow( DragSource* drag_source, ServerWindow* window, DragTargetConnection* source_connection, int32_t drag_pointer, const base::flat_map>& mime_data, uint32_t drag_operations) { CancelImplicitCaptureExcept(nullptr, kInvalidClientId); drag_controller_ = std::make_unique( this, drag_source, window, source_connection, drag_pointer, mime_data, drag_operations); } void EventProcessor::CancelDragDrop() { if (drag_controller_) drag_controller_->Cancel(); } void EventProcessor::EndDragDrop() { drag_controller_.reset(); } void EventProcessor::OnWillDestroyDragTargetConnection( DragTargetConnection* connection) { if (drag_controller_) drag_controller_->OnWillDestroyDragTargetConnection(connection); } void EventProcessor::AddSystemModalWindow(ServerWindow* window) { modal_window_controller_.AddSystemModalWindow(window); ReleaseCaptureBlockedByAnyModalWindow(); } void EventProcessor::ReleaseCaptureBlockedByAnyModalWindow() { if (!capture_window_) return; if (modal_window_controller_.IsWindowBlocked(capture_window_)) SetCaptureWindow(nullptr, kInvalidClientId); } const ServerWindow* EventProcessor::GetWindowForMouseCursor() const { if (mouse_cursor_in_non_client_area_ || !mouse_cursor_source_window_) return mouse_cursor_source_window_; // Return the ancestor (starting at |mouse_cursor_source_window_|) whose // client id differs. In other words, return the first window ancestor that is // an embed root. This is done to match the behavior of aura, which sets the // cursor on the root. const ClientSpecificId target_client_id = delegate_->GetEventTargetClientId( mouse_cursor_source_window_, mouse_cursor_in_non_client_area_); const ServerWindow* window = mouse_cursor_source_window_; while (window && window->owning_tree_id() == target_client_id) window = window->parent(); return window; } void EventProcessor::UpdateNonClientAreaForCurrentWindow() { if (!mouse_button_down_ && mouse_cursor_source_window_) { event_targeter_->FindTargetForLocation( EventSource::MOUSE, {mouse_pointer_last_location_, mouse_pointer_last_location_, mouse_pointer_display_id_}, base::BindOnce( &EventProcessor::UpdateNonClientAreaForCurrentWindowOnFoundWindow, base::Unretained(this))); } } void EventProcessor::UpdateCursorProviderByLastKnownLocation() { if (!mouse_button_down_) { event_targeter_->FindTargetForLocation( EventSource::MOUSE, {mouse_pointer_last_location_, mouse_pointer_last_location_, mouse_pointer_display_id_}, base::BindOnce(&EventProcessor:: UpdateCursorProviderByLastKnownLocationOnFoundWindow, base::Unretained(this))); } } bool EventProcessor::AddAccelerator(uint32_t id, mojom::EventMatcherPtr event_matcher) { std::unique_ptr accelerator(new Accelerator(id, *event_matcher)); // If an accelerator with the same id or matcher already exists, then abort. for (const auto& pair : accelerators_) { if (pair.first == id) { DVLOG(1) << "duplicate accelerator. Accelerator id=" << accelerator->id() << " type=" << event_matcher->type_matcher->type << " flags=" << event_matcher->flags_matcher->flags; return false; } else if (accelerator->EqualEventMatcher(pair.second.get())) { DVLOG(1) << "duplicate matcher. Accelerator id=" << accelerator->id() << " type=" << event_matcher->type_matcher->type << " flags=" << event_matcher->flags_matcher->flags; return false; } } accelerators_.insert(Entry(id, std::move(accelerator))); return true; } void EventProcessor::RemoveAccelerator(uint32_t id) { auto it = accelerators_.find(id); // Clients may pass bogus ids. if (it != accelerators_.end()) accelerators_.erase(it); } void EventProcessor::SetKeyEventsThatDontHideCursor( std::vector<::ui::mojom::EventMatcherPtr> dont_hide_cursor_list) { dont_hide_cursor_matchers_.clear(); for (auto& matcher_ptr : dont_hide_cursor_list) { EventMatcher matcher(*matcher_ptr); // Ensure we don't have pointer matchers in our key only list. DCHECK(!matcher.HasFields(EventMatcher::POINTER_KIND | EventMatcher::POINTER_LOCATION)); dont_hide_cursor_matchers_.push_back(std::move(matcher)); } } bool EventProcessor::IsProcessingEvent() const { return waiting_on_event_targeter_; } void EventProcessor::ProcessEvent(const ui::Event& event, const EventLocation& event_location, AcceleratorMatchPhase match_phase) { #if !defined(NDEBUG) if (match_phase == AcceleratorMatchPhase::POST_ONLY) { // POST_ONLY should always be preceeded by ANY with the same event. DCHECK(previous_event_); // Event doesn't define ==, so this compares the key fields. DCHECK(event.type() == previous_event_->type() && event.time_stamp() == previous_event_->time_stamp() && event.flags() == previous_event_->flags()); DCHECK_EQ(previous_accelerator_match_phase_, AcceleratorMatchPhase::ANY); } previous_event_ = Event::Clone(event); previous_accelerator_match_phase_ = match_phase; #endif if (event.IsKeyEvent()) { const ui::KeyEvent* key_event = event.AsKeyEvent(); if (!key_event->is_char() && match_phase == AcceleratorMatchPhase::ANY) { Accelerator* pre_target = FindAccelerator(*key_event, ui::mojom::AcceleratorPhase::PRE_TARGET); if (pre_target) { event_dispatcher_->OnAccelerator( pre_target->id(), event_location.display_id, event, EventDispatcher::AcceleratorPhase::kPre); return; } } ProcessKeyEvent(*key_event, event_location.display_id, match_phase); return; } DCHECK(event.IsPointerEvent() || event.IsScrollEvent()); DCHECK(event_location.location == event.AsLocatedEvent()->root_location_f()); DCHECK(event_location.location == event.AsLocatedEvent()->location_f()); DCHECK(!waiting_on_event_targeter_); if (ShouldUseEventTargeter(event)) { waiting_on_event_targeter_ = true; const EventSource event_source = event.IsMousePointerEvent() ? EventSource::MOUSE : EventSource::TOUCH; event_targeter_->FindTargetForLocation( event_source, event_location, base::BindOnce(&EventProcessor::ProcessEventOnFoundTarget, base::Unretained(this), ui::Event::Clone(event))); } else { ProcessEventOnFoundTargetImpl(ui::Event::Clone(event), event_location, nullptr); } } ServerWindow* EventProcessor::GetRootWindowForDisplay(int64_t display_id) { return delegate_->GetRootWindowForDisplay(display_id); } viz::HitTestQuery* EventProcessor::GetHitTestQueryForDisplay( int64_t display_id) { return delegate_->GetHitTestQueryForDisplay(display_id); } ServerWindow* EventProcessor::GetWindowFromFrameSinkId( const viz::FrameSinkId& frame_sink_id) { return delegate_->GetWindowFromFrameSinkId(frame_sink_id); } DeepestWindow EventProcessor::AdjustTargetForModal( const DeepestWindow& target) const { const ServerWindow* modal_transient = modal_window_controller_.GetModalTransient(target.window); if (!modal_transient && !modal_window_controller_.IsWindowBlocked(target.window)) { return target; } DeepestWindow updated_target = target; updated_target.in_non_client_area = true; updated_target.window = target.window ? delegate_->GetFallbackTargetForEventBlockedByModal( target.window->GetRootForDrawn()) : nullptr; return updated_target; } void EventProcessor::SetMouseCursorSourceWindow(ServerWindow* window) { if (mouse_cursor_source_window_ == window) return; if (mouse_cursor_source_window_) UnobserveWindow(mouse_cursor_source_window_); mouse_cursor_source_window_ = window; if (mouse_cursor_source_window_) ObserveWindow(mouse_cursor_source_window_); } void EventProcessor::SetMousePointerLocation( const gfx::PointF& new_mouse_location, int64_t new_mouse_display_id) { // TODO: this needs to account for grab and a different display. By that I // mean during a grab |mouse_pointer_last_location_| may actually be in a // different display. mouse_pointer_last_location_ = new_mouse_location; mouse_pointer_display_id_ = new_mouse_display_id; } void EventProcessor::ProcessKeyEvent(const ui::KeyEvent& event, int64_t display_id, AcceleratorMatchPhase match_phase) { Accelerator* post_target = FindAccelerator(event, ui::mojom::AcceleratorPhase::POST_TARGET); if (drag_controller_ && event.type() == ui::ET_KEY_PRESSED && event.key_code() == ui::VKEY_ESCAPE) { drag_controller_->Cancel(); return; } ServerWindow* focused_window = delegate_->GetFocusedWindowForEventProcessor(display_id); if (focused_window) { // We only hide the cursor when there's a window to receive the key // event. We want to hide the cursor when the user is entering text // somewhere so if the user is at the desktop with no window to react to // the key press, there's no reason to hide the cursor. HideCursorOnMatchedKeyEvent(event); // Assume key events are for the client area. const bool in_nonclient_area = false; const ClientSpecificId client_id = delegate_->GetEventTargetClientId(focused_window, in_nonclient_area); event_dispatcher_->DispatchInputEventToWindow(focused_window, client_id, EventLocation(display_id), event, post_target); return; } delegate_->OnEventTargetNotFound(event, display_id); if (post_target) event_dispatcher_->OnAccelerator(post_target->id(), display_id, event, EventDispatcher::AcceleratorPhase::kPost); } void EventProcessor::HideCursorOnMatchedKeyEvent(const ui::KeyEvent& event) { if (event.IsSynthesized()) { // Don't bother performing the matching; it will be rejected anyway. return; } bool hide_cursor = !dont_hide_cursor_matchers_.empty(); for (auto& matcher : dont_hide_cursor_matchers_) { if (matcher.MatchesEvent(event)) { hide_cursor = false; break; } } if (hide_cursor) delegate_->OnEventChangesCursorVisibility(event, false); } bool EventProcessor::ShouldUseEventTargeter(const Event& event) const { if (drag_controller_) return true; if (capture_window_) return false; auto iter = pointer_targets_.find(GetPointerId(event)); if (iter == pointer_targets_.end() || !iter->second.is_pointer_down) return true; return (event.IsMousePointerEvent() && IsPointerGoingUp(event)) || event.type() == ET_POINTER_DOWN; } void EventProcessor::ProcessEventOnFoundTarget( std::unique_ptr event, const EventLocation& event_location, const DeepestWindow& target) { DCHECK(waiting_on_event_targeter_); waiting_on_event_targeter_ = false; ProcessEventOnFoundTargetImpl(std::move(event), event_location, &target); } void EventProcessor::ProcessEventOnFoundTargetImpl( std::unique_ptr event, const EventLocation& event_location, const DeepestWindow* found_target) { // WARNING: |found_target| may be null! DCHECK(!waiting_on_event_targeter_); UpdateCursorRelatedProperties(*event, event_location); const bool is_mouse_event = event->IsMousePointerEvent(); const bool is_pointer_going_up = IsPointerGoingUp(*event); // Update mouse down state upon events which change it. if (is_mouse_event) { if (event->type() == ui::ET_POINTER_DOWN) mouse_button_down_ = true; else if (is_pointer_going_up) mouse_button_down_ = false; } if (drag_controller_ && event->IsPointerEvent()) { DCHECK(found_target); if (drag_controller_->DispatchPointerEvent( *event->AsPointerEvent(), AdjustTargetForModal(*found_target).window)) { return; } } if (capture_window_) { SetMouseCursorSourceWindow(capture_window_); DispatchToClient(capture_window_, capture_window_client_id_, *event->AsLocatedEvent(), event_location); return; } std::unique_ptr result; if (found_target) { result = std::make_unique(); result->deepest_window = AdjustTargetForModal(*found_target); result->pointer_target.is_mouse_event = is_mouse_event; result->pointer_target.window = result->deepest_window.window; result->pointer_target.in_nonclient_area = result->deepest_window.in_non_client_area; result->pointer_target.is_pointer_down = event->type() == ui::ET_POINTER_DOWN; result->pointer_target.display_id = event_location.display_id; } const int32_t pointer_id = GetPointerId(*event); if (!IsTrackingPointer(pointer_id) || !pointer_targets_[pointer_id].is_pointer_down) { DCHECK(result); const bool any_pointers_down = AreAnyPointersDown(); UpdateTargetForPointer(pointer_id, *event->AsLocatedEvent(), result->pointer_target, event_location); if (is_mouse_event) SetMouseCursorSourceWindow(pointer_targets_[pointer_id].window); PointerTarget& pointer_target = pointer_targets_[pointer_id]; if (pointer_target.is_pointer_down) { if (!any_pointers_down) { // Don't attempt to change focus on pointer down. We assume client code // will do that. ServerWindow* capture_window = pointer_target.window; if (!capture_window) { capture_window = delegate_->GetRootWindowForDisplay(event_location.display_id); } delegate_->SetNativeCapture(capture_window); } } } // When we release the mouse button, we want the cursor to be sourced from // the window under the mouse pointer, even though we're sending the button // up event to the window that had implicit capture. We have to set this // before we perform dispatch because the Delegate is going to read this // information from us. if (is_pointer_going_up && is_mouse_event) { DCHECK(result); UpdateCursorProvider(result->deepest_window); } DispatchToPointerTarget(pointer_targets_[pointer_id], *event->AsLocatedEvent(), event_location); if (is_pointer_going_up) { if (is_mouse_event) pointer_targets_[pointer_id].is_pointer_down = false; else StopTrackingPointer(pointer_id); if (!AreAnyPointersDown()) delegate_->ReleaseNativeCapture(); } if (event->type() == ET_POINTER_DOWN) { // Use |found_target| as |result| has already been adjusted for the // modal window. DCHECK(found_target); if (found_target->window) HandleClickOnBlockedWindow(*found_target); } } void EventProcessor::UpdateCursorRelatedProperties( const ui::Event& event, const EventLocation& event_location) { if (event.IsMousePointerEvent()) { // This corresponds to the code in CompoundEventFilter which updates // visibility on each mouse event. Here, we're sure that we're a non-exit // mouse event and FROM_TOUCH doesn't exist in mus so we shouldn't need // further filtering. delegate_->OnEventChangesCursorTouchVisibility(event, true); delegate_->OnEventChangesCursorVisibility(event, true); SetMousePointerLocation(event_location.raw_location, event_location.display_id); delegate_->OnMouseCursorLocationChanged(event_location.raw_location, event_location.display_id); } else if (event.IsPointerEvent()) { // When we have a non-touch event that wasn't synthesized, hide the mouse // cursor until the next non-synthesized mouse event. delegate_->OnEventChangesCursorTouchVisibility(event, false); } } void EventProcessor::UpdateNonClientAreaForCurrentWindowOnFoundWindow( const EventLocation& event_location, const DeepestWindow& target) { if (!mouse_cursor_source_window_) return; const DeepestWindow updated_target = AdjustTargetForModal(target); if (updated_target.window == mouse_cursor_source_window_) { mouse_cursor_in_non_client_area_ = mouse_cursor_source_window_ ? updated_target.in_non_client_area : false; } delegate_->UpdateNativeCursorFromEventProcessor(); } void EventProcessor::UpdateCursorProviderByLastKnownLocationOnFoundWindow( const EventLocation& event_location, const DeepestWindow& target) { UpdateCursorProvider(AdjustTargetForModal(target)); } void EventProcessor::UpdateCursorProvider(const DeepestWindow& target) { if (mouse_button_down_) return; SetMouseCursorSourceWindow(target.window); if (mouse_cursor_source_window_) { mouse_cursor_in_non_client_area_ = target.in_non_client_area; } else { SetMouseCursorSourceWindow( delegate_->GetRootWindowForDisplay(mouse_pointer_display_id_)); mouse_cursor_in_non_client_area_ = true; } delegate_->UpdateNativeCursorFromEventProcessor(); } void EventProcessor::HandleClickOnBlockedWindow(const DeepestWindow& target) { ServerWindow* modal_transient = modal_window_controller_.GetModalTransient(target.window); if (modal_transient) { ServerWindow* toplevel = modal_window_controller_.GetToplevelWindow(target.window); DCHECK(toplevel); delegate_->SetFocusedWindowFromEventProcessor(toplevel); delegate_->OnEventOccurredOutsideOfModalWindow(modal_transient); } else if (target.window->IsDrawn() && modal_window_controller_.IsWindowBlocked(target.window) && modal_window_controller_.GetActiveSystemModalWindow()) { delegate_->OnEventOccurredOutsideOfModalWindow( modal_window_controller_.GetActiveSystemModalWindow()); } } void EventProcessor::StartTrackingPointer(int32_t pointer_id, const PointerTarget& pointer_target) { DCHECK(!IsTrackingPointer(pointer_id)); if (pointer_target.window) ObserveWindow(pointer_target.window); pointer_targets_[pointer_id] = pointer_target; } void EventProcessor::StopTrackingPointer(int32_t pointer_id) { DCHECK(IsTrackingPointer(pointer_id)); ServerWindow* window = pointer_targets_[pointer_id].window; pointer_targets_.erase(pointer_id); if (window) UnobserveWindow(window); } void EventProcessor::UpdateTargetForPointer( int32_t pointer_id, const ui::LocatedEvent& event, const PointerTarget& pointer_target, const EventLocation& event_location) { if (!IsTrackingPointer(pointer_id)) { StartTrackingPointer(pointer_id, pointer_target); return; } if (pointer_target.window == pointer_targets_[pointer_id].window && pointer_target.in_nonclient_area == pointer_targets_[pointer_id].in_nonclient_area) { // The targets are the same, only set the down state to true if necessary. // Down going to up is handled by ProcessLocatedEvent(). if (pointer_target.is_pointer_down) pointer_targets_[pointer_id].is_pointer_down = true; return; } // The targets are changing. Send an exit if appropriate. if (event.IsMousePointerEvent()) { ui::PointerEvent exit_event( ui::ET_POINTER_EXITED, event.location(), event.root_location(), event.flags(), 0 /* changed_button_flags */, ui::PointerDetails(ui::EventPointerType::POINTER_TYPE_MOUSE, ui::MouseEvent::kMousePointerId), event.time_stamp()); DispatchToPointerTarget(pointer_targets_[pointer_id], exit_event, event_location); } // Technically we're updating in place, but calling start then stop makes for // simpler code. StopTrackingPointer(pointer_id); StartTrackingPointer(pointer_id, pointer_target); } bool EventProcessor::AreAnyPointersDown() const { for (const auto& pair : pointer_targets_) { if (pair.second.is_pointer_down) return true; } return false; } void EventProcessor::DispatchToPointerTarget( const PointerTarget& target, const ui::LocatedEvent& event, const EventLocation& event_location) { if (!target.window) { delegate_->OnEventTargetNotFound(event, target.display_id); return; } if (target.is_mouse_event) mouse_cursor_in_non_client_area_ = target.in_nonclient_area; DispatchToClient(target.window, delegate_->GetEventTargetClientId(target.window, target.in_nonclient_area), event, event_location); } void EventProcessor::DispatchToClient(ServerWindow* window, ClientSpecificId client_id, const ui::LocatedEvent& event, const EventLocation& event_location) { gfx::Point location = ConvertPointFromRootForEventDispatch( delegate_->GetRootWindowForEventDispatch(window), window, event.location()); std::unique_ptr clone = ui::Event::Clone(event); clone->AsLocatedEvent()->set_location(location); // TODO(jonross): add post-target accelerator support once accelerators // support pointer events. event_dispatcher_->DispatchInputEventToWindow( window, client_id, event_location, *clone, nullptr); } void EventProcessor::CancelPointerEventsToTarget(ServerWindow* window) { if (capture_window_ == window) { UnobserveWindow(window); capture_window_ = nullptr; capture_window_client_id_ = kInvalidClientId; mouse_button_down_ = false; // A window only cares to be informed that it lost capture if it explicitly // requested capture. A window can lose capture if another window gains // explicit capture. delegate_->OnCaptureChanged(nullptr, window); delegate_->ReleaseNativeCapture(); UpdateCursorProviderByLastKnownLocation(); return; } for (auto& pair : pointer_targets_) { if (pair.second.window == window) { UnobserveWindow(window); pair.second.window = nullptr; } } } void EventProcessor::ObserveWindow(ServerWindow* window) { auto iter = observed_windows_.find(window); if (iter != observed_windows_.end()) { iter->second->num_observers++; return; } std::unique_ptr observed_window = std::make_unique(); observed_window->num_observers = 1; observed_window->drawn_tracker = std::make_unique(window, this); observed_windows_[window] = std::move(observed_window); } void EventProcessor::UnobserveWindow(ServerWindow* window) { auto it = observed_windows_.find(window); DCHECK(it != observed_windows_.end()); DCHECK_LT(0u, it->second->num_observers); if (--it->second->num_observers == 0u) observed_windows_.erase(it); } Accelerator* EventProcessor::FindAccelerator( const ui::KeyEvent& event, const ui::mojom::AcceleratorPhase phase) { for (const auto& pair : accelerators_) { if (pair.second->MatchesEvent(event, phase)) return pair.second.get(); } return nullptr; } void EventProcessor::CancelImplicitCaptureExcept(ServerWindow* window, ClientSpecificId client_id) { for (const auto& pair : pointer_targets_) { ServerWindow* target = pair.second.window; if (!target) continue; UnobserveWindow(target); if (target == window) continue; // Don't send cancel events to the same client requesting capture, // otherwise the client can easily get confused. if (window && client_id == delegate_->GetEventTargetClientId( target, pair.second.in_nonclient_area)) { continue; } ui::EventType event_type = pair.second.is_mouse_event ? ui::ET_POINTER_EXITED : ui::ET_POINTER_CANCELLED; ui::EventPointerType pointer_type = pair.second.is_mouse_event ? ui::EventPointerType::POINTER_TYPE_MOUSE : ui::EventPointerType::POINTER_TYPE_TOUCH; // TODO(jonross): Track previous location in PointerTarget for sending // cancels. ui::PointerEvent event(event_type, gfx::Point(), gfx::Point(), ui::EF_NONE, 0 /* changed_button_flags */, ui::PointerDetails(pointer_type, pair.first), ui::EventTimeForNow()); DispatchToPointerTarget(pair.second, event, EventLocation(pair.second.display_id)); } pointer_targets_.clear(); } void EventProcessor::WindowNoLongerValidTarget(ServerWindow* window) { CancelPointerEventsToTarget(window); if (mouse_cursor_source_window_ == window) SetMouseCursorSourceWindow(nullptr); } void EventProcessor::OnDrawnStateChanged(ServerWindow* ancestor, ServerWindow* window, bool is_drawn) { if (!is_drawn) WindowNoLongerValidTarget(window); } void EventProcessor::OnRootDidChange(ServerWindow* ancestor, ServerWindow* window) { if (!delegate_->GetRootWindowForEventDispatch(window)) WindowNoLongerValidTarget(window); } void EventProcessor::OnDragCursorUpdated() { delegate_->UpdateNativeCursorFromEventProcessor(); } } // namespace ws } // namespace ui