RADSlintPlot.h

Go to the documentation of this file.

#ifndef RADSLINTPLOT_H
#define RADSLINTPLOT_H
 
#pragma once
 
#include <RADUi/RADPlot.h>
#include <RADUi/RADSlintBackend.h>
 
#include <slint.h>
 
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
 
namespace RADUi::Slint {
 
    inline slint::Image toSlintImage(const RADUi::PlotImage& image) {
        const uint32_t width = static_cast<uint32_t>(std::max(1, image.width));
        const uint32_t height = static_cast<uint32_t>(std::max(1, image.height));
        slint::SharedPixelBuffer<slint::Rgba8Pixel> buffer(width, height);
 
        auto* pixels = buffer.begin();
        const size_t count = static_cast<size_t>(width * height);
        for (size_t i = 0; i < count; ++i) {
            const auto source = i < image.pixels.size()
                ? image.pixels[i]
                : RADUi::PlotPixel{};
            pixels[i] = {source.r, source.g, source.b, source.a};
        }
 
        return slint::Image(buffer);
    }
 
    namespace Detail {
        template<typename Component, typename Setter>
        class PlotComponentBridge : public RADCore::RADObject {
        public:
            PlotComponentBridge(
                RADUi::PlotModel& model,
                const slint::ComponentHandle<Component>& component,
                Setter setter,
                RADUi::PlotViewport viewport,
                double framesPerSecond,
                RADUi::PlotRenderMode renderMode)
                : state_(std::make_shared<State>(
                      model,
                      component,
                      setter,
                      viewport,
                      framesPerSecond,
                      renderMode)) {
                connection_ = model.dataChanged.connect(this, &PlotComponentBridge::handleDataChanged);
                handleDataChanged();
            }
 
            void handleDataChanged() {
                auto state = state_;
                state->scheduler.requestUpdate([state]() mutable {
                    if (auto componentHandle = state->weakComponent.lock()) {
                        const auto snapshot = state->model.snapshot();
                        auto image = state->renderer->render(snapshot, state->viewport);
                        auto& component = **componentHandle;
                        (component.*state->setter)(RADUi::Slint::toSlintImage(image));
                    }
                });
            }
 
        private:
            struct State {
                State(
                    RADUi::PlotModel& modelRef,
                    const slint::ComponentHandle<Component>& component,
                    Setter setterRef,
                    RADUi::PlotViewport viewportRef,
                    double framesPerSecond,
                    RADUi::PlotRenderMode renderMode)
                    : model(modelRef),
                      weakComponent(component),
                      setter(setterRef),
                      viewport(viewportRef),
                      scheduler(framesPerSecond),
                      renderer(RADUi::createPlotRenderer(renderMode)) {}
 
                RADUi::PlotModel& model;
                slint::ComponentWeakHandle<Component> weakComponent;
                Setter setter;
                RADUi::PlotViewport viewport;
                RADUi::FrameScheduler scheduler;
                std::unique_ptr<RADUi::PlotRenderer> renderer;
            };
 
            std::shared_ptr<State> state_;
            RADCore::Connection connection_;
        };
    } // namespace Detail
 
    template<typename Component, typename Setter>
    RADUi::Binding bindPlotToImageProperty(
        RADUi::PlotModel& model,
        const slint::ComponentHandle<Component>& component,
        Setter setter,
        RADUi::PlotViewport viewport,
        double framesPerSecond = 60.0,
        RADUi::PlotRenderMode renderMode = RADUi::PlotRenderMode::Software) {
        using Bridge = Detail::PlotComponentBridge<Component, Setter>;
        return RADUi::Binding(std::make_shared<Bridge>(
            model, component, setter, viewport, framesPerSecond, renderMode));
    }
 
} // namespace RADUi::Slint
 
#endif