Merge lp:~alan-griffiths/miral/drag-and-drop into lp:miral
- drag-and-drop
- Merge into trunk
Proposed by
Alan Griffiths
| Status: | Merged |
|---|---|
| Approved by: | Brandon Schaefer |
| Approved revision: | 558 |
| Merged at revision: | 549 |
| Proposed branch: | lp:~alan-griffiths/miral/drag-and-drop |
| Merge into: | lp:miral |
| Prerequisite: | lp:~alan-griffiths/miral/1.3 |
| Diff against target: |
1092 lines (+850/-11) 16 files modified
CMakeLists.txt (+2/-2) debian/changelog (+13/-2) debian/libmiral2.symbols (+4/-0) include/miral/window_management_policy_addendum2.h (+61/-0) include/miral/window_manager_tools.h (+12/-0) miral/CMakeLists.txt (+1/-0) miral/basic_window_manager.cpp (+42/-5) miral/basic_window_manager.h (+4/-0) miral/symbols.map (+21/-0) miral/window_management_trace.cpp (+18/-0) miral/window_management_trace.h (+2/-0) miral/window_manager_tools.cpp (+6/-0) miral/window_manager_tools_implementation.h (+3/-0) scripts/process_doxygen_xml.py (+12/-1) test/CMakeLists.txt (+10/-1) test/drag_and_drop.cpp (+639/-0) |
| To merge this branch: | bzr merge lp:~alan-griffiths/miral/drag-and-drop |
| Related bugs: |
| Reviewer | Review Type | Date Requested | Status |
|---|---|---|---|
| Mir CI Bot | continuous-integration | Approve | |
| Brandon Schaefer (community) | Approve | ||
| Albert Astals Cid | Pending | ||
|
Review via email:
|
|||
This proposal supersedes a proposal from 2017-03-21.
Commit message
[libmiral] Support for Drag and Drop messages
Description of the change
To post a comment you must log in.
Revision history for this message
| Albert Astals Cid (aacid) wrote : Posted in a previous version of this proposal | # |
review:
Needs Information
Revision history for this message
| Alan Griffiths (alan-griffiths) wrote : Posted in a previous version of this proposal | # |
> By just reading the documentation i would not know on what to pass as
> std::vector<
> want"?
>
> I guess it is since it's a randomly generated uuid in the example.
>
> But what is this parameter for? I mean as a miral user, you pass it in, but do
> you ever get it back? It seems not, so maybe miral can constrcut the uuid
> itself?
OK, so the documentation needs to state that "the handle will be passed to the client which can then use it to talk to the whatever service is being used to support drag and drop (e.g. on Ubuntu the content hub)".
Revision history for this message
| Albert Astals Cid (aacid) wrote : Posted in a previous version of this proposal | # |
> > By just reading the documentation i would not know on what to pass as
> > std::vector<
> > want"?
> >
> > I guess it is since it's a randomly generated uuid in the example.
> >
> > But what is this parameter for? I mean as a miral user, you pass it in, but
> do
> > you ever get it back? It seems not, so maybe miral can constrcut the uuid
> > itself?
>
> OK, so the documentation needs to state that "the handle will be passed to the
> client which can then use it to talk to the whatever service is being used to
> support drag and drop (e.g. on Ubuntu the content hub)".
That looks good to me :)
Revision history for this message
| Albert Astals Cid (aacid) wrote : Posted in a previous version of this proposal | # |
Looks good to me
review:
Approve
Revision history for this message
| Mir CI Bot (mir-ci-bot) wrote : Posted in a previous version of this proposal | # |
PASSED: Continuous integration, rev:556
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
review:
Approve
(continuous-integration)
Revision history for this message
| Mir CI Bot (mir-ci-bot) wrote : Posted in a previous version of this proposal | # |
PASSED: Continuous integration, rev:556
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
review:
Approve
(continuous-integration)
Revision history for this message
| Mir CI Bot (mir-ci-bot) wrote : | # |
PASSED: Continuous integration, rev:557
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
review:
Approve
(continuous-integration)
- 558. By Alan Griffiths
-
1.3.2 release changelog
Revision history for this message
| Mir CI Bot (mir-ci-bot) wrote : | # |
PASSED: Continuous integration, rev:558
https:/
Executed test runs:
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
SUCCESS: https:/
deb: https:/
Click here to trigger a rebuild:
https:/
review:
Approve
(continuous-integration)
Revision history for this message
| Brandon Schaefer (brandontschaefer) wrote : | # |
lgtm
review:
Approve
Revision history for this message
| Mir CI Bot (mir-ci-bot) : | # |
review:
Approve
(continuous-integration)
Preview Diff
[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
| 1 | === modified file 'CMakeLists.txt' | |||
| 2 | --- CMakeLists.txt 2017-04-05 08:25:21 +0000 | |||
| 3 | +++ CMakeLists.txt 2017-04-05 08:25:21 +0000 | |||
| 4 | @@ -41,8 +41,8 @@ | |||
| 5 | 41 | include_directories(include SYSTEM ${MIRCLIENT_INCLUDE_DIRS}) | 41 | include_directories(include SYSTEM ${MIRCLIENT_INCLUDE_DIRS}) |
| 6 | 42 | 42 | ||
| 7 | 43 | set(MIRAL_VERSION_MAJOR 1) | 43 | set(MIRAL_VERSION_MAJOR 1) |
| 10 | 44 | set(MIRAL_VERSION_MINOR 3) | 44 | set(MIRAL_VERSION_MINOR 4) |
| 11 | 45 | set(MIRAL_VERSION_PATCH 2) | 45 | set(MIRAL_VERSION_PATCH 0) |
| 12 | 46 | 46 | ||
| 13 | 47 | set(MIRAL_VERSION ${MIRAL_VERSION_MAJOR}.${MIRAL_VERSION_MINOR}.${MIRAL_VERSION_PATCH}) | 47 | set(MIRAL_VERSION ${MIRAL_VERSION_MAJOR}.${MIRAL_VERSION_MINOR}.${MIRAL_VERSION_PATCH}) |
| 14 | 48 | 48 | ||
| 15 | 49 | 49 | ||
| 16 | === modified file 'debian/changelog' | |||
| 17 | --- debian/changelog 2017-04-05 08:25:21 +0000 | |||
| 18 | +++ debian/changelog 2017-04-05 08:25:21 +0000 | |||
| 19 | @@ -1,3 +1,14 @@ | |||
| 20 | 1 | miral (1.4.0) UNRELEASED; urgency=medium | ||
| 21 | 2 | |||
| 22 | 3 | * New upstream release 1.4.0 (https://launchpad.net/miral/+milestone/1.4.0) | ||
| 23 | 4 | - ABI summary: | ||
| 24 | 5 | . miral ABI unchanged at 2 | ||
| 25 | 6 | - Enhancements: | ||
| 26 | 7 | . Support for passing messages to enable Drag & Drop | ||
| 27 | 8 | - Bugs fixed: | ||
| 28 | 9 | |||
| 29 | 10 | -- Alan Griffiths <alan@Octopull-X1c3> Tue, 21 Mar 2017 17:57:20 +0000 | ||
| 30 | 11 | |||
| 31 | 1 | miral (1.3.2+17.04.20170330.5-0ubuntu1) zesty; urgency=medium | 12 | miral (1.3.2+17.04.20170330.5-0ubuntu1) zesty; urgency=medium |
| 32 | 2 | 13 | ||
| 33 | 3 | * New upstream release 1.3.2 (https://launchpad.net/miral/+milestone/1.3.2) | 14 | * New upstream release 1.3.2 (https://launchpad.net/miral/+milestone/1.3.2) |
| 34 | @@ -74,11 +85,11 @@ | |||
| 35 | 74 | . Chrome-less shell hint does not work any more (LP: #1658117) | 85 | . Chrome-less shell hint does not work any more (LP: #1658117) |
| 36 | 75 | . WindowSpec::set_state() wrapper for mir_window_spec_set_state() | 86 | . WindowSpec::set_state() wrapper for mir_window_spec_set_state() |
| 37 | 76 | (LP: #1661256) | 87 | (LP: #1661256) |
| 39 | 77 | . "$ miral-app -kiosk" fails with "Unknown command line options: | 88 | . "$ miral-app -kiosk" fails with "Unknown command line options: |
| 40 | 78 | --desktop_file_hint=miral-shell.desktop" (LP: #1660933) | 89 | --desktop_file_hint=miral-shell.desktop" (LP: #1660933) |
| 41 | 79 | . libmiral] Fix focus and movement rules for Input Method and Satellite | 90 | . libmiral] Fix focus and movement rules for Input Method and Satellite |
| 42 | 80 | windows. (LP: #1660691) | 91 | windows. (LP: #1660691) |
| 44 | 81 | 92 | ||
| 45 | 82 | 93 | ||
| 46 | 83 | -- Alan Griffiths <alan.griffiths@canonical.com> Wed, 15 Feb 2017 14:05:46 +0000 | 94 | -- Alan Griffiths <alan.griffiths@canonical.com> Wed, 15 Feb 2017 14:05:46 +0000 |
| 47 | 84 | 95 | ||
| 48 | 85 | 96 | ||
| 49 | === modified file 'debian/libmiral2.symbols' | |||
| 50 | --- debian/libmiral2.symbols 2017-03-15 17:44:36 +0000 | |||
| 51 | +++ debian/libmiral2.symbols 2017-04-05 08:25:21 +0000 | |||
| 52 | @@ -389,3 +389,7 @@ | |||
| 53 | 389 | (c++)"miral::SetWindowManagementPolicy::~SetWindowManagementPolicy()@MIRAL_1.3.1" 1.3.1 | 389 | (c++)"miral::SetWindowManagementPolicy::~SetWindowManagementPolicy()@MIRAL_1.3.1" 1.3.1 |
| 54 | 390 | (c++)"miral::SetWindowManagementPolicy::~SetWindowManagementPolicy()@MIRAL_1.3.1" 1.3.1 | 390 | (c++)"miral::SetWindowManagementPolicy::~SetWindowManagementPolicy()@MIRAL_1.3.1" 1.3.1 |
| 55 | 391 | (c++)"miral::SetWindowManagementPolicy::operator()(mir::Server&) const@MIRAL_1.3.1" 1.3.1 | 391 | (c++)"miral::SetWindowManagementPolicy::operator()(mir::Server&) const@MIRAL_1.3.1" 1.3.1 |
| 56 | 392 | MIRAL_1.4.0@MIRAL_1.4.0 1.4.0 | ||
| 57 | 393 | (c++)"miral::WindowManagerTools::end_drag_and_drop()@MIRAL_1.4.0" 1.4.0 | ||
| 58 | 394 | (c++)"miral::WindowManagerTools::start_drag_and_drop(miral::WindowInfo&, std::vector<unsigned char, std::allocator<unsigned char> > const&)@MIRAL_1.4.0" 1.4.0 | ||
| 59 | 395 | (c++)"typeinfo for miral::WindowManagementPolicyAddendum2@MIRAL_1.4.0" 1.4.0 | ||
| 60 | 392 | 396 | ||
| 61 | === added file 'include/miral/window_management_policy_addendum2.h' | |||
| 62 | --- include/miral/window_management_policy_addendum2.h 1970-01-01 00:00:00 +0000 | |||
| 63 | +++ include/miral/window_management_policy_addendum2.h 2017-04-05 08:25:21 +0000 | |||
| 64 | @@ -0,0 +1,61 @@ | |||
| 65 | 1 | /* | ||
| 66 | 2 | * Copyright © 2017 Canonical Ltd. | ||
| 67 | 3 | * | ||
| 68 | 4 | * This program is free software: you can redistribute it and/or modify it | ||
| 69 | 5 | * under the terms of the GNU General Public License version 3, | ||
| 70 | 6 | * as published by the Free Software Foundation. | ||
| 71 | 7 | * | ||
| 72 | 8 | * This program is distributed in the hope that it will be useful, | ||
| 73 | 9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 74 | 10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 75 | 11 | * GNU General Public License for more details. | ||
| 76 | 12 | * | ||
| 77 | 13 | * You should have received a copy of the GNU General Public License | ||
| 78 | 14 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| 79 | 15 | * | ||
| 80 | 16 | * Authored by: Alan Griffiths <alan@octopull.co.uk> | ||
| 81 | 17 | */ | ||
| 82 | 18 | |||
| 83 | 19 | #ifndef MIRAL_WINDOW_MANAGEMENT_ADDENDUM2_H | ||
| 84 | 20 | #define MIRAL_WINDOW_MANAGEMENT_ADDENDUM2_H | ||
| 85 | 21 | |||
| 86 | 22 | #include <mir/version.h> | ||
| 87 | 23 | |||
| 88 | 24 | namespace miral | ||
| 89 | 25 | { | ||
| 90 | 26 | struct WindowInfo; | ||
| 91 | 27 | |||
| 92 | 28 | /** | ||
| 93 | 29 | * Handle additional client requests. | ||
| 94 | 30 | * | ||
| 95 | 31 | * \note This interface is intended to be implemented by a WindowManagementPolicy | ||
| 96 | 32 | * implementation, we can't add these functions directly to that interface without | ||
| 97 | 33 | * breaking ABI (the vtab could be incompatible). | ||
| 98 | 34 | * When initializing the window manager this interface will be detected by | ||
| 99 | 35 | * dynamic_cast and registered accordingly. | ||
| 100 | 36 | */ | ||
| 101 | 37 | class WindowManagementPolicyAddendum2 | ||
| 102 | 38 | { | ||
| 103 | 39 | public: | ||
| 104 | 40 | /** @name handle requests originating from the client | ||
| 105 | 41 | * The policy is expected to update the model as appropriate | ||
| 106 | 42 | * @{ */ | ||
| 107 | 43 | /** request from client to initiate drag and drop | ||
| 108 | 44 | * \note the request has already been validated against the requesting event | ||
| 109 | 45 | * | ||
| 110 | 46 | * @param window_info the window | ||
| 111 | 47 | */ | ||
| 112 | 48 | virtual void handle_request_drag_and_drop(WindowInfo& window_info) = 0; | ||
| 113 | 49 | /** @} */ | ||
| 114 | 50 | |||
| 115 | 51 | virtual ~WindowManagementPolicyAddendum2() = default; | ||
| 116 | 52 | WindowManagementPolicyAddendum2() = default; | ||
| 117 | 53 | WindowManagementPolicyAddendum2(WindowManagementPolicyAddendum2 const&) = delete; | ||
| 118 | 54 | WindowManagementPolicyAddendum2& operator=(WindowManagementPolicyAddendum2 const&) = delete; | ||
| 119 | 55 | }; | ||
| 120 | 56 | #if MIRAL_VERSION >= MIR_VERSION_NUMBER(2, 0, 0) | ||
| 121 | 57 | #error "We've presumably broken ABI - please roll this interface into WindowManagementPolicy" | ||
| 122 | 58 | #endif | ||
| 123 | 59 | } | ||
| 124 | 60 | |||
| 125 | 61 | #endif //MIRAL_WINDOW_MANAGEMENT_ADDENDUM2_H | ||
| 126 | 0 | 62 | ||
| 127 | === modified file 'include/miral/window_manager_tools.h' | |||
| 128 | --- include/miral/window_manager_tools.h 2017-03-02 14:29:04 +0000 | |||
| 129 | +++ include/miral/window_manager_tools.h 2017-04-05 08:25:21 +0000 | |||
| 130 | @@ -166,6 +166,18 @@ | |||
| 131 | 166 | /// Raise window and all its children | 166 | /// Raise window and all its children |
| 132 | 167 | void raise_tree(Window const& root); | 167 | void raise_tree(Window const& root); |
| 133 | 168 | 168 | ||
| 134 | 169 | /** Start drag and drop. The handle will be passed to the client which can | ||
| 135 | 170 | * then use it to talk to the whatever service is being used to support drag | ||
| 136 | 171 | * and drop (e.g. on Ubuntu the content hub). | ||
| 137 | 172 | * | ||
| 138 | 173 | * @param window_info source window | ||
| 139 | 174 | * @param handle drag handle | ||
| 140 | 175 | */ | ||
| 141 | 176 | void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle); | ||
| 142 | 177 | |||
| 143 | 178 | /// End drag and drop | ||
| 144 | 179 | void end_drag_and_drop(); | ||
| 145 | 180 | |||
| 146 | 169 | /// Apply modifications to a window | 181 | /// Apply modifications to a window |
| 147 | 170 | void modify_window(WindowInfo& window_info, WindowSpecification const& modifications); | 182 | void modify_window(WindowInfo& window_info, WindowSpecification const& modifications); |
| 148 | 171 | 183 | ||
| 149 | 172 | 184 | ||
| 150 | === modified file 'miral/CMakeLists.txt' | |||
| 151 | --- miral/CMakeLists.txt 2017-03-20 12:28:06 +0000 | |||
| 152 | +++ miral/CMakeLists.txt 2017-04-05 08:25:21 +0000 | |||
| 153 | @@ -61,6 +61,7 @@ | |||
| 154 | 61 | ${CMAKE_SOURCE_DIR}/include/mir/client/display_config.h | 61 | ${CMAKE_SOURCE_DIR}/include/mir/client/display_config.h |
| 155 | 62 | ${CMAKE_SOURCE_DIR}/include/mir/client/window.h | 62 | ${CMAKE_SOURCE_DIR}/include/mir/client/window.h |
| 156 | 63 | ${CMAKE_SOURCE_DIR}/include/mir/client/detail/mir_forward_compatibility.h | 63 | ${CMAKE_SOURCE_DIR}/include/mir/client/detail/mir_forward_compatibility.h |
| 157 | 64 | ${CMAKE_SOURCE_DIR}/include/miral/window_management_policy_addendum2.h | ||
| 158 | 64 | ) | 65 | ) |
| 159 | 65 | 66 | ||
| 160 | 66 | target_link_libraries(miral | 67 | target_link_libraries(miral |
| 161 | 67 | 68 | ||
| 162 | === modified file 'miral/basic_window_manager.cpp' | |||
| 163 | --- miral/basic_window_manager.cpp 2017-03-21 12:30:42 +0000 | |||
| 164 | +++ miral/basic_window_manager.cpp 2017-04-05 08:25:21 +0000 | |||
| 165 | @@ -19,6 +19,7 @@ | |||
| 166 | 19 | #include "basic_window_manager.h" | 19 | #include "basic_window_manager.h" |
| 167 | 20 | #include "miral/window_manager_tools.h" | 20 | #include "miral/window_manager_tools.h" |
| 168 | 21 | #include "miral/workspace_policy.h" | 21 | #include "miral/workspace_policy.h" |
| 169 | 22 | #include "miral/window_management_policy_addendum2.h" | ||
| 170 | 22 | 23 | ||
| 171 | 23 | #include <mir/scene/session.h> | 24 | #include <mir/scene/session.h> |
| 172 | 24 | #include <mir/scene/surface.h> | 25 | #include <mir/scene/surface.h> |
| 173 | @@ -70,7 +71,6 @@ | |||
| 174 | 70 | 71 | ||
| 175 | 71 | namespace | 72 | namespace |
| 176 | 72 | { | 73 | { |
| 177 | 73 | |||
| 178 | 74 | auto find_workspace_policy(std::unique_ptr<miral::WindowManagementPolicy> const& policy) -> miral::WorkspacePolicy* | 74 | auto find_workspace_policy(std::unique_ptr<miral::WindowManagementPolicy> const& policy) -> miral::WorkspacePolicy* |
| 179 | 75 | { | 75 | { |
| 180 | 76 | miral::WorkspacePolicy* result = dynamic_cast<miral::WorkspacePolicy*>(policy.get()); | 76 | miral::WorkspacePolicy* result = dynamic_cast<miral::WorkspacePolicy*>(policy.get()); |
| 181 | @@ -82,6 +82,22 @@ | |||
| 182 | 82 | 82 | ||
| 183 | 83 | return &null_workspace_policy; | 83 | return &null_workspace_policy; |
| 184 | 84 | } | 84 | } |
| 185 | 85 | |||
| 186 | 86 | auto find_policy_addendum2(std::unique_ptr<miral::WindowManagementPolicy> const& policy) -> miral::WindowManagementPolicyAddendum2* | ||
| 187 | 87 | { | ||
| 188 | 88 | miral::WindowManagementPolicyAddendum2* result = dynamic_cast<miral::WindowManagementPolicyAddendum2*>(policy.get()); | ||
| 189 | 89 | |||
| 190 | 90 | if (result) | ||
| 191 | 91 | return result; | ||
| 192 | 92 | |||
| 193 | 93 | struct NullWindowManagementPolicyAddendum2 : miral::WindowManagementPolicyAddendum2 | ||
| 194 | 94 | { | ||
| 195 | 95 | void handle_request_drag_and_drop(miral::WindowInfo&) override {} | ||
| 196 | 96 | }; | ||
| 197 | 97 | static NullWindowManagementPolicyAddendum2 null_workspace_policy; | ||
| 198 | 98 | |||
| 199 | 99 | return &null_workspace_policy; | ||
| 200 | 100 | } | ||
| 201 | 85 | } | 101 | } |
| 202 | 86 | 102 | ||
| 203 | 87 | 103 | ||
| 204 | @@ -94,7 +110,8 @@ | |||
| 205 | 94 | display_layout(display_layout), | 110 | display_layout(display_layout), |
| 206 | 95 | persistent_surface_store{persistent_surface_store}, | 111 | persistent_surface_store{persistent_surface_store}, |
| 207 | 96 | policy(build(WindowManagerTools{this})), | 112 | policy(build(WindowManagerTools{this})), |
| 209 | 97 | workspace_policy{find_workspace_policy(policy)} | 113 | workspace_policy{find_workspace_policy(policy)}, |
| 210 | 114 | policy2{find_policy_addendum2(policy)} | ||
| 211 | 98 | { | 115 | { |
| 212 | 99 | } | 116 | } |
| 213 | 100 | 117 | ||
| 214 | @@ -362,10 +379,12 @@ | |||
| 215 | 362 | #if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0) | 379 | #if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0) |
| 216 | 363 | void miral::BasicWindowManager::handle_request_drag_and_drop( | 380 | void miral::BasicWindowManager::handle_request_drag_and_drop( |
| 217 | 364 | std::shared_ptr<mir::scene::Session> const& /*session*/, | 381 | std::shared_ptr<mir::scene::Session> const& /*session*/, |
| 220 | 365 | std::shared_ptr<mir::scene::Surface> const& /*surface*/, | 382 | std::shared_ptr<mir::scene::Surface> const& surface, |
| 221 | 366 | uint64_t /*timestamp*/) | 383 | uint64_t timestamp) |
| 222 | 367 | { | 384 | { |
| 224 | 368 | // TODO | 385 | Locker lock{this}; |
| 225 | 386 | if (timestamp >= last_input_event_timestamp) | ||
| 226 | 387 | policy2->handle_request_drag_and_drop(info_for(surface)); | ||
| 227 | 369 | } | 388 | } |
| 228 | 370 | #endif | 389 | #endif |
| 229 | 371 | 390 | ||
| 230 | @@ -741,6 +760,24 @@ | |||
| 231 | 741 | focus_controller->raise({begin(windows), end(windows)}); | 760 | focus_controller->raise({begin(windows), end(windows)}); |
| 232 | 742 | } | 761 | } |
| 233 | 743 | 762 | ||
| 234 | 763 | void miral::BasicWindowManager::start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) | ||
| 235 | 764 | { | ||
| 236 | 765 | #if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0) | ||
| 237 | 766 | std::shared_ptr<scene::Surface>(window_info.window())->start_drag_and_drop(handle); | ||
| 238 | 767 | focus_controller->set_drag_and_drop_handle(handle); | ||
| 239 | 768 | #else | ||
| 240 | 769 | (void)window_info; | ||
| 241 | 770 | (void)handle; | ||
| 242 | 771 | #endif | ||
| 243 | 772 | } | ||
| 244 | 773 | |||
| 245 | 774 | void miral::BasicWindowManager::end_drag_and_drop() | ||
| 246 | 775 | { | ||
| 247 | 776 | #if MIR_SERVER_VERSION >= MIR_VERSION_NUMBER(0, 27, 0) | ||
| 248 | 777 | focus_controller->clear_drag_and_drop_handle(); | ||
| 249 | 778 | #endif | ||
| 250 | 779 | } | ||
| 251 | 780 | |||
| 252 | 744 | void miral::BasicWindowManager::move_tree(miral::WindowInfo& root, mir::geometry::Displacement movement) | 781 | void miral::BasicWindowManager::move_tree(miral::WindowInfo& root, mir::geometry::Displacement movement) |
| 253 | 745 | { | 782 | { |
| 254 | 746 | if (movement == mir::geometry::Displacement{}) | 783 | if (movement == mir::geometry::Displacement{}) |
| 255 | 747 | 784 | ||
| 256 | === modified file 'miral/basic_window_manager.h' | |||
| 257 | --- miral/basic_window_manager.h 2017-03-21 12:30:42 +0000 | |||
| 258 | +++ miral/basic_window_manager.h 2017-04-05 08:25:21 +0000 | |||
| 259 | @@ -46,6 +46,7 @@ | |||
| 260 | 46 | namespace miral | 46 | namespace miral |
| 261 | 47 | { | 47 | { |
| 262 | 48 | class WorkspacePolicy; | 48 | class WorkspacePolicy; |
| 263 | 49 | class WindowManagementPolicyAddendum2; | ||
| 264 | 49 | using mir::shell::SurfaceSet; | 50 | using mir::shell::SurfaceSet; |
| 265 | 50 | using WindowManagementPolicyBuilder = | 51 | using WindowManagementPolicyBuilder = |
| 266 | 51 | std::function<std::unique_ptr<miral::WindowManagementPolicy>(miral::WindowManagerTools const& tools)>; | 52 | std::function<std::unique_ptr<miral::WindowManagementPolicy>(miral::WindowManagerTools const& tools)>; |
| 267 | @@ -161,6 +162,8 @@ | |||
| 268 | 161 | auto active_display() -> mir::geometry::Rectangle const override; | 162 | auto active_display() -> mir::geometry::Rectangle const override; |
| 269 | 162 | 163 | ||
| 270 | 163 | void raise_tree(Window const& root) override; | 164 | void raise_tree(Window const& root) override; |
| 271 | 165 | void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) override; | ||
| 272 | 166 | void end_drag_and_drop() override; | ||
| 273 | 164 | 167 | ||
| 274 | 165 | void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override; | 168 | void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override; |
| 275 | 166 | 169 | ||
| 276 | @@ -190,6 +193,7 @@ | |||
| 277 | 190 | 193 | ||
| 278 | 191 | std::unique_ptr<WindowManagementPolicy> const policy; | 194 | std::unique_ptr<WindowManagementPolicy> const policy; |
| 279 | 192 | WorkspacePolicy* const workspace_policy; | 195 | WorkspacePolicy* const workspace_policy; |
| 280 | 196 | WindowManagementPolicyAddendum2* const policy2; | ||
| 281 | 193 | 197 | ||
| 282 | 194 | std::mutex mutex; | 198 | std::mutex mutex; |
| 283 | 195 | SessionInfoMap app_info; | 199 | SessionInfoMap app_info; |
| 284 | 196 | 200 | ||
| 285 | === modified file 'miral/symbols.map' | |||
| 286 | --- miral/symbols.map 2017-03-15 17:44:36 +0000 | |||
| 287 | +++ miral/symbols.map 2017-04-05 08:25:21 +0000 | |||
| 288 | @@ -401,3 +401,24 @@ | |||
| 289 | 401 | vtable?for?miral::SetWindowManagementPolicy; | 401 | vtable?for?miral::SetWindowManagementPolicy; |
| 290 | 402 | }; | 402 | }; |
| 291 | 403 | } MIRAL_1.3; | 403 | } MIRAL_1.3; |
| 292 | 404 | |||
| 293 | 405 | MIRAL_1.4.0 { | ||
| 294 | 406 | global: | ||
| 295 | 407 | extern "C++" { | ||
| 296 | 408 | miral::WindowManagementPolicyAddendum2::?WindowManagementPolicyAddendum2*; | ||
| 297 | 409 | miral::WindowManagementPolicyAddendum2::WindowManagementPolicyAddendum2*; | ||
| 298 | 410 | miral::WindowManagementPolicyAddendum2::operator*; | ||
| 299 | 411 | miral::WindowManagerTools::end_drag_and_drop*; | ||
| 300 | 412 | miral::WindowManagerTools::start_drag_and_drop*; | ||
| 301 | 413 | miral::toolkit::Window::Window*; | ||
| 302 | 414 | non-virtual?thunk?to?miral::WindowManagementPolicyAddendum2::?WindowManagementPolicyAddendum2*; | ||
| 303 | 415 | typeinfo?for?miral::WindowManagementPolicyAddendum2; | ||
| 304 | 416 | typeinfo?for?miral::toolkit::Window; | ||
| 305 | 417 | typeinfo?for?miral::toolkit::WindowId; | ||
| 306 | 418 | typeinfo?for?miral::toolkit::WindowSpec; | ||
| 307 | 419 | vtable?for?miral::WindowManagementPolicyAddendum2; | ||
| 308 | 420 | vtable?for?miral::toolkit::Window; | ||
| 309 | 421 | vtable?for?miral::toolkit::WindowId; | ||
| 310 | 422 | vtable?for?miral::toolkit::WindowSpec; | ||
| 311 | 423 | }; | ||
| 312 | 424 | } MIRAL_1.3.1; | ||
| 313 | 404 | 425 | ||
| 314 | === modified file 'miral/window_management_trace.cpp' | |||
| 315 | --- miral/window_management_trace.cpp 2017-03-03 10:06:02 +0000 | |||
| 316 | +++ miral/window_management_trace.cpp 2017-04-05 08:25:21 +0000 | |||
| 317 | @@ -547,6 +547,24 @@ | |||
| 318 | 547 | } | 547 | } |
| 319 | 548 | MIRAL_TRACE_EXCEPTION | 548 | MIRAL_TRACE_EXCEPTION |
| 320 | 549 | 549 | ||
| 321 | 550 | void miral::WindowManagementTrace::start_drag_and_drop(miral::WindowInfo& window_info, std::vector<uint8_t> const& handle) | ||
| 322 | 551 | try { | ||
| 323 | 552 | log_input(); | ||
| 324 | 553 | mir::log_info("%s window_info=%s", __func__, dump_of(window_info).c_str()); | ||
| 325 | 554 | trace_count++; | ||
| 326 | 555 | wrapped.start_drag_and_drop(window_info, handle); | ||
| 327 | 556 | } | ||
| 328 | 557 | MIRAL_TRACE_EXCEPTION | ||
| 329 | 558 | |||
| 330 | 559 | void miral::WindowManagementTrace::end_drag_and_drop() | ||
| 331 | 560 | try { | ||
| 332 | 561 | log_input(); | ||
| 333 | 562 | mir::log_info("%s window_info=%s", __func__); | ||
| 334 | 563 | trace_count++; | ||
| 335 | 564 | wrapped.end_drag_and_drop(); | ||
| 336 | 565 | } | ||
| 337 | 566 | MIRAL_TRACE_EXCEPTION | ||
| 338 | 567 | |||
| 339 | 550 | void miral::WindowManagementTrace::modify_window( | 568 | void miral::WindowManagementTrace::modify_window( |
| 340 | 551 | miral::WindowInfo& window_info, miral::WindowSpecification const& modifications) | 569 | miral::WindowInfo& window_info, miral::WindowSpecification const& modifications) |
| 341 | 552 | try { | 570 | try { |
| 342 | 553 | 571 | ||
| 343 | === modified file 'miral/window_management_trace.h' | |||
| 344 | --- miral/window_management_trace.h 2017-03-02 14:29:04 +0000 | |||
| 345 | +++ miral/window_management_trace.h 2017-04-05 08:25:21 +0000 | |||
| 346 | @@ -69,6 +69,8 @@ | |||
| 347 | 69 | virtual void focus_prev_within_application() override; | 69 | virtual void focus_prev_within_application() override; |
| 348 | 70 | 70 | ||
| 349 | 71 | virtual void raise_tree(Window const& root) override; | 71 | virtual void raise_tree(Window const& root) override; |
| 350 | 72 | virtual void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) override; | ||
| 351 | 73 | virtual void end_drag_and_drop() override; | ||
| 352 | 72 | 74 | ||
| 353 | 73 | virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override; | 75 | virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) override; |
| 354 | 74 | 76 | ||
| 355 | 75 | 77 | ||
| 356 | === modified file 'miral/window_manager_tools.cpp' | |||
| 357 | --- miral/window_manager_tools.cpp 2017-03-02 14:29:04 +0000 | |||
| 358 | +++ miral/window_manager_tools.cpp 2017-04-05 08:25:21 +0000 | |||
| 359 | @@ -83,6 +83,12 @@ | |||
| 360 | 83 | void miral::WindowManagerTools::raise_tree(Window const& root) | 83 | void miral::WindowManagerTools::raise_tree(Window const& root) |
| 361 | 84 | { tools->raise_tree(root); } | 84 | { tools->raise_tree(root); } |
| 362 | 85 | 85 | ||
| 363 | 86 | void miral::WindowManagerTools::start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) | ||
| 364 | 87 | { tools->start_drag_and_drop(window_info, handle); } | ||
| 365 | 88 | |||
| 366 | 89 | void miral::WindowManagerTools::end_drag_and_drop() | ||
| 367 | 90 | { tools->end_drag_and_drop(); } | ||
| 368 | 91 | |||
| 369 | 86 | void miral::WindowManagerTools::modify_window(WindowInfo& window_info, WindowSpecification const& modifications) | 92 | void miral::WindowManagerTools::modify_window(WindowInfo& window_info, WindowSpecification const& modifications) |
| 370 | 87 | { tools->modify_window(window_info,modifications); } | 93 | { tools->modify_window(window_info,modifications); } |
| 371 | 88 | 94 | ||
| 372 | 89 | 95 | ||
| 373 | === modified file 'miral/window_manager_tools_implementation.h' | |||
| 374 | --- miral/window_manager_tools_implementation.h 2017-03-02 14:29:04 +0000 | |||
| 375 | +++ miral/window_manager_tools_implementation.h 2017-04-05 08:25:21 +0000 | |||
| 376 | @@ -26,6 +26,7 @@ | |||
| 377 | 26 | 26 | ||
| 378 | 27 | #include <functional> | 27 | #include <functional> |
| 379 | 28 | #include <memory> | 28 | #include <memory> |
| 380 | 29 | #include <vector> | ||
| 381 | 29 | 30 | ||
| 382 | 30 | namespace mir { namespace scene { class Surface; } } | 31 | namespace mir { namespace scene { class Surface; } } |
| 383 | 31 | 32 | ||
| 384 | @@ -66,6 +67,8 @@ | |||
| 385 | 66 | virtual auto window_at(mir::geometry::Point cursor) const -> Window = 0; | 67 | virtual auto window_at(mir::geometry::Point cursor) const -> Window = 0; |
| 386 | 67 | virtual auto active_display() -> mir::geometry::Rectangle const = 0; | 68 | virtual auto active_display() -> mir::geometry::Rectangle const = 0; |
| 387 | 68 | virtual void raise_tree(Window const& root) = 0; | 69 | virtual void raise_tree(Window const& root) = 0; |
| 388 | 70 | virtual void start_drag_and_drop(WindowInfo& window_info, std::vector<uint8_t> const& handle) = 0; | ||
| 389 | 71 | virtual void end_drag_and_drop() = 0; | ||
| 390 | 69 | virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) = 0; | 72 | virtual void modify_window(WindowInfo& window_info, WindowSpecification const& modifications) = 0; |
| 391 | 70 | virtual auto info_for_window_id(std::string const& id) const -> WindowInfo& = 0; | 73 | virtual auto info_for_window_id(std::string const& id) const -> WindowInfo& = 0; |
| 392 | 71 | virtual auto id_for_window(Window const& window) const -> std::string = 0; | 74 | virtual auto id_for_window(Window const& window) const -> std::string = 0; |
| 393 | 72 | 75 | ||
| 394 | === modified file 'scripts/process_doxygen_xml.py' | |||
| 395 | --- scripts/process_doxygen_xml.py 2017-03-15 17:44:36 +0000 | |||
| 396 | +++ scripts/process_doxygen_xml.py 2017-04-05 08:25:21 +0000 | |||
| 397 | @@ -476,10 +476,21 @@ | |||
| 398 | 476 | 476 | ||
| 399 | 477 | MIRAL_1.3.1 { | 477 | MIRAL_1.3.1 { |
| 400 | 478 | global: | 478 | global: |
| 401 | 479 | extern "C++" { | ||
| 402 | 480 | miral::SetWindowManagementPolicy::?SetWindowManagementPolicy*; | ||
| 403 | 481 | miral::SetWindowManagementPolicy::SetWindowManagementPolicy*; | ||
| 404 | 482 | miral::SetWindowManagementPolicy::operator*; | ||
| 405 | 483 | typeinfo?for?miral::SetWindowManagementPolicy; | ||
| 406 | 484 | vtable?for?miral::SetWindowManagementPolicy; | ||
| 407 | 485 | }; | ||
| 408 | 486 | } MIRAL_1.3; | ||
| 409 | 487 | |||
| 410 | 488 | MIRAL_1.4.0 { | ||
| 411 | 489 | global: | ||
| 412 | 479 | extern "C++" {''' | 490 | extern "C++" {''' |
| 413 | 480 | 491 | ||
| 414 | 481 | END_NEW_STANZA = ''' }; | 492 | END_NEW_STANZA = ''' }; |
| 416 | 482 | } MIRAL_1.3;''' | 493 | } MIRAL_1.3.1;''' |
| 417 | 483 | 494 | ||
| 418 | 484 | def _print_report(): | 495 | def _print_report(): |
| 419 | 485 | print OLD_STANZAS | 496 | print OLD_STANZAS |
| 420 | 486 | 497 | ||
| 421 | === modified file 'test/CMakeLists.txt' | |||
| 422 | --- test/CMakeLists.txt 2017-02-13 16:23:29 +0000 | |||
| 423 | +++ test/CMakeLists.txt 2017-04-05 08:25:21 +0000 | |||
| 424 | @@ -39,6 +39,13 @@ | |||
| 425 | 39 | ${GTEST_INCLUDE_DIR} | 39 | ${GTEST_INCLUDE_DIR} |
| 426 | 40 | ) | 40 | ) |
| 427 | 41 | 41 | ||
| 428 | 42 | # MIRAL_TEST_MODERN_FEATURES lists test sourcefiles that require a recent version of Mir | ||
| 429 | 43 | if (MIRTEST_VERSION VERSION_LESS 0.27) | ||
| 430 | 44 | set(MIRAL_TEST_MODERN_FEATURES) | ||
| 431 | 45 | else() | ||
| 432 | 46 | set(MIRAL_TEST_MODERN_FEATURES drag_and_drop.cpp) | ||
| 433 | 47 | endif() | ||
| 434 | 48 | |||
| 435 | 42 | add_executable(miral-test | 49 | add_executable(miral-test |
| 436 | 43 | mru_window_list.cpp | 50 | mru_window_list.cpp |
| 437 | 44 | active_outputs.cpp | 51 | active_outputs.cpp |
| 438 | @@ -56,7 +63,9 @@ | |||
| 439 | 56 | display_reconfiguration.cpp | 63 | display_reconfiguration.cpp |
| 440 | 57 | active_window.cpp | 64 | active_window.cpp |
| 441 | 58 | raise_tree.cpp | 65 | raise_tree.cpp |
| 443 | 59 | workspaces.cpp) | 66 | workspaces.cpp |
| 444 | 67 | ${MIRAL_TEST_MODERN_FEATURES} | ||
| 445 | 68 | ) | ||
| 446 | 60 | 69 | ||
| 447 | 61 | target_link_libraries(miral-test | 70 | target_link_libraries(miral-test |
| 448 | 62 | ${MIRTEST_LDFLAGS} | 71 | ${MIRTEST_LDFLAGS} |
| 449 | 63 | 72 | ||
| 450 | === added file 'test/drag_and_drop.cpp' | |||
| 451 | --- test/drag_and_drop.cpp 1970-01-01 00:00:00 +0000 | |||
| 452 | +++ test/drag_and_drop.cpp 2017-04-05 08:25:21 +0000 | |||
| 453 | @@ -0,0 +1,639 @@ | |||
| 454 | 1 | /* | ||
| 455 | 2 | * Copyright © 2017 Canonical Ltd. | ||
| 456 | 3 | * | ||
| 457 | 4 | * This program is free software: you can redistribute it and/or modify it | ||
| 458 | 5 | * under the terms of the GNU General Public License version 3, | ||
| 459 | 6 | * as published by the Free Software Foundation. | ||
| 460 | 7 | * | ||
| 461 | 8 | * This program is distributed in the hope that it will be useful, | ||
| 462 | 9 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
| 463 | 10 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
| 464 | 11 | * GNU General Public License for more details. | ||
| 465 | 12 | * | ||
| 466 | 13 | * You should have received a copy of the GNU General Public License | ||
| 467 | 14 | * along with this program. If not, see <http://www.gnu.org/licenses/>. | ||
| 468 | 15 | * | ||
| 469 | 16 | * Authored by: Alan Griffiths <alan@octopull.co.uk> | ||
| 470 | 17 | */ | ||
| 471 | 18 | |||
| 472 | 19 | #include <miral/window_management_policy_addendum2.h> | ||
| 473 | 20 | |||
| 474 | 21 | #include <mir/client/blob.h> | ||
| 475 | 22 | #include <mir/client/cookie.h> | ||
| 476 | 23 | #include <mir/client/window.h> | ||
| 477 | 24 | #include <mir/client/window_spec.h> | ||
| 478 | 25 | #include <mir_toolkit/mir_buffer_stream.h> | ||
| 479 | 26 | #include <mir_toolkit/extensions/drag_and_drop.h> | ||
| 480 | 27 | |||
| 481 | 28 | #include <mir/geometry/displacement.h> | ||
| 482 | 29 | #include <mir/input/input_device_info.h> | ||
| 483 | 30 | #include <mir/input/device_capability.h> | ||
| 484 | 31 | #include <mir/shell/shell.h> | ||
| 485 | 32 | |||
| 486 | 33 | #include "test_server.h" | ||
| 487 | 34 | #include <mir_test_framework/fake_input_device.h> | ||
| 488 | 35 | #include <mir_test_framework/stub_server_platform_factory.h> | ||
| 489 | 36 | #include <mir/test/event_factory.h> | ||
| 490 | 37 | #include <mir/test/signal.h> | ||
| 491 | 38 | |||
| 492 | 39 | #include <gmock/gmock.h> | ||
| 493 | 40 | #include <gtest/gtest.h> | ||
| 494 | 41 | |||
| 495 | 42 | #include <linux/input.h> | ||
| 496 | 43 | #include <uuid/uuid.h> | ||
| 497 | 44 | |||
| 498 | 45 | #include <boost/throw_exception.hpp> | ||
| 499 | 46 | #include <atomic> | ||
| 500 | 47 | |||
| 501 | 48 | using namespace std::chrono_literals; | ||
| 502 | 49 | using namespace mir::client; | ||
| 503 | 50 | using namespace mir::geometry; | ||
| 504 | 51 | using namespace testing; | ||
| 505 | 52 | using mir::test::Signal; | ||
| 506 | 53 | |||
| 507 | 54 | namespace | ||
| 508 | 55 | { | ||
| 509 | 56 | struct MouseMoverAndFaker | ||
| 510 | 57 | { | ||
| 511 | 58 | void start_dragging_mouse() | ||
| 512 | 59 | { | ||
| 513 | 60 | using namespace mir::input::synthesis; | ||
| 514 | 61 | fake_mouse->emit_event(a_button_down_event().of_button(BTN_LEFT)); | ||
| 515 | 62 | } | ||
| 516 | 63 | |||
| 517 | 64 | void move_mouse(Displacement const& displacement) | ||
| 518 | 65 | { | ||
| 519 | 66 | using mir::input::synthesis::a_pointer_event; | ||
| 520 | 67 | fake_mouse->emit_event(a_pointer_event().with_movement(displacement.dx.as_int(), displacement.dy.as_int())); | ||
| 521 | 68 | } | ||
| 522 | 69 | |||
| 523 | 70 | void release_mouse() | ||
| 524 | 71 | { | ||
| 525 | 72 | using namespace mir::input::synthesis; | ||
| 526 | 73 | fake_mouse->emit_event(a_button_up_event().of_button(BTN_LEFT)); | ||
| 527 | 74 | } | ||
| 528 | 75 | |||
| 529 | 76 | private: | ||
| 530 | 77 | std::unique_ptr<mir_test_framework::FakeInputDevice> fake_mouse{ | ||
| 531 | 78 | mir_test_framework::add_fake_input_device( | ||
| 532 | 79 | mir::input::InputDeviceInfo{"mouse", "mouse-uid", mir::input::DeviceCapability::pointer})}; | ||
| 533 | 80 | }; | ||
| 534 | 81 | |||
| 535 | 82 | Rectangle const screen_geometry{{0,0}, {800,600}}; | ||
| 536 | 83 | auto const receive_event_timeout = 1s; //90s; | ||
| 537 | 84 | |||
| 538 | 85 | struct ConnectedClientWithAWindow : miral::TestServer | ||
| 539 | 86 | { | ||
| 540 | 87 | Connection connection; | ||
| 541 | 88 | Window window; | ||
| 542 | 89 | |||
| 543 | 90 | void SetUp() override | ||
| 544 | 91 | { | ||
| 545 | 92 | miral::TestServer::SetUp(); | ||
| 546 | 93 | connection = connect_client(__func__); | ||
| 547 | 94 | window = WindowSpec::for_normal_window(connection, surface_size.width.as_int(), surface_size.height.as_int()) | ||
| 548 | 95 | .set_pixel_format(mir_pixel_format_abgr_8888) | ||
| 549 | 96 | .set_name("ConnectedClientWithAWindow") | ||
| 550 | 97 | .set_buffer_usage(mir_buffer_usage_hardware) | ||
| 551 | 98 | .create_window(); | ||
| 552 | 99 | } | ||
| 553 | 100 | |||
| 554 | 101 | void TearDown() override | ||
| 555 | 102 | { | ||
| 556 | 103 | window.reset(); | ||
| 557 | 104 | connection.reset(); | ||
| 558 | 105 | miral::TestServer::TearDown(); | ||
| 559 | 106 | } | ||
| 560 | 107 | |||
| 561 | 108 | mir::geometry::Size const surface_size {640, 480}; | ||
| 562 | 109 | }; | ||
| 563 | 110 | |||
| 564 | 111 | struct DragAndDrop : ConnectedClientWithAWindow, | ||
| 565 | 112 | MouseMoverAndFaker | ||
| 566 | 113 | { | ||
| 567 | 114 | MirDragAndDropV1 const* dnd = nullptr; | ||
| 568 | 115 | |||
| 569 | 116 | void SetUp() override | ||
| 570 | 117 | { | ||
| 571 | 118 | mir_test_framework::set_next_display_rects(std::unique_ptr<std::vector<Rectangle>>(new std::vector<Rectangle>({screen_geometry}))); | ||
| 572 | 119 | |||
| 573 | 120 | ConnectedClientWithAWindow::SetUp(); | ||
| 574 | 121 | dnd = mir_drag_and_drop_v1(connection); | ||
| 575 | 122 | mir_window_set_event_handler(window, &window_event_handler, this); | ||
| 576 | 123 | if (dnd) dnd->set_start_drag_and_drop_callback(window, &window_dnd_start_handler, this); | ||
| 577 | 124 | |||
| 578 | 125 | create_target_window(); | ||
| 579 | 126 | |||
| 580 | 127 | paint_window(window); | ||
| 581 | 128 | |||
| 582 | 129 | center_mouse(); | ||
| 583 | 130 | } | ||
| 584 | 131 | |||
| 585 | 132 | void TearDown() override | ||
| 586 | 133 | { | ||
| 587 | 134 | reset_window_event_handler(target_window); | ||
| 588 | 135 | reset_window_event_handler(window); | ||
| 589 | 136 | target_window.reset(); | ||
| 590 | 137 | another_connection.reset(); | ||
| 591 | 138 | ConnectedClientWithAWindow::TearDown(); | ||
| 592 | 139 | } | ||
| 593 | 140 | |||
| 594 | 141 | auto user_initiates_drag() -> Cookie; | ||
| 595 | 142 | auto client_requests_drag(Cookie const& cookie) -> Blob; | ||
| 596 | 143 | auto handle_from_mouse_move() -> Blob; | ||
| 597 | 144 | auto handle_from_mouse_leave() -> Blob; | ||
| 598 | 145 | auto handle_from_mouse_enter() -> Blob; | ||
| 599 | 146 | auto handle_from_mouse_release() -> Blob; | ||
| 600 | 147 | auto count_of_handles_when_moving_mouse() -> int; | ||
| 601 | 148 | |||
| 602 | 149 | private: | ||
| 603 | 150 | auto build_window_manager_policy(miral::WindowManagerTools const& tools) -> std::unique_ptr<TestWindowManagerPolicy> override; | ||
| 604 | 151 | void center_mouse(); | ||
| 605 | 152 | void paint_window(MirWindow* w); | ||
| 606 | 153 | void set_window_event_handler(MirWindow* window, std::function<void(MirEvent const* event)> const& handler); | ||
| 607 | 154 | void set_window_dnd_start_handler(MirWindow* window, std::function<void(MirDragAndDropEvent const*)> const& handler); | ||
| 608 | 155 | void reset_window_event_handler(MirWindow* window); | ||
| 609 | 156 | |||
| 610 | 157 | void create_target_window() | ||
| 611 | 158 | { | ||
| 612 | 159 | another_connection = connect_client("another_connection"); | ||
| 613 | 160 | target_window = WindowSpec:: | ||
| 614 | 161 | for_normal_window(connection, screen_geometry.size.width.as_int(), screen_geometry.size.height.as_int()) | ||
| 615 | 162 | .set_pixel_format(mir_pixel_format_abgr_8888) | ||
| 616 | 163 | .set_name("target_window") | ||
| 617 | 164 | .set_buffer_usage(mir_buffer_usage_hardware) | ||
| 618 | 165 | .set_event_handler(&window_event_handler, this) | ||
| 619 | 166 | .create_window(); | ||
| 620 | 167 | |||
| 621 | 168 | paint_window(target_window); | ||
| 622 | 169 | } | ||
| 623 | 170 | |||
| 624 | 171 | void invoke_window_event_handler(MirWindow* window, MirEvent const* event) | ||
| 625 | 172 | { | ||
| 626 | 173 | std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex}; | ||
| 627 | 174 | if (window == this->window) window_event_handler_(event); | ||
| 628 | 175 | if (window == target_window) target_window_event_handler_(event); | ||
| 629 | 176 | } | ||
| 630 | 177 | |||
| 631 | 178 | void invoke_window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event) | ||
| 632 | 179 | { | ||
| 633 | 180 | std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex}; | ||
| 634 | 181 | if (window == this->window) window_dnd_start_(event); | ||
| 635 | 182 | } | ||
| 636 | 183 | |||
| 637 | 184 | std::mutex window_event_handler_mutex; | ||
| 638 | 185 | std::function<void(MirDragAndDropEvent const* event)> window_dnd_start_ = [](MirDragAndDropEvent const*) {}; | ||
| 639 | 186 | std::function<void(MirEvent const* event)> window_event_handler_ = [](MirEvent const*) {}; | ||
| 640 | 187 | std::function<void(MirEvent const* event)> target_window_event_handler_ = [](MirEvent const*) {}; | ||
| 641 | 188 | |||
| 642 | 189 | static void window_event_handler(MirWindow* window, MirEvent const* event, void* context); | ||
| 643 | 190 | static void window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event, void* context); | ||
| 644 | 191 | |||
| 645 | 192 | Connection another_connection; | ||
| 646 | 193 | Window target_window; | ||
| 647 | 194 | }; | ||
| 648 | 195 | |||
| 649 | 196 | void DragAndDrop::set_window_event_handler(MirWindow* window, std::function<void(MirEvent const* event)> const& handler) | ||
| 650 | 197 | { | ||
| 651 | 198 | std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex}; | ||
| 652 | 199 | if (window == this->window) window_event_handler_ = handler; | ||
| 653 | 200 | if (window == target_window) target_window_event_handler_ = handler; | ||
| 654 | 201 | } | ||
| 655 | 202 | |||
| 656 | 203 | void DragAndDrop::set_window_dnd_start_handler(MirWindow* window, std::function<void(MirDragAndDropEvent const*)> const& handler) | ||
| 657 | 204 | { | ||
| 658 | 205 | std::lock_guard<decltype(window_event_handler_mutex)> lock{window_event_handler_mutex}; | ||
| 659 | 206 | if (window == this->window) window_dnd_start_ = handler; | ||
| 660 | 207 | } | ||
| 661 | 208 | |||
| 662 | 209 | |||
| 663 | 210 | void DragAndDrop::reset_window_event_handler(MirWindow* window) | ||
| 664 | 211 | { | ||
| 665 | 212 | if (window == this->window) window_event_handler_ = [](MirEvent const*) {}; | ||
| 666 | 213 | if (window == target_window) target_window_event_handler_ = [](MirEvent const*) {}; | ||
| 667 | 214 | } | ||
| 668 | 215 | |||
| 669 | 216 | void DragAndDrop::paint_window(MirWindow* w) | ||
| 670 | 217 | { | ||
| 671 | 218 | Signal have_focus; | ||
| 672 | 219 | |||
| 673 | 220 | set_window_event_handler(w, [&](MirEvent const* event) | ||
| 674 | 221 | { | ||
| 675 | 222 | if (mir_event_get_type(event) != mir_event_type_window) | ||
| 676 | 223 | return; | ||
| 677 | 224 | |||
| 678 | 225 | auto const window_event = mir_event_get_window_event(event); | ||
| 679 | 226 | if (mir_window_event_get_attribute(window_event) != mir_window_attrib_focus) | ||
| 680 | 227 | return; | ||
| 681 | 228 | |||
| 682 | 229 | if (mir_window_event_get_attribute_value(window_event)) | ||
| 683 | 230 | have_focus.raise(); | ||
| 684 | 231 | }); | ||
| 685 | 232 | |||
| 686 | 233 | mir_buffer_stream_swap_buffers_sync(mir_window_get_buffer_stream(w)); | ||
| 687 | 234 | |||
| 688 | 235 | EXPECT_THAT(have_focus.wait_for(receive_event_timeout), Eq(true)); | ||
| 689 | 236 | |||
| 690 | 237 | reset_window_event_handler(w); | ||
| 691 | 238 | } | ||
| 692 | 239 | |||
| 693 | 240 | void DragAndDrop::center_mouse() | ||
| 694 | 241 | { | ||
| 695 | 242 | Signal have_mouseover; | ||
| 696 | 243 | |||
| 697 | 244 | set_window_event_handler(window, [&](MirEvent const* event) | ||
| 698 | 245 | { | ||
| 699 | 246 | if (mir_event_get_type(event) != mir_event_type_input) | ||
| 700 | 247 | return; | ||
| 701 | 248 | |||
| 702 | 249 | auto const input_event = mir_event_get_input_event(event); | ||
| 703 | 250 | |||
| 704 | 251 | if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer) | ||
| 705 | 252 | return; | ||
| 706 | 253 | |||
| 707 | 254 | auto const pointer_event = mir_input_event_get_pointer_event(input_event); | ||
| 708 | 255 | |||
| 709 | 256 | if (mir_pointer_event_action(pointer_event) != mir_pointer_action_enter) | ||
| 710 | 257 | return; | ||
| 711 | 258 | |||
| 712 | 259 | have_mouseover.raise(); | ||
| 713 | 260 | }); | ||
| 714 | 261 | |||
| 715 | 262 | move_mouse(0.5 * as_displacement(screen_geometry.size)); | ||
| 716 | 263 | |||
| 717 | 264 | // We miss the "mouseover" occasionally (with valgrind and heavy stress about 1/20). | ||
| 718 | 265 | // But it isn't essential for the test and we've probably waited long enough | ||
| 719 | 266 | // for the mouse-down needed by the test to reach the window. | ||
| 720 | 267 | // EXPECT_THAT(have_mouseover.wait_for(receive_event_timeout), Eq(true)); | ||
| 721 | 268 | have_mouseover.wait_for(receive_event_timeout); | ||
| 722 | 269 | |||
| 723 | 270 | reset_window_event_handler(window); | ||
| 724 | 271 | } | ||
| 725 | 272 | |||
| 726 | 273 | void DragAndDrop::window_event_handler(MirWindow* window, MirEvent const* event, void* context) | ||
| 727 | 274 | { | ||
| 728 | 275 | static_cast<DragAndDrop*>(context)->invoke_window_event_handler(window, event); | ||
| 729 | 276 | } | ||
| 730 | 277 | |||
| 731 | 278 | void DragAndDrop::window_dnd_start_handler(MirWindow* window, MirDragAndDropEvent const* event, void* context) | ||
| 732 | 279 | { | ||
| 733 | 280 | static_cast<DragAndDrop*>(context)->invoke_window_dnd_start_handler(window, event); | ||
| 734 | 281 | } | ||
| 735 | 282 | |||
| 736 | 283 | |||
| 737 | 284 | auto DragAndDrop::user_initiates_drag() -> Cookie | ||
| 738 | 285 | { | ||
| 739 | 286 | Cookie cookie; | ||
| 740 | 287 | Signal have_cookie; | ||
| 741 | 288 | |||
| 742 | 289 | set_window_event_handler(window, [&](MirEvent const* event) | ||
| 743 | 290 | { | ||
| 744 | 291 | if (mir_event_get_type(event) != mir_event_type_input) | ||
| 745 | 292 | return; | ||
| 746 | 293 | |||
| 747 | 294 | auto const input_event = mir_event_get_input_event(event); | ||
| 748 | 295 | |||
| 749 | 296 | if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer) | ||
| 750 | 297 | return; | ||
| 751 | 298 | |||
| 752 | 299 | auto const pointer_event = mir_input_event_get_pointer_event(input_event); | ||
| 753 | 300 | |||
| 754 | 301 | if (mir_pointer_event_action(pointer_event) != mir_pointer_action_button_down) | ||
| 755 | 302 | return; | ||
| 756 | 303 | |||
| 757 | 304 | cookie = Cookie{mir_input_event_get_cookie(input_event)}; | ||
| 758 | 305 | have_cookie.raise(); | ||
| 759 | 306 | }); | ||
| 760 | 307 | |||
| 761 | 308 | start_dragging_mouse(); | ||
| 762 | 309 | |||
| 763 | 310 | EXPECT_THAT(have_cookie.wait_for(receive_event_timeout), Eq(true)); | ||
| 764 | 311 | |||
| 765 | 312 | reset_window_event_handler(window); | ||
| 766 | 313 | return cookie; | ||
| 767 | 314 | } | ||
| 768 | 315 | |||
| 769 | 316 | auto DragAndDrop::client_requests_drag(Cookie const& cookie) -> Blob | ||
| 770 | 317 | { | ||
| 771 | 318 | Blob blob; | ||
| 772 | 319 | Signal initiated; | ||
| 773 | 320 | |||
| 774 | 321 | set_window_dnd_start_handler(window, [&](MirDragAndDropEvent const* event) | ||
| 775 | 322 | { | ||
| 776 | 323 | if (dnd) | ||
| 777 | 324 | blob.reset(dnd->start_drag_and_drop(event)); | ||
| 778 | 325 | |||
| 779 | 326 | if (blob) | ||
| 780 | 327 | initiated.raise(); | ||
| 781 | 328 | }); | ||
| 782 | 329 | |||
| 783 | 330 | EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension"; | ||
| 784 | 331 | |||
| 785 | 332 | if (dnd) | ||
| 786 | 333 | dnd->request_drag_and_drop(window, cookie); | ||
| 787 | 334 | |||
| 788 | 335 | EXPECT_TRUE(initiated.wait_for(receive_event_timeout)); | ||
| 789 | 336 | |||
| 790 | 337 | reset_window_event_handler(window); | ||
| 791 | 338 | return blob; | ||
| 792 | 339 | } | ||
| 793 | 340 | |||
| 794 | 341 | auto DragAndDrop::handle_from_mouse_move() -> Blob | ||
| 795 | 342 | { | ||
| 796 | 343 | Blob blob; | ||
| 797 | 344 | Signal have_blob; | ||
| 798 | 345 | |||
| 799 | 346 | set_window_event_handler(window, [&](MirEvent const* event) | ||
| 800 | 347 | { | ||
| 801 | 348 | if (mir_event_get_type(event) != mir_event_type_input) | ||
| 802 | 349 | return; | ||
| 803 | 350 | |||
| 804 | 351 | auto const input_event = mir_event_get_input_event(event); | ||
| 805 | 352 | |||
| 806 | 353 | if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer) | ||
| 807 | 354 | return; | ||
| 808 | 355 | |||
| 809 | 356 | auto const pointer_event = mir_input_event_get_pointer_event(input_event); | ||
| 810 | 357 | |||
| 811 | 358 | EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension"; | ||
| 812 | 359 | |||
| 813 | 360 | if (dnd) | ||
| 814 | 361 | blob.reset(dnd->pointer_drag_and_drop(pointer_event)); | ||
| 815 | 362 | |||
| 816 | 363 | if (blob) | ||
| 817 | 364 | have_blob.raise(); | ||
| 818 | 365 | }); | ||
| 819 | 366 | |||
| 820 | 367 | move_mouse({1,1}); | ||
| 821 | 368 | |||
| 822 | 369 | EXPECT_TRUE(have_blob.wait_for(receive_event_timeout)); | ||
| 823 | 370 | |||
| 824 | 371 | reset_window_event_handler(window); | ||
| 825 | 372 | return blob; | ||
| 826 | 373 | } | ||
| 827 | 374 | |||
| 828 | 375 | auto DragAndDrop::handle_from_mouse_leave() -> Blob | ||
| 829 | 376 | { | ||
| 830 | 377 | Blob blob; | ||
| 831 | 378 | Signal have_blob; | ||
| 832 | 379 | |||
| 833 | 380 | set_window_event_handler(window, [&](MirEvent const* event) | ||
| 834 | 381 | { | ||
| 835 | 382 | if (mir_event_get_type(event) != mir_event_type_input) | ||
| 836 | 383 | return; | ||
| 837 | 384 | |||
| 838 | 385 | auto const input_event = mir_event_get_input_event(event); | ||
| 839 | 386 | |||
| 840 | 387 | if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer) | ||
| 841 | 388 | return; | ||
| 842 | 389 | |||
| 843 | 390 | auto const pointer_event = mir_input_event_get_pointer_event(input_event); | ||
| 844 | 391 | |||
| 845 | 392 | if (mir_pointer_event_action(pointer_event) != mir_pointer_action_leave) | ||
| 846 | 393 | return; | ||
| 847 | 394 | |||
| 848 | 395 | EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension"; | ||
| 849 | 396 | |||
| 850 | 397 | if (dnd) | ||
| 851 | 398 | blob.reset(dnd->pointer_drag_and_drop(pointer_event)); | ||
| 852 | 399 | |||
| 853 | 400 | if (blob) | ||
| 854 | 401 | have_blob.raise(); | ||
| 855 | 402 | }); | ||
| 856 | 403 | |||
| 857 | 404 | move_mouse({1,1}); | ||
| 858 | 405 | move_mouse(0.5 * as_displacement(surface_size)); | ||
| 859 | 406 | |||
| 860 | 407 | EXPECT_TRUE(have_blob.wait_for(receive_event_timeout)); | ||
| 861 | 408 | |||
| 862 | 409 | reset_window_event_handler(window); | ||
| 863 | 410 | return blob; | ||
| 864 | 411 | } | ||
| 865 | 412 | |||
| 866 | 413 | auto DragAndDrop::handle_from_mouse_enter() -> Blob | ||
| 867 | 414 | { | ||
| 868 | 415 | Blob blob; | ||
| 869 | 416 | Signal have_blob; | ||
| 870 | 417 | |||
| 871 | 418 | set_window_event_handler(target_window, [&](MirEvent const* event) | ||
| 872 | 419 | { | ||
| 873 | 420 | if (mir_event_get_type(event) != mir_event_type_input) | ||
| 874 | 421 | return; | ||
| 875 | 422 | |||
| 876 | 423 | auto const input_event = mir_event_get_input_event(event); | ||
| 877 | 424 | |||
| 878 | 425 | if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer) | ||
| 879 | 426 | return; | ||
| 880 | 427 | |||
| 881 | 428 | auto const pointer_event = mir_input_event_get_pointer_event(input_event); | ||
| 882 | 429 | |||
| 883 | 430 | if (mir_pointer_event_action(pointer_event) != mir_pointer_action_enter) | ||
| 884 | 431 | return; | ||
| 885 | 432 | |||
| 886 | 433 | EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension"; | ||
| 887 | 434 | |||
| 888 | 435 | if (dnd) | ||
| 889 | 436 | blob.reset(dnd->pointer_drag_and_drop(pointer_event)); | ||
| 890 | 437 | |||
| 891 | 438 | if (blob) | ||
| 892 | 439 | have_blob.raise(); | ||
| 893 | 440 | }); | ||
| 894 | 441 | |||
| 895 | 442 | move_mouse({1,1}); | ||
| 896 | 443 | move_mouse(0.5 * as_displacement(surface_size)); | ||
| 897 | 444 | |||
| 898 | 445 | EXPECT_TRUE(have_blob.wait_for(receive_event_timeout)); | ||
| 899 | 446 | |||
| 900 | 447 | reset_window_event_handler(target_window); | ||
| 901 | 448 | return blob; | ||
| 902 | 449 | } | ||
| 903 | 450 | |||
| 904 | 451 | auto DragAndDrop::handle_from_mouse_release() -> Blob | ||
| 905 | 452 | { | ||
| 906 | 453 | Blob blob; | ||
| 907 | 454 | Signal have_blob; | ||
| 908 | 455 | |||
| 909 | 456 | set_window_event_handler(target_window, [&](MirEvent const* event) | ||
| 910 | 457 | { | ||
| 911 | 458 | if (mir_event_get_type(event) != mir_event_type_input) | ||
| 912 | 459 | return; | ||
| 913 | 460 | |||
| 914 | 461 | auto const input_event = mir_event_get_input_event(event); | ||
| 915 | 462 | |||
| 916 | 463 | if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer) | ||
| 917 | 464 | return; | ||
| 918 | 465 | |||
| 919 | 466 | auto const pointer_event = mir_input_event_get_pointer_event(input_event); | ||
| 920 | 467 | |||
| 921 | 468 | if (mir_pointer_event_action(pointer_event) != mir_pointer_action_button_up) | ||
| 922 | 469 | return; | ||
| 923 | 470 | |||
| 924 | 471 | EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension"; | ||
| 925 | 472 | |||
| 926 | 473 | if (dnd) | ||
| 927 | 474 | blob.reset(dnd->pointer_drag_and_drop(pointer_event)); | ||
| 928 | 475 | |||
| 929 | 476 | if (blob) | ||
| 930 | 477 | have_blob.raise(); | ||
| 931 | 478 | }); | ||
| 932 | 479 | |||
| 933 | 480 | move_mouse({1,1}); | ||
| 934 | 481 | move_mouse(0.5 * as_displacement(surface_size)); | ||
| 935 | 482 | release_mouse(); | ||
| 936 | 483 | |||
| 937 | 484 | EXPECT_TRUE(have_blob.wait_for(receive_event_timeout)); | ||
| 938 | 485 | |||
| 939 | 486 | reset_window_event_handler(target_window); | ||
| 940 | 487 | return blob; | ||
| 941 | 488 | } | ||
| 942 | 489 | |||
| 943 | 490 | auto DragAndDrop::count_of_handles_when_moving_mouse() -> int | ||
| 944 | 491 | { | ||
| 945 | 492 | Signal have_3_events; | ||
| 946 | 493 | std::atomic<int> events{0}; | ||
| 947 | 494 | std::atomic<int> handles{0}; | ||
| 948 | 495 | |||
| 949 | 496 | auto counter = [&](MirEvent const* event) | ||
| 950 | 497 | { | ||
| 951 | 498 | if (mir_event_get_type(event) != mir_event_type_input) | ||
| 952 | 499 | return; | ||
| 953 | 500 | |||
| 954 | 501 | auto const input_event = mir_event_get_input_event(event); | ||
| 955 | 502 | |||
| 956 | 503 | if (mir_input_event_get_type(input_event) != mir_input_event_type_pointer) | ||
| 957 | 504 | return; | ||
| 958 | 505 | |||
| 959 | 506 | auto const pointer_event = mir_input_event_get_pointer_event(input_event); | ||
| 960 | 507 | |||
| 961 | 508 | EXPECT_THAT(dnd, Ne(nullptr)) << "No Drag and Drop extension"; | ||
| 962 | 509 | |||
| 963 | 510 | Blob blob; | ||
| 964 | 511 | if (dnd) | ||
| 965 | 512 | blob.reset(dnd->pointer_drag_and_drop(pointer_event)); | ||
| 966 | 513 | |||
| 967 | 514 | if (blob) | ||
| 968 | 515 | handles.fetch_add(1); | ||
| 969 | 516 | |||
| 970 | 517 | if (events.fetch_add(1) == 2) | ||
| 971 | 518 | have_3_events.raise(); | ||
| 972 | 519 | }; | ||
| 973 | 520 | |||
| 974 | 521 | set_window_event_handler(window, counter); | ||
| 975 | 522 | set_window_event_handler(target_window, counter); | ||
| 976 | 523 | |||
| 977 | 524 | start_dragging_mouse(); | ||
| 978 | 525 | move_mouse({1,1}); | ||
| 979 | 526 | release_mouse(); | ||
| 980 | 527 | |||
| 981 | 528 | EXPECT_TRUE(have_3_events.wait_for(receive_event_timeout)); | ||
| 982 | 529 | |||
| 983 | 530 | reset_window_event_handler(window); | ||
| 984 | 531 | reset_window_event_handler(target_window); | ||
| 985 | 532 | return handles; | ||
| 986 | 533 | } | ||
| 987 | 534 | |||
| 988 | 535 | auto DragAndDrop::build_window_manager_policy(miral::WindowManagerTools const& tools) -> std::unique_ptr<TestWindowManagerPolicy> | ||
| 989 | 536 | { | ||
| 990 | 537 | struct DnDWindowManagerPolicy : miral::TestServer::TestWindowManagerPolicy, miral::WindowManagementPolicyAddendum2 | ||
| 991 | 538 | { | ||
| 992 | 539 | using miral::TestServer::TestWindowManagerPolicy::TestWindowManagerPolicy; | ||
| 993 | 540 | |||
| 994 | 541 | void handle_request_drag_and_drop(miral::WindowInfo& window_info) override | ||
| 995 | 542 | { | ||
| 996 | 543 | uuid_t uuid; | ||
| 997 | 544 | uuid_generate(uuid); | ||
| 998 | 545 | std::vector<uint8_t> const handle{std::begin(uuid), std::end(uuid)}; | ||
| 999 | 546 | |||
| 1000 | 547 | tools.start_drag_and_drop(window_info, handle); | ||
| 1001 | 548 | } | ||
| 1002 | 549 | }; | ||
| 1003 | 550 | |||
| 1004 | 551 | return std::make_unique<DnDWindowManagerPolicy>(tools, *this); | ||
| 1005 | 552 | } | ||
| 1006 | 553 | |||
| 1007 | 554 | MATCHER_P(BlobContentEq, p, "") | ||
| 1008 | 555 | { | ||
| 1009 | 556 | if (!arg || !p) | ||
| 1010 | 557 | return false; | ||
| 1011 | 558 | if (mir_blob_size(arg) != mir_blob_size(p)) | ||
| 1012 | 559 | return false; | ||
| 1013 | 560 | return !memcmp(mir_blob_data(arg), mir_blob_data(p), mir_blob_size(p)); | ||
| 1014 | 561 | } | ||
| 1015 | 562 | } | ||
| 1016 | 563 | |||
| 1017 | 564 | TEST_F(DragAndDrop, when_user_initiates_drag_client_receives_cookie) | ||
| 1018 | 565 | { | ||
| 1019 | 566 | auto const cookie = user_initiates_drag(); | ||
| 1020 | 567 | |||
| 1021 | 568 | EXPECT_THAT(cookie, NotNull()); | ||
| 1022 | 569 | } | ||
| 1023 | 570 | |||
| 1024 | 571 | TEST_F(DragAndDrop, when_client_requests_drags_it_receives_handle) | ||
| 1025 | 572 | { | ||
| 1026 | 573 | auto const cookie = user_initiates_drag(); | ||
| 1027 | 574 | ASSERT_THAT(cookie, NotNull()); | ||
| 1028 | 575 | |||
| 1029 | 576 | auto const handle = client_requests_drag(cookie); | ||
| 1030 | 577 | |||
| 1031 | 578 | EXPECT_THAT(handle, NotNull()); | ||
| 1032 | 579 | } | ||
| 1033 | 580 | |||
| 1034 | 581 | TEST_F(DragAndDrop, during_drag_when_user_moves_mouse_client_receives_handle) | ||
| 1035 | 582 | { | ||
| 1036 | 583 | auto const cookie = user_initiates_drag(); | ||
| 1037 | 584 | ASSERT_THAT(cookie, NotNull()); | ||
| 1038 | 585 | auto const handle_from_request = client_requests_drag(cookie); | ||
| 1039 | 586 | |||
| 1040 | 587 | auto const handle = handle_from_mouse_move(); | ||
| 1041 | 588 | |||
| 1042 | 589 | EXPECT_THAT(handle, NotNull()); | ||
| 1043 | 590 | EXPECT_THAT(handle, BlobContentEq(handle_from_request)); | ||
| 1044 | 591 | } | ||
| 1045 | 592 | |||
| 1046 | 593 | TEST_F(DragAndDrop, when_drag_moves_from_window_leave_event_contains_handle) | ||
| 1047 | 594 | { | ||
| 1048 | 595 | auto const cookie = user_initiates_drag(); | ||
| 1049 | 596 | ASSERT_THAT(cookie, NotNull()); | ||
| 1050 | 597 | auto const handle_from_request = client_requests_drag(cookie); | ||
| 1051 | 598 | |||
| 1052 | 599 | auto const handle = handle_from_mouse_leave(); | ||
| 1053 | 600 | |||
| 1054 | 601 | EXPECT_THAT(handle, NotNull()); | ||
| 1055 | 602 | EXPECT_THAT(handle, BlobContentEq(handle_from_request)); | ||
| 1056 | 603 | } | ||
| 1057 | 604 | |||
| 1058 | 605 | TEST_F(DragAndDrop, when_drag_enters_target_window_enter_event_contains_handle) | ||
| 1059 | 606 | { | ||
| 1060 | 607 | auto const cookie = user_initiates_drag(); | ||
| 1061 | 608 | ASSERT_THAT(cookie, NotNull()); | ||
| 1062 | 609 | auto const handle_from_request = client_requests_drag(cookie); | ||
| 1063 | 610 | |||
| 1064 | 611 | auto const handle = handle_from_mouse_enter(); | ||
| 1065 | 612 | |||
| 1066 | 613 | EXPECT_THAT(handle, NotNull()); | ||
| 1067 | 614 | EXPECT_THAT(handle, BlobContentEq(handle_from_request)); | ||
| 1068 | 615 | } | ||
| 1069 | 616 | |||
| 1070 | 617 | TEST_F(DragAndDrop, when_drag_releases_target_window_release_event_contains_handle) | ||
| 1071 | 618 | { | ||
| 1072 | 619 | auto const cookie = user_initiates_drag(); | ||
| 1073 | 620 | ASSERT_THAT(cookie, NotNull()); | ||
| 1074 | 621 | auto const handle_from_request = client_requests_drag(cookie); | ||
| 1075 | 622 | |||
| 1076 | 623 | auto const handle = handle_from_mouse_release(); | ||
| 1077 | 624 | |||
| 1078 | 625 | EXPECT_THAT(handle, NotNull()); | ||
| 1079 | 626 | EXPECT_THAT(handle, BlobContentEq(handle_from_request)); | ||
| 1080 | 627 | } | ||
| 1081 | 628 | |||
| 1082 | 629 | TEST_F(DragAndDrop, after_drag_finishes_pointer_events_no_longer_contain_handle) | ||
| 1083 | 630 | { | ||
| 1084 | 631 | auto const cookie = user_initiates_drag(); | ||
| 1085 | 632 | ASSERT_THAT(cookie, NotNull()); | ||
| 1086 | 633 | client_requests_drag(cookie); | ||
| 1087 | 634 | handle_from_mouse_release(); | ||
| 1088 | 635 | |||
| 1089 | 636 | invoke_tools([](miral::WindowManagerTools& tools) { tools.end_drag_and_drop(); }); | ||
| 1090 | 637 | |||
| 1091 | 638 | EXPECT_THAT(count_of_handles_when_moving_mouse(), Eq(0)); | ||
| 1092 | 639 | } | ||
By just reading the documentation i would not know on what to pass as std::vector<
I guess it is since it's a randomly generated uuid in the example.
But what is this parameter for? I mean as a miral user, you pass it in, but do you ever get it back? It seems not, so maybe miral can constrcut the uuid itself?