GNEViewNetHelper.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
/****************************************************************************/
// A file used to reduce the size of GNEViewNet.h grouping structs and classes
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <unordered_set>
#include <utils/foxtools/MFXButtonTooltip.h>
#include <utils/foxtools/MFXMenuButtonTooltip.h>
#include <utils/foxtools/MFXCheckableButton.h>
#include <utils/foxtools/MFXLCDLabel.h>
#include <utils/gui/globjects/GUIGlObject.h>
#include <utils/gui/globjects/GUIGlObjectTypes.h>
#include <utils/gui/div/GUIGlobalViewObjectsHandler.h>
 
#include "GNEMoveElement.h"
 
// ===========================================================================
// enum
// ===========================================================================
 
enum class Supermode {
    NETWORK,
    DEMAND,
    DATA
};
 
enum class NetworkEditMode {
    NETWORK_NONE,
    NETWORK_INSPECT,
    NETWORK_DELETE,
    NETWORK_SELECT,
    NETWORK_MOVE,
    NETWORK_CREATE_EDGE,
    NETWORK_CONNECT,
    NETWORK_TLS,
    NETWORK_ADDITIONAL,
    NETWORK_CROSSING,
    NETWORK_TAZ,
    NETWORK_SHAPE,
    NETWORK_PROHIBITION,
    NETWORK_WIRE,
    NETWORK_DECAL
};
 
enum class DemandEditMode {
    DEMAND_NONE,
    DEMAND_INSPECT,
    DEMAND_DELETE,
    DEMAND_SELECT,
    DEMAND_MOVE,
    DEMAND_ROUTE,
    DEMAND_ROUTEDISTRIBUTION,
    DEMAND_VEHICLE,
    DEMAND_TYPE,
    DEMAND_TYPEDISTRIBUTION,
    DEMAND_STOP,
    DEMAND_PERSON,
    DEMAND_PERSONPLAN,
    DEMAND_CONTAINER,
    DEMAND_CONTAINERPLAN
};
 
enum class DataEditMode {
    DATA_NONE,
    DATA_INSPECT,
    DATA_DELETE,
    DATA_SELECT,
    DATA_EDGEDATA,
    DATA_EDGERELDATA,
    DATA_TAZRELDATA,
    DATA_MEANDATA
};
 
// ===========================================================================
// class declarations
// ===========================================================================
 
// main elements
class GNEAttributeCarrier;
class GNEViewNet;
// network elements
class GNENetworkElement;
class GNEJunction;
class GNEEdge;
class GNELane;
class GNEConnection;
class GNECrossing;
class GNEWalkingArea;
class GNEInternalLane;
// additional elements
class GNEAdditional;
class GNEPoly;
class GNEPOI;
class GNETAZ;
// demand elements
class GNEDemandElement;
// data elements
class GNEDataSet;
class GNEGenericData;
class GNEEdgeData;
class GNEEdgeRelData;
class GNETAZRelData;
 
// ===========================================================================
// classes and structs definitions
// ===========================================================================
 
struct GNEViewNetHelper {
 
    class LockManager {
 
    public:
        LockManager(GNEViewNet* viewNet);
 
        ~LockManager();
 
        bool isObjectLocked(GUIGlObjectType objectType, const bool selected) const;
 
        void updateFlags();
 
        void updateLockMenuBar();
 
    private:
        class OperationLocked {
 
        public:
            OperationLocked();
 
            OperationLocked(Supermode supermode);
 
            ~OperationLocked();
 
            Supermode getSupermode() const;
 
            bool lock = false;
 
        private:
            Supermode mySupermode;
        };
 
        GNEViewNet* myViewNet;
 
        std::map<GUIGlObjectType, OperationLocked> myLockedElements;
 
        LockManager(const LockManager&) = delete;
 
        LockManager& operator=(const LockManager&) = delete;
    };
 
    class InspectedElements {
 
    public:
        InspectedElements();
 
        void inspectAC(GNEAttributeCarrier* AC);
 
        void inspectACs(const std::vector<GNEAttributeCarrier*>& ACs);
 
        void uninspectAC(GNEAttributeCarrier* AC);
 
 
        GNEAttributeCarrier* getFirstAC() const;
 
        const std::unordered_set<GNEAttributeCarrier*>& getACs() const;
 
 
        // @brief check if the given AC is inspected
        bool isACInspected(GNEAttributeCarrier* AC) const;
 
        // @brief check if the given constant AC is inspected
        bool isACInspected(const GNEAttributeCarrier* AC) const;
 
        bool isInspectingElements() const;
 
        bool isInspectingSingleElement() const;
 
        bool isInspectingMultipleElements() const;
 
 
    private:
        GNEAttributeCarrier* myFirstInspectedAC = nullptr;
 
        std::unordered_set<GNEAttributeCarrier*> myInspectedACs;
 
        InspectedElements(const InspectedElements&) = delete;
 
        InspectedElements& operator=(const InspectedElements&) = delete;
    };
 
    class ViewObjectsSelector {
 
    public:
        ViewObjectsSelector(GNEViewNet* viewNet);
 
        void updateObjects();
 
        void filterEdges();
 
        void filterLanes();
 
        void filterShapes();
 
        void filterAdditionals(const bool includeStoppigPlaces, const bool includeTAZs);
 
        void filterDemandElements(const bool includeRoutes);
 
        void filterLockedElements(const std::vector<GUIGlObjectType> ignoreFilter = {});
 
        const GUIGlObject* getGUIGlObjectFront() const;
 
        GNEAttributeCarrier* getAttributeCarrierFront() const;
 
        GNENetworkElement* getNetworkElementFront() const;
 
        GNEAdditional* getAdditionalFront() const;
 
        GNEDemandElement* getDemandElementFront() const;
 
        GNEGenericData* getGenericDataElementFront() const;
 
        GNEJunction* getJunctionFront() const;
 
        GNEEdge* getEdgeFront() const;
 
        GNELane* getLaneFront() const;
 
        GNELane* getLaneFrontNonLocked() const;
 
        const std::vector<GNELane*>& getLanes() const;
 
        GNECrossing* getCrossingFront() const;
 
        GNEWalkingArea* getWalkingAreaFront() const;
 
        GNEConnection* getConnectionFront() const;
 
        GNEInternalLane* getInternalLaneFront() const;
 
        GNETAZ* getTAZFront() const;
 
        GNEPOI* getPOIFront() const;
 
        GNEPoly* getPolyFront() const;
 
        GNEEdgeData* getEdgeDataElementFront() const;
 
        GNEEdgeRelData* getEdgeRelDataElementFront() const;
 
        GNETAZRelData* getTAZRelDataElementFront() const;
 
        const std::vector<GUIGlObject*>& getGLObjects() const;
 
        const std::vector<GNEAttributeCarrier*>& getAttributeCarriers() const;
 
        const std::vector<GNEJunction*>& getJunctions() const;
 
        const std::vector<GNEEdge*>& getEdges() const;
 
        const std::vector<GNETAZ*>& getTAZs() const;
 
        const std::vector<GNEAdditional*>& getAdditionals() const;
 
        const std::vector<GNEDemandElement*>& getDemandElements() const;
 
    protected:
        class ViewObjectsContainer {
 
        public:
            ViewObjectsContainer();
 
            void clearElements();
 
            void filterElements(const std::vector<const GUIGlObject*>& objects);
 
            std::vector<GUIGlObject*> GUIGlObjects;
 
            std::vector<GNEAttributeCarrier*> attributeCarriers;
 
            std::vector<GNENetworkElement*> networkElements;
 
            std::vector<GNEAdditional*> additionals;
 
            std::vector<GNEDemandElement*> demandElements;
 
            std::vector<GNEGenericData*> genericDatas;
 
            std::vector<GNEJunction*> junctions;
 
            std::vector<GNEEdge*> edges;
 
            std::vector<GNELane*> lanes;
 
            std::vector<GNECrossing*> crossings;
 
            std::vector<GNEWalkingArea*> walkingAreas;
 
            std::vector<GNEConnection*> connections;
 
            std::vector<GNEInternalLane*> internalLanes;
 
            std::vector<GNETAZ*> TAZs;
 
            std::vector<GNEPOI*> POIs;
 
            std::vector<GNEPoly*> polys;
 
            std::vector<GNEEdgeData*> edgeDatas;
 
            std::vector<GNEEdgeRelData*> edgeRelDatas;
 
            std::vector<GNETAZRelData*> TAZRelDatas;
 
        private:
            ViewObjectsContainer(const ViewObjectsContainer&) = delete;
 
            ViewObjectsContainer& operator=(const ViewObjectsContainer&) = delete;
        };
 
        const GNEViewNet* myViewNet;
 
        ViewObjectsContainer myViewObjects;
 
    private:
        void updateNetworkElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
        void updateAdditionalElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
        void updateShapeElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
        void updateTAZElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
        void updateDemandElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
        void updateGenericDataElements(ViewObjectsContainer& container, const GUIGlObject* glObject);
 
        void processGUIGlObjects(const GUIViewObjectsHandler::GLObjectsSortedContainer& objectsContainer);
 
        ViewObjectsSelector();
 
        ViewObjectsSelector(const ViewObjectsSelector&) = delete;
 
        ViewObjectsSelector& operator=(const ViewObjectsSelector&) = delete;
    };
 
    struct MouseButtonKeyPressed {
 
        MouseButtonKeyPressed();
 
        void update(void* eventData);
 
        bool shiftKeyPressed() const;
 
        bool controlKeyPressed() const;
 
        bool altKeyPressed() const;
 
        bool mouseLeftButtonPressed() const;
 
        bool mouseRightButtonPressed() const;
 
    private:
        FXEvent* myEventInfo;
 
        MouseButtonKeyPressed(const MouseButtonKeyPressed&) = delete;
 
        MouseButtonKeyPressed& operator=(const MouseButtonKeyPressed&) = delete;
    };
 
    struct SaveElements {
 
        SaveElements(GNEViewNet* viewNet);
 
        ~SaveElements();
 
        void buildSaveElementsButtons();
 
        void setSaveIndividualFiles(bool value);
 
    private:
        GNEViewNet* myViewNet;
 
        FXPopup* mySaveIndividualFilesPopup = nullptr;
 
        MFXMenuButtonTooltip* mySaveIndividualFiles = nullptr;
 
        MFXButtonTooltip* mySaveNeteditConfig = nullptr;
 
        MFXButtonTooltip* mySaveSumoConfig = nullptr;
 
        MFXButtonTooltip* mySaveNetwork = nullptr;
 
        MFXButtonTooltip* mySaveAdditionalElements = nullptr;
 
        MFXButtonTooltip* mySaveDemandElements = nullptr;
 
        MFXButtonTooltip* mySaveDataElements = nullptr;
 
        MFXButtonTooltip* mySaveMeanDataElements = nullptr;
 
        SaveElements(const SaveElements&) = delete;
 
        SaveElements& operator=(const SaveElements&) = delete;
    };
 
    struct TimeFormat {
 
        TimeFormat(GNEViewNet* viewNet);
 
        void buildTimeFormatButtons();
 
        void switchTimeFormat();
 
        void updateButtonLabel();
 
    private:
        GNEViewNet* myViewNet;
 
        MFXButtonTooltip* mySwitchButton = nullptr;
 
        TimeFormat(const TimeFormat&) = delete;
 
        TimeFormat& operator=(const TimeFormat&) = delete;
    };
 
    struct EditModes {
 
        EditModes(GNEViewNet* viewNet);
 
        ~EditModes();
 
        void buildSuperModeButtons();
 
        void setSupermode(Supermode supermode, const bool force);
 
        void setNetworkEditMode(NetworkEditMode networkMode, const bool force = false);
 
        void setDemandEditMode(DemandEditMode demandMode, const bool force = false);
 
        void setDataEditMode(DataEditMode dataMode, const bool force = false);
 
        bool isCurrentSupermodeNetwork() const;
 
        bool isCurrentSupermodeDemand() const;
 
        bool isCurrentSupermodeData() const;
 
        void setView(FXSelector sel);
 
        bool isDefaultView() const;
 
        bool isJuPedSimView() const;
 
        Supermode currentSupermode;
 
        NetworkEditMode networkEditMode;
 
        DemandEditMode demandEditMode;
 
        DataEditMode dataEditMode;
 
        MFXCheckableButton* networkButton = nullptr;
 
        MFXCheckableButton* demandButton = nullptr;
 
        MFXCheckableButton* dataButton = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        FXPopup* myNeteditViewsPopup = nullptr;
 
        MFXMenuButtonTooltip* myNeteditViewsButton = nullptr;
 
        MFXButtonTooltip* myDefaultViewButton = nullptr;
 
        MFXButtonTooltip* myJuPedSimViewButton = nullptr;
 
        EditModes(const EditModes&) = delete;
 
        EditModes& operator=(const EditModes&) = delete;
    };
 
    struct NetworkViewOptions {
 
        NetworkViewOptions(GNEViewNet* viewNet);
 
        void buildNetworkViewOptionsMenuChecks();
 
        void hideNetworkViewOptionsMenuChecks();
 
        void getVisibleNetworkMenuCommands(std::vector<MFXCheckableButton*>& commands) const;
 
        bool drawSpreadVehicles() const;
 
        bool showDemandElements() const;
 
        bool selectEdges() const;
 
        bool showConnections() const;
 
        bool showSubAdditionals() const;
 
        bool showTAZElements() const;
 
        bool editingElevation() const;
 
        MFXCheckableButton* menuCheckToggleGrid = nullptr;
 
        MFXCheckableButton* menuCheckToggleDrawJunctionShape = nullptr;
 
        MFXCheckableButton* menuCheckDrawSpreadVehicles = nullptr;
 
        MFXCheckableButton* menuCheckShowDemandElements = nullptr;
 
        MFXCheckableButton* menuCheckSelectEdges = nullptr;
 
        MFXCheckableButton* menuCheckShowConnections = nullptr;
 
        MFXCheckableButton* menuCheckHideConnections = nullptr;
 
        MFXCheckableButton* menuCheckShowAdditionalSubElements = nullptr;
 
        MFXCheckableButton* menuCheckShowTAZElements = nullptr;
 
        MFXCheckableButton* menuCheckExtendSelection = nullptr;
 
        MFXCheckableButton* menuCheckChangeAllPhases = nullptr;
 
        MFXCheckableButton* menuCheckWarnAboutMerge = nullptr;
 
        MFXCheckableButton* menuCheckShowJunctionBubble = nullptr;
 
        MFXCheckableButton* menuCheckMoveElevation = nullptr;
 
        MFXCheckableButton* menuCheckChainEdges = nullptr;
 
        MFXCheckableButton* menuCheckAutoOppositeEdge = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        NetworkViewOptions(const NetworkViewOptions&) = delete;
 
        NetworkViewOptions& operator=(const NetworkViewOptions&) = delete;
    };
 
    struct DemandViewOptions {
 
        DemandViewOptions(GNEViewNet* viewNet);
 
        void buildDemandViewOptionsMenuChecks();
 
        void hideDemandViewOptionsMenuChecks();
 
        void getVisibleDemandMenuCommands(std::vector<MFXCheckableButton*>& commands) const;
 
        bool drawSpreadVehicles() const;
 
        bool showNonInspectedDemandElements(const GNEDemandElement* demandElement) const;
 
        bool showShapes() const;
 
        bool showAllTrips() const;
 
        bool showAllPersonPlans() const;
 
        void lockPerson(const GNEDemandElement* person);
 
        void unlockPerson();
 
        const GNEDemandElement* getLockedPerson() const;
 
        bool showAllContainerPlans() const;
 
        void lockContainer(const GNEDemandElement* container);
 
        void unlockContainer();
 
        bool showOverlappedRoutes() const;
 
        const GNEDemandElement* getLockedContainer() const;
 
        MFXCheckableButton* menuCheckToggleGrid = nullptr;
 
        MFXCheckableButton* menuCheckToggleDrawJunctionShape = nullptr;
 
        MFXCheckableButton* menuCheckDrawSpreadVehicles = nullptr;
 
        MFXCheckableButton* menuCheckHideShapes = nullptr;
 
        MFXCheckableButton* menuCheckShowAllTrips = nullptr;
 
        MFXCheckableButton* menuCheckShowAllPersonPlans = nullptr;
 
        MFXCheckableButton* menuCheckLockPerson = nullptr;
 
        MFXCheckableButton* menuCheckShowAllContainerPlans = nullptr;
 
        MFXCheckableButton* menuCheckLockContainer = nullptr;
 
        MFXCheckableButton* menuCheckHideNonInspectedDemandElements = nullptr;
 
        MFXCheckableButton* menuCheckShowOverlappedRoutes = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        const GNEDemandElement* myLockedPerson = nullptr;
 
        const GNEDemandElement* myLockedContainer = nullptr;
 
        DemandViewOptions(const DemandViewOptions&) = delete;
 
        DemandViewOptions& operator=(const DemandViewOptions&) = delete;
    };
 
    struct DataViewOptions {
 
        DataViewOptions(GNEViewNet* viewNet);
 
        void buildDataViewOptionsMenuChecks();
 
        void hideDataViewOptionsMenuChecks();
 
        void getVisibleDataMenuCommands(std::vector<MFXCheckableButton*>& commands) const;
 
        bool showAdditionals() const;
 
        bool showShapes() const;
 
        bool showDemandElements() const;
 
        bool TAZRelDrawing() const;
 
        bool TAZDrawFill() const;
 
        bool TAZRelOnlyFrom() const;
 
        bool TAZRelOnlyTo() const;
 
        MFXCheckableButton* menuCheckToggleDrawJunctionShape = nullptr;
 
        MFXCheckableButton* menuCheckShowAdditionals = nullptr;
 
        MFXCheckableButton* menuCheckShowShapes = nullptr;
 
        MFXCheckableButton* menuCheckShowDemandElements = nullptr;
 
        MFXCheckableButton* menuCheckToggleTAZRelDrawing = nullptr;
 
        MFXCheckableButton* menuCheckToggleTAZDrawFill = nullptr;
 
        MFXCheckableButton* menuCheckToggleTAZRelOnlyFrom = nullptr;
 
        MFXCheckableButton* menuCheckToggleTAZRelOnlyTo = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        DataViewOptions(const DataViewOptions&) = delete;
 
        DataViewOptions& operator=(const DataViewOptions&) = delete;
    };
 
    class IntervalBar {
 
    public:
        IntervalBar(GNEViewNet* viewNet);
 
        void buildIntervalBarElements();
 
        void showIntervalBar();
 
        void hideIntervalBar();
 
        void updateIntervalBar();
 
        // @brief mark for update
        void markForUpdate();
 
 
        SumoXMLTag getGenericDataType() const;
 
        GNEDataSet* getDataSet() const;
 
        double getBegin() const;
 
        double getEnd() const;
 
        std::string getParameter() const;
 
 
 
        void setGenericDataType();
 
        void setDataSet();
 
        void setInterval();
 
        void setBegin();
 
        void setEnd();
 
        void setParameter();
 
 
    protected:
        void enableIntervalBar();
 
        void disableIntervalBar();
 
    private:
        GNEViewNet* myViewNet;
 
        bool myUpdateInterval = true;
 
        MFXComboBoxIcon* myGenericDataTypesComboBox = nullptr;
 
        MFXComboBoxIcon* myDataSetsComboBox = nullptr;
 
        FXCheckButton* myIntervalCheckBox = nullptr;
 
        FXTextField* myBeginTextField = nullptr;
 
        FXTextField* myEndTextField = nullptr;
 
        MFXComboBoxIcon* myParametersComboBox = nullptr;
 
        std::vector<std::string> myDataSets;
 
        std::set<std::string> myParameters;
 
        IntervalBar(const IntervalBar&) = delete;
 
        IntervalBar& operator=(const IntervalBar&) = delete;
    };
 
    struct MoveSingleElementModul {
 
        MoveSingleElementModul(GNEViewNet* viewNet);
 
        bool beginMoveNetworkElementShape();
 
        bool beginMoveSingleElementNetworkMode();
 
        bool beginMoveSingleElementDemandMode();
 
        void moveSingleElement(const bool mouseLeftButtonPressed);
 
        void finishMoveSingleElement();
 
        bool isCurrentlyMovingSingleElement() const;
 
        GNEMoveElement* getMovedElement() const;
 
    protected:
        const GNEMoveOffset calculateMoveOffset() const;
 
    private:
        GNEViewNet* myViewNet;
 
        Position myRelativeClickedPosition;
 
        GNEMoveOperation* myMoveOperation = nullptr;
 
        MoveSingleElementModul(const MoveSingleElementModul&) = delete;
 
        MoveSingleElementModul& operator=(const MoveSingleElementModul&) = delete;
    };
 
    struct MoveMultipleElementModul {
 
        MoveMultipleElementModul(GNEViewNet* viewNet);
 
        void beginMoveSelection();
 
        void moveSelection(const bool mouseLeftButtonPressed);
 
        void finishMoveSelection();
 
        bool isMovingSelection() const;
 
        bool isMovingSelectedEdge() const;
 
        void resetMovingSelectedEdge();
 
        double getEdgeOffset() const;
 
        bool isCurrentlyMovingMultipleElements() const;
 
    protected:
        const GNEMoveOffset calculateMoveOffset() const;
 
        void calculateJunctionSelection();
 
        void calculateEdgeSelection(const GNEEdge* clickedEdge);
 
    private:
        GNEViewNet* myViewNet;
 
        Position myClickedPosition;
 
        bool myMovingSelectedEdge;
 
        double myEdgeOffset;
 
        std::vector<GNEMoveOperation*> myMoveOperations;
 
        MoveMultipleElementModul(const MoveMultipleElementModul&) = delete;
 
        MoveMultipleElementModul& operator=(const MoveMultipleElementModul&) = delete;
    };
 
    struct VehicleOptions {
 
        VehicleOptions(GNEViewNet* viewNet);
 
        void buildVehicleOptionsMenuChecks();
 
        void hideVehicleOptionsMenuChecks();
 
    private:
        GNEViewNet* myViewNet;
 
        VehicleOptions(const VehicleOptions&) = delete;
 
        VehicleOptions& operator=(const VehicleOptions&) = delete;
    };
 
    struct VehicleTypeOptions {
 
        VehicleTypeOptions(GNEViewNet* viewNet);
 
        void buildVehicleTypeOptionsMenuChecks();
 
        void hideVehicleTypeOptionsMenuChecks();
 
    private:
        GNEViewNet* myViewNet;
 
        VehicleTypeOptions(const VehicleTypeOptions&) = delete;
 
        VehicleTypeOptions& operator=(const VehicleTypeOptions&) = delete;
    };
 
    struct SelectingArea {
 
        SelectingArea(GNEViewNet* viewNet);
 
        void beginRectangleSelection();
 
        void moveRectangleSelection();
 
        void finishRectangleSelection();
 
        void processRectangleSelection();
 
        std::vector<GNEEdge*> processEdgeRectangleSelection();
 
        void drawRectangleSelection(const RGBColor& color) const;
 
        bool selectingUsingRectangle;
 
        bool startDrawing;
 
    private:
        void processBoundarySelection(const Boundary& boundary);
 
        Position selectionCorner1;
 
        Position selectionCorner2;
 
        GNEViewNet* myViewNet;
 
        SelectingArea(const SelectingArea&) = delete;
 
        SelectingArea& operator=(const SelectingArea&) = delete;
    };
 
    struct TestingMode {
 
        TestingMode(GNEViewNet* viewNet);
 
        void initTestingMode();
 
        void drawTestingElements(GUIMainWindow* mainWindow);
 
    private:
        GNEViewNet* myViewNet;
 
        int myTestingWidth = 0;
 
        int myTestingHeight = 0;
 
        TestingMode(const TestingMode&) = delete;
 
        TestingMode& operator=(const TestingMode&) = delete;
    };
 
    struct CommonCheckableButtons {
 
        CommonCheckableButtons(GNEViewNet* viewNet);
 
        void buildCommonCheckableButtons();
 
        void showCommonCheckableButtons();
 
        void hideCommonCheckableButtons();
 
        void disableCommonCheckableButtons();
 
        void updateCommonCheckableButtons();
 
        MFXCheckableButton* inspectButton = nullptr;
 
        MFXCheckableButton* deleteButton = nullptr;
 
        MFXCheckableButton* selectButton = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        CommonCheckableButtons(const CommonCheckableButtons&) = delete;
 
        CommonCheckableButtons& operator=(const CommonCheckableButtons&) = delete;
    };
 
    struct NetworkCheckableButtons {
 
        NetworkCheckableButtons(GNEViewNet* viewNet);
 
        void buildNetworkCheckableButtons();
 
        void showNetworkCheckableButtons();
 
        void hideNetworkCheckableButtons();
 
        void disableNetworkCheckableButtons();
 
        void updateNetworkCheckableButtons();
 
        MFXCheckableButton* moveNetworkElementsButton = nullptr;
 
        MFXCheckableButton* createEdgeButton = nullptr;
 
        MFXCheckableButton* connectionButton = nullptr;
 
        MFXCheckableButton* trafficLightButton = nullptr;
 
        MFXCheckableButton* additionalButton = nullptr;
 
        MFXCheckableButton* crossingButton = nullptr;
 
        MFXCheckableButton* TAZButton = nullptr;
 
        MFXCheckableButton* shapeButton = nullptr;
 
        MFXCheckableButton* prohibitionButton = nullptr;
 
        MFXCheckableButton* wireButton = nullptr;
 
        MFXCheckableButton* decalButton = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        NetworkCheckableButtons(const NetworkCheckableButtons&) = delete;
 
        NetworkCheckableButtons& operator=(const NetworkCheckableButtons&) = delete;
    };
 
    struct DemandCheckableButtons {
 
        DemandCheckableButtons(GNEViewNet* viewNet);
 
        void buildDemandCheckableButtons();
 
        void showDemandCheckableButtons();
 
        void hideDemandCheckableButtons();
 
        void disableDemandCheckableButtons();
 
        void updateDemandCheckableButtons();
 
        MFXCheckableButton* moveDemandElementsButton = nullptr;
 
        MFXCheckableButton* routeButton = nullptr;
 
        MFXCheckableButton* routeDistributionButton = nullptr;
 
        MFXCheckableButton* vehicleButton = nullptr;
 
        MFXCheckableButton* typeButton = nullptr;
 
        MFXCheckableButton* typeDistributionButton = nullptr;
 
        MFXCheckableButton* stopButton = nullptr;
 
        MFXCheckableButton* personButton = nullptr;
 
        MFXCheckableButton* personPlanButton = nullptr;
 
        MFXCheckableButton* containerButton = nullptr;
 
        MFXCheckableButton* containerPlanButton = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        DemandCheckableButtons(const DemandCheckableButtons&) = delete;
 
        DemandCheckableButtons& operator=(const DemandCheckableButtons&) = delete;
    };
 
    struct DataCheckableButtons {
 
        DataCheckableButtons(GNEViewNet* viewNet);
 
        void buildDataCheckableButtons();
 
        void showDataCheckableButtons();
 
        void hideDataCheckableButtons();
 
        void disableDataCheckableButtons();
 
        void updateDataCheckableButtons();
 
        MFXCheckableButton* edgeDataButton = nullptr;
 
        MFXCheckableButton* edgeRelDataButton = nullptr;
 
        MFXCheckableButton* TAZRelDataButton = nullptr;
 
        MFXCheckableButton* meanDataButton = nullptr;
 
    private:
        GNEViewNet* myViewNet;
 
        DataCheckableButtons(const DataCheckableButtons&) = delete;
 
        DataCheckableButtons& operator=(const DataCheckableButtons&) = delete;
    };
 
    struct EditNetworkElementShapes {
 
        EditNetworkElementShapes(GNEViewNet* viewNet);
 
        void startEditCustomShape(GNENetworkElement* element);
 
        void stopEditCustomShape();
 
        void commitShapeEdited();
 
        GNENetworkElement* getEditedNetworkElement() const;
 
    private:
        GNEViewNet* myViewNet;
 
        GNENetworkElement* myEditedNetworkElement = nullptr;
 
        NetworkEditMode myPreviousNetworkEditMode;
 
        EditNetworkElementShapes(const EditNetworkElementShapes&) = delete;
 
        EditNetworkElementShapes& operator=(const EditNetworkElementShapes&) = delete;
    };
 
    struct LockIcon {
        static void drawLockIcon(const GUIVisualizationSettings::Detail d, const GNEAttributeCarrier* AC, GUIGlObjectType type, const Position position,
                                 const double exaggeration, const double size = 0.5,
                                 const double offsetx = 0, const double offsety = 0);
 
        static bool checkDrawing(const GUIVisualizationSettings::Detail d, const GNEAttributeCarrier* AC,
                                 GUIGlObjectType type, const double exaggeration);
    private:
        LockIcon();
 
        LockIcon(const LockIcon&) = delete;
 
        LockIcon& operator=(const LockIcon&) = delete;
    };
 
    static const std::vector<RGBColor>& getRainbowScaledColors();
 
    static const RGBColor& getRainbowScaledColor(const double min, const double max, const double value);
 
    static std::vector<GUIGlObject*> filterElementsByLayer(const std::vector<GUIGlObject*>& GLObjects);
 
private:
    static std::vector<RGBColor> myRainbowScaledColors;
};