maptoolselectprofile.h

Go to the documentation of this file.

 
#ifndef MAPTOOLSELECTPROFILE_H
#define MAPTOOLSELECTPROFILE_H
 
#include "map/tools/maptool.h"
#include "plot/profilerouter.h"
 
#include <QPointer>
#include <QVector>
 
class SWMMModelLayer;
class ProfilePathOverlay;
class ProfilePathPickerDialog;
class QGraphicsScene;
template<typename T> class QFutureWatcher;
 
class OpenSWMMVisMapToolSelectProfile : public OpenSWMMVisMapTool
{
    Q_OBJECT
 
public:
    explicit OpenSWMMVisMapToolSelectProfile(MapCanvas *canvas,
                                             QObject    *parent = nullptr);
    ~OpenSWMMVisMapToolSelectProfile() override;
 
    void activate()   override;
    void deactivate() override;
 
    void mousePressEvent(QMouseEvent *event) override;
    void keyPressEvent  (QKeyEvent   *event) override;
 
    [[nodiscard]] ProfileRouter::Path acceptedPath() const;
 
    void clearSelection();
 
signals:
    void profilePathSelected(const ProfileRouter::Path &path);
 
    void statusMessageChanged(const QString &message);
 
    void routingBusyChanged(bool busy);
 
private:
    enum class State {
        Idle,           
        AwaitingEnd,    
        PickingPath,    
    };
 
    // Returns the engine node index for a click at (mapX, mapY), snapping
    // through a link's nearest endpoint if a link is hit.  Returns -1 on
    // miss.  `tolerance` is in map units.
    [[nodiscard]] int resolveNodeAt(double mapX, double mapY, double tolerance) const;
 
    // Computes the click tolerance in map units for the current viewport
    // (12-pixel target like MapToolSelect).
    [[nodiscard]] double clickTolerance() const;
 
    // Materializes the candidate paths via ProfileNetworkAdapter +
    // ProfileRouter on a worker thread.  Returns immediately after
    // kicking off the future and showing a busy progress dialog; the
    // post-routing flow continues in onRoutingComplete().
    void routeAndPick();
 
    // Continuation invoked on the main thread once the worker thread's
    // ProfileRouter call finishes (or is cancelled).  Handles the
    // single-path auto-accept and multi-path picker dialog flows.
    void onRoutingComplete(const ProfileRouter::Result &result,
                           int graphNodeCount, int graphEdgeCount);
 
    // Tears down the overlay, clears endpoints/waypoints, returns to Idle.
    void resetState();
 
    // Lighter cleanup that clears only the in-progress endpoint capture +
    // any open picker, while leaving the persisted accepted path and its
    // overlay alone.  Used by `activate()` / `deactivate()` so toggling
    // the tool off and back on preserves the previously-selected profile.
    void clearInProgress();
 
    SWMMModelLayer        *activeModel() const;
 
    State                  m_state       = State::Idle;
    int                    m_startNode   = -1;     // engine node index
    int                    m_endNode     = -1;
    QVector<int>           m_waypoints;            // engine node indices, in order
    ProfilePathOverlay        *m_overlay      = nullptr;
    // QPointer to the scene that owns m_overlay — used as a liveness
    // guard in the tool destructor / resetState() since QGraphicsItem
    // is not a QObject and we cannot QPointer the overlay itself.  If
    // the scene was destroyed first (typical project-teardown order),
    // the overlay is already freed and we must not touch it.
    QPointer<QGraphicsScene>   m_overlayScene;
    ProfileRouter::Path        m_acceptedPath;
 
    // Non-modal picker state — kept on the tool so the map remains
    // interactive while the dialog is open.  Cleared in `resetState()`
    // and on dialog accept/reject.
    QPointer<ProfilePathPickerDialog> m_pendingPicker;
    QVector<ProfileRouter::Path>      m_pendingPaths;
 
    // Async routing state — the worker future.  Parented to `this` so it
    // cleans up when the tool dies.  Status-bar busy indication is
    // surfaced via the routingBusyChanged() signal rather than a local
    // progress dialog so the user can keep panning/zooming the map.
    QFutureWatcher<ProfileRouter::Result> *m_routingWatcher = nullptr;
};
 
#endif // MAPTOOLSELECTPROFILE_H