slider_core.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <functional>
#include <utility>
#include <vector>
 
namespace pulp::view {

enum class Notify {
    none,   
    sync,   
    async,  
};

void flush_async_notifications();

void queue_async_notification(std::function<void()> fn);
 
// ── The engine ───────────────────────────────────────────────────────────────
 
class SliderCore {
public:
    // ── Range ────────────────────────────────────────────────────────────

    void set_range(double min_value, double max_value, double interval = 0.0) {
        minimum_ = min_value;
        maximum_ = std::max(min_value, max_value);
        interval_ = std::max(0.0, interval);
        value_ = constrain(value_);
    }
    double minimum() const { return minimum_; }
    double maximum() const { return maximum_; }
    double interval() const { return interval_; }
 
    // ── Response curve ───────────────────────────────────────────────────

    void set_skew(double skew) { skew_ = std::max(1e-4, skew); }
    double skew() const { return skew_; }

    void set_skew_from_midpoint(double mid_value) {
        const double n = std::clamp(normalized_for(mid_value), 1e-4, 1.0 - 1e-4);
        skew_ = std::max(1e-4, std::log(0.5) / std::log(n));
    }
 
    // ── Value ────────────────────────────────────────────────────────────
 
    double value() const { return value_; }

    bool set_value(double v, Notify notify = Notify::sync) {
        const double next = constrain(v);
        if (next == value_) return false;
        value_ = next;
        notify_value(notify);
        return true;
    }

    double proportion() const { return proportion_for(value_); }

    bool set_proportion(double p, Notify notify = Notify::sync) {
        return set_value(value_for_proportion(p), notify);
    }

    double normalized() const { return std::clamp(normalized_for(value_), 0.0, 1.0); }
    double value_for_normalized(double n) const {
        return minimum_ + std::clamp(n, 0.0, 1.0) * (maximum_ - minimum_);
    }
    bool set_normalized(double n, Notify notify = Notify::sync) {
        return set_value(value_for_normalized(n), notify);
    }
 
    double proportion_for(double v) const {
        const double n = std::clamp(normalized_for(v), 0.0, 1.0);
        return skew_ == 1.0 ? n : std::pow(n, skew_);
    }
    double value_for_proportion(double p) const {
        p = std::clamp(p, 0.0, 1.0);
        const double n = skew_ == 1.0 ? p : std::pow(p, 1.0 / skew_);
        return minimum_ + n * (maximum_ - minimum_);
    }

    double constrain(double v) const {
        v = std::clamp(v, minimum_, maximum_);
        if (interval_ > 0.0) {
            v = minimum_ + std::round((v - minimum_) / interval_) * interval_;
            v = std::clamp(v, minimum_, maximum_);
        }
        return v;
    }
 
    // ── Default ──────────────────────────────────────────────────────────

    void set_default_value(double v) {
        default_value_ = constrain(v);
        has_default_ = true;
    }
    bool has_default() const { return has_default_; }
    double default_value() const { return default_value_; }
    bool reset_to_default(Notify notify = Notify::sync) {
        if (!has_default_) return false;
        return set_value(default_value_, notify);
    }
 
    // ── Drag law ─────────────────────────────────────────────────────────

    void set_drag_sensitivity(int pixels) { drag_pixels_ = std::max(1, pixels); }
    int drag_sensitivity() const { return drag_pixels_; }

    void set_velocity_mode(bool on) { velocity_mode_ = on; }
    bool velocity_mode() const { return velocity_mode_; }
    void set_velocity_sensitivity(double s) { velocity_sensitivity_ = std::max(1e-3, s); }

    bool drag_to(double delta_pixels, double proportion_at_press, bool fine,
                 Notify notify = Notify::sync) {
        double span = static_cast<double>(drag_pixels_);
        if (fine) span *= fine_divisor_;
        return set_proportion(proportion_at_press + delta_pixels / span, notify);
    }

    bool drag_step(double delta_pixels, bool fine, Notify notify = Notify::sync) {
        double span = static_cast<double>(drag_pixels_);
        if (fine) span *= fine_divisor_;
        return set_proportion(proportion() + (delta_pixels / span) * velocity_sensitivity_,
                              notify);
    }
 
    void set_fine_divisor(double d) { fine_divisor_ = std::max(1.0, d); }
    double fine_divisor() const { return fine_divisor_; }
 
    // ── Gesture bracket ──────────────────────────────────────────────────
    //
    // A host records automation between these two. They are edge-triggered:
    // a second begin without an end is ignored, so a widget that funnels both a
    // rich event and a legacy pointer callback into the same handler cannot
    // open two gestures.
 
    void begin_gesture() {
        if (gesture_active_) return;
        gesture_active_ = true;
        if (on_gesture_begin) on_gesture_begin();
    }
    void end_gesture() {
        if (!gesture_active_) return;
        gesture_active_ = false;
        if (on_gesture_end) on_gesture_end();
    }
    bool gesture_active() const { return gesture_active_; }
 
    // ── Listeners ────────────────────────────────────────────────────────
 
    std::function<void(double)> on_value_change;
    std::function<void()> on_gesture_begin;
    std::function<void()> on_gesture_end;
 
private:
    double normalized_for(double v) const {
        const double span = maximum_ - minimum_;
        if (span <= 0.0) return 0.0;
        return (v - minimum_) / span;
    }
 
    void notify_value(Notify notify) {
        if (notify == Notify::none || !on_value_change) return;
        if (notify == Notify::sync) {
            on_value_change(value_);
            return;
        }
        // Copy the value, not `this`: an async notification that outlives the
        // control would otherwise read a dead object. The callback itself is a
        // copy for the same reason.
        auto fn = on_value_change;
        const double v = value_;
        queue_async_notification([fn, v] { fn(v); });
    }
 
    double minimum_ = 0.0;
    double maximum_ = 1.0;
    double interval_ = 0.0;
    double skew_ = 1.0;
    double value_ = 0.0;
    double default_value_ = 0.0;
    bool has_default_ = false;
    int drag_pixels_ = 250;
    bool velocity_mode_ = false;
    double velocity_sensitivity_ = 1.0;
    double fine_divisor_ = 10.0;
    bool gesture_active_ = false;
};
 
} // namespace pulp::view