GNEPathCreator.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Frame for create paths
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <utils/foxtools/MFXGroupBoxModule.h>
 
// ===========================================================================
// class declaration
// ===========================================================================
 
class GNEFrame;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNEPathCreator : public MFXGroupBoxModule {
    FXDECLARE(GNEPathCreator)
 
public:
    class Path {
 
    public:
        Path(const SUMOVehicleClass vClass, GNEEdge* edge);
 
        Path(GNEViewNet* viewNet, const SUMOVehicleClass vClass, GNEEdge* edgeFrom, GNEEdge* edgeTo);
 
        Path(GNEViewNet* viewNet, const SUMOVehicleClass vClass, GNEJunction* junctionFrom, GNEJunction* junctionTo);
 
        const std::vector<GNEEdge*>& getSubPath() const;
 
        bool isConflictVClass() const;
 
        bool isConflictDisconnected() const;
 
    protected:
        std::vector<GNEEdge*> mySubPath;
 
        bool myConflictVClass;
 
        bool myConflictDisconnected;
 
    private:
        Path();
 
        Path(Path*) = delete;
 
        Path& operator=(Path*) = delete;
    };
 
    GNEPathCreator(GNEFrame* frameParent);
 
    ~GNEPathCreator();
 
    void showPathCreatorModule(const GNETagProperties& tagProperty, const bool consecutives);
 
    void hidePathCreatorModule();
 
    SUMOVehicleClass getVClass() const;
 
    void setVClass(SUMOVehicleClass vClass);
 
    bool addJunction(GNEJunction* junction);
 
    bool addTAZ(GNETAZ* taz);
 
    bool addEdge(GNEEdge* edge, const bool shiftKeyPressed, const bool controlKeyPressed);
 
    const std::vector<GNEEdge*>& getSelectedEdges() const;
 
    const std::vector<GNEJunction*>& getSelectedJunctions() const;
 
    const std::vector<GNETAZ*>& getSelectedTAZs() const;
 
    bool addRoute(GNEDemandElement* route);
 
    GNEDemandElement* getRoute() const;
 
    const std::vector<Path>& getPath() const;
 
    bool drawCandidateEdgesWithSpecialColor() const;
 
    void updateJunctionColors();
 
    void updateEdgeColors();
 
    void clearJunctionColors();
 
    void clearEdgeColors();
 
    void drawTemporalRoute(const GUIVisualizationSettings& s) const;
 
    bool createPath(const bool useLastRoute);
 
    void abortPathCreation();
 
    void removeLastElement();
 
    long onCmdCreatePath(FXObject*, FXSelector, void*);
 
    long onCmdUseLastRoute(FXObject*, FXSelector, void*);
 
    long onUpdUseLastRoute(FXObject*, FXSelector, void*);
 
    long onCmdAbortPathCreation(FXObject*, FXSelector, void*);
 
    long onCmdRemoveLastElement(FXObject*, FXSelector, void*);
 
    long onCmdShowCandidateEdges(FXObject*, FXSelector, void*);
 
protected:
    FOX_CONSTRUCTOR(GNEPathCreator)
 
    // @brief creation mode
    enum Mode {
        ONLY_FROMTO              = 1 << 0,   // Path only had two elements (first and last)
        CONSECUTIVE_EDGES        = 1 << 1,   // Path's edges are consecutives
        NONCONSECUTIVE_EDGES     = 1 << 2,   // Path's edges aren't consecutives
        START_EDGE               = 1 << 3,   // Path begins in edge
        END_EDGE                 = 1 << 4,   // Path ends in edge
        START_JUNCTION           = 1 << 5,   // Path begins in junction
        END_JUNCTION             = 1 << 6,   // Path ends in junction
        START_TAZ                = 1 << 7,   // Path begins in TAZ
        END_TAZ                  = 1 << 8,   // Path ends in TAZ
        ROUTE                    = 1 << 9,   // Path is over an existent edge
        SHOW_CANDIDATE_EDGES     = 1 << 10,  // Show candidate edges
        SHOW_CANDIDATE_JUNCTIONS = 1 << 11,  // show candidate junctions
    };
 
    void updateInfoRouteLabel();
 
    void clearPath();
 
    void recalculatePath();
 
    void setSpecialCandidates(GNEEdge* originEdge);
 
    void setPossibleCandidates(GNEEdge* originEdge, const SUMOVehicleClass vClass);
 
    GNEFrame* myFrameParent;
 
    SUMOVehicleClass myVClass;
 
    int myCreationMode;
 
    std::vector<GNEJunction*> mySelectedJunctions;
 
    std::vector<GNETAZ*> mySelectedTAZs;
 
    std::vector<GNEEdge*> mySelectedEdges;
 
    GNEDemandElement* myRoute;
 
    std::vector<Path> myPath;
 
    FXLabel* myInfoRouteLabel;
 
    FXButton* myUseLastRoute;
 
    FXButton* myFinishCreationButton;
 
    FXButton* myAbortCreationButton;
 
    FXButton* myRemoveLastInsertedElement;
 
    FXCheckButton* myShowCandidateEdges;
 
    FXLabel* myShiftLabel;
 
    FXLabel* myControlLabel;
 
    FXLabel* myBackSpaceLabel;
private:
    GNEPathCreator(GNEPathCreator*) = delete;
 
    GNEPathCreator& operator=(GNEPathCreator*) = delete;
};