animationcontroller.h

Go to the documentation of this file.

 
#ifndef ANIMATIONCONTROLLER_H
#define ANIMATIONCONTROLLER_H
 
#include <QDateTime>
#include <QList>
#include <QObject>
#include <QPointer>
 
// QPointer<SWMM2DResultsLayer> in the private section requires the
// inheritance chain to be visible; include the layer header instead of just
// forward-declaring.
#include "layers/swmm2dresultslayer.h"
 
class QTimer;
class SWMMResultsLayer;
 
class AnimationController : public QObject
{
    Q_OBJECT
 
public:
    explicit AnimationController(QObject *parent = nullptr);
    ~AnimationController() override;
 
    // ----- Primary layer -------------------------------------------------
 
    void setPrimaryLayer(SWMMResultsLayer *layer);
    [[nodiscard]] SWMMResultsLayer *primaryLayer() const;
 
    // ----- 2D fallback layer (Slice CF.MVP-fix.1) -----------------------
    //
    // When no 1D primary is set, the controller drives a SWMM2DResultsLayer
    // directly so 2D-only runs (no .out results loaded) still animate.
    // When a 1D primary becomes available the fallback is silently demoted;
    // the 2D layer keeps following via the QDateTime fan-out in
    // SWMMVis::onAnimationCurrentTimeChanged.
    void setFallback2DLayer(SWMM2DResultsLayer *layer);
    [[nodiscard]] SWMM2DResultsLayer *fallback2DLayer() const { return m_fallback2D; }
 
    // ----- Secondary layers ----------------------------------------------
 
    void addSecondaryLayer(SWMMResultsLayer *layer);
    void removeSecondaryLayer(SWMMResultsLayer *layer);
    void clearSecondaryLayers();
 
    [[nodiscard]] QList<SWMMResultsLayer *> allLayers() const;
 
    // ----- State query ---------------------------------------------------
 
    [[nodiscard]] bool   isPlaying() const { return m_playing; }
    [[nodiscard]] double speed()     const { return m_speed;   }
 
    // ----- Sync window (causal "as-of within timespan") ------------------
    //
    // Non-driver outputs display the latest frame at or before the cursor
    // (causal floor). The window is the look-back span [t - w, t] used by the
    // range-slider UI and to classify an output as fresh/stale; under the
    // hold-last policy it does not change which frame shows.
    [[nodiscard]] qint64 windowMs() const { return m_windowMs; }
 
    [[nodiscard]] QDateTime driverStartTime() const;
    [[nodiscard]] QDateTime driverEndTime()   const;
    [[nodiscard]] QDateTime currentDateTime() const;
 
    // ----- Speed ---------------------------------------------------------
 
    void setSpeed(double speed);
 
    void setWindowMs(qint64 ms);
    void setWindowSec(double sec) { setWindowMs(static_cast<qint64>(sec * 1000.0)); }
 
    // ----- Looping (toolbar "Cycle" checkbox) ----------------------------
 
    void setLooping(bool on) { m_loop = on; }
    [[nodiscard]] bool looping() const { return m_loop; }
 
public slots:
    void play();
    void pause();
    void stop();
    void stepForward();
    void stepBackward();
    void seekToFirst();
    void seekToLast();
    void seekToPeriod(int period);
    void seekToTime(const QDateTime &dt);
 
signals:
    void currentTimeChanged(const QDateTime &dt);
    void currentPeriodChanged(int period);
    void playStateChanged(bool playing);
    void totalPeriodsChanged(int total);
    void primaryLayerChanged(SWMMResultsLayer *layer);
    void windowChanged(qint64 windowMs);
 
private slots:
    void onTimerTick();
    void onPrimaryPeriodChanged(int step);
    void onPrimaryTotalStepsChanged(int total);
 
    // 2D fallback re-emit slots (mirror the 1D ones).
    void onFallback2DPeriodChanged(int step);
    void onFallback2DTimeChanged(const QDateTime &dt);
    void onFallback2DRangeChanged(int lo, int hi);
 
private:
    void updateTimerInterval();
    void connectPrimary();
    void disconnectPrimary();
    void connectFallback2D();
    void disconnectFallback2D();
 
    // Returns true when either a 1D primary or a 2D fallback is set.
    [[nodiscard]] bool   hasDriver() const;
    // Total step count from whichever driver is active (1D primary preferred).
    [[nodiscard]] int    driverTotalSteps() const;
    // Current step index from whichever driver is active.
    [[nodiscard]] int    driverCurrentStep() const;
    // Advance whichever driver is active to \p step.
    void driverSetStep(int step);
    [[nodiscard]] bool   driverIsLive() const;
 
    void effectiveStepRange(int &outMin, int &outMax) const;
 
    QPointer<SWMMResultsLayer>        m_primaryLayer;
    QList<QPointer<SWMMResultsLayer>> m_secondaryLayers;
    QPointer<SWMM2DResultsLayer>      m_fallback2D;
    QTimer *m_timer    = nullptr;
    bool    m_playing  = false;
    bool    m_loop     = true;   
    double  m_speed    = 1.0;
    qint64  m_windowMs = 0;   
 
    int     m_stepsPerTick = 1;
 
    int     m_direction = 1;
 
    static constexpr int kMinIntervalMs  = 50;
    static constexpr int kDefaultStepMs  = 200; // fallback when primary has no report step
};
 
#endif // ANIMATIONCONTROLLER_H