← Back to branch summary

~mir-team/unity-system-compositor/development-branch

« back to all changes in this revision

Viewing changes to src/system_compositor.cpp

  • Committer: CI bot
  • Author(s): Cemil Azizoglu, Kevin Gunn, Alberto Aguirre, Michał Sawicz
  • Date: 2014-06-05 13:49:52 UTC
  • mfrom: (137 devel)
  • mto: (137.1.1 usc-devel)
  • mto: This revision was merged to the branch mainline in revision 138.
  • Revision ID: ps-jenkins@lists.canonical.com-20140605134952-k3mfoe24e5usvken
Bumped Mir server ABI to 20. 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/system_compositor.cpp
63
63
    // These are defined below, since they reference methods defined in other classes
64
64
    void mark_ready();
65
65
    void raise(std::shared_ptr<msc::SurfaceCoordinator> const& coordinator);
66
 
    std::shared_ptr<mf::Surface> get_surface(mf::SurfaceId surface) const;
67
 
    mf::SurfaceId create_surface(msc::SurfaceCreationParameters const& params);
 
66
    std::shared_ptr<mf::Surface> get_surface(mf::SurfaceId surface) const override;
 
67
    mf::SurfaceId create_surface(msc::SurfaceCreationParameters const& params) override;
68
68
 
69
69
    bool is_ready() const
70
70
    {
76
76
        return self;
77
77
    }
78
78
 
79
 
    void destroy_surface(mf::SurfaceId surface)
 
79
    void destroy_surface(mf::SurfaceId surface) override
80
80
    {
81
81
        surfaces.erase(surface);
82
82
        self->destroy_surface(surface);
91
91
        return vector;
92
92
    }
93
93
 
94
 
    std::string name() const {return self->name();}
95
 
    void hide() {self->hide();}
96
 
    void show() {self->show();}
97
 
    void send_display_config(mg::DisplayConfiguration const&config) {self->send_display_config(config);}
98
 
    pid_t process_id() const {return self->process_id();}
99
 
    void force_requests_to_complete() {self->force_requests_to_complete();}
100
 
    void take_snapshot(msc::SnapshotCallback const& snapshot_taken) {self->take_snapshot(snapshot_taken);}
101
 
    std::shared_ptr<msc::Surface> default_surface() const {return self->default_surface();}
102
 
    void set_lifecycle_state(MirLifecycleState state) {self->set_lifecycle_state(state);}
 
94
    std::string name() const override {return self->name();}
 
95
    void hide() override {self->hide();}
 
96
    void show() override {self->show();}
 
97
    void send_display_config(mg::DisplayConfiguration const&config) override {self->send_display_config(config);}
 
98
    pid_t process_id() const override {return self->process_id();}
 
99
    void force_requests_to_complete() override {self->force_requests_to_complete();}
 
100
    void take_snapshot(msc::SnapshotCallback const& snapshot_taken) override {self->take_snapshot(snapshot_taken);}
 
101
    std::shared_ptr<msc::Surface> default_surface() const override {return self->default_surface();}
 
102
    void set_lifecycle_state(MirLifecycleState state) override {self->set_lifecycle_state(state);}
103
103
 
104
104
private:
105
105
    std::shared_ptr<msc::Session> const self;
120
120
        return self;
121
121
    }
122
122
 
123
 
    void swap_buffers(mg::Buffer* old_buffer, std::function<void(mg::Buffer* new_buffer)> complete)
 
123
    void swap_buffers(mg::Buffer* old_buffer, std::function<void(mg::Buffer* new_buffer)> complete) override
124
124
    {
125
125
        self->swap_buffers(old_buffer, complete);
126
 
        // If we have content (and we're not the first buffer -- first buffer
127
 
        // is actually not enough in my experience; maybe a bug in Qt?)
128
 
        if (old_buffer != NULL && !session->is_ready() && buffer_count++ == 2)
 
126
        // Mark it available only after some content has been rendered
 
127
        if (old_buffer != NULL && !session->is_ready() && buffer_count++ == 1)
129
128
            session->mark_ready();
130
129
    }
131
130
 
132
131
    // mf::Surface methods
133
 
    void force_requests_to_complete() {self->force_requests_to_complete();}
134
 
    geom::Size size() const {return self->size();}
135
 
    MirPixelFormat pixel_format() const {return self->pixel_format();}
136
 
    bool supports_input() const {return self->supports_input();}
137
 
    int client_input_fd() const {return self->client_input_fd();}
138
 
    int configure(MirSurfaceAttrib attrib, int value) {return self->configure(attrib, value);}
139
 
 
140
 
    // msc::Surface methods
141
 
    std::string name() const {return self->name();}
142
 
    MirSurfaceType type() const {return self->type();}
143
 
    MirSurfaceState state() const {return self->state();}
144
 
    void hide() {self->hide();}
145
 
    void show() {self->show();}
146
 
    void move_to(geom::Point const& top_left) {self->move_to(top_left);}
147
 
    geom::Point top_left() const {return self->top_left();}
148
 
    void take_input_focus(std::shared_ptr<msh::InputTargeter> const& targeter) {self->take_input_focus(targeter);}
149
 
    void set_input_region(std::vector<geom::Rectangle> const& region) {self->set_input_region(region);}
150
 
    void allow_framedropping(bool allow) {self->allow_framedropping(allow);}
151
 
    void resize(geom::Size const& size) {self->resize(size);}
152
 
    void set_transformation(glm::mat4 const& t) {self->set_transformation(t);}
153
 
    float alpha() const {return self->alpha();}
154
 
    void set_alpha(float alpha) {self->set_alpha(alpha);}
155
 
    void with_most_recent_buffer_do(std::function<void(mg::Buffer&)> const& exec) {self->with_most_recent_buffer_do(exec);}
156
 
 
157
 
    // msc::Surface methods
158
 
    std::shared_ptr<mi::InputChannel> input_channel() const {return self->input_channel();}
159
 
    void add_observer(std::shared_ptr<msc::SurfaceObserver> const& observer) {self->add_observer(observer);}
160
 
    void remove_observer(std::shared_ptr<msc::SurfaceObserver> const& observer) {self->remove_observer(observer);}
 
132
    void force_requests_to_complete() override {self->force_requests_to_complete();}
 
133
    geom::Size size() const override {return self->size();}
 
134
    MirPixelFormat pixel_format() const override {return self->pixel_format();}
 
135
    bool supports_input() const override {return self->supports_input();}
 
136
    int client_input_fd() const override {return self->client_input_fd();}
 
137
    int configure(MirSurfaceAttrib attrib, int value) override {return self->configure(attrib, value);}
 
138
 
 
139
    // msc::Surface methods
 
140
    std::string name() const override {return self->name();}
 
141
    geom::Size client_size() const override { return self->client_size(); };
 
142
    geom::Rectangle input_bounds() const override { return self->input_bounds(); };
 
143
 
 
144
    MirSurfaceType type() const override {return self->type();}
 
145
    MirSurfaceState state() const override {return self->state();}
 
146
    void hide() override {self->hide();}
 
147
    void show() override {self->show();}
 
148
    void move_to(geom::Point const& top_left) override {self->move_to(top_left);}
 
149
    geom::Point top_left() const override {return self->top_left();}
 
150
    void take_input_focus(std::shared_ptr<msh::InputTargeter> const& targeter) override {self->take_input_focus(targeter);}
 
151
    void set_input_region(std::vector<geom::Rectangle> const& region) override {self->set_input_region(region);}
 
152
    void allow_framedropping(bool allow) override {self->allow_framedropping(allow);}
 
153
    void resize(geom::Size const& size) override {self->resize(size);}
 
154
    void set_transformation(glm::mat4 const& t) override {self->set_transformation(t);}
 
155
    float alpha() const override {return self->alpha();}
 
156
    void set_alpha(float alpha) override {self->set_alpha(alpha);}
 
157
    void with_most_recent_buffer_do(std::function<void(mg::Buffer&)> const& exec) override {self->with_most_recent_buffer_do(exec);}
 
158
 
 
159
    // msc::Surface methods
 
160
    std::shared_ptr<mi::InputChannel> input_channel() const override {return self->input_channel();}
 
161
    void set_reception_mode(mi::InputReceptionMode mode) override { self->set_reception_mode(mode); }
 
162
    void add_observer(std::shared_ptr<msc::SurfaceObserver> const& observer) override {self->add_observer(observer);}
 
163
    void remove_observer(std::weak_ptr<msc::SurfaceObserver> const& observer) override {self->remove_observer(observer);}
161
164
 
162
165
    // mi::Surface methods
163
 
    bool contains(geom::Point const& point) const {return self->contains(point);}
 
166
    bool input_area_contains(geom::Point const& point) const override {return self->input_area_contains(point);}
 
167
    mi::InputReceptionMode reception_mode() const override { return self->reception_mode(); }
164
168
 
165
169
    // mg::Renderable methods
166
 
    std::shared_ptr<mg::Buffer> buffer(void const* user_id) const {return self->buffer(user_id);}
167
 
    bool alpha_enabled() const {return self->alpha_enabled();}
168
 
    geom::Rectangle screen_position() const {return self->screen_position();}
169
 
    glm::mat4 transformation() const {return self->transformation();}
170
 
    bool visible() const {return self->visible();}
171
 
    bool shaped() const {return self->shaped();}
172
 
    int buffers_ready_for_compositor() const {return self->buffers_ready_for_compositor();}
173
 
    mg::Renderable::ID id() const {return self->id();}
 
170
    std::unique_ptr<mg::Renderable> compositor_snapshot(void const* compositor_id) const override { return self->compositor_snapshot(compositor_id); }
174
171
 
175
172
private:
176
173
    std::shared_ptr<msc::Surface> const self;
283
280
    std::shared_ptr<mf::Session> open_session(
284
281
        pid_t client_pid,
285
282
        std::string const& name,
286
 
        std::shared_ptr<mf::EventSink> const& sink)
 
283
        std::shared_ptr<mf::EventSink> const& sink) override
287
284
    {
288
285
        std::cerr << "Opening session " << name << std::endl;
289
286
 
306
303
        return result;
307
304
    }
308
305
 
309
 
    void close_session(std::shared_ptr<mf::Session> const& session_in)
 
306
    void close_session(std::shared_ptr<mf::Session> const& session_in) override
310
307
    {
311
308
        std::cerr << "Closing session " << session_in->name() << std::endl;
312
309
 
323
320
 
324
321
    mf::SurfaceId create_surface_for(
325
322
        std::shared_ptr<mf::Session> const& session,
326
 
        msc::SurfaceCreationParameters const& params)
 
323
        msc::SurfaceCreationParameters const& params) override
327
324
    {
328
325
        return self->create_surface_for(session, params);
329
326
    }
330
327
 
331
 
    void handle_surface_created(std::shared_ptr<mf::Session> const& session)
 
328
    void handle_surface_created(std::shared_ptr<mf::Session> const& session) override
332
329
    {
333
330
        self->handle_surface_created(session);
334
331
 
354
351
class SystemCompositorScene : public mc::Scene
355
352
{
356
353
public:
357
 
    SystemCompositorScene(std::shared_ptr<mc::Scene> const& self,
358
 
                          std::shared_ptr<SystemCompositorShell> shell)
359
 
        : self{self}, shell{shell} {}
360
 
 
361
 
    mg::RenderableList generate_renderable_list() const
362
 
    {
 
354
    SystemCompositorScene(std::shared_ptr<mc::Scene> const& self)
 
355
        : self{self}, shell{nullptr} {}
 
356
 
 
357
    void set_shell(std::shared_ptr<SystemCompositorShell> const& the_shell)
 
358
    {
 
359
        shell = the_shell;
 
360
    }
 
361
 
 
362
    mg::RenderableList renderable_list_for(CompositorID id) const override
 
363
    {
 
364
        if (shell == nullptr)
 
365
            return self->renderable_list_for(id);
 
366
 
363
367
        mg::RenderableList list;
364
368
        std::shared_ptr<SystemCompositorSession> session;
365
369
 
367
371
        if (session)
368
372
        {
369
373
            for (auto const& surface : session->get_surfaces())
370
 
                list.emplace_back(surface);
 
374
                list.emplace_back(surface->compositor_snapshot(id));
371
375
        }
372
376
 
373
377
        session = shell->get_active_session();
374
378
        if (session)
375
379
        {
376
380
            for (auto const& surface : session->get_surfaces())
377
 
                list.emplace_back(surface);
 
381
                list.emplace_back(surface->compositor_snapshot(id));
378
382
        }
379
383
 
380
384
        return list;
381
385
    }
382
386
 
383
 
    void set_change_callback(std::function<void()> const& f) {self->set_change_callback(f);}
 
387
    void add_observer(std::shared_ptr<msc::Observer> const& observer) override { self->add_observer(observer); }
 
388
    void remove_observer(std::weak_ptr<msc::Observer> const& observer) override { self->remove_observer(observer); }
384
389
 
385
390
private:
386
391
    std::shared_ptr<mc::Scene> const self;
387
 
    std::shared_ptr<SystemCompositorShell> const shell;
 
392
    std::shared_ptr<SystemCompositorShell> shell;
388
393
};
389
394
 
390
395
 
534
539
 
535
540
    std::shared_ptr<SystemCompositorShell> the_system_compositor_shell()
536
541
    {
537
 
        return sc_shell([this]
 
542
        auto shell =  sc_shell([this]
538
543
        {
539
544
            return std::make_shared<SystemCompositorShell>(
540
545
                compositor,
542
547
                the_focus_controller(),
543
548
                the_surface_coordinator());
544
549
        });
 
550
 
 
551
        the_system_compositor_scene()->set_shell(shell);
 
552
        return shell;
545
553
    }
546
554
 
547
 
    std::shared_ptr<mc::Scene> the_scene()
 
555
    std::shared_ptr<SystemCompositorScene> the_system_compositor_scene()
548
556
    {
549
557
        return sc_scene([this]
550
558
        {
551
559
            return std::make_shared<SystemCompositorScene>(
552
 
                mir::DefaultServerConfiguration::the_scene(),
553
 
                the_system_compositor_shell());
 
560
                mir::DefaultServerConfiguration::the_scene());
554
561
        });
555
562
    }
556
563
 
 
564
    std::shared_ptr<mc::Scene> the_scene()
 
565
    {
 
566
        return the_system_compositor_scene();
 
567
    }
 
568
 
557
569
private:
558
570
    mir::CachedPtr<SystemCompositorShell> sc_shell;
559
571
    mir::CachedPtr<SystemCompositorScene> sc_scene;