parameter_binding.hpp

Go to the documentation of this file.

#pragma once

 
#include <optional>
#include <pulp/state/parameter.hpp>
#include <pulp/state/store.hpp>
#include <pulp/view/design_frame_view.hpp> // DesignStepper
#include <pulp/view/ui_components.hpp>     // ComboBox
#include <pulp/view/widgets.hpp>
#include <utility>
 
namespace pulp::view {

class ParameterBinding {
public:
    ParameterBinding() = default;
    explicit ParameterBinding(state::ListenerToken token) : token_(std::move(token)) {}
    ParameterBinding(state::ListenerToken token, state::StateStore::ModulationWatch watch)
        : token_(std::move(token)), watch_(std::move(watch)) {}

    ParameterBinding(state::ListenerToken token, state::StateStore::ModulationWatch watch,
                     state::StateStore::ModulationWatch second_watch)
        : token_(std::move(token)), watch_(std::move(watch)),
          second_watch_(std::move(second_watch)) {}
    ParameterBinding(ParameterBinding&&) noexcept = default;
    ParameterBinding& operator=(ParameterBinding&&) noexcept = default;
    ParameterBinding(const ParameterBinding&) = delete;
    ParameterBinding& operator=(const ParameterBinding&) = delete;
 
private:
    state::ListenerToken token_;
    state::StateStore::ModulationWatch watch_;
    state::StateStore::ModulationWatch second_watch_;
};
 
namespace detail {
template <typename Control>
state::StateStore::ModulationWatch
watch_modulated_display(Control& control, state::StateStore& store, state::ParamID id) {
    return store.watch_modulation(id, [&control](std::optional<float> played) {
        if (played)
            control.set_modulated_value(*played);
        else
            control.clear_modulated_value();
    });
}
} // namespace detail

[[nodiscard]] inline ParameterBinding
bind_parameter(Knob& knob, state::StateStore& store, state::ParamID id) {
    knob.set_value(store.get_normalized(id));
    knob.on_gesture_begin = [&store, id] { store.begin_gesture(id); };
    knob.on_change = [&store, id](float v) { store.set_normalized(id, v); };
    knob.on_gesture_end = [&store, id] { store.end_gesture(id); };
    return ParameterBinding(store.add_listener(
                                [&knob, &store, id](state::ParamID changed, float) {
                                    if (changed == id)
                                        knob.set_value(store.get_normalized(id));
                                },
                                state::ListenerThread::Main,
                                state::ListenerRestoreBehavior::Reconcile),
                            detail::watch_modulated_display(knob, store, id));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(Fader& fader, state::StateStore& store, state::ParamID id) {
    fader.set_value(store.get_normalized(id));
    fader.on_gesture_begin = [&store, id] { store.begin_gesture(id); };
    fader.on_change = [&store, id](float v) { store.set_normalized(id, v); };
    fader.on_gesture_end = [&store, id] { store.end_gesture(id); };
    return ParameterBinding(store.add_listener(
                                [&fader, &store, id](state::ParamID changed, float) {
                                    if (changed == id)
                                        fader.set_value(store.get_normalized(id));
                                },
                                state::ListenerThread::Main,
                                state::ListenerRestoreBehavior::Reconcile),
                            detail::watch_modulated_display(fader, store, id));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(XYPad& pad, state::StateStore& store, state::ParamID x_id, state::ParamID y_id) {
    pad.on_gesture_begin = [&store, x_id, y_id] {
        store.begin_gesture(x_id);
        store.begin_gesture(y_id);
    };
    pad.on_change = [&store, x_id, y_id](float x, float y) {
        store.set_normalized(x_id, x);
        store.set_normalized(y_id, y);
    };
    pad.on_gesture_end = [&store, x_id, y_id] {
        store.end_gesture(x_id);
        store.end_gesture(y_id);
    };
    pad.set_x(store.get_normalized(x_id));
    pad.set_y(store.get_normalized(y_id));
    return ParameterBinding(store.add_listener(
                                [&pad, &store, x_id, y_id](state::ParamID changed, float) {
                                    if (changed == x_id)
                                        pad.set_x(store.get_normalized(x_id));
                                    if (changed == y_id)
                                        pad.set_y(store.get_normalized(y_id));
                                },
                                state::ListenerThread::Main,
                                state::ListenerRestoreBehavior::Reconcile),
                            store.watch_modulation(x_id,
                                                   [&pad](std::optional<float> played) {
                                                       if (played)
                                                           pad.set_modulated_x(*played);
                                                       else
                                                           pad.clear_modulated_x();
                                                   }),
                            store.watch_modulation(y_id, [&pad](std::optional<float> played) {
                                if (played)
                                    pad.set_modulated_y(*played);
                                else
                                    pad.clear_modulated_y();
                            }));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(RangeSlider& slider, state::StateStore& store, state::ParamID id) {
    // Synced FROM the parameter without notifying, so playback never echoes
    // a write back into the store.
    slider.set_value(store.get_normalized(id), Notify::none);
    slider.on_gesture_begin = [&store, id] { store.begin_gesture(id); };
    slider.on_change = [&store, id](float v) { store.set_normalized(id, v); };
    slider.on_gesture_end = [&store, id] { store.end_gesture(id); };
    return ParameterBinding(store.add_listener(
                                [&slider, &store, id](state::ParamID changed, float) {
                                    if (changed == id)
                                        slider.set_value(store.get_normalized(id), Notify::none);
                                },
                                state::ListenerThread::Main,
                                state::ListenerRestoreBehavior::Reconcile),
                            detail::watch_modulated_display(slider, store, id));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(ComboBox& combo, state::StateStore& store, state::ParamID id) {
    combo.set_selected_silent(static_cast<int>(store.get_value(id)));
    combo.on_change = [&store, id](int index) {
        store.begin_gesture(id);
        store.set_value(id, static_cast<float>(index));
        store.end_gesture(id);
    };
    return ParameterBinding(store.add_listener(
        [&combo, &store, id](state::ParamID changed, float) {
            if (changed == id) combo.set_selected_silent(static_cast<int>(store.get_value(id)));
        },
        state::ListenerThread::Main,
        state::ListenerRestoreBehavior::Reconcile));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(DesignStepper& stepper, state::StateStore& store, state::ParamID id) {
    stepper.set_selected_silent(static_cast<int>(store.get_value(id)));
    stepper.on_select = [&store, id](int index) {
        store.begin_gesture(id);
        store.set_value(id, static_cast<float>(index));
        store.end_gesture(id);
    };
    return ParameterBinding(store.add_listener(
        [&stepper, &store, id](state::ParamID changed, float) {
            if (changed == id) stepper.set_selected_silent(static_cast<int>(store.get_value(id)));
        },
        state::ListenerThread::Main,
        state::ListenerRestoreBehavior::Reconcile));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(Toggle& toggle, state::StateStore& store, state::ParamID id) {
    toggle.set_on(store.get_value(id) >= 0.5f);
    toggle.on_toggle = [&store, id](bool on) {
        store.begin_gesture(id);
        store.set_value(id, on ? 1.0f : 0.0f);
        store.end_gesture(id);
    };
    return ParameterBinding(store.add_listener(
        [&toggle, &store, id](state::ParamID changed, float) {
            if (changed == id) toggle.set_on(store.get_value(id) >= 0.5f);
        },
        state::ListenerThread::Main,
        state::ListenerRestoreBehavior::Reconcile));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(Checkbox& box, state::StateStore& store, state::ParamID id) {
    box.set_checked(store.get_value(id) >= 0.5f);
    box.on_change = [&store, id](bool on) {
        store.begin_gesture(id);
        store.set_value(id, on ? 1.0f : 0.0f);
        store.end_gesture(id);
    };
    return ParameterBinding(store.add_listener(
        [&box, &store, id](state::ParamID changed, float) {
            if (changed == id) box.set_checked(store.get_value(id) >= 0.5f);
        },
        state::ListenerThread::Main,
        state::ListenerRestoreBehavior::Reconcile));
}

[[nodiscard]] inline ParameterBinding
bind_parameter(ToggleButton& button, state::StateStore& store, state::ParamID id) {
    button.set_on(store.get_value(id) >= 0.5f);
    button.on_toggle = [&store, id](bool on) {
        store.begin_gesture(id);
        store.set_value(id, on ? 1.0f : 0.0f);
        store.end_gesture(id);
    };
    return ParameterBinding(store.add_listener(
        [&button, &store, id](state::ParamID changed, float) {
            if (changed == id) button.set_on(store.get_value(id) >= 0.5f);
        },
        state::ListenerThread::Main,
        state::ListenerRestoreBehavior::Reconcile));
}
 
} // namespace pulp::view