tooltip_window.hpp

Go to the documentation of this file.

#pragma once

 
#include <algorithm>
#include <functional>
#include <string>
#include <pulp/view/animation.hpp>
#include <pulp/view/geometry.hpp>
#include <pulp/view/motion_preferences.hpp>
 
namespace pulp::view {
 
class TooltipWindow {
public:
    enum class Phase {
        idle,        
        pending,     
        showing,     
        hiding,      
    };
 
    TooltipWindow() = default;

    void show(std::string text, Point anchor) {
        last_anchor_ = anchor;
        if (phase_ == Phase::showing || phase_ == Phase::hiding) {
            // Already up — replace text + anchor and re-anchor.
            text_ = std::move(text);
            position_ = compute_position(anchor);
            if (phase_ == Phase::hiding) {
                phase_ = Phase::showing;
                opacity_.animate_to(1.0f, fade_duration_);
                elapsed_visible_ = 0;
            }
            return;
        }
        text_ = std::move(text);
        position_ = compute_position(anchor);
        elapsed_pending_ = 0;
        elapsed_visible_ = 0;
        phase_ = Phase::pending;
    }

    void move_to(Point anchor) {
        last_anchor_ = anchor;
        if (phase_ == Phase::idle) return;
        position_ = compute_position(anchor);
    }

    void hide() {
        if (phase_ == Phase::idle || phase_ == Phase::hiding) return;
        if (phase_ == Phase::pending) {
            phase_ = Phase::idle;
            elapsed_pending_ = 0;
            return;
        }
        opacity_.animate_to(0.0f, fade_duration_);
        phase_ = Phase::hiding;
    }

    void cancel_pending() {
        if (phase_ == Phase::pending) {
            phase_ = Phase::idle;
            elapsed_pending_ = 0;
        }
    }

    bool tick(float dt) {
        switch (phase_) {
            case Phase::idle:
                return false;
 
            case Phase::pending:
                elapsed_pending_ += dt;
                if (elapsed_pending_ >= hover_delay_) {
                    phase_ = Phase::showing;
                    opacity_.set(0.0f);
                    opacity_.animate_to(1.0f, fade_duration_);
                    elapsed_visible_ = 0;
                }
                return true;
 
            case Phase::showing:
                opacity_.advance(dt);
                elapsed_visible_ += dt;
                if (auto_hide_ > 0 && elapsed_visible_ >= auto_hide_) {
                    hide();
                }
                return opacity_.animating() || (auto_hide_ > 0);
 
            case Phase::hiding:
                opacity_.advance(dt);
                if (!opacity_.animating()) {
                    phase_ = Phase::idle;
                    return false;
                }
                return true;
        }
        return false;
    }
 
    // ── State accessors ──────────────────────────────────────────────

    bool visible() const {
        return phase_ == Phase::showing || phase_ == Phase::hiding;
    }
    bool pending() const { return phase_ == Phase::pending; }
    Phase phase() const { return phase_; }
 
    float opacity() const { return opacity_.value(); }
    Point position() const { return position_; }
    const std::string& text() const { return text_; }
    Point last_anchor() const { return last_anchor_; }
 
    // ── Configuration ────────────────────────────────────────────────

    void set_hover_delay(float seconds) { hover_delay_ = std::max(0.0f, seconds); }
    float hover_delay() const { return hover_delay_; }

    void set_fade_duration(float seconds) { fade_duration_ = std::max(0.0f, seconds); }
    float fade_duration() const { return fade_duration_; }

    void set_auto_hide(float seconds) { auto_hide_ = std::max(0.0f, seconds); }
    float auto_hide() const { return auto_hide_; }

    void set_cursor_offset(Point offset) { cursor_offset_ = offset; }
    Point cursor_offset() const { return cursor_offset_; }

    std::function<void(Phase)> on_phase_change;
 
private:
    Point compute_position(Point anchor) const {
        return {anchor.x + cursor_offset_.x, anchor.y + cursor_offset_.y};
    }
 
    Phase phase_ = Phase::idle;
    std::string text_;
    Point last_anchor_{};
    Point position_{};
 
    float hover_delay_ = 0.6f;
    float fade_duration_ = 0.12f;
    float auto_hide_ = 0.0f;
    Point cursor_offset_{12, 18};
 
    float elapsed_pending_ = 0;
    float elapsed_visible_ = 0;
    ValueAnimation opacity_{0.0f};
};
 
} // namespace pulp::view