Add Wayland decorations strategy

debian/libmiral7.symbols

@@ -434,6 +434,12 @@ libmiral.so.7 libmiral7 #MINVER#
  (c++)"vtable for miral::MinimalWindowManager@MIRAL_5.0" 5.0.0
  (c++)"vtable for miral::WindowManagementPolicy@MIRAL_5.0" 5.0.0
  MIRAL_5.1@MIRAL_5.1 5.1.0
+ (c++)"miral::Decorations::Decorations(std::shared_ptr<miral::Decorations::Self>)@MIRAL_5.1" 5.1.0
+ (c++)"miral::Decorations::always_csd()@MIRAL_5.1" 5.1.0
+ (c++)"miral::Decorations::always_ssd()@MIRAL_5.1" 5.1.0
+ (c++)"miral::Decorations::operator()(mir::Server&) const@MIRAL_5.1" 5.1.0
+ (c++)"miral::Decorations::prefer_csd()@MIRAL_5.1" 5.1.0
+ (c++)"miral::Decorations::prefer_ssd()@MIRAL_5.1" 5.1.0
  (c++)"miral::IdleListener::IdleListener()@MIRAL_5.1" 5.1.0
  (c++)"miral::IdleListener::on_dim(std::function<void ()> const&)@MIRAL_5.1" 5.1.0
  (c++)"miral::IdleListener::on_off(std::function<void ()> const&)@MIRAL_5.1" 5.1.0

include/miral/miral/decorations.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright © Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 or 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/>.
+ */
+
+#ifndef MIRAL_DECORATIONS_H
+#define MIRAL_DECORATIONS_H
+
+
+#include <memory>
+
+namespace mir { class Server; }
+
+namespace miral
+{
+/// Configures the window decoration strategy.
+/// \note The strategy can only be applied to clients that are able to negotiate the decoration style with the server.
+/// \remark Since MirAL 5.1
+class Decorations
+{
+public:
+    Decorations() = delete;
+    Decorations(Decorations const&) = default;
+    auto operator=(Decorations const&) -> Decorations& = default;
+
+    void operator()(mir::Server&) const;
+
+    /// Always use server side decorations regardless of the client's choice
+    static auto always_ssd() -> Decorations;
+
+    /// Always use client side decorations regardless of the client's choice
+    static auto always_csd() -> Decorations;
+
+    /// Prefer server side decorations if the client does not set a specific
+    /// mode. Otherwise use the mode specified by the client.
+    static auto prefer_ssd() -> Decorations;
+
+    /// Prefer client side decorations if the client does not set a specific
+    /// mode. Otherwise use the mode specified by the client.
+    static auto prefer_csd() -> Decorations;
+
+private:
+    struct Self;
+
+    Decorations(std::shared_ptr<Self> strategy);
+
+    std::shared_ptr<Self> self;
+};
+}
+
+#endif // MIRAL_DECORATIONS_H
+

src/include/server/mir/decoration_strategy.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright © Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 or 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/>.
+ */
+
+namespace mir
+{
+class DecorationStrategy
+{
+public:
+    enum class DecorationsType
+    {
+        csd,
+        ssd
+    };
+
+    virtual ~DecorationStrategy() = default;
+    virtual auto default_style() const -> DecorationsType = 0;
+    virtual auto request_style(DecorationsType type) const -> DecorationsType = 0;
+};
+}

src/include/server/mir/default_server_configuration.h

@@ -36,6 +36,7 @@ template<class Observer>
 class ObserverMultiplexer;
 
 class ConsoleServices;
+class DecorationStrategy;
 
 namespace dispatch
 {
@@ -334,6 +335,9 @@ class DefaultServerConfiguration : public virtual ServerConfiguration
 
     auto default_reports() -> std::shared_ptr<void>;
 
+    auto the_decoration_strategy() -> std::shared_ptr<DecorationStrategy> override;
+    void set_the_decoration_strategy(std::shared_ptr<DecorationStrategy> strategy) override;
+
 protected:
     std::shared_ptr<options::Option> the_options() const;
     std::shared_ptr<input::DefaultInputDeviceHub>  the_default_input_device_hub();
@@ -420,6 +424,7 @@ class DefaultServerConfiguration : public virtual ServerConfiguration
     CachedPtr<cookie::Authority> cookie_authority;
     CachedPtr<input::KeyMapper> key_mapper;
     std::shared_ptr<ConsoleServices> console_services;
+    std::shared_ptr<DecorationStrategy> decoration_strategy;
 
 private:
     std::shared_ptr<options::Configuration> const configuration_options;

src/include/server/mir/server.h

@@ -75,6 +75,7 @@ class RendererFactory;
 class Fd;
 class MainLoop;
 class ServerStatusListener;
+class DecorationStrategy;
 
 enum class OptionType
 {
@@ -476,6 +477,8 @@ class Server
     void set_enabled_wayland_extensions(std::vector<std::string> const& extensions);
 /** @} */
 
+    auto the_decoration_strategy() const -> std::shared_ptr<DecorationStrategy>;
+    void set_the_decoration_strategy(std::shared_ptr<DecorationStrategy> strategy);
 private:
     struct ServerConfiguration;
     struct Self;

src/include/server/mir/server_configuration.h

@@ -72,6 +72,7 @@ class ServerStatusListener;
 class DisplayChanger;
 class EmergencyCleanup;
 class ConsoleServices;
+class DecorationStrategy;
 
 class ServerConfiguration
 {
@@ -111,6 +112,8 @@ class ServerConfiguration
     virtual void set_wayland_extension_filter(WaylandProtocolExtensionFilter const& extension_filter) = 0;
     virtual void set_enabled_wayland_extensions(std::vector<std::string> const& extensions) = 0;
 
+    virtual auto the_decoration_strategy() -> std::shared_ptr<DecorationStrategy> = 0;
+    virtual void set_the_decoration_strategy(std::shared_ptr<DecorationStrategy> strategy) = 0;
 protected:
     ServerConfiguration() = default;
     virtual ~ServerConfiguration() = default;

src/miral/CMakeLists.txt

@@ -85,6 +85,7 @@ add_library(miral-external OBJECT
     ${miral_include}/miral/lambda_as_function.h
     x11_support.cpp                     ${miral_include}/miral/x11_support.h
     zone.cpp                            ${miral_include}/miral/zone.h
+    decorations.cpp                     ${miral_include}/miral/decorations.h
 )
 
 add_library(miral SHARED

src/miral/decorations.cpp

@@ -0,0 +1,86 @@
+/*
+ * Copyright © Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 or 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/>.
+ */
+
+#include "miral/decorations.h"
+
+#include <memory>
+
+#include <mir/default_server_configuration.h>
+#include <mir/server.h>
+#include <mir/decoration_strategy.h>
+
+
+struct miral::Decorations::Self : mir::DecorationStrategy
+{
+};
+
+void miral::Decorations::operator()(mir::Server& server) const
+{
+    server.add_pre_init_callback(
+        [this, &server]()
+        {
+            server.set_the_decoration_strategy(self);
+        });
+}
+
+miral::Decorations::Decorations(std::shared_ptr<Self> strategy) :
+    self{std::move(strategy)}
+{
+}
+
+auto miral::Decorations::always_ssd() -> Decorations
+{
+    struct AlwaysServerSide : Self
+    {
+        DecorationsType default_style() const override { return DecorationsType::ssd; }
+        DecorationsType request_style(DecorationsType) const override { return DecorationsType::ssd; }
+    };
+
+    return Decorations(std::make_shared<AlwaysServerSide>());
+}
+
+auto miral::Decorations::always_csd() -> Decorations
+{
+    struct AlwaysClientSide : Self
+    {
+        DecorationsType default_style() const override { return DecorationsType::csd; }
+        DecorationsType request_style(DecorationsType) const override { return DecorationsType::csd; }
+    };
+
+    return Decorations(std::make_shared<AlwaysClientSide>());
+}
+
+auto miral::Decorations::prefer_ssd() -> Decorations
+{
+    struct PreferServerSide : Self
+    {
+        DecorationsType default_style() const override { return DecorationsType::ssd; }
+        DecorationsType request_style(DecorationsType type) const override { return type; }
+    };
+
+    return Decorations(std::make_shared<PreferServerSide>());
+}
+
+auto miral::Decorations::prefer_csd() -> Decorations
+{
+    struct PreferClientSide : Self
+    {
+        DecorationsType default_style() const override { return DecorationsType::csd; }
+        DecorationsType request_style(DecorationsType type) const override { return type; }
+    };
+
+    return Decorations(std::make_shared<PreferClientSide>());
+}

src/miral/symbols.map

@@ -456,13 +456,20 @@ local: *;
 MIRAL_5.1 {
 global:
   extern "C++" {
+    miral::Decorations::Decorations*;
+    miral::Decorations::always_csd*;
+    miral::Decorations::always_ssd*;
+    miral::Decorations::operator*;
+    miral::Decorations::prefer_csd*;
+    miral::Decorations::prefer_ssd*;
     miral::IdleListener::?IdleListener*;
     miral::IdleListener::IdleListener*;
     miral::IdleListener::on_dim*;
     miral::IdleListener::on_off*;
     miral::IdleListener::on_wake*;
     miral::IdleListener::operator*;
-    typeinfo?for?miral::IdleListener;
     miral::WindowManagerTools::move_cursor_to*;
+    typeinfo?for?miral::IdleListener;
+    typeinfo?for?miral::Decorations;
   };
 } MIRAL_5.0;

src/server/default_server_configuration.cpp

@@ -38,6 +38,7 @@
 #include "default_emergency_cleanup.h"
 #include "mir/graphics/platform.h"
 #include "mir/console_services.h"
+#include "mir/decoration_strategy.h"
 
 namespace mc = mir::compositor;
 namespace geom = mir::geometry;
@@ -198,3 +199,24 @@ auto mir::DefaultServerConfiguration::the_logger()
             return std::make_shared<ml::DumbConsoleLogger>();
         });
 }
+
+auto mir::DefaultServerConfiguration::the_decoration_strategy() -> std::shared_ptr<mir::DecorationStrategy>
+{
+    if (!decoration_strategy)
+    {
+        class DefaultDecorationStrategy: public mir::DecorationStrategy
+        {
+            DecorationsType default_style() const override { return DecorationsType::csd; }
+            DecorationsType request_style(DecorationsType type) const override { return type; }
+        };
+
+        decoration_strategy = std::make_shared<DefaultDecorationStrategy>();
+    }
+
+    return decoration_strategy;
+}
+
+void mir::DefaultServerConfiguration::set_the_decoration_strategy(std::shared_ptr<mir::DecorationStrategy> strategy)
+{
+    decoration_strategy = strategy;
+}

src/server/frontend_wayland/wayland_connector.cpp

@@ -239,7 +239,8 @@ mf::WaylandConnector::WaylandConnector(
     std::unique_ptr<WaylandExtensions> extensions_,
     WaylandProtocolExtensionFilter const& extension_filter,
     bool enable_key_repeat,
-    std::shared_ptr<scene::SessionLock> const& session_lock)
+    std::shared_ptr<scene::SessionLock> const& session_lock,
+    std::shared_ptr<mir::DecorationStrategy> const& decoration_strategy)
     : extension_filter{extension_filter},
       display{wl_display_create(), &cleanup_display},
       pause_signal{eventfd(0, EFD_CLOEXEC | EFD_SEMAPHORE)},
@@ -325,7 +326,8 @@ mf::WaylandConnector::WaylandConnector(
         screen_shooter,
         main_loop,
         desktop_file_manager,
-        session_lock_});
+        session_lock_,
+        decoration_strategy});
 
     shm_global = std::make_unique<WlShm>(display.get(), executor);
 

src/server/frontend_wayland/wayland_connector.h

@@ -36,6 +36,7 @@ class Executor;
 class MainLoop;
 template<typename>
 class ObserverRegistrar;
+class DecorationStrategy;
 
 namespace compositor
 {
@@ -110,6 +111,7 @@ class WaylandExtensions
         std::shared_ptr<MainLoop> main_loop;
         std::shared_ptr<DesktopFileManager> desktop_file_manager;
         std::shared_ptr<scene::SessionLock> session_lock;
+        std::shared_ptr<mir::DecorationStrategy> decoration_strategy;
     };
 
     WaylandExtensions() = default;
@@ -161,7 +163,8 @@ class WaylandConnector : public Connector
         std::unique_ptr<WaylandExtensions> extensions,
         WaylandProtocolExtensionFilter const& extension_filter,
         bool enable_key_repeat,
-        std::shared_ptr<scene::SessionLock> const& session_lock);
+        std::shared_ptr<scene::SessionLock> const& session_lock,
+        std::shared_ptr<DecorationStrategy> const& decoration_strategy);
 
     ~WaylandConnector() override;
 

src/server/frontend_wayland/wayland_default_configuration.cpp

@@ -218,7 +218,7 @@ std::vector<ExtensionBuilder> const internal_extension_builders = {
         }),
     make_extension_builder<mw::XdgDecorationManagerV1>([](auto const& ctx)
 	{
-	    return mf::create_xdg_decoration_unstable_v1(ctx.display);
+	    return mf::create_xdg_decoration_unstable_v1(ctx.display, ctx.decoration_strategy);
 	})
 };
 
@@ -375,7 +375,8 @@ std::shared_ptr<mf::Connector>
                     wayland_extension_hooks),
                 wayland_extension_filter,
                 enable_repeat,
-                the_session_lock());
+                the_session_lock(),
+                the_decoration_strategy());
         });
 }