GNETLSEditorFrame.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 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
/****************************************************************************/
// The Widget for modifying traffic lights
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netedit/frames/GNEFrame.h>
#include <netedit/GNEViewNetHelper.h>
#include <netbuild/NBTrafficLightLogic.h>
#include <utils/foxtools/MFXGroupBoxModule.h>
 
// ===========================================================================
// class declarations
// ===========================================================================
 
class GNEOverlappedInspection;
class GNETLSTable;
class MFXComboBoxIcon;
class MFXTextFieldIcon;
class MFXToggleButtonTooltip;
class NBLoadedSUMOTLDef;
class NBTrafficLightDefinition;
 
// ===========================================================================
// class definitions
// ===========================================================================
 
class GNETLSEditorFrame : public GNEFrame {
 
public:
    // ===========================================================================
    // class TLSJunction
    // ===========================================================================
 
    class TLSJunction : public MFXGroupBoxModule {
        FXDECLARE(GNETLSEditorFrame::TLSJunction)
 
    public:
        TLSJunction(GNETLSEditorFrame* TLSEditorParent);
 
        ~TLSJunction();
 
        void updateTLSJunction();
 
        GNEJunction* getCurrentJunction() const;
 
        void setCurrentJunction(GNEJunction* junction);
 
        bool isJoiningJunctions() const;
 
        bool isJunctionSelected(const GNEJunction* junction) const;
 
        void toggleJunctionSelected(const GNEJunction* junction);
 
        const std::vector<std::string>& getSelectedJunctionIDs() const;
 
        long onCmdRenameTLS(FXObject*, FXSelector, void*);
 
        long onCmdChangeType(FXObject*, FXSelector, void*);
 
        long onCmdToggleJoinTLS(FXObject*, FXSelector, void*);
 
        long onCmdDisjoinTLS(FXObject*, FXSelector, void*);
 
        long onCmdAcceptJoin(FXObject*, FXSelector, void*);
 
        long onCmdCancelJoin(FXObject*, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(TLSJunction)
 
        
        void refreshTLSJunction();
 
    private:
        GNETLSEditorFrame* myTLSEditorParent;
 
        FXLabel* myJunctionIDLabel = nullptr;
 
        MFXTextFieldIcon* myJunctionIDTextField = nullptr;
 
        MFXTextFieldIcon* myTLSIDTextField = nullptr;
 
        MFXComboBoxIcon* myTLSTypeComboBox = nullptr;
 
        MFXToggleButtonTooltip* myJoinTLSToggleButton = nullptr;
 
        MFXButtonTooltip* myDisjoinTLSButton = nullptr;
 
        FXHorizontalFrame* myJoinControlButtons = nullptr;
 
        GNEJunction* myCurrentJunction = nullptr;
 
        std::vector<std::string> mySelectedJunctionIDs;
 
        std::vector<std::string> myOriginalSelectedJunctionIDs;
 
        TLSJunction(const TLSJunction&) = delete;
 
        TLSJunction& operator=(const TLSJunction&) = delete;
    };
 
    // ===========================================================================
    // class TLSPrograms
    // ===========================================================================
 
    class TLSPrograms : public MFXGroupBoxModule {
        FXDECLARE(GNETLSEditorFrame::TLSPrograms)
 
    public:
        TLSPrograms(GNETLSEditorFrame* TLSEditorParent);
 
        ~TLSPrograms();
 
        void updateTLSPrograms();
 
        void showTLSPrograms();
 
        void hideTLSPrograms();
 
        bool initTLSPrograms();
 
        void clearTLSProgramss();
 
        int getNumberOfPrograms() const;
 
        bool checkHaveModifications() const;
 
        void markAsModified();
 
        NBTrafficLightDefinition* getCurrentTLSPrograms() const;
 
        const std::string getCurrentTLSProgramID() const;
 
        void discardChanges(const bool editJunctionAgain);
 
        long onCmdCreate(FXObject*, FXSelector, void*);
 
        long onCmdDelete(FXObject*, FXSelector, void*);
 
        long onCmdResetCurrentProgram(FXObject*, FXSelector, void*);
 
        long onCmdResetAll(FXObject*, FXSelector, void*);
 
        long onCmdDefSwitchTLSProgram(FXObject*, FXSelector, void*);
 
        long onCmdSaveChanges(FXObject*, FXSelector, void*);
 
        long onCmdDiscardChanges(FXObject*, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(TLSPrograms)
 
        
        void createTLS(GNEJunction* junction);
 
        bool switchProgram();
 
    private:
        GNETLSEditorFrame* myTLSEditorParent = nullptr;
 
        std::vector<NBTrafficLightDefinition*> myTLSPrograms;
 
        MFXComboBoxIcon* myProgramComboBox;
 
        bool myHaveModifications = false;
 
        FXButton* myCreateButton = nullptr;
 
        FXButton* myDeleteButton = nullptr;
 
        FXButton* myResetSingleButton = nullptr;
 
        FXButton* myResetAllButton = nullptr;
 
        FXButton* mySaveButon = nullptr;
 
        FXButton* myCancelButon = nullptr;
 
        TLSPrograms(const TLSPrograms&) = delete;
 
        TLSPrograms& operator=(const TLSPrograms&) = delete;
    };
 
    // ===========================================================================
    // class TLSAttributes
    // ===========================================================================
 
    class TLSAttributes : public MFXGroupBoxModule {
        FXDECLARE(GNETLSEditorFrame::TLSAttributes)
 
    public:
        TLSAttributes(GNETLSEditorFrame* TLSEditorParent);
 
        ~TLSAttributes();
 
        void updateTLSAttributes();
 
        void showTLSAttributes();
 
        void hideTLSAttributes();
 
        void initTLSAttributes();
 
        void clearTLSAttributes();
 
        SUMOTime getOffset() const;
 
        void setOffset(const SUMOTime& offset);
 
        bool isValidOffset();
 
        std::string getParameters() const;
 
        void setParameters(const std::string& parameters);
 
        bool isValidParameters();
 
        bool isSetDetectorsToggleButtonEnabled() const;
 
        bool toggleE1DetectorSelection(const GNEAdditional* E1);
 
        const std::map<std::string, std::string>& getE1Detectors() const;
 
        void disableE1DetectorMode();
 
        long onCmdSetOffset(FXObject*, FXSelector, void*);
 
        long onCmdSetParameters(FXObject*, FXSelector, void*);
 
        long onCmdParametersDialog(FXObject*, FXSelector, void* ptr);
 
        long onCmdToggleDetectorMode(FXObject*, FXSelector, void* ptr);
 
 
    protected:
        FOX_CONSTRUCTOR(TLSAttributes)
 
        
        void updateE1Detectors();
 
    private:
        GNETLSEditorFrame* myTLSEditorParent;
 
        FXTextField* myOffsetTextField = nullptr;
 
        FXButton* myButtonEditParameters = nullptr;
 
        FXTextField* myParametersTextField = nullptr;
 
        MFXToggleButtonTooltip* mySetDetectorsToggleButton = nullptr;
 
        std::map<std::string, std::string> myE1Detectors;
 
        TLSAttributes(const TLSAttributes&) = delete;
 
        TLSAttributes& operator=(const TLSAttributes&) = delete;
    };
 
    // ===========================================================================
    // class TLSPhases
    // ===========================================================================
 
    class TLSPhases : public MFXGroupBoxModule {
        FXDECLARE(GNETLSEditorFrame::TLSPhases)
 
    public:
        TLSPhases(GNETLSEditorFrame* TLSEditorParent);
 
        ~TLSPhases();
 
        void updateTLSPhases();
 
        void showTLSPhases();
 
        void hideTLSPhases();
 
        GNETLSEditorFrame* getTLSEditorParent() const;
 
        GNETLSTable* getPhaseTable() const;
 
        void initPhaseTable();
 
        void clearPhaseTable();
 
        bool changePhaseValue(const int col, const int row, const std::string& value);
 
        void addPhase(const int row, const char c = ' ');
 
        void duplicatePhase(const int row);
 
        void removePhase(const int row);
 
        void movePhaseUp(const int row);
 
        void movePhaseDown(const int row);
 
        void updateTLSColoring();
 
        long onCmdCleanStates(FXObject*, FXSelector, void*);
 
        long onCmdAddUnusedStates(FXObject*, FXSelector, void*);
 
        long onCmdGroupStates(FXObject*, FXSelector, void*);
 
        long onCmdUngroupStates(FXObject*, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(TLSPhases)
 
        
        void updateTable();
 
    private:
        void initStaticPhaseTable();
 
        void initActuatedPhaseTable();
 
        void initDelayBasePhaseTable();
 
        void initNEMAPhaseTable();
 
        int buildDefaultPhase(const int row);
 
        bool setDuration(const int col, const int row, const std::string& value);
 
        bool setState(const int col, const int row, const std::string& value);
 
        bool setNext(const int row, const std::string& value);
 
        bool setName(const int row, const std::string& value);
 
        bool setMinDur(const int row, const std::string& value);
 
        bool setMaxDur(const int row, const std::string& value);
 
        bool setEarliestEnd(const int row, const std::string& value);
 
        bool setLatestEnd(const int row, const std::string& value);
 
        bool setVehExt(const int row, const std::string& value);
 
        bool setYellow(const int row, const std::string& value);
 
        bool setRed(const int row, const std::string& value);
 
        void updateCycleDuration(const int col);
 
        void updateStateSize(const int col);
 
        GNETLSEditorFrame* myTLSEditorParent;
 
        GNETLSTable* myPhaseTable;
 
        MFXButtonTooltip* myCleanStatesButton = nullptr;
 
        MFXButtonTooltip* myAddStates = nullptr;
 
        MFXButtonTooltip* myGroupSignalsButton = nullptr;
 
        MFXButtonTooltip* myUngroupSignalsButton = nullptr;
 
        TLSPhases(const TLSPhases&) = delete;
 
        TLSPhases& operator=(const TLSPhases&) = delete;
    };
 
    // ===========================================================================
    // class TLSFile
    // ===========================================================================
 
    class TLSFile : public MFXGroupBoxModule {
        FXDECLARE(GNETLSEditorFrame::TLSFile)
 
    public:
        TLSFile(GNETLSEditorFrame* TLSEditorParent);
 
        ~TLSFile();
 
        void updateTLSFile();
 
        void showTLSFile();
 
        void hideTLSFile();
 
 
        long onCmdLoadTLSProgram(FXObject*, FXSelector, void*);
 
        long onCmdSaveTLSProgram(FXObject*, FXSelector, void*);
 
 
    protected:
        FOX_CONSTRUCTOR(TLSFile)
 
        
        std::string writeSUMOTime(SUMOTime steps);
 
    private:
        GNETLSEditorFrame* myTLSEditorParent;
 
        FXButton* myLoadButton = nullptr;
 
        FXButton* mySaveButton = nullptr;
 
        TLSFile(const TLSFile&) = delete;
 
        TLSFile& operator=(const TLSFile&) = delete;
    };
 
    GNETLSEditorFrame(GNEViewParent* viewParent, GNEViewNet* viewNet);
 
    ~GNETLSEditorFrame();
 
    void show();
 
    void frameWidthUpdated();
 
    void updateModules();
 
    void editTLS(GNEViewNetHelper::ViewObjectsSelector& viewObjects, const Position& clickedPosition, const bool shiftKeyPressed);
 
    bool isTLSSaved();
 
    bool parseTLSPrograms(const std::string& file);
 
    void handleChange(GNEInternalLane* lane);
 
    void handleMultiChange(GNELane* lane, FXObject* obj, FXSelector sel, void* data);
 
    bool controlsEdge(GNEEdge* edge) const;
 
    void selectedOverlappedElement(GNEAttributeCarrier* AC);
 
    void editJunction(GNEJunction* junction);
 
    GNETLSEditorFrame::TLSJunction* getTLSJunction() const;
 
    GNETLSEditorFrame::TLSPrograms* getTLSPrograms() const;
 
    GNETLSEditorFrame::TLSAttributes* getTLSAttributes() const;
 
    GNETLSEditorFrame::TLSPhases* getTLSPhases() const;
 
protected:
    static SUMOTime getSUMOTime(const std::string& value);
 
    static const std::string getSteps2Time(const SUMOTime value);
 
private:
    GNEOverlappedInspection* myOverlappedInspection = nullptr;
 
    GNETLSEditorFrame::TLSJunction* myTLSJunction = nullptr;
 
    GNETLSEditorFrame::TLSPrograms* myTLSPrograms = nullptr;
 
    GNETLSEditorFrame::TLSAttributes* myTLSAttributes = nullptr;
 
    GNETLSEditorFrame::TLSPhases* myTLSPhases = nullptr;
 
    GNETLSEditorFrame::TLSFile* myTLSFile = nullptr;
 
    std::map<int, std::vector<GNEInternalLane*> > myInternalLanes;
 
    NBLoadedSUMOTLDef* myEditedDef = nullptr;
 
    void cleanup();
 
    void buildInternalLanes(const NBTrafficLightDefinition* tlDef);
 
    const NBTrafficLightLogic::PhaseDefinition& getPhase(const int index);
 
    static std::string varDurString(SUMOTime dur);
 
    GNETLSEditorFrame(const GNETLSEditorFrame&) = delete;
 
    GNETLSEditorFrame& operator=(const GNETLSEditorFrame&) = delete;
};