GUITLLogicPhasesTrackerWindow.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
/****************************************************************************/
// A window displaying the phase diagram of a tl-logic
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <string>
#include <bitset>
#include <utility>
#include <utils/foxtools/fxheader.h>
// fx3d includes windows.h so we need to guard against macro pollution
#ifdef WIN32
#define NOMINMAX
#endif
#include <fx3d.h>
#ifdef WIN32
#undef NOMINMAX
#endif
#include <microsim/traffic_lights/MSSimpleTrafficLightLogic.h>
#include <microsim/traffic_lights/MSTLLogicControl.h>
#include <utils/common/ValueRetriever.h>
#include <utils/gui/div/GLObjectValuePassConnector.h>
#include <microsim/logging/FunctionBinding.h>
#include <utils/common/SUMOTime.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class GUIMainWindow;
class MSTrafficLightLogic;
class GUITrafficLightLogicWrapper;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class GUITLLogicPhasesTrackerWindow
    : public FXMainWindow,
      public ValueRetriever<std::pair<SUMOTime, MSPhaseDefinition> > {
    FXDECLARE(GUITLLogicPhasesTrackerWindow)
public:
    GUITLLogicPhasesTrackerWindow(GUIMainWindow& app,
                                  MSTrafficLightLogic& logic, GUITrafficLightLogicWrapper& wrapper,
                                  ValueSource<std::pair<SUMOTime, MSPhaseDefinition> >* src);
 

    GUITLLogicPhasesTrackerWindow(
        GUIMainWindow& app,
        MSTrafficLightLogic& logic, GUITrafficLightLogicWrapper& wrapper,
        const MSSimpleTrafficLightLogic::Phases& phases);
 

    ~GUITLLogicPhasesTrackerWindow();
 

    void create();
 

    void addValue(std::pair<SUMOTime, MSPhaseDefinition> def);
 

    void setBeginTime(SUMOTime time);
 


    long onConfigure(FXObject* sender, FXSelector sel, void* ptr);

    long onPaint(FXObject* sender, FXSelector sel, void* ptr);

    long onSimStep(FXObject* sender, FXSelector sel, void* ptr);

 
 
 
public:
    typedef std::vector<MSPhaseDefinition> PhasesVector;

    typedef std::vector<SUMOTime> DurationsVector;

    typedef std::vector<int> IndexVector;

    typedef std::vector<std::vector<double > > AdditionalStatesVector;

    class GUITLLogicPhasesTrackerPanel : public FXGLCanvas {
        FXDECLARE(GUITLLogicPhasesTrackerPanel)
    public:
        GUITLLogicPhasesTrackerPanel(FXComposite* c,
                                     GUIMainWindow& app, GUITLLogicPhasesTrackerWindow& parent);

        ~GUITLLogicPhasesTrackerPanel();

        friend class GUITLLogicPhasesTrackerWindow;
 


        long onConfigure(FXObject*, FXSelector, void*);

        long onPaint(FXObject*, FXSelector, void*);

        long onMouseMove(FXObject*, FXSelector, void*);
 
        const Position& getMousePos() const {
            return myMousePos;
        };
 
    private:
        GUITLLogicPhasesTrackerWindow* myParent;
 
        Position myMousePos;
 
    protected:
        GUITLLogicPhasesTrackerPanel() { }
 
    };
 

    void drawValues(GUITLLogicPhasesTrackerPanel& caller);
 
 
private:
    GUIMainWindow* myApplication;

    MSTrafficLightLogic* myTLLogic;

    PhasesVector myPhases;

    DurationsVector myDurations;

    DurationsVector myTimeInCycle;

    IndexVector myPhaseIndex;

    AdditionalStatesVector myDetectorStates;
    AdditionalStatesVector myConditionStates;

    DurationsVector myDetectorDurations;
    DurationsVector myConditionDurations;

    GUITLLogicPhasesTrackerPanel* myPanel;

    FXMutex myLock;

    std::vector<std::string> myLinkNames;
    std::vector<std::string> myDetectorNames;
    std::vector<std::string> myConditionNames;

    int myFirstPhase2Show;
    int myFirstDet2Show;
    int myFirstCond2Show;

    SUMOTime myFirstPhaseOffset;
    SUMOTime myFirstDetOffset;
    SUMOTime myFirstCondOffset;

    SUMOTime myFirstTime2Show;

    SUMOTime myBeginTime;

    SUMOTime myLastTime;

    GLObjectValuePassConnector<std::pair<SUMOTime, MSPhaseDefinition> >* myConnector;

    bool myAmInTrackingMode;

    FXToolBarShell* myToolBarDrag;

    FXToolBar* myToolBar;

    FXRealSpinner* myBeginOffset;

    MFXComboBoxIcon* myTimeMode;

    MFXComboBoxIcon* myGreenMode;

    FXCheckButton* myIndexMode;

    FXCheckButton* myDetectorMode;

    FXCheckButton* myConditionMode;

    static int myLastY;
 
private:
 
    void initToolBar();
 
    void saveSettings();
    void loadSettings();

    int computeHeight();

    void drawNames(const std::vector<std::string>& names, double fontHeight, double fontWidth, double divHeight, double divWidth, double& h, int extraLines);

    void drawAdditionalStates(GUITLLogicPhasesTrackerPanel& caller,
                              const AdditionalStatesVector& states, const DurationsVector& durations,
                              SUMOTime firstOffset, int first2Show, double hStart,
                              double panelWidth, double leftOffset, double barWidth, double stateHeight, double h20, double& h);

    SUMOTime findTimeInCycle(SUMOTime t);
 
protected:
    GUITLLogicPhasesTrackerWindow() { }
 
 
};