maptoolselect.h

Go to the documentation of this file.

 
#ifndef MAPTOOLSELECT_H
#define MAPTOOLSELECT_H
 
#include "map/tools/maptool.h"
#include "plot/plotattribute.h"
#include "plot/resultdescriptor.h"
#include "selection/selectionmanager.h"
 
#include <QPoint>
#include <QPointF>
#include <QRect>
#include <QSet>
#include <QVector>
 
class OpenSWMMVisLayer;
class SWMMModelLayer;
class FeatureLayer;
 
class OpenSWMMVisMapToolSelect : public OpenSWMMVisMapTool
{
    Q_OBJECT
 
    Q_PROPERTY(int    pixelTolerance READ pixelTolerance WRITE setPixelTolerance
               NOTIFY pixelToleranceChanged)
    Q_PROPERTY(QColor rubberBandColor READ rubberBandColor WRITE setRubberBandColor
               NOTIFY rubberBandColorChanged)
 
public:
 
    explicit OpenSWMMVisMapToolSelect(MapCanvas *canvas, QObject *parent = nullptr);
 
    [[nodiscard]] QCursor cursor() const override;
 
    // ----- Configuration -------------------------------------------------
 
    [[nodiscard]] int    pixelTolerance()  const;
    void setPixelTolerance(int pixels);
 
    [[nodiscard]] QColor rubberBandColor() const;
    void setRubberBandColor(const QColor &color);
 
    // ----- Tool interface ------------------------------------------------
 
    void activate()   override;
    void deactivate() override;
 
    void mousePressEvent(QMouseEvent *event)       override;
    void mouseMoveEvent(QMouseEvent *event)        override;
    void mouseReleaseEvent(QMouseEvent *event)     override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;
    void keyPressEvent(QKeyEvent *event)           override;
 
    void paint(QPainter *painter,
               const MapExtent &canvasExtent,
               const SpatialReferenceSystem *canvasSRS) override;
 
signals:
    void pixelToleranceChanged(int pixels);
    void rubberBandColorChanged(const QColor &color);
 
    void selectionChanged(OpenSWMMVisLayer *layer);
 
    void plotTimeSeriesRequested(const SWMMObjectRef &ref);
 
    void plotAttributeRequested(const SWMMObjectRef &ref,
                                const openswmmvis::plot::ResultDescriptor &descriptor);
 
    void plotAttributeForLayerRequested(const SWMMObjectRef &ref,
                                         const openswmmvis::plot::ResultDescriptor &descriptor,
                                         class SWMMResultsLayer *layer);
 
    void plotSystemRequested(openswmmvis::plot::PlotAttribute attribute);
 
    void deleteFeaturesRequested(FeatureLayer *layer);
 
    void rainfallVisualizationRequested(const SWMMObjectRef &ref);
 
private:
    void selectAtPoint(const QPoint &pixel, Qt::KeyboardModifiers mods);
    void selectInRect(const QRect &pixelRect, Qt::KeyboardModifiers mods);
 
    void showContextMenu(const QPoint &pixel);
 
    void deleteSelectedObjects();
 
    // ----- Inline edit sub-mode -------------------------------------------
    // Activated by double-clicking a node or link. Vertex handles appear in
    // the overlay and can be dragged without switching tools. Escape or
    // double-clicking empty space exits back to normal selection behaviour.
 
    // Gage rides the Node code path (one whole-object handle, drag =
    // move) but previews/commits through the rain-gage move APIs.
    enum class EditKind { None, Node, Gage, Link, Subcatch };
 
    void enterEditMode(SWMMModelLayer *layer, const QString &name,
                       EditKind kind, int soaIndex);
    void clearEditMode();
    int  hitTestEditHandle(const QPoint &pixel) const;
    void selectHandlesInRect(const QRect &pixelRect);
    void applyGroupDragDelta(double dx, double dy);
    void commitNodeDrag(double newX, double newY);
    void commitGageDrag(double newX, double newY);
    void commitLinkDrag(QVector<QPointF> newInterior);
    void commitSubcatchDrag(QVector<QPointF> newVertices);
 
    void deleteSelectedEditHandles();
 
    EditKind         m_editKind      = EditKind::None;
    SWMMModelLayer  *m_editLayer     = nullptr;
    QString          m_editName;
    int              m_editSoaIdx    = -1;
    // Handle layout per EditKind:
    //   Node:    [0] = node position (circle+crosshair, translates node)
    //   Link:    [0..N-1] = interior vertices (squares)
    //   Subcatch:[0] = centroid (filled square, translates all vertices)
    //            [1..N] = polygon vertices (circles)
    QVector<QPointF> m_editHandles;
    QVector<QPointF> m_editSubcatchVerts; // cached polygon vertices (Subcatch mode)
    bool             m_editDragging     = false;
    int              m_editDragHandle   = -1;
    QPointF          m_editDragOrigPt;       // pre-drag map position of dragged vertex (for snap exclusion)
    QPointF          m_editCentroidPrev;     // centroid before current drag tick (Subcatch)
    QPointF          m_editGroupDragPrev;    // map pos of previous move tick (group drag)
    double           m_editNodeOrigX    = 0.0;
    double           m_editNodeOrigY    = 0.0;
 
    // Rubber-band vertex selection within edit mode
    QSet<int>        m_editSelectedHandles;
    bool             m_editRubberbanding = false;
    bool             m_editPressedEmpty  = false; // pressed on empty, not yet a drag
    QPoint           m_editRubberStart;
    QPoint           m_editRubberCurrent;
 
    static constexpr int kEditHandlePx  = 7;  // half-size of a vertex handle in pixels
    static constexpr int kSnapRadiusPx  = 15; // pixel radius within which snap kicks in
 
    // Snap state — updated each drag tick, consumed by paint()
    bool    m_snapping = false;
    QPointF m_snapPt;              // snapped position in map/layer CRS
 
    // ----- Normal selection state -----------------------------------------
 
    bool   m_dragging    = false;
    QPoint m_startPixel;
    QPoint m_currentPixel;
    // Default user-preference tolerance. The EFFECTIVE pixel radius
    // used at pick time is `max(m_pixelTol, largest-rendered-marker-
    // half-bounds + halo)`, so clicks inside the visible glyph always
    // succeed regardless of this number. See
    // `selectAtPoint` in the .cpp — it pulls the marker floor from
    // the layer's symbology. Slice V will turn this into a
    // user-configurable preference.
    int    m_pixelTol    = 16;
    // Drag threshold — only start the rubber-band once the cursor
    // moves this many pixels from the press point. Trackpad micro-
    // jitter on a click commonly hits 10–12 px, which used to flip
    // the tool into rubber-band mode and select a node + its
    // connected line together. 15 leaves enough slack to kill that
    // while still responding to intentional drags. Override via
    // PreferencesManager.
    int    m_dragThreshPx = 15;
    QColor m_rubberColor = QColor(0, 120, 255, 80);
};
 
#endif // MAPTOOLSELECT_H