RADSlintBackend.h

Go to the documentation of this file.

#ifndef RADSLINTBACKEND_H
#define RADSLINTBACKEND_H
 
#pragma once
 
#include <RADUi/RADUi.h>
#include <RADUi/RADTheme.h>
 
#include <slint.h>
 
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace RADUi::Slint {
 
    class SlintBackend : public RADUi::Backend {
    public:
        SlintBackend();
 
        void run() override;
        void quit() override;
        void postToUi(std::function<void()> task) override;
        bool isUiThread() const override;
 
    private:
        std::thread::id uiThreadId_;
    };
 
    std::shared_ptr<SlintBackend> installBackend();
 
    template<typename Component, typename F>
    void postToComponent(const slint::ComponentHandle<Component>& component, F&& action) {
        slint::ComponentWeakHandle<Component> weakComponent(component);
        RADUi::postToUi([weakComponent, action = std::forward<F>(action)]() mutable {
            if (auto componentHandle = weakComponent.lock()) {
                action(*componentHandle);
            }
        });
    }
 
    namespace Detail {
        template<typename Component, typename Callback, typename... Args>
        class EventComponentBridge : public RADCore::RADObject {
        public:
            EventComponentBridge(
                RADCore::Event<void(Args...)>& event,
                const slint::ComponentHandle<Component>& component,
                Callback callback)
                : weakComponent_(component), callback_(std::move(callback)) {
                connection_ = event.connect(this, &EventComponentBridge::handle);
            }
 
            void handle(Args... args) {
                using StoredArgs = std::tuple<std::decay_t<Args>...>;
                StoredArgs storedArgs(std::forward<Args>(args)...);
                auto weakComponent = weakComponent_;
                auto callback = callback_;
 
                RADUi::postToUi([weakComponent, callback, storedArgs = std::move(storedArgs)]() mutable {
                    if (auto componentHandle = weakComponent.lock()) {
                        std::apply([&](auto&&... unpacked) {
                            callback(*componentHandle, std::forward<decltype(unpacked)>(unpacked)...);
                        }, std::move(storedArgs));
                    }
                });
            }
 
        private:
            slint::ComponentWeakHandle<Component> weakComponent_;
            Callback callback_;
            RADCore::Connection connection_;
        };
 
        template<typename Component, typename Callback>
        class ThemeComponentBridge : public RADCore::RADObject {
        public:
            ThemeComponentBridge(
                RADUi::ThemeManager& manager,
                const slint::ComponentHandle<Component>& component,
                Callback callback)
                : manager_(manager), weakComponent_(component), callback_(std::move(callback)) {
                connection_ = manager_.changed.connect(this, &ThemeComponentBridge::handle);
                handle();
            }
 
            void handle() {
                auto weakComponent = weakComponent_;
                auto callback = callback_;
                auto theme = manager_.theme();
                RADUi::postToUi([weakComponent, callback, theme = std::move(theme)]() mutable {
                    if (auto componentHandle = weakComponent.lock()) {
                        callback(*componentHandle, theme);
                    }
                });
            }
 
        private:
            RADUi::ThemeManager& manager_;
            slint::ComponentWeakHandle<Component> weakComponent_;
            Callback callback_;
            RADCore::Connection connection_;
        };
    } // namespace Detail
 
    template<typename Component, typename... Args, typename F>
    RADUi::Binding connectEventToComponent(
        RADCore::Event<void(Args...)>& event,
        const slint::ComponentHandle<Component>& component,
        F&& callback) {
        using Bridge = Detail::EventComponentBridge<Component, std::decay_t<F>, Args...>;
        return RADUi::Binding(std::make_shared<Bridge>(event, component, std::forward<F>(callback)));
    }
 
    template<typename Component, typename... Args, typename F>
    RADUi::Binding bindEventToComponent(
        RADCore::Event<void(Args...)>& event,
        const slint::ComponentHandle<Component>& component,
        F&& callback) {
        return connectEventToComponent(event, component, std::forward<F>(callback));
    }
 
    template<typename Component, typename Value, typename Setter>
    RADUi::Binding bindProperty(
        RADCore::Event<void(Value)>& event,
        const slint::ComponentHandle<Component>& component,
        Setter setter) {
        return bindEventToComponent(event, component,
            [setter](auto componentHandle, Value value) mutable {
                ((*componentHandle).*setter)(std::move(value));
            });
    }
 
    template<typename Component, typename Value, typename Setter, typename Transform>
    RADUi::Binding bindProperty(
        RADCore::Event<void(Value)>& event,
        const slint::ComponentHandle<Component>& component,
        Setter setter,
        Transform transform) {
        return bindEventToComponent(event, component,
            [setter, transform = std::move(transform)](auto componentHandle, Value value) mutable {
                ((*componentHandle).*setter)(transform(std::move(value)));
            });
    }
 
    template<typename Component, typename F>
    RADUi::Binding bindTheme(
        RADUi::ThemeManager& manager,
        const slint::ComponentHandle<Component>& component,
        F&& callback) {
        using Bridge = Detail::ThemeComponentBridge<Component, std::decay_t<F>>;
        return RADUi::Binding(std::make_shared<Bridge>(manager, component, std::forward<F>(callback)));
    }
 
} // namespace RADUi::Slint
 
#endif