~ubuntu-branches/ubuntu/wily/mir/wily-proposed : revision 1.1.87

examples/server_example_window_manager.cpp

* This program is free software: you can redistribute it and/or modify it

* under the terms of the GNU General Public License version 3,

* as published by the Free Software Foundation.

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

* You should have received a copy of the GNU General Public License

* along with this program. If not, see <http://www.gnu.org/licenses/>.

* Authored By: Alan Griffiths <alan@octopull.co.uk>

#include "server_example_window_manager.h"

#include "server_example_window_management.h"

#include "mir/server.h"

#include "mir/compositor/display_buffer_compositor_factory.h"

#include "mir/compositor/display_buffer_compositor.h"

#include "mir/graphics/display_buffer.h"

#include "mir/options/option.h"

#include "mir/scene/session_listener.h"

namespace mc = mir::compositor;

namespace me = mir::examples;

namespace mg = mir::graphics;

namespace ms = mir::scene;

using namespace mir::geometry;

///\example server_example_window_manager.cpp

/// Demonstrate introducing a window management strategy

namespace

{

class SceneTracker : public ms::SessionListener

{

public:

SceneTracker(std::shared_ptr<me::WindowManager> const& window_manager) :

window_manager(window_manager)

{

}

private:

void starting(std::shared_ptr<ms::Session> const& session) override

{

window_manager->add_session(session);

}

void stopping(std::shared_ptr<ms::Session> const& session) override

{

window_manager->remove_session(session);

}

void focused(std::shared_ptr<ms::Session> const& /*session*/) override {}

void unfocused() override {}

void surface_created(ms::Session& session, std::shared_ptr<ms::Surface> const& surface) override

{

window_manager->add_surface(surface, &session);

}

void destroying_surface(ms::Session& session, std::shared_ptr<ms::Surface> const& surface) override

{

window_manager->remove_surface(surface, &session);

}

std::shared_ptr<me::WindowManager> const window_manager;

};

class DisplayTracker : public mc::DisplayBufferCompositor

{

public:

DisplayTracker(

std::unique_ptr<mc::DisplayBufferCompositor>&& wrapped,

Rectangle const& area,

std::shared_ptr<me::WindowManager> const& window_manager) :

wrapped{std::move(wrapped)},

area{area},

window_manager(window_manager)

{

window_manager->add_display(area);

}

~DisplayTracker() noexcept

{

window_manager->remove_display(area);

}

private:

void composite(mc::SceneElementSequence&& scene_sequence) override

{

wrapped->composite(std::move(scene_sequence));

100

}

101

102

std::unique_ptr<mc::DisplayBufferCompositor> const wrapped;

103

Rectangle const area;

104

std::shared_ptr<me::WindowManager> const window_manager;

105

};

106

107

class DisplayTrackerFactory : public mc::DisplayBufferCompositorFactory

108

{

109

public:

110

DisplayTrackerFactory(

111

std::shared_ptr<mc::DisplayBufferCompositorFactory> const& wrapped,

112

std::shared_ptr<me::WindowManager> const& window_manager) :

113

wrapped{wrapped},

114

window_manager(window_manager)

115

{

116

}

117

118

private:

119

std::unique_ptr<mc::DisplayBufferCompositor> create_compositor_for(mg::DisplayBuffer& display_buffer)

120

{

121

auto compositor = wrapped->create_compositor_for(display_buffer);

122

return std::unique_ptr<mc::DisplayBufferCompositor>{

123

new DisplayTracker{std::move(compositor), display_buffer.view_area(), window_manager}};

124

}

125

126

std::shared_ptr<mc::DisplayBufferCompositorFactory> const wrapped;

127

std::shared_ptr<me::WindowManager> const window_manager;

128

};

129

}

130

131

void me::add_window_manager_option_to(Server& server)

132

{

133

server.add_configuration_option(me::wm_option, me::wm_description, mir::OptionType::string);

134

135

auto const factory = std::make_shared<me::WindowManagmentFactory>(server);

136

137

server.override_the_placement_strategy([factory, &server]()

138

-> std::shared_ptr<ms::PlacementStrategy>

139

{

140

auto const options = server.get_options();

141

142

if (!options->is_set(me::wm_option))

143

return std::shared_ptr<ms::PlacementStrategy>{};

144

145

return factory->window_manager();

146

});

147

148

server.override_the_session_listener([factory, &server]()

149

-> std::shared_ptr<ms::SessionListener>

150

{

151

auto const options = server.get_options();

152

153

if (!options->is_set(me::wm_option))

154

return std::shared_ptr<ms::SessionListener>{};

155

156

return std::make_shared<SceneTracker>(factory->window_manager());

157

});

158

159

server.override_the_surface_configurator([factory, &server]()

160

-> std::shared_ptr<ms::SurfaceConfigurator>

161

{

162

auto const options = server.get_options();

163

164

if (!options->is_set(me::wm_option))

165

return std::shared_ptr<ms::SurfaceConfigurator>{};

166

167

return factory->window_manager();

168

});

169

170

server.wrap_display_buffer_compositor_factory([factory, &server]

171

(std::shared_ptr<mc::DisplayBufferCompositorFactory> const& wrapped)

172

-> std::shared_ptr<mc::DisplayBufferCompositorFactory>

173

{

174

auto const options = server.get_options();

175

176

if (!options->is_set(me::wm_option))

177

return wrapped;

178

179

return std::make_shared<DisplayTrackerFactory>(wrapped, factory->window_manager());

180

});

181

}

Older »