| // Copyright 2020 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ui/aura/test/ui_controls_ozone.h" |
| |
| #include <tuple> |
| |
| #include "base/functional/callback.h" |
| #include "base/task/single_thread_task_runner.h" |
| #include "build/build_config.h" |
| #include "ui/events/event_utils.h" |
| #include "ui/events/ozone/events_ozone.h" |
| |
| namespace aura { |
| namespace test { |
| |
| // static |
| unsigned UIControlsOzone::button_down_mask_ = 0; |
| |
| UIControlsOzone::UIControlsOzone(WindowTreeHost* host) : host_(host) {} |
| |
| UIControlsOzone::~UIControlsOzone() = default; |
| |
| bool UIControlsOzone::SendKeyEvents(gfx::NativeWindow window, |
| ui::KeyboardCode key, |
| int key_event_types, |
| int accelerator_state) { |
| return SendKeyEventsNotifyWhenDone(window, key, key_event_types, |
| base::OnceClosure(), accelerator_state, |
| ui_controls::KeyEventType::kKeyRelease); |
| } |
| |
| bool UIControlsOzone::SendKeyEventsNotifyWhenDone( |
| gfx::NativeWindow window, |
| ui::KeyboardCode key, |
| int key_event_types, |
| base::OnceClosure closure, |
| int accelerator_state, |
| ui_controls::KeyEventType wait_for) { |
| CHECK(wait_for == ui_controls::KeyEventType::kKeyPress || |
| wait_for == ui_controls::KeyEventType::kKeyRelease); |
| // This doesn't time out if `window` is deleted before the key release events |
| // are dispatched, so it's fine to ignore `wait_for` and always wait for key |
| // release events. |
| WindowTreeHost* optional_host = nullptr; |
| // Send the key event to the window's host, which may not match |host_|. |
| // This logic should probably exist for the non-aura path as well. |
| // TODO(crbug.com/40144825) Support non-aura path. |
| #if defined(USE_AURA) |
| if (window != nullptr && window->GetHost() != nullptr && |
| window->GetHost() != host_) |
| optional_host = window->GetHost(); |
| #endif |
| |
| bool has_press = key_event_types & ui_controls::kKeyPress; |
| bool has_release = key_event_types & ui_controls::kKeyRelease; |
| |
| bool has_control = accelerator_state & ui_controls::kControl; |
| bool has_shift = accelerator_state & ui_controls::kShift; |
| bool has_command = accelerator_state & ui_controls::kCommand; |
| bool has_alt = accelerator_state & ui_controls::kAlt; |
| |
| int flags = button_down_mask_; |
| int64_t display_id = |
| display::Screen::Get()->GetDisplayNearestWindow(window).id(); |
| |
| if (has_press) { |
| if (has_control) { |
| flags |= ui::EF_CONTROL_DOWN; |
| PostKeyEvent(ui::EventType::kKeyPressed, ui::VKEY_CONTROL, flags, |
| display_id, base::OnceClosure(), optional_host); |
| } |
| |
| if (has_shift) { |
| flags |= ui::EF_SHIFT_DOWN; |
| PostKeyEvent(ui::EventType::kKeyPressed, ui::VKEY_SHIFT, flags, |
| display_id, base::OnceClosure(), optional_host); |
| } |
| |
| if (has_alt) { |
| flags |= ui::EF_ALT_DOWN; |
| PostKeyEvent(ui::EventType::kKeyPressed, ui::VKEY_MENU, flags, display_id, |
| base::OnceClosure(), optional_host); |
| } |
| |
| if (has_command) { |
| flags |= ui::EF_COMMAND_DOWN; |
| PostKeyEvent(ui::EventType::kKeyPressed, ui::VKEY_LWIN, flags, display_id, |
| base::OnceClosure(), optional_host); |
| } |
| |
| PostKeyEvent(ui::EventType::kKeyPressed, key, flags, display_id, |
| has_release ? base::OnceClosure() : std::move(closure), |
| optional_host); |
| } |
| |
| if (has_release) { |
| PostKeyEvent(ui::EventType::kKeyReleased, key, flags, display_id, |
| (has_control || has_shift || has_alt || has_command) |
| ? base::OnceClosure() |
| : std::move(closure), |
| optional_host); |
| |
| if (has_alt) { |
| flags &= ~ui::EF_ALT_DOWN; |
| PostKeyEvent( |
| ui::EventType::kKeyReleased, ui::VKEY_MENU, flags, display_id, |
| (has_shift || has_control || has_command) ? base::OnceClosure() |
| : std::move(closure), |
| optional_host); |
| } |
| |
| if (has_shift) { |
| flags &= ~ui::EF_SHIFT_DOWN; |
| PostKeyEvent(ui::EventType::kKeyReleased, ui::VKEY_SHIFT, flags, |
| display_id, |
| (has_control || has_command) ? base::OnceClosure() |
| : std::move(closure), |
| optional_host); |
| } |
| |
| if (has_control) { |
| flags &= ~ui::EF_CONTROL_DOWN; |
| PostKeyEvent(ui::EventType::kKeyReleased, ui::VKEY_CONTROL, flags, |
| display_id, |
| has_command ? base::OnceClosure() : std::move(closure), |
| optional_host); |
| } |
| |
| if (has_command) { |
| flags &= ~ui::EF_COMMAND_DOWN; |
| PostKeyEvent(ui::EventType::kKeyReleased, ui::VKEY_LWIN, flags, |
| display_id, std::move(closure), optional_host); |
| } |
| } |
| |
| return true; |
| } |
| |
| bool UIControlsOzone::SendMouseMove(int screen_x, int screen_y) { |
| return SendMouseMoveNotifyWhenDone(screen_x, screen_y, base::OnceClosure()); |
| } |
| |
| bool UIControlsOzone::SendMouseMoveNotifyWhenDone(int screen_x, |
| int screen_y, |
| base::OnceClosure closure) { |
| gfx::PointF host_location(screen_x, screen_y); |
| int64_t display_id = display::kInvalidDisplayId; |
| if (!ScreenDIPToHostPixels(&host_location, &display_id)) |
| return false; |
| ui::EventType event_type; |
| |
| if (button_down_mask_) |
| event_type = ui::EventType::kMouseDragged; |
| else |
| event_type = ui::EventType::kMouseMoved; |
| |
| PostMouseEvent(event_type, host_location, button_down_mask_, 0, display_id, |
| std::move(closure)); |
| |
| return true; |
| } |
| |
| bool UIControlsOzone::SendMouseEvents(ui_controls::MouseButton type, |
| int button_state, |
| int accelerator_state) { |
| return SendMouseEventsNotifyWhenDone(type, button_state, base::OnceClosure(), |
| accelerator_state); |
| } |
| |
| bool UIControlsOzone::SendMouseEventsNotifyWhenDone( |
| ui_controls::MouseButton type, |
| int button_state, |
| base::OnceClosure closure, |
| int accelerator_state) { |
| gfx::PointF host_location(Env::GetInstance()->last_mouse_location()); |
| int64_t display_id = display::kInvalidDisplayId; |
| if (!ScreenDIPToHostPixels(&host_location, &display_id)) |
| return false; |
| |
| int changed_button_flag = 0; |
| |
| switch (type) { |
| case ui_controls::LEFT: |
| changed_button_flag = ui::EF_LEFT_MOUSE_BUTTON; |
| break; |
| case ui_controls::MIDDLE: |
| changed_button_flag = ui::EF_MIDDLE_MOUSE_BUTTON; |
| break; |
| case ui_controls::RIGHT: |
| changed_button_flag = ui::EF_RIGHT_MOUSE_BUTTON; |
| break; |
| default: |
| NOTREACHED(); |
| } |
| |
| // Process the accelerator key state. |
| int flag = changed_button_flag; |
| if (accelerator_state & ui_controls::kShift) |
| flag |= ui::EF_SHIFT_DOWN; |
| if (accelerator_state & ui_controls::kControl) |
| flag |= ui::EF_CONTROL_DOWN; |
| if (accelerator_state & ui_controls::kAlt) |
| flag |= ui::EF_ALT_DOWN; |
| if (accelerator_state & ui_controls::kCommand) |
| flag |= ui::EF_COMMAND_DOWN; |
| |
| if (button_state & ui_controls::DOWN) { |
| button_down_mask_ |= flag; |
| // Pass the real closure to the last generated MouseEvent. |
| PostMouseEvent(ui::EventType::kMousePressed, host_location, |
| button_down_mask_ | flag, changed_button_flag, display_id, |
| (button_state & ui_controls::UP) ? base::OnceClosure() |
| : std::move(closure)); |
| } |
| if (button_state & ui_controls::UP) { |
| button_down_mask_ &= ~flag; |
| PostMouseEvent(ui::EventType::kMouseReleased, host_location, |
| button_down_mask_ | flag, changed_button_flag, display_id, |
| std::move(closure)); |
| } |
| |
| return true; |
| } |
| |
| bool UIControlsOzone::SendMouseClick(ui_controls::MouseButton type) { |
| return SendMouseEvents(type, ui_controls::UP | ui_controls::DOWN, |
| ui_controls::kNoAccelerator); |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| bool UIControlsOzone::SendTouchEventsNotifyWhenDone(int action, |
| int id, |
| int x, |
| int y, |
| base::OnceClosure task) { |
| DCHECK_NE(0, action); |
| gfx::PointF host_location(x, y); |
| int64_t display_id = display::kInvalidDisplayId; |
| if (!ScreenDIPToHostPixels(&host_location, &display_id)) |
| return false; |
| bool has_move = action & ui_controls::kTouchMove; |
| bool has_release = action & ui_controls::kTouchRelease; |
| if (action & ui_controls::kTouchPress) { |
| PostTouchEvent( |
| ui::EventType::kTouchPressed, host_location, id, display_id, |
| (has_move || has_release) ? base::OnceClosure() : std::move(task)); |
| } |
| if (has_move) { |
| PostTouchEvent(ui::EventType::kTouchMoved, host_location, id, display_id, |
| has_release ? base::OnceClosure() : std::move(task)); |
| } |
| if (has_release) { |
| PostTouchEvent(ui::EventType::kTouchReleased, host_location, id, display_id, |
| std::move(task)); |
| } |
| return true; |
| } |
| #endif |
| |
| void UIControlsOzone::SendEventToSink(ui::Event* event, |
| int64_t display_id, |
| base::OnceClosure closure, |
| WindowTreeHost* optional_host) { |
| // Post the task before processing the event. This is necessary in case |
| // processing the event results in a nested message loop. |
| if (closure) { |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, std::move(closure)); |
| } |
| WindowTreeHost* host = optional_host ? optional_host : host_.get(); |
| ui::EventSourceTestApi event_source_test(host->GetEventSource()); |
| std::ignore = event_source_test.SendEventToSink(event); |
| } |
| |
| void UIControlsOzone::PostKeyEvent(ui::EventType type, |
| ui::KeyboardCode key_code, |
| int flags, |
| int64_t display_id, |
| base::OnceClosure closure, |
| WindowTreeHost* optional_host) { |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, base::BindOnce(&UIControlsOzone::PostKeyEventTask, |
| base::Unretained(this), type, key_code, flags, |
| display_id, std::move(closure), optional_host)); |
| } |
| |
| void UIControlsOzone::PostKeyEventTask(ui::EventType type, |
| ui::KeyboardCode key_code, |
| int flags, |
| int64_t display_id, |
| base::OnceClosure closure, |
| WindowTreeHost* optional_host) { |
| // Do not rewrite injected events. See crbug.com/136465. |
| flags |= ui::EF_FINAL; |
| |
| ui::KeyEvent key_event(type, key_code, flags); |
| if (type == ui::EventType::kKeyPressed) { |
| // Set a property as if this is a key event not consumed by IME. |
| // Ozone/X11+GTK IME works so already. Ozone/wayland IME relies on this |
| // flag to work properly. |
| ui::SetKeyboardImeFlags(&key_event, ui::kPropertyKeyboardImeIgnoredFlag); |
| } |
| SendEventToSink(&key_event, display_id, std::move(closure), optional_host); |
| } |
| |
| void UIControlsOzone::PostMouseEvent(ui::EventType type, |
| const gfx::PointF& host_location, |
| int flags, |
| int changed_button_flags, |
| int64_t display_id, |
| base::OnceClosure closure) { |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, |
| base::BindOnce(&UIControlsOzone::PostMouseEventTask, |
| base::Unretained(this), type, host_location, flags, |
| changed_button_flags, display_id, std::move(closure))); |
| } |
| |
| void UIControlsOzone::PostMouseEventTask(ui::EventType type, |
| const gfx::PointF& host_location, |
| int flags, |
| int changed_button_flags, |
| int64_t display_id, |
| base::OnceClosure closure) { |
| ui::MouseEvent mouse_event(type, host_location, host_location, |
| ui::EventTimeForNow(), flags, |
| changed_button_flags); |
| |
| // This hack is necessary to set the repeat count for clicks. |
| ui::MouseEvent mouse_event2(&mouse_event); |
| |
| SendEventToSink(&mouse_event2, display_id, std::move(closure), nullptr); |
| } |
| |
| void UIControlsOzone::PostTouchEvent(ui::EventType type, |
| const gfx::PointF& host_location, |
| int id, |
| int64_t display_id, |
| base::OnceClosure closure) { |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, base::BindOnce(&UIControlsOzone::PostTouchEventTask, |
| base::Unretained(this), type, host_location, id, |
| display_id, std::move(closure))); |
| } |
| |
| void UIControlsOzone::PostTouchEventTask(ui::EventType type, |
| const gfx::PointF& host_location, |
| int id, |
| int64_t display_id, |
| base::OnceClosure closure) { |
| ui::PointerDetails details(ui::EventPointerType::kTouch, id, 1.0f, 1.0f, |
| 0.0f); |
| ui::TouchEvent touch_event(type, host_location, host_location, |
| ui::EventTimeForNow(), details); |
| SendEventToSink(&touch_event, display_id, std::move(closure)); |
| } |
| |
| bool UIControlsOzone::ScreenDIPToHostPixels(gfx::PointF* location, |
| int64_t* display_id) { |
| // The location needs to be in display's coordinate. |
| display::Display display = display::Screen::Get()->GetDisplayNearestPoint( |
| gfx::ToFlooredPoint(*location)); |
| if (!display.is_valid()) { |
| LOG(ERROR) << "Failed to find the display for " << location->ToString(); |
| return false; |
| } |
| *display_id = display.id(); |
| *location -= display.bounds().OffsetFromOrigin(); |
| location->Scale(display.device_scale_factor()); |
| return true; |
| } |
| |
| ui_controls::UIControlsAura* CreateUIControlsAura(WindowTreeHost* host) { |
| return new UIControlsOzone(host); |
| } |
| |
| } // namespace test |
| } // namespace aura |
