bubble_message.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>
 
namespace pulp::view {
 
class View;  // fwd
 
class BubbleMessageComponent {
public:
    enum class Phase {
        idle,     
        showing,  
        hiding,   
    };

    enum class Side {
        above,   
        below,   
        left,    
        right,   
    };
 
    BubbleMessageComponent() = default;

    void show_for(View* source, std::string text, float lifetime = 3.0f) {
        source_ = source;
        text_ = std::move(text);
        lifetime_ = std::max(0.0f, lifetime);
        elapsed_ = 0.0f;
        recompute_anchor();
        if (phase_ != Phase::showing) {
            phase_ = Phase::showing;
            opacity_.set(0.0f);
            opacity_.animate_to(1.0f, fade_duration_);
        }
    }

    void move_to(Point anchor) {
        explicit_anchor_ = anchor;
        has_explicit_anchor_ = true;
        position_ = compute_offset(anchor);
    }

    void recompute_anchor();

    void hide() {
        if (phase_ != Phase::showing) return;
        opacity_.animate_to(0.0f, fade_duration_);
        phase_ = Phase::hiding;
    }

    bool tick(float dt) {
        switch (phase_) {
            case Phase::idle:
                return false;
            case Phase::showing:
                opacity_.advance(dt);
                elapsed_ += dt;
                if (lifetime_ > 0.0f && elapsed_ >= lifetime_) {
                    hide();
                }
                return true;
            case Phase::hiding:
                opacity_.advance(dt);
                if (!opacity_.animating()) {
                    phase_ = Phase::idle;
                    source_ = nullptr;  // Transient: forget the source.
                    has_explicit_anchor_ = false;
                    return false;
                }
                return true;
        }
        return false;
    }
 
    // ── State ────────────────────────────────────────────────────────
 
    bool visible() const {
        return phase_ == Phase::showing || phase_ == Phase::hiding;
    }
    Phase phase() const { return phase_; }
    float opacity() const { return opacity_.value(); }
    Point position() const { return position_; }
    const std::string& text() const { return text_; }
    View* source_view() const { return source_; }
    float elapsed() const { return elapsed_; }
 
    // ── Configuration ───────────────────────────────────────────────
 
    void set_side(Side s) { side_ = s; }
    Side side() const { return side_; }

    void set_offset(Point offset) { offset_ = offset; }
    Point offset() const { return offset_; }

    void set_lifetime(float seconds) { lifetime_ = std::max(0.0f, seconds); }
    float lifetime() const { return lifetime_; }

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

    std::function<void(Phase)> on_phase_change;
 
private:
    Point compute_offset(Point anchor) const {
        return {anchor.x + offset_.x, anchor.y + offset_.y};
    }
 
    View* source_ = nullptr;
    std::string text_;
    Side side_ = Side::above;
    Point position_{};
    Point offset_{0, -8};
    Point explicit_anchor_{};
    bool has_explicit_anchor_ = false;
 
    Phase phase_ = Phase::idle;
    float lifetime_ = 3.0f;
    float elapsed_ = 0.0f;
    float fade_duration_ = 0.12f;
    ValueAnimation opacity_{0.0f};
};
 
} // namespace pulp::view