← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/server/scene/application_session.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/scene/application_session.cpp
16
16
 * Authored by: Robert Carr <racarr@canonical.com>
17
17
 */
18
18
 
19
 
#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
20
 
 
21
19
#include "application_session.h"
22
20
#include "snapshot_strategy.h"
23
21
#include "default_session_container.h"
 
22
#include "surfaceless_buffer_stream.h"
24
23
 
25
24
#include "mir/scene/surface.h"
26
25
#include "mir/scene/surface_event_source.h"
27
26
#include "mir/scene/surface_coordinator.h"
28
27
#include "mir/scene/surface_creation_parameters.h"
29
28
#include "mir/scene/session_listener.h"
 
29
#include "mir/scene/buffer_stream_factory.h"
30
30
#include "mir/events/event_builders.h"
31
31
#include "mir/frontend/event_sink.h"
32
32
 
46
46
 
47
47
ms::ApplicationSession::ApplicationSession(
48
48
    std::shared_ptr<ms::SurfaceCoordinator> const& surface_coordinator,
 
49
    std::shared_ptr<ms::BufferStreamFactory> const& buffer_stream_factory,
49
50
    pid_t pid,
50
51
    std::string const& session_name,
51
52
    std::shared_ptr<SnapshotStrategy> const& snapshot_strategy,
52
53
    std::shared_ptr<SessionListener> const& session_listener,
53
54
    std::shared_ptr<mf::EventSink> const& sink) :
54
55
    surface_coordinator(surface_coordinator),
 
56
    buffer_stream_factory(buffer_stream_factory),
55
57
    pid(pid),
56
58
    session_name(session_name),
57
59
    snapshot_strategy(snapshot_strategy),
64
66
 
65
67
ms::ApplicationSession::~ApplicationSession()
66
68
{
67
 
    std::unique_lock<std::mutex> lock(surfaces_mutex);
 
69
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
68
70
    for (auto const& pair_id_surface : surfaces)
69
71
    {
70
72
        session_listener->destroying_surface(*this, pair_id_surface.second);
99
101
    surf->add_observer(observer);
100
102
 
101
103
    {
102
 
        std::unique_lock<std::mutex> lock(surfaces_mutex);
 
104
        std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
103
105
        surfaces[id] = surf;
104
106
    }
105
107
 
124
126
 
125
127
std::shared_ptr<ms::Surface> ms::ApplicationSession::surface(mf::SurfaceId id) const
126
128
{
127
 
    std::unique_lock<std::mutex> lock(surfaces_mutex);
 
129
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
128
130
 
129
131
    return checked_find(id)->second;
130
132
}
131
133
 
 
134
std::shared_ptr<ms::Surface> ms::ApplicationSession::surface_after(std::shared_ptr<ms::Surface> const& before) const
 
135
{
 
136
    std::lock_guard<std::mutex> lock(surfaces_and_streams_mutex);
 
137
    auto i = surfaces.begin();
 
138
    for (; i != surfaces.end(); ++i)
 
139
    {
 
140
        if (i->second == before)
 
141
            break;
 
142
    }
 
143
    if (i == surfaces.end())
 
144
        BOOST_THROW_EXCEPTION(std::runtime_error("surface_after: surface is not a member of this session"));
 
145
 
 
146
    i = std::find_if(++i, end(surfaces), [](Surfaces::value_type const& s)
 
147
        {
 
148
            switch (s.second->type())
 
149
            {
 
150
            case mir_surface_type_normal:       /**< AKA "regular"                       */
 
151
            case mir_surface_type_utility:      /**< AKA "floating"                      */
 
152
            case mir_surface_type_dialog:
 
153
            case mir_surface_type_satellite:    /**< AKA "toolbox"/"toolbar"             */
 
154
            case mir_surface_type_freestyle:
 
155
            case mir_surface_type_menu:
 
156
            case mir_surface_type_inputmethod:  /**< AKA "OSK" or handwriting etc.       */
 
157
                return true;
 
158
 
 
159
            case mir_surface_type_gloss:
 
160
            case mir_surface_type_tip:          /**< AKA "tooltip"                       */
 
161
            default:
 
162
                // Cannot have input focus - skip it
 
163
                return false;
 
164
            }
 
165
        });
 
166
 
 
167
    if (i == surfaces.end())
 
168
        i = surfaces.begin();
 
169
 
 
170
    return i->second;
 
171
}
 
172
 
132
173
void ms::ApplicationSession::take_snapshot(SnapshotCallback const& snapshot_taken)
133
174
{
134
175
    if (auto surface = default_surface())
139
180
 
140
181
std::shared_ptr<ms::Surface> ms::ApplicationSession::default_surface() const
141
182
{
142
 
    std::unique_lock<std::mutex> lock(surfaces_mutex);
 
183
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
143
184
 
144
185
    if (surfaces.size())
145
186
        return surfaces.begin()->second;
149
190
 
150
191
void ms::ApplicationSession::destroy_surface(mf::SurfaceId id)
151
192
{
152
 
    std::unique_lock<std::mutex> lock(surfaces_mutex);
 
193
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
153
194
    auto p = checked_find(id);
154
195
    auto const surface = p->second;
155
196
 
173
214
 
174
215
void ms::ApplicationSession::force_requests_to_complete()
175
216
{
176
 
    std::unique_lock<std::mutex> lock(surfaces_mutex);
 
217
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
177
218
    for (auto& id_s : surfaces)
178
219
    {
179
220
        id_s.second->force_requests_to_complete();
182
223
 
183
224
void ms::ApplicationSession::hide()
184
225
{
185
 
    std::unique_lock<std::mutex> lock(surfaces_mutex);
 
226
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
186
227
    for (auto& id_s : surfaces)
187
228
    {
188
229
        id_s.second->hide();
191
232
 
192
233
void ms::ApplicationSession::show()
193
234
{
194
 
    std::unique_lock<std::mutex> lock(surfaces_mutex);
 
235
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
195
236
    for (auto& id_s : surfaces)
196
237
    {
197
238
        id_s.second->show();
228
269
{
229
270
    start_prompt_session();
230
271
}
 
272
 
 
273
std::shared_ptr<mf::BufferStream> ms::ApplicationSession::get_buffer_stream(mf::BufferStreamId id) const
 
274
{
 
275
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
 
276
 
 
277
    auto p = streams.find(id);
 
278
    if (p == streams.end())
 
279
        return checked_find(mf::SurfaceId(id.as_value()))->second;
 
280
    else 
 
281
        return p->second;
 
282
}
 
283
 
 
284
mf::BufferStreamId ms::ApplicationSession::create_buffer_stream(mg::BufferProperties const& props)
 
285
{
 
286
    auto const id = static_cast<mf::BufferStreamId>(next_id().as_value());
 
287
    auto stream = std::make_shared<ms::SurfacelessBufferStream>(buffer_stream_factory->create_buffer_stream(2, props));
 
288
    
 
289
    {
 
290
        std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
 
291
        streams[id] = stream;
 
292
    }
 
293
 
 
294
    return id;
 
295
}
 
296
 
 
297
void ms::ApplicationSession::destroy_buffer_stream(mf::BufferStreamId id)
 
298
{
 
299
    std::unique_lock<std::mutex> lock(surfaces_and_streams_mutex);
 
300
    auto p = streams.find(id);
 
301
    if (p == streams.end())
 
302
        BOOST_THROW_EXCEPTION(std::runtime_error("Invalid buffer stream id"));
 
303
    auto const stream = p->second;
 
304
 
 
305
    streams.erase(p);
 
306
}