1
=== modified file 'examples/CMakeLists.txt'
2
--- examples/CMakeLists.txt	2015-03-05 04:24:05 +0000
3
+++ examples/CMakeLists.txt	2015-03-05 13:54:59 +0000
4
@@ -17,7 +17,6 @@
5
17
17
6
18
add_library(exampleserverconfig STATIC
18
add_library(exampleserverconfig STATIC
7
19
  server_example_canonical_window_manager.cpp
19
  server_example_canonical_window_manager.cpp
8
20
  server_example_generic_shell.cpp
9
21
  server_example_display_configuration_policy.cpp
20
  server_example_display_configuration_policy.cpp
10
22
  server_example_input_event_filter.cpp
21
  server_example_input_event_filter.cpp
11
23
  server_example_log_options.cpp
22
  server_example_log_options.cpp
12
24
23
13
=== modified file 'examples/server_example_basic_window_manager.h'
14
--- examples/server_example_basic_window_manager.h	2015-03-05 05:47:28 +0000
15
+++ examples/server_example_basic_window_manager.h	2015-03-05 13:54:59 +0000
16
@@ -19,11 +19,10 @@
17
19
#ifndef MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
19
#ifndef MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
18
20
#define MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
20
#define MIR_EXAMPLE_BASIC_WINDOW_MANAGER_H_
19
21
21
20
22
#include "server_example_generic_shell.h"
21
23
22
24
#include "mir/geometry/rectangles.h"
22
#include "mir/geometry/rectangles.h"
23
25
#include "mir/scene/session.h"
23
#include "mir/scene/session.h"
24
26
#include "mir/scene/surface_creation_parameters.h"
24
#include "mir/scene/surface_creation_parameters.h"
25
25
#include "mir/shell/generic_shell.h"
26
27
26
27
28
#include <map>
27
#include <map>
28
29
#include <mutex>
28
#include <mutex>
29
@@ -105,7 +104,7 @@
30
105
///
104
///
31
106
/// \tparam SurfaceInfo must be constructable from (std::shared_ptr<ms::Session>, std::shared_ptr<ms::Surface>)
105
/// \tparam SurfaceInfo must be constructable from (std::shared_ptr<ms::Session>, std::shared_ptr<ms::Surface>)
32
107
template<typename WindowManagementPolicy, typename SessionInfo, typename SurfaceInfo>
106
template<typename WindowManagementPolicy, typename SessionInfo, typename SurfaceInfo>
34
108
class BasicWindowManager : public WindowManager,
107
class BasicWindowManager : public shell::WindowManager,
35
109
    private BasicWindowManagerTools<SessionInfo, SurfaceInfo>
108
    private BasicWindowManagerTools<SessionInfo, SurfaceInfo>
36
110
{
109
{
37
111
public:
110
public:
38
@@ -148,8 +147,8 @@
39
148
    }
147
    }
40
149
148
41
150
    void remove_surface(
149
    void remove_surface(
44
151
        std::weak_ptr<scene::Surface> const& surface,
150
        std::shared_ptr<scene::Session> const& session,
45
152
        std::shared_ptr<scene::Session> const& session) override
151
        std::weak_ptr<scene::Surface> const& surface) override
46
153
    {
152
    {
47
154
        std::lock_guard<decltype(mutex)> lock(mutex);
153
        std::lock_guard<decltype(mutex)> lock(mutex);
48
155
        policy.handle_delete_surface(session, surface);
154
        policy.handle_delete_surface(session, surface);
49
156
155
50
=== modified file 'examples/server_example_window_management.cpp'
51
--- examples/server_example_window_management.cpp	2015-03-05 04:24:05 +0000
52
+++ examples/server_example_window_management.cpp	2015-03-05 13:54:59 +0000
53
@@ -127,25 +127,25 @@
54
127
127
55
128
            auto const selection = options->get<std::string>(wm_option);
128
            auto const selection = options->get<std::string>(wm_option);
56
129
129
58
130
            std::function<std::shared_ptr<WindowManager>(msh::FocusController* focus_controller)> wm_builder;
130
            std::function<std::shared_ptr<msh::WindowManager>(msh::FocusController* focus_controller)> wm_builder;
59
131
131
60
132
            if (selection == wm_tiling)
132
            if (selection == wm_tiling)
61
133
            {
133
            {
63
134
                wm_builder = [&server](msh::FocusController* focus_controller) -> std::shared_ptr<WindowManager>
134
                wm_builder = [&server](msh::FocusController* focus_controller) -> std::shared_ptr<msh::WindowManager>
64
135
                    {
135
                    {
65
136
                        return std::make_shared<TilingWindowManager>(focus_controller);
136
                        return std::make_shared<TilingWindowManager>(focus_controller);
66
137
                    };
137
                    };
67
138
            }
138
            }
68
139
            else if (selection == wm_fullscreen)
139
            else if (selection == wm_fullscreen)
69
140
            {
140
            {
71
141
                wm_builder = [&server](msh::FocusController* focus_controller) -> std::shared_ptr<WindowManager>
141
                wm_builder = [&server](msh::FocusController* focus_controller) -> std::shared_ptr<msh::WindowManager>
72
142
                    {
142
                    {
73
143
                        return std::make_shared<FullscreenWindowManager>(focus_controller, server.the_shell_display_layout());
143
                        return std::make_shared<FullscreenWindowManager>(focus_controller, server.the_shell_display_layout());
74
144
                    };
144
                    };
75
145
            }
145
            }
76
146
            else if (selection == wm_canonical)
146
            else if (selection == wm_canonical)
77
147
            {
147
            {
79
148
                wm_builder = [&server](msh::FocusController* focus_controller) -> std::shared_ptr<WindowManager>
148
                wm_builder = [&server](msh::FocusController* focus_controller) -> std::shared_ptr<msh::WindowManager>
80
149
                    {
149
                    {
81
150
                        return std::make_shared<CanonicalWindowManager>(focus_controller);
150
                        return std::make_shared<CanonicalWindowManager>(focus_controller);
82
151
                    };
151
                    };
83
@@ -154,7 +154,7 @@
84
154
                throw mir::AbnormalExit("Unknown window manager: " + selection);
154
                throw mir::AbnormalExit("Unknown window manager: " + selection);
85
155
155
86
156
156
88
157
            auto tmp = std::make_shared<GenericShell>(
157
            auto tmp = std::make_shared<msh::GenericShell>(
89
158
                server.the_input_targeter(),
158
                server.the_input_targeter(),
90
159
                server.the_surface_coordinator(),
159
                server.the_surface_coordinator(),
91
160
                server.the_session_coordinator(),
160
                server.the_session_coordinator(),
92
161
161
93
=== renamed file 'examples/server_example_generic_shell.h' => 'include/server/mir/shell/generic_shell.h'
94
--- examples/server_example_generic_shell.h	2015-03-05 05:47:28 +0000
95
+++ include/server/mir/shell/generic_shell.h	2015-03-05 13:54:59 +0000
96
@@ -16,28 +16,25 @@
97
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
98
17
 */
17
 */
99
18
18
104
19
#ifndef MIR_EXAMPLE_GENERIC_SHELL_H_
19
#ifndef MIR_SHELL_GENERIC_SHELL_H_
105
20
#define MIR_EXAMPLE_GENERIC_SHELL_H_
20
#define MIR_SHELL_GENERIC_SHELL_H_
102
21
103
22
#include "server_example_window_manager.h"
106
23
21
107
24
#include "mir/shell/abstract_shell.h"
22
#include "mir/shell/abstract_shell.h"
111
25
23
#include "mir/shell/window_manager.h"
109
26
///\example server_example_generic_shell.h
110
27
/// A generic shell that supports a window manager
112
28
24
113
29
namespace mir
25
namespace mir
114
30
{
26
{
115
31
namespace geometry { class Point; }
27
namespace geometry { class Point; }
116
32
28
118
33
namespace examples
29
namespace shell
119
34
{
30
{
122
35
class GenericShell : public virtual shell::Shell, public virtual shell::FocusController,
31
/// A generic shell that supports a window manager
123
36
    private shell::AbstractShell
32
class GenericShell : public virtual Shell, public virtual FocusController,
124
33
    private AbstractShell
125
37
{
34
{
126
38
public:
35
public:
127
39
    GenericShell(
36
    GenericShell(
129
40
        std::shared_ptr<shell::InputTargeter> const& input_targeter,
37
        std::shared_ptr<InputTargeter> const& input_targeter,
130
41
        std::shared_ptr<scene::SurfaceCoordinator> const& surface_coordinator,
38
        std::shared_ptr<scene::SurfaceCoordinator> const& surface_coordinator,
131
42
        std::shared_ptr<scene::SessionCoordinator> const& session_coordinator,
39
        std::shared_ptr<scene::SessionCoordinator> const& session_coordinator,
132
43
        std::shared_ptr<scene::PromptSessionManager> const& prompt_session_manager,
40
        std::shared_ptr<scene::PromptSessionManager> const& prompt_session_manager,
133
@@ -62,13 +59,13 @@
134
62
        MirSurfaceAttrib attrib,
59
        MirSurfaceAttrib attrib,
135
63
        int value) override;
60
        int value) override;
136
64
61
137
65
private:
138
66
    void add_display(geometry::Rectangle const& area) override;
62
    void add_display(geometry::Rectangle const& area) override;
139
67
    void remove_display(geometry::Rectangle const& area) override;
63
    void remove_display(geometry::Rectangle const& area) override;
140
68
64
141
65
private:
142
69
    std::shared_ptr<WindowManager> const window_manager;
66
    std::shared_ptr<WindowManager> const window_manager;
143
70
};
67
};
144
71
}
68
}
145
72
}
69
}
146
73
70
148
74
#endif /* MIR_EXAMPLE_GENERIC_SHELL_H_ */
71
#endif /* MIR_SHELL_GENERIC_SHELL_H_ */
149
75
72
150
=== renamed file 'examples/server_example_window_manager.h' => 'include/server/mir/shell/window_manager.h'
151
--- examples/server_example_window_manager.h	2015-02-27 15:23:05 +0000
152
+++ include/server/mir/shell/window_manager.h	2015-03-05 13:54:59 +0000
153
@@ -16,8 +16,8 @@
154
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
155
17
 */
17
 */
156
18
18
159
19
#ifndef MIR_EXAMPLE_WINDOW_MANAGER_H_
19
#ifndef MIR_SHELL_WINDOW_MANAGER_H_
160
20
#define MIR_EXAMPLE_WINDOW_MANAGER_H_
20
#define MIR_SHELL_WINDOW_MANAGER_H_
161
21
21
162
22
#include "mir/frontend/surface_id.h"
22
#include "mir/frontend/surface_id.h"
163
23
#include "mir_toolkit/common.h"
23
#include "mir_toolkit/common.h"
164
@@ -25,15 +25,13 @@
165
25
25
166
26
#include <memory>
26
#include <memory>
167
27
27
168
28
///\example server_example_window_manager.h
169
29
/// A window manager interface
170
30
171
31
namespace mir
28
namespace mir
172
32
{
29
{
173
33
namespace geometry { class Rectangle; }
30
namespace geometry { class Rectangle; }
174
34
namespace scene { class Session; class Surface; class SurfaceCreationParameters; }
31
namespace scene { class Session; class Surface; class SurfaceCreationParameters; }
176
35
namespace examples
32
namespace shell
177
36
{
33
{
178
34
/// interface to provide window management logic
179
37
class WindowManager
35
class WindowManager
180
38
{
36
{
181
39
public:
37
public:
182
@@ -47,8 +45,8 @@
183
47
        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build) = 0;
45
        std::function<frontend::SurfaceId(std::shared_ptr<scene::Session> const& session, scene::SurfaceCreationParameters const& params)> const& build) = 0;
184
48
46
185
49
    virtual void remove_surface(
47
    virtual void remove_surface(
188
50
        std::weak_ptr<scene::Surface> const& surface,
48
        std::shared_ptr<scene::Session> const& session,
189
51
        std::shared_ptr<scene::Session> const& session) = 0;
49
        std::weak_ptr<scene::Surface> const& surface) = 0;
190
52
50
191
53
    virtual void add_display(geometry::Rectangle const& area) = 0;
51
    virtual void add_display(geometry::Rectangle const& area) = 0;
192
54
52
193
@@ -70,4 +68,4 @@
194
70
}
68
}
195
71
}
69
}
196
72
70
198
73
#endif /* MIR_EXAMPLE_WINDOW_MANAGER_H_ */
71
#endif /* MIR_SHELL_WINDOW_MANAGER_H_ */
199
74
72
200
=== modified file 'src/server/shell/CMakeLists.txt'
201
--- src/server/shell/CMakeLists.txt	2015-02-18 05:27:28 +0000
202
+++ src/server/shell/CMakeLists.txt	2015-03-05 13:54:59 +0000
203
@@ -4,6 +4,7 @@
204
4
  abstract_shell.cpp
4
  abstract_shell.cpp
205
5
  default_placement_strategy.cpp
5
  default_placement_strategy.cpp
206
6
  frontend_shell.cpp
6
  frontend_shell.cpp
207
7
  generic_shell.cpp
208
7
  graphics_display_layout.cpp
8
  graphics_display_layout.cpp
209
8
  default_configuration.cpp
9
  default_configuration.cpp
210
9
  default_shell.cpp
10
  default_shell.cpp
211
10
11
212
=== renamed file 'examples/server_example_generic_shell.cpp' => 'src/server/shell/generic_shell.cpp'
213
--- examples/server_example_generic_shell.cpp	2015-03-05 05:47:28 +0000
214
+++ src/server/shell/generic_shell.cpp	2015-03-05 13:54:59 +0000
215
@@ -16,66 +16,62 @@
216
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
16
 * Authored By: Alan Griffiths <alan@octopull.co.uk>
217
17
 */
17
 */
218
18
18
220
19
#include "server_example_generic_shell.h"
19
#include "mir/shell/generic_shell.h"
221
20
20
222
21
#include "mir/geometry/point.h"
21
#include "mir/geometry/point.h"
223
22
#include "mir/scene/session.h"
22
#include "mir/scene/session.h"
224
23
#include "mir/scene/surface_coordinator.h"
23
#include "mir/scene/surface_coordinator.h"
225
24
#include "mir/scene/surface_creation_parameters.h"
24
#include "mir/scene/surface_creation_parameters.h"
226
25
25
227
26
namespace me = mir::examples;
228
27
namespace mf = mir::frontend;
26
namespace mf = mir::frontend;
229
28
namespace ms = mir::scene;
27
namespace ms = mir::scene;
230
29
namespace msh = mir::shell;
28
namespace msh = mir::shell;
231
30
29
237
31
///\example server_example_generic_shell.cpp
30
msh::GenericShell::GenericShell(
238
32
/// A shell that accepts a WindowManager
31
    std::shared_ptr<InputTargeter> const& input_targeter,
234
33
235
34
me::GenericShell::GenericShell(
236
35
    std::shared_ptr<msh::InputTargeter> const& input_targeter,
239
36
    std::shared_ptr<ms::SurfaceCoordinator> const& surface_coordinator,
32
    std::shared_ptr<ms::SurfaceCoordinator> const& surface_coordinator,
240
37
    std::shared_ptr<ms::SessionCoordinator> const& session_coordinator,
33
    std::shared_ptr<ms::SessionCoordinator> const& session_coordinator,
241
38
    std::shared_ptr<ms::PromptSessionManager> const& prompt_session_manager,
34
    std::shared_ptr<ms::PromptSessionManager> const& prompt_session_manager,
243
39
    std::function<std::shared_ptr<WindowManager>(FocusController* focus_controller)> const& wm_builder) :
35
    std::function<std::shared_ptr<shell::WindowManager>(FocusController* focus_controller)> const& wm_builder) :
244
40
    AbstractShell(input_targeter, surface_coordinator, session_coordinator, prompt_session_manager),
36
    AbstractShell(input_targeter, surface_coordinator, session_coordinator, prompt_session_manager),
245
41
    window_manager(wm_builder(this))
37
    window_manager(wm_builder(this))
246
42
{
38
{
247
43
}
39
}
248
44
40
250
45
std::shared_ptr<ms::Session> me::GenericShell::open_session(
41
std::shared_ptr<ms::Session> msh::GenericShell::open_session(
251
46
    pid_t client_pid,
42
    pid_t client_pid,
252
47
    std::string const& name,
43
    std::string const& name,
253
48
    std::shared_ptr<mf::EventSink> const& sink)
44
    std::shared_ptr<mf::EventSink> const& sink)
254
49
{
45
{
256
50
    auto const result = msh::AbstractShell::open_session(client_pid, name, sink);
46
    auto const result = AbstractShell::open_session(client_pid, name, sink);
257
51
    window_manager->add_session(result);
47
    window_manager->add_session(result);
258
52
    return result;
48
    return result;
259
53
}
49
}
260
54
50
262
55
void me::GenericShell::close_session(std::shared_ptr<ms::Session> const& session)
51
void msh::GenericShell::close_session(std::shared_ptr<ms::Session> const& session)
263
56
{
52
{
264
57
    window_manager->remove_session(session);
53
    window_manager->remove_session(session);
266
58
    msh::AbstractShell::close_session(session);
54
    AbstractShell::close_session(session);
267
59
}
55
}
268
60
56
270
61
auto me::GenericShell::create_surface(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)
57
auto msh::GenericShell::create_surface(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)
271
62
-> mf::SurfaceId
58
-> mf::SurfaceId
272
63
{
59
{
273
64
    auto const build = [this](std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& placed_params)
60
    auto const build = [this](std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& placed_params)
274
65
        {
61
        {
276
66
            return msh::AbstractShell::create_surface(session, placed_params);
62
            return AbstractShell::create_surface(session, placed_params);
277
67
        };
63
        };
278
68
64
279
69
    return window_manager->add_surface(session, params, build);
65
    return window_manager->add_surface(session, params, build);
280
70
}
66
}
281
71
67
283
72
void me::GenericShell::destroy_surface(std::shared_ptr<ms::Session> const& session, mf::SurfaceId surface)
68
void msh::GenericShell::destroy_surface(std::shared_ptr<ms::Session> const& session, mf::SurfaceId surface)
284
73
{
69
{
287
74
    window_manager->remove_surface(session->surface(surface), session);
70
    window_manager->remove_surface(session, session->surface(surface));
288
75
    msh::AbstractShell::destroy_surface(session, surface);
71
    AbstractShell::destroy_surface(session, surface);
289
76
}
72
}
290
77
73
292
78
bool me::GenericShell::handle(MirEvent const& event)
74
bool msh::GenericShell::handle(MirEvent const& event)
293
79
{
75
{
294
80
    if (mir_event_get_type(&event) != mir_event_type_input)
76
    if (mir_event_get_type(&event) != mir_event_type_input)
295
81
        return false;
77
        return false;
296
@@ -97,7 +93,7 @@
297
97
    return false;
93
    return false;
298
98
}
94
}
299
99
95
301
100
int me::GenericShell::set_surface_attribute(
96
int msh::GenericShell::set_surface_attribute(
302
101
    std::shared_ptr<ms::Session> const& session,
97
    std::shared_ptr<ms::Session> const& session,
303
102
    std::shared_ptr<ms::Surface> const& surface,
98
    std::shared_ptr<ms::Surface> const& surface,
304
103
    MirSurfaceAttrib attrib,
99
    MirSurfaceAttrib attrib,
305
@@ -108,19 +104,19 @@
306
108
    case mir_surface_attrib_state:
104
    case mir_surface_attrib_state:
307
109
    {
105
    {
308
110
        auto const state = window_manager->handle_set_state(surface, MirSurfaceState(value));
106
        auto const state = window_manager->handle_set_state(surface, MirSurfaceState(value));
310
111
        return msh::AbstractShell::set_surface_attribute(session, surface, attrib, state);
107
        return AbstractShell::set_surface_attribute(session, surface, attrib, state);
311
112
    }
108
    }
312
113
    default:
109
    default:
314
114
        return msh::AbstractShell::set_surface_attribute(session, surface, attrib, value);
110
        return AbstractShell::set_surface_attribute(session, surface, attrib, value);
315
115
    }
111
    }
316
116
}
112
}
317
117
113
319
118
void me::GenericShell::add_display(geometry::Rectangle const& area)
114
void msh::GenericShell::add_display(geometry::Rectangle const& area)
320
119
{
115
{
321
120
    window_manager->add_display(area);
116
    window_manager->add_display(area);
322
121
}
117
}
323
122
118
325
123
void me::GenericShell::remove_display(geometry::Rectangle const& area)
119
void msh::GenericShell::remove_display(geometry::Rectangle const& area)
326
124
{
120
{
327
125
    window_manager->remove_display(area);
121
    window_manager->remove_display(area);
328
126
}
122
}
329
127
123
330
=== modified file 'src/server/symbols.map'
331
--- src/server/symbols.map	2015-03-05 05:47:28 +0000
332
+++ src/server/symbols.map	2015-03-05 13:54:59 +0000
333
@@ -392,6 +392,16 @@
334
392
    mir::shell::FocusController::focused_session*;
392
    mir::shell::FocusController::focused_session*;
335
393
    mir::shell::FocusController::operator*;
393
    mir::shell::FocusController::operator*;
336
394
    mir::shell::FocusController::set_focus_to*;
394
    mir::shell::FocusController::set_focus_to*;
337
395
    mir::shell::FocusController::surface_at*;
338
396
    mir::shell::GenericShell::add_display*;
339
397
    mir::shell::GenericShell::close_session*;
340
398
    mir::shell::GenericShell::create_surface*;
341
399
    mir::shell::GenericShell::destroy_surface*;
342
400
    mir::shell::GenericShell::GenericShell*;
343
401
    mir::shell::GenericShell::handle*;
344
402
    mir::shell::GenericShell::open_session*;
345
403
    mir::shell::GenericShell::remove_display*;
346
404
    mir::shell::GenericShell::set_surface_attribute*;
347
395
    mir::shell::HostLifecycleEventListener::?HostLifecycleEventListener*;
405
    mir::shell::HostLifecycleEventListener::?HostLifecycleEventListener*;
348
396
    mir::shell::HostLifecycleEventListener::HostLifecycleEventListener*;
406
    mir::shell::HostLifecycleEventListener::HostLifecycleEventListener*;
349
397
    mir::shell::HostLifecycleEventListener::lifecycle_event_occurred*;
407
    mir::shell::HostLifecycleEventListener::lifecycle_event_occurred*;
350
398
408
351
=== modified file 'tests/unit-tests/scene/CMakeLists.txt'
352
--- tests/unit-tests/scene/CMakeLists.txt	2015-03-05 05:47:28 +0000
353
+++ tests/unit-tests/scene/CMakeLists.txt	2015-03-05 13:54:59 +0000
354
@@ -16,6 +16,7 @@
355
16
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_impl.cpp
16
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_impl.cpp
356
17
  ${CMAKE_CURRENT_SOURCE_DIR}/test_basic_surface.cpp
17
  ${CMAKE_CURRENT_SOURCE_DIR}/test_basic_surface.cpp
357
18
  ${CMAKE_CURRENT_SOURCE_DIR}/test_default_shell.cpp
18
  ${CMAKE_CURRENT_SOURCE_DIR}/test_default_shell.cpp
358
19
  ${CMAKE_CURRENT_SOURCE_DIR}/test_generic_shell.cpp
359
19
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_stack.cpp
20
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_stack.cpp
360
20
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_controller.cpp
21
  ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_controller.cpp
361
21
  ${CMAKE_CURRENT_SOURCE_DIR}/test_legacy_scene_change_notification.cpp
22
  ${CMAKE_CURRENT_SOURCE_DIR}/test_legacy_scene_change_notification.cpp
362
22
23
363
=== added file 'tests/unit-tests/scene/test_generic_shell.cpp'
364
--- tests/unit-tests/scene/test_generic_shell.cpp	1970-01-01 00:00:00 +0000
365
+++ tests/unit-tests/scene/test_generic_shell.cpp	2015-03-05 13:54:59 +0000
366
@@ -0,0 +1,466 @@
367
1
/*
368
2
 * Copyright © 2015 Canonical Ltd.
369
3
 *
370
4
 * This program is free software: you can redistribute it and/or modify
371
5
 * it under the terms of the GNU General Public License version 3 as
372
6
 * published by the Free Software Foundation.
373
7
 *
374
8
 * This program is distributed in the hope that it will be useful,
375
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
376
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
377
11
 * GNU General Public License for more details.
378
12
 *
379
13
 * You should have received a copy of the GNU General Public License
380
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
381
15
 *
382
16
 * Authored by: ALan Griffiths <alan.griffiths@canonical.com>
383
17
 */
384
18
385
19
#include "mir/shell/generic_shell.h"
386
20
#include "mir/shell/window_manager.h"
387
21
388
22
#include "mir/events/event_builders.h"
389
23
#include "mir/scene/session.h"
390
24
#include "mir/scene/null_session_listener.h"
391
25
#include "mir/scene/surface_creation_parameters.h"
392
26
393
27
#include "src/server/scene/default_session_container.h"
394
28
#include "src/server/scene/session_event_sink.h"
395
29
#include "src/server/scene/session_manager.h"
396
30
397
31
#include "mir_test_doubles/mock_surface_coordinator.h"
398
32
#include "mir_test_doubles/mock_session_listener.h"
399
33
#include "mir_test_doubles/mock_surface.h"
400
34
#include "mir_test_doubles/null_snapshot_strategy.h"
401
35
#include "mir_test_doubles/null_prompt_session_manager.h"
402
36
#include "mir_test_doubles/stub_input_targeter.h"
403
37
404
38
#include "mir_test/fake_shared.h"
405
39
406
40
#include <gmock/gmock.h>
407
41
#include <gtest/gtest.h>
408
42
409
43
namespace mf = mir::frontend;
410
44
namespace mi = mir::input;
411
45
namespace ms = mir::scene;
412
46
namespace msh = mir::shell;
413
47
namespace geom = mir::geometry;
414
48
415
49
namespace mt = mir::test;
416
50
namespace mtd = mir::test::doubles;
417
51
using namespace ::testing;
418
52
419
53
namespace
420
54
{
421
55
MATCHER_P(WeakPtrTo, p, "")
422
56
{
423
57
  return !arg.owner_before(p) && !p.owner_before(arg);
424
58
}
425
59
426
60
struct MockSessionContainer : public ms::SessionContainer
427
61
{
428
62
    MOCK_METHOD1(insert_session, void(std::shared_ptr<ms::Session> const&));
429
63
    MOCK_METHOD1(remove_session, void(std::shared_ptr<ms::Session> const&));
430
64
    MOCK_CONST_METHOD1(successor_of, std::shared_ptr<ms::Session>(std::shared_ptr<ms::Session> const&));
431
65
    MOCK_CONST_METHOD1(for_each, void(std::function<void(std::shared_ptr<ms::Session> const&)>));
432
66
    MOCK_METHOD0(lock, void());
433
67
    MOCK_METHOD0(unlock, void());
434
68
    ~MockSessionContainer() noexcept {}
435
69
};
436
70
437
71
struct MockSessionEventSink : public ms::SessionEventSink
438
72
{
439
73
    MOCK_METHOD1(handle_focus_change, void(std::shared_ptr<ms::Session> const& session));
440
74
    MOCK_METHOD0(handle_no_focus, void());
441
75
    MOCK_METHOD1(handle_session_stopping, void(std::shared_ptr<ms::Session> const& session));
442
76
};
443
77
444
78
struct MockSessionManager : ms::SessionManager
445
79
{
446
80
    using ms::SessionManager::SessionManager;
447
81
448
82
    MOCK_METHOD1(set_focus_to, void (std::shared_ptr<ms::Session> const& focus));
449
83
450
84
    void unmocked_set_focus_to(std::shared_ptr<ms::Session> const& focus)
451
85
    { ms::SessionManager::set_focus_to(focus); }
452
86
};
453
87
454
88
struct MockWindowManager : msh::WindowManager
455
89
{
456
90
    MockWindowManager()
457
91
    {
458
92
        ON_CALL(*this, add_surface(_,_,_)).WillByDefault(Invoke(
459
93
            [](std::shared_ptr<ms::Session> const& session,
460
94
                ms::SurfaceCreationParameters const& params,
461
95
                std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)> const& build)
462
96
                { return build(session, params); }));
463
97
    }
464
98
465
99
    MOCK_METHOD1(add_session, void (std::shared_ptr<ms::Session> const&));
466
100
    MOCK_METHOD1(remove_session, void (std::shared_ptr<ms::Session> const&));
467
101
468
102
    MOCK_METHOD3(add_surface, mf::SurfaceId(
469
103
        std::shared_ptr<ms::Session> const& session,
470
104
        ms::SurfaceCreationParameters const& params,
471
105
        std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& params)> const& build));
472
106
473
107
    MOCK_METHOD2(remove_surface, void(std::shared_ptr<ms::Session> const&, std::weak_ptr<ms::Surface> const&));
474
108
475
109
    MOCK_METHOD1(add_display, void(geom::Rectangle const&));
476
110
    MOCK_METHOD1(remove_display, void(geom::Rectangle const&));
477
111
478
112
    MOCK_METHOD1(handle_key_event, bool(MirKeyInputEvent const*));
479
113
    MOCK_METHOD1(handle_touch_event, bool(MirTouchInputEvent const*));
480
114
    MOCK_METHOD1(handle_pointer_event, bool(MirPointerInputEvent const*));
481
115
482
116
    MOCK_METHOD2(handle_set_state, int(std::shared_ptr<ms::Surface> const&, MirSurfaceState value));
483
117
};
484
118
485
119
using NiceMockWindowManager = NiceMock<MockWindowManager>;
486
120
487
121
struct GenericShell : Test
488
122
{
489
123
    NiceMock<mtd::MockSurface> mock_surface;
490
124
    NiceMock<mtd::MockSurfaceCoordinator> surface_coordinator;
491
125
    NiceMock<MockSessionContainer> session_container;
492
126
    NiceMock<MockSessionEventSink> session_event_sink;
493
127
    NiceMock<mtd::MockSessionListener> session_listener;
494
128
495
129
    NiceMock<MockSessionManager> session_manager{
496
130
        mt::fake_shared(surface_coordinator),
497
131
        mt::fake_shared(session_container),
498
132
        std::make_shared<mtd::NullSnapshotStrategy>(),
499
133
        mt::fake_shared(session_event_sink),
500
134
        mt::fake_shared(session_listener)};
501
135
502
136
    mtd::StubInputTargeter input_targeter;
503
137
    std::shared_ptr<MockWindowManager> wm;
504
138
505
139
    msh::GenericShell shell{
506
140
        mt::fake_shared(input_targeter),
507
141
        mt::fake_shared(surface_coordinator),
508
142
        mt::fake_shared(session_manager),
509
143
        std::make_shared<mtd::NullPromptSessionManager>(),
510
144
        [this](msh::FocusController*) { return wm = std::make_shared<NiceMockWindowManager>(); }};
511
145
512
146
    void SetUp() override
513
147
    {
514
148
        ON_CALL(session_container, successor_of(_)).WillByDefault(Return((std::shared_ptr<ms::Session>())));
515
149
        ON_CALL(session_manager, set_focus_to(_)).
516
150
            WillByDefault(Invoke(&session_manager, &MockSessionManager::unmocked_set_focus_to));
517
151
        ON_CALL(surface_coordinator, add_surface(_,_))
518
152
            .WillByDefault(Return(mt::fake_shared(mock_surface)));
519
153
    }
520
154
};
521
155
}
522
156
523
157
TEST_F(GenericShell, open_session_adds_session_to_window_manager)
524
158
{
525
159
    std::shared_ptr<ms::Session> new_session;
526
160
527
161
    InSequence s;
528
162
    EXPECT_CALL(session_container, insert_session(_)).Times(1);
529
163
    EXPECT_CALL(*wm, add_session(_)).WillOnce(SaveArg<0>(&new_session));
530
164
531
165
    auto session = shell.open_session(__LINE__, "Visual Basic Studio", std::shared_ptr<mf::EventSink>());
532
166
    EXPECT_EQ(session, new_session);
533
167
}
534
168
535
169
TEST_F(GenericShell, close_session_removes_session_from_window_manager)
536
170
{
537
171
    std::shared_ptr<ms::Session> old_session;
538
172
539
173
    InSequence s;
540
174
    EXPECT_CALL(session_container, insert_session(_));
541
175
    EXPECT_CALL(*wm, remove_session(_)).WillOnce(SaveArg<0>(&old_session));
542
176
543
177
    auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
544
178
    shell.close_session(session);
545
179
    EXPECT_EQ(session, old_session);
546
180
}
547
181
548
182
TEST_F(GenericShell, close_session_notifies_session_event_sink)
549
183
{
550
184
    auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
551
185
    auto session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
552
186
553
187
    InSequence s;
554
188
    EXPECT_CALL(session_event_sink, handle_session_stopping(session1));
555
189
    EXPECT_CALL(session_event_sink, handle_session_stopping(session));
556
190
557
191
    shell.close_session(session1);
558
192
    shell.close_session(session);
559
193
}
560
194
561
195
TEST_F(GenericShell, create_surface_provides_create_parameters_to_window_manager)
562
196
{
563
197
    std::shared_ptr<ms::Session> session =
564
198
        shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
565
199
566
200
    auto params = ms::a_surface();
567
201
568
202
    EXPECT_CALL(*wm, add_surface(session, Ref(params), _));
569
203
570
204
    shell.create_surface(session, params);
571
205
}
572
206
573
207
TEST_F(GenericShell, create_surface_allows_window_manager_to_set_create_parameters)
574
208
{
575
209
    std::shared_ptr<ms::Session> const session =
576
210
        shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
577
211
578
212
    auto params = ms::a_surface();
579
213
    auto placed_params = params;
580
214
    placed_params.size.width = geom::Width{100};
581
215
582
216
    EXPECT_CALL(surface_coordinator, add_surface(placed_params, _));
583
217
584
218
    EXPECT_CALL(*wm, add_surface(session, Ref(params), _)).WillOnce(Invoke(
585
219
        [&](std::shared_ptr<ms::Session> const& session,
586
220
            ms::SurfaceCreationParameters const&,
587
221
            std::function<mf::SurfaceId(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const&)> const& build)
588
222
            { return build(session, placed_params); }));
589
223
590
224
    shell.create_surface(session, params);
591
225
}
592
226
593
227
TEST_F(GenericShell, destroy_surface_removes_surface_from_window_manager)
594
228
{
595
229
    auto const params = ms::a_surface();
596
230
    std::shared_ptr<ms::Session> const session =
597
231
        shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
598
232
599
233
    auto const surface_id = shell.create_surface(session, params);
600
234
    auto const surface = session->surface(surface_id);
601
235
602
236
    EXPECT_CALL(*wm, remove_surface(session, WeakPtrTo(surface)));
603
237
604
238
    shell.destroy_surface(session, surface_id);
605
239
}
606
240
607
241
TEST_F(GenericShell, add_display_adds_display_to_window_manager)
608
242
{
609
243
    geom::Rectangle const arbitrary_area{{0,0}, {__LINE__,__LINE__}};
610
244
611
245
    EXPECT_CALL(*wm, add_display(arbitrary_area));
612
246
613
247
    shell.add_display(arbitrary_area);
614
248
}
615
249
616
250
TEST_F(GenericShell, remove_display_adds_display_to_window_manager)
617
251
{
618
252
    geom::Rectangle const arbitrary_area{{0,0}, {__LINE__,__LINE__}};
619
253
620
254
    EXPECT_CALL(*wm, remove_display(arbitrary_area));
621
255
622
256
    shell.remove_display(arbitrary_area);
623
257
}
624
258
625
259
TEST_F(GenericShell, key_input_events_are_handled_by_window_manager)
626
260
{
627
261
    int64_t const timestamp{0};
628
262
    MirKeyInputEventAction const action{mir_key_input_event_action_down};
629
263
    xkb_keysym_t const key_code{0};
630
264
    int const scan_code{0};
631
265
    MirInputEventModifiers const modifiers{mir_input_event_modifier_none};
632
266
633
267
    auto const event = mir::events::make_event(
634
268
        mir_input_event_type_key,
635
269
        timestamp,
636
270
        action,
637
271
        key_code,
638
272
        scan_code,
639
273
        modifiers);
640
274
641
275
    EXPECT_CALL(*wm, handle_key_event(_))
642
276
        .WillOnce(Return(false))
643
277
        .WillOnce(Return(true));
644
278
645
279
    EXPECT_FALSE(shell.handle(*event));
646
280
    EXPECT_TRUE(shell.handle(*event));
647
281
}
648
282
649
283
TEST_F(GenericShell, touch_input_events_are_handled_by_window_manager)
650
284
{
651
285
    int64_t const timestamp{0};
652
286
    MirInputEventModifiers const modifiers{mir_input_event_modifier_none};
653
287
654
288
    auto const event = mir::events::make_event(
655
289
        mir_input_event_type_touch,
656
290
        timestamp,
657
291
        modifiers);
658
292
659
293
    EXPECT_CALL(*wm, handle_touch_event(_))
660
294
        .WillOnce(Return(false))
661
295
        .WillOnce(Return(true));
662
296
663
297
    EXPECT_FALSE(shell.handle(*event));
664
298
    EXPECT_TRUE(shell.handle(*event));
665
299
}
666
300
667
301
TEST_F(GenericShell, pointer_input_events_are_handled_by_window_manager)
668
302
{
669
303
    int64_t const timestamp{0};
670
304
    MirInputEventModifiers const modifiers{mir_input_event_modifier_none};
671
305
    MirPointerInputEventAction const action{mir_pointer_input_event_action_button_down};
672
306
    std::vector<MirPointerInputEventButton> const buttons_pressed{mir_pointer_input_button_primary};
673
307
    float const x_axis_value{0.0};
674
308
    float const y_axis_value{0.0};
675
309
    float const hscroll_value{0.0};
676
310
    float const vscroll_value{0.0};
677
311
678
312
    auto const event = mir::events::make_event(
679
313
        mir_input_event_type_pointer,
680
314
        timestamp,
681
315
        modifiers,
682
316
        action,
683
317
        buttons_pressed,
684
318
        x_axis_value,
685
319
        y_axis_value,
686
320
        hscroll_value,
687
321
        vscroll_value);
688
322
689
323
    EXPECT_CALL(*wm, handle_pointer_event(_))
690
324
        .WillOnce(Return(false))
691
325
        .WillOnce(Return(true));
692
326
693
327
    EXPECT_FALSE(shell.handle(*event));
694
328
    EXPECT_TRUE(shell.handle(*event));
695
329
}
696
330
697
331
TEST_F(GenericShell, setting_surface_state_is_handled_by_window_manager)
698
332
{
699
333
    std::shared_ptr<ms::Session> const session =
700
334
        shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
701
335
702
336
    auto const surface_id = shell.create_surface(session, ms::a_surface());
703
337
    auto const surface = session->surface(surface_id);
704
338
705
339
    MirSurfaceState const state{mir_surface_state_fullscreen};
706
340
707
341
    EXPECT_CALL(*wm, handle_set_state(surface, state))
708
342
        .WillOnce(Return(mir_surface_state_maximized));
709
343
710
344
    EXPECT_CALL(mock_surface, configure(mir_surface_attrib_state, mir_surface_state_maximized));
711
345
712
346
    shell.set_surface_attribute(session, surface, mir_surface_attrib_state, mir_surface_state_fullscreen);
713
347
}
714
348
715
349
TEST_F(GenericShell, as_focus_controller_set_focus_to_notifies_session_event_sink)
716
350
{
717
351
    auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
718
352
    auto session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
719
353
720
354
    InSequence s;
721
355
    EXPECT_CALL(session_event_sink, handle_focus_change(session1));
722
356
    EXPECT_CALL(session_event_sink, handle_focus_change(session));
723
357
    EXPECT_CALL(session_event_sink, handle_no_focus());
724
358
725
359
    msh::FocusController& focus_controller = shell;
726
360
    focus_controller.set_focus_to(session1, {});
727
361
    focus_controller.set_focus_to(session, {});
728
362
    focus_controller.set_focus_to({}, {});
729
363
}
730
364
731
365
TEST_F(GenericShell, as_focus_controller_focus_next_notifies_session_event_sink)
732
366
{
733
367
    msh::FocusController& focus_controller = shell;
734
368
    auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
735
369
    auto session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
736
370
    focus_controller.set_focus_to(session, {});
737
371
738
372
    EXPECT_CALL(session_container, successor_of(session)).
739
373
        WillOnce(Return(session1));
740
374
741
375
    EXPECT_CALL(session_event_sink, handle_focus_change(session1));
742
376
743
377
    focus_controller.focus_next();
744
378
}
745
379
746
380
TEST_F(GenericShell, as_focus_controller_focused_session_follows_focus)
747
381
{
748
382
    auto session = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
749
383
    auto session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
750
384
    EXPECT_CALL(session_container, successor_of(session1)).
751
385
        WillOnce(Return(session));
752
386
753
387
    msh::FocusController& focus_controller = shell;
754
388
755
389
    focus_controller.set_focus_to(session, {});
756
390
    EXPECT_THAT(focus_controller.focused_session(), Eq(session));
757
391
    focus_controller.set_focus_to(session1, {});
758
392
    EXPECT_THAT(focus_controller.focused_session(), Eq(session1));
759
393
    focus_controller.focus_next();
760
394
    EXPECT_THAT(focus_controller.focused_session(), Eq(session));
761
395
}
762
396
763
397
TEST_F(GenericShell, as_focus_controller_focused_surface_follows_focus)
764
398
{
765
399
    auto const session0 = shell.open_session(__LINE__, "XPlane", std::shared_ptr<mf::EventSink>());
766
400
    auto const session1 = shell.open_session(__LINE__, "Bla", std::shared_ptr<mf::EventSink>());
767
401
    NiceMock<mtd::MockSurface> dummy_surface;
768
402
769
403
    EXPECT_CALL(surface_coordinator, add_surface(_,_)).Times(AnyNumber())
770
404
        .WillOnce(Return(mt::fake_shared(dummy_surface)))
771
405
        .WillOnce(Return(mt::fake_shared(mock_surface)));
772
406
    EXPECT_CALL(session_container, successor_of(session1)).
773
407
        WillOnce(Return(session0));
774
408
775
409
776
410
    auto const surface0_id = shell.create_surface(session0, ms::a_surface());
777
411
    auto const surface0 = session0->surface(surface0_id);
778
412
    auto const surface1_id = shell.create_surface(session1, ms::a_surface());
779
413
    auto const surface1 = session1->surface(surface1_id);
780
414
781
415
    msh::FocusController& focus_controller = shell;
782
416
783
417
    focus_controller.set_focus_to(session0, surface0);
784
418
    EXPECT_THAT(focus_controller.focused_surface(), Eq(surface0));
785
419
    focus_controller.set_focus_to(session1, surface1);
786
420
    EXPECT_THAT(focus_controller.focused_surface(), Eq(surface1));
787
421
    focus_controller.focus_next();
788
422
    EXPECT_THAT(focus_controller.focused_surface(), Eq(surface0));
789
423
790
424
    shell.destroy_surface(session0, surface0_id);
791
425
    shell.destroy_surface(session1, surface1_id);
792
426
    shell.close_session(session1);
793
427
    shell.close_session(session0);
794
428
}
795
429
796
430
TEST_F(GenericShell, as_focus_controller_delegates_surface_at_to_surface_coordinator)
797
431
{
798
432
    auto const surface = mt::fake_shared(mock_surface);
799
433
    geom::Point const cursor{__LINE__, __LINE__};
800
434
801
435
    EXPECT_CALL(surface_coordinator, surface_at(cursor)).
802
436
        WillOnce(Return(surface));
803
437
804
438
    msh::FocusController& focus_controller = shell;
805
439
806
440
    EXPECT_THAT(focus_controller.surface_at(cursor), Eq(surface));
807
441
}
808
442
809
443
namespace mir
810
444
{
811
445
namespace scene
812
446
{
813
447
// The next test is easier to write if we can compare std::weak_ptr<ms::Surface>
814
448
inline bool operator==(
815
449
    std::weak_ptr<ms::Surface> const& lhs,
816
450
    std::weak_ptr<ms::Surface> const& rhs)
817
451
{
818
452
    return !lhs.owner_before(rhs) && !rhs.owner_before(lhs);
819
453
}
820
454
}
821
455
}
822
456
823
457
TEST_F(GenericShell, as_focus_controller_delegates_raise_to_surface_coordinator)
824
458
{
825
459
    msh::SurfaceSet const surfaces{mt::fake_shared(mock_surface)};
826
460
827
461
    EXPECT_CALL(surface_coordinator, raise(surfaces));
828
462
829
463
    msh::FocusController& focus_controller = shell;
830
464
831
465
    focus_controller.raise(surfaces);
832
466
}
Status:	Merged
Approved by:	Alan Griffiths on 2015-03-06
Approved revision:	no longer in the source branch.
Merged at revision:	2375
Proposed branch:	lp:~alan-griffiths/mir/integrate-generic-shell
Merge into:	lp:mir
Prerequisite:	lp:~alan-griffiths/mir/integrate-focus-controller
Diff against target:	832 lines (+523/-56) 10 files modified examples/CMakeLists.txt (+0/-1) examples/server_example_basic_window_manager.h (+4/-5) examples/server_example_window_management.cpp (+5/-5) include/server/mir/shell/generic_shell.h (+10/-13) include/server/mir/shell/window_manager.h (+7/-9) src/server/shell/CMakeLists.txt (+1/-0) src/server/shell/generic_shell.cpp (+19/-23) src/server/symbols.map (+10/-0) tests/unit-tests/scene/CMakeLists.txt (+1/-0) tests/unit-tests/scene/test_generic_shell.cpp (+466/-0)
To merge this branch:	bzr merge lp:~alan-griffiths/mir/integrate-generic-shell
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Alexandros Frantzis (community)			Approve on 2015-03-05
PS Jenkins bot (community)	continuous-integration		Approve on 2015-03-05
Robert Carr (community)		2015-03-03	Approve on 2015-03-04
Review via email: mp+251581@code.launchpad.net