← Back to branch summary

~ubuntu-branches/ubuntu/wily/mir/wily-proposed

« back to all changes in this revision

Viewing changes to src/server/shell/abstract_shell.cpp

  • Committer: Package Import Robot
  • Author(s): CI Train Bot
  • Date: 2015-05-12 13:12:55 UTC
  • mto: This revision was merged to the branch mainline in revision 96.
  • Revision ID: package-import@ubuntu.com-20150512131255-y7z12i8n4pbvo70x
Tags: upstream-0.13.0+15.10.20150512
Import upstream version 0.13.0+15.10.20150512

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/server/shell/abstract_shell.cpp
18
18
 
19
19
#include "mir/shell/abstract_shell.h"
20
20
#include "mir/shell/input_targeter.h"
 
21
#include "mir/shell/window_manager.h"
21
22
#include "mir/scene/prompt_session.h"
22
23
#include "mir/scene/prompt_session_manager.h"
23
24
#include "mir/scene/session_coordinator.h"
31
32
 
32
33
msh::AbstractShell::AbstractShell(
33
34
    std::shared_ptr<InputTargeter> const& input_targeter,
34
 
    std::shared_ptr<scene::SurfaceCoordinator> const& surface_coordinator,
35
 
    std::shared_ptr<scene::SessionCoordinator> const& session_coordinator,
36
 
    std::shared_ptr<scene::PromptSessionManager> const& prompt_session_manager) :
 
35
    std::shared_ptr<ms::SurfaceCoordinator> const& surface_coordinator,
 
36
    std::shared_ptr<ms::SessionCoordinator> const& session_coordinator,
 
37
    std::shared_ptr<ms::PromptSessionManager> const& prompt_session_manager,
 
38
    std::function<std::shared_ptr<shell::WindowManager>(FocusController* focus_controller)> const& wm_builder) :
37
39
    input_targeter(input_targeter),
38
40
    surface_coordinator(surface_coordinator),
39
41
    session_coordinator(session_coordinator),
40
 
    prompt_session_manager(prompt_session_manager)
 
42
    prompt_session_manager(prompt_session_manager),
 
43
    window_manager(wm_builder(this))
41
44
{
42
45
}
43
46
 
50
53
    std::string const& name,
51
54
    std::shared_ptr<mf::EventSink> const& sink)
52
55
{
53
 
    return session_coordinator->open_session(client_pid, name, sink);
 
56
    auto const result = session_coordinator->open_session(client_pid, name, sink);
 
57
    window_manager->add_session(result);
 
58
    return result;
54
59
}
55
60
 
56
61
void msh::AbstractShell::close_session(
58
63
{
59
64
    prompt_session_manager->remove_session(session);
60
65
    session_coordinator->close_session(session);
 
66
    window_manager->remove_session(session);
61
67
}
62
68
 
63
69
mf::SurfaceId msh::AbstractShell::create_surface(
64
70
    std::shared_ptr<ms::Session> const& session,
65
71
    ms::SurfaceCreationParameters const& params)
66
72
{
67
 
    return session->create_surface(params);
 
73
    auto const build = [this](std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& placed_params)
 
74
        {
 
75
            return session->create_surface(placed_params);
 
76
        };
 
77
 
 
78
    return window_manager->add_surface(session, params, build);
 
79
}
 
80
 
 
81
void msh::AbstractShell::modify_surface(std::shared_ptr<scene::Session> const& session, std::shared_ptr<scene::Surface> const& surface, SurfaceSpecification const& modifications)
 
82
{
 
83
    window_manager->modify_surface(session, surface, modifications);
68
84
}
69
85
 
70
86
void msh::AbstractShell::destroy_surface(
71
87
    std::shared_ptr<ms::Session> const& session,
72
88
    mf::SurfaceId surface)
73
89
{
 
90
    window_manager->remove_surface(session, session->surface(surface));
74
91
    session->destroy_surface(surface);
75
92
}
76
93
 
77
 
void msh::AbstractShell::handle_surface_created(
78
 
    std::shared_ptr<ms::Session> const& /*session*/)
79
 
{
80
 
}
81
 
 
82
94
std::shared_ptr<ms::PromptSession> msh::AbstractShell::start_prompt_session_for(
83
95
    std::shared_ptr<ms::Session> const& session,
84
96
    scene::PromptSessionCreationParameters const& params)
100
112
}
101
113
 
102
114
int msh::AbstractShell::set_surface_attribute(
103
 
    std::shared_ptr<ms::Session> const& /*session*/,
 
115
    std::shared_ptr<ms::Session> const& session,
104
116
    std::shared_ptr<ms::Surface> const& surface,
105
117
    MirSurfaceAttrib attrib,
106
118
    int value)
107
119
{
108
 
    return surface->configure(attrib, value);
 
120
    return window_manager->set_surface_attribute(session, surface, attrib, value);
109
121
}
110
122
 
111
123
int msh::AbstractShell::get_surface_attribute(
116
128
}
117
129
 
118
130
 
119
 
void msh::AbstractShell::focus_next()
 
131
void msh::AbstractShell::focus_next_session()
120
132
{
121
133
    std::unique_lock<std::mutex> lock(focus_mutex);
122
 
    auto focus = focus_session.lock();
123
 
 
124
 
    focus = session_coordinator->successor_of(focus);
125
 
 
126
 
    set_focus_to_locked(lock, focus);
 
134
    auto session = focus_session.lock();
 
135
 
 
136
    session = session_coordinator->successor_of(session);
 
137
 
 
138
    std::shared_ptr<ms::Surface> surface;
 
139
 
 
140
    if (session)
 
141
        surface = session->default_surface();
 
142
 
 
143
    set_focus_to_locked(lock, session, surface);
127
144
}
128
145
 
129
 
std::weak_ptr<ms::Session> msh::AbstractShell::focussed_application() const
 
146
std::shared_ptr<ms::Session> msh::AbstractShell::focused_session() const
130
147
{
131
148
    std::unique_lock<std::mutex> lg(focus_mutex);
132
 
    return focus_session;
 
149
    return focus_session.lock();
 
150
}
 
151
 
 
152
std::shared_ptr<ms::Surface> msh::AbstractShell::focused_surface() const
 
153
{
 
154
    std::unique_lock<std::mutex> lock(focus_mutex);
 
155
    return focus_surface.lock();
133
156
}
134
157
 
135
158
void msh::AbstractShell::set_focus_to(
136
 
    std::shared_ptr<scene::Session> const& focus)
 
159
    std::shared_ptr<ms::Session> const& focus_session,
 
160
    std::shared_ptr<ms::Surface> const& focus_surface)
137
161
{
138
 
    std::unique_lock<std::mutex> lg(focus_mutex);
139
 
    set_focus_to_locked(lg, focus);
 
162
    std::unique_lock<std::mutex> lock(focus_mutex);
 
163
 
 
164
    set_focus_to_locked(lock, focus_session, focus_surface);
140
165
}
141
166
 
142
167
void msh::AbstractShell::set_focus_to_locked(
143
168
    std::unique_lock<std::mutex> const& /*lock*/,
 
169
    std::shared_ptr<ms::Session> const& session,
144
170
    std::shared_ptr<ms::Surface> const& surface)
145
171
{
146
 
    setting_focus_to(surface);
147
 
 
148
172
    if (surface)
149
173
    {
150
 
        // Ensure the surface has really taken the focus before notifying it that it is focused
151
 
        surface->take_input_focus(input_targeter);
152
 
        if (auto current_focus = focus_surface.lock())
153
 
            current_focus->configure(mir_surface_attrib_focus, mir_surface_unfocused);
154
 
 
155
 
        surface->configure(mir_surface_attrib_focus, mir_surface_focused);
156
 
        focus_surface = surface;
 
174
        auto current_focus = focus_surface.lock();
 
175
 
 
176
        if (surface != current_focus)
 
177
        {
 
178
            // Ensure the surface has really taken the focus before notifying it that it is focused
 
179
            input_targeter->set_focus(surface);
 
180
            if (current_focus)
 
181
                current_focus->configure(mir_surface_attrib_focus, mir_surface_unfocused);
 
182
 
 
183
            surface->configure(mir_surface_attrib_focus, mir_surface_focused);
 
184
            focus_surface = surface;
 
185
        }
157
186
    }
158
187
    else
159
188
    {
160
 
        input_targeter->focus_cleared();
 
189
        input_targeter->clear_focus();
161
190
    }
162
 
}
163
 
 
164
 
void msh::AbstractShell::set_focus_to_locked(
165
 
    std::unique_lock<std::mutex> const& lock,
166
 
    std::shared_ptr<ms::Session> const& session)
167
 
{
168
 
    setting_focus_to(session);
169
 
 
170
 
    auto old_focus = focus_session.lock();
171
 
 
172
 
    std::shared_ptr<ms::Surface> surface;
173
 
 
174
 
    if (session)
175
 
        surface = session->default_surface();
176
 
 
177
 
    set_focus_to_locked(lock, surface);
178
191
 
179
192
    focus_session = session;
180
193
 
188
201
    }
189
202
}
190
203
 
191
 
void msh::AbstractShell::setting_focus_to(std::shared_ptr<ms::Surface> const& /*surface*/)
192
 
{
193
 
}
194
 
 
195
 
void msh::AbstractShell::setting_focus_to(std::shared_ptr<ms::Session> const& /*session*/)
196
 
{
197
 
}
 
204
void msh::AbstractShell::add_display(geometry::Rectangle const& area)
 
205
{
 
206
    window_manager->add_display(area);
 
207
}
 
208
 
 
209
void msh::AbstractShell::remove_display(geometry::Rectangle const& area)
 
210
{
 
211
    window_manager->remove_display(area);
 
212
}
 
213
 
 
214
bool msh::AbstractShell::handle(MirEvent const& event)
 
215
{
 
216
    if (mir_event_get_type(&event) != mir_event_type_input)
 
217
        return false;
 
218
 
 
219
    auto const input_event = mir_event_get_input_event(&event);
 
220
 
 
221
    switch (mir_input_event_get_type(input_event))
 
222
    {
 
223
    case mir_input_event_type_key:
 
224
        return window_manager->handle_keyboard_event(mir_input_event_get_keyboard_event(input_event));
 
225
 
 
226
    case mir_input_event_type_touch:
 
227
        return window_manager->handle_touch_event(mir_input_event_get_touch_event(input_event));
 
228
 
 
229
    case mir_input_event_type_pointer:
 
230
        return window_manager->handle_pointer_event(mir_input_event_get_pointer_event(input_event));
 
231
    }
 
232
 
 
233
    return false;
 
234
}
 
235
 
 
236
auto msh::AbstractShell::surface_at(geometry::Point cursor) const
 
237
-> std::shared_ptr<scene::Surface>
 
238
{
 
239
    return surface_coordinator->surface_at(cursor);
 
240
}
 
241
 
 
242
void msh::AbstractShell::raise(SurfaceSet const& surfaces)
 
243
{
 
244
    surface_coordinator->raise(surfaces);
 
245
}
 
246