GNEApplicationWindowHelper.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
/****************************************************************************/
// Functions from main window of netedit
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <netedit/dialogs/file/GNEFileDialog.h>
#include <netedit/GNETagProperties.h>
#include <utils/common/SUMOTime.h>
#include <utils/foxtools/MFXInterThreadEventClient.h>
#include <utils/foxtools/MFXRecentNetworks.h>
#include <utils/foxtools/MFXSynchQue.h>
#include <utils/foxtools/MFXThreadEvent.h>
#include <utils/geom/Position.h>
#include <utils/gui/div/GUIMessageWindow.h>
#include <utils/gui/windows/GUIMainWindow.h>
#include <utils/options/OptionsCont.h>
#include <utils/shapes/ShapeHandler.h>
#include <utils/tests/InternalTestStep.h>
 
#include "GNEViewNetHelper.h"
 
// ===========================================================================
// class declarations
// ===========================================================================
 
class GNEApplicationWindow;
class FileBucket;
class GNENet;
class GNENetgenerateDialog;
class GNEPythonTool;
class GNEPythonToolDialog;
class GNERunNetgenerateDialog;
class GNERunPythonToolDialog;
class GNEViewNet;
class MFXMenuCheckIcon;
 
// ===========================================================================
// class definition
// ===========================================================================
 
struct GNEApplicationWindowHelper {
 
    struct ToolbarsGrip {
 
        ToolbarsGrip(GNEApplicationWindow* applicationWindow);
 
        void buildMenuToolbarsGrip();
 
        void buildViewParentToolbarsGrips();
 
        void destroyParentToolbarsGrips();
 
        FXMenuBar* menu = nullptr;
 
        FXMenuBar* superModes = nullptr;
 
        FXMenuBar* saveElements = nullptr;
 
        FXMenuBar* timeSwitch = nullptr;
 
        FXMenuBar* navigation = nullptr;
 
        FXMenuBar* modes = nullptr;
 
        FXMenuBar* intervalBar = nullptr;
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        FXToolBarShell* myPythonToolBarShellMenu = nullptr;
 
        FXToolBarShell* myPythonToolBarShellSuperModes = nullptr;
 
        FXToolBarShell* myPythonToolBarShellSaveElements = nullptr;
 
        FXToolBarShell* myPythonToolBarShellTimeFormat = nullptr;
 
        FXToolBarShell* myPythonToolBarShellNavigation = nullptr;
 
        FXToolBarShell* myPythonToolBarShellModes = nullptr;
 
        FXToolBarShell* myPythonToolBarShellIntervalBar = nullptr;
 
        ToolbarsGrip(const ToolbarsGrip&) = delete;
 
        ToolbarsGrip& operator=(const ToolbarsGrip&) = delete;
    };
 
    struct MenuBarFile {
 
        MenuBarFile(GNEApplicationWindow* applicationWindow);
 
        void buildRecentNetworkFiles(FXMenuPane* fileMenu, FXMenuPane* fileMenuRecentNetworkFiles);
 
        void buildRecentConfigFiles(FXMenuPane* fileMenu, FXMenuPane* fileMenuRecentConfigFiles);
 
        MFXRecentNetworks myRecentNetworks;
 
        MFXRecentNetworks myRecentConfigs;
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        MenuBarFile(const MenuBarFile&) = delete;
 
        MenuBarFile& operator=(const MenuBarFile&) = delete;
    };
 
    struct FileMenuCommands {
 
        FileMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildFileMenuCommands(FXMenuPane* fileMenu, FXMenuPane* fileMenuNEEDITConfig, FXMenuPane* fileMenuSumoConfig,
                                   FXMenuPane* fileMenuTLS, FXMenuPane* fileMenuEdgeTypes, FXMenuPane* fileMenuAdditionals,
                                   FXMenuPane* fileMenuDemandElements, FXMenuPane* fileMenuDataElements,
                                   FXMenuPane* fileMenuMeanDataElements);
 
        void enableMenuCascades();
 
        void disableMenuCascades();
 
        void setDefaultView();
 
        void setJuPedSimView();
 
        FXMenuCheck* menuCheckAllowUndoRedoLoading = nullptr;
 
    private:
        void buildNeteditConfigSection(FXMenuPane* menuPane);
 
        void buildSumoConfigSection(FXMenuPane* menuPane);
 
        void buildTrafficLightSection(FXMenuPane* menuPane);
 
        void buildEdgeTypeSection(FXMenuPane* menuPane);
 
        void buildAdditionalSection(FXMenuPane* menuPane);
 
        void buildDemandSection(FXMenuPane* menuPane);
 
        void buildDataSection(FXMenuPane* menuPane);
 
        void buildMeanDataSection(FXMenuPane* menuPane);
 
        GNEApplicationWindow* myApplicationWindow = nullptr;
 
        FXMenuCascade* myNeteditConfigMenuCascade = nullptr;
 
        FXMenuCascade* mySumoConfigMenuCascade = nullptr;
 
        FXMenuCascade* myTLSMenuCascade = nullptr;
 
        FXMenuCascade* myEdgeTypesMenuCascade = nullptr;
 
        FXMenuCascade* myAdditionalMenuCascade = nullptr;
 
        FXMenuCascade* myDemandMenuCascade = nullptr;
 
        FXMenuCascade* myDataMenuCascade = nullptr;
 
        FXMenuCascade* myMeanDataMenuCascade = nullptr;
 
        FileMenuCommands(const FileMenuCommands&) = delete;
 
        FileMenuCommands& operator=(const FileMenuCommands&) = delete;
    };
 
    struct ModesMenuCommands {
 
        struct CommonMenuCommands {
 
            CommonMenuCommands(const ModesMenuCommands* modesMenuCommandsParent);
 
            void buildCommonMenuCommands(FXMenuPane* modesMenu);
 
            FXMenuCommand* deleteMode = nullptr;
 
            FXMenuCommand* inspectMode = nullptr;
 
            FXMenuCommand* selectMode = nullptr;
 
        private:
            const ModesMenuCommands* myModesMenuCommandsParent;
 
            CommonMenuCommands(const CommonMenuCommands&) = delete;
 
            CommonMenuCommands& operator=(const CommonMenuCommands&) = delete;
        };
 
        struct NetworkMenuCommands {
 
            NetworkMenuCommands(const ModesMenuCommands* modesMenuCommandsParent);
 
            void buildNetworkMenuCommands(FXMenuPane* modesMenu);
 
            void showNetworkMenuCommands();
 
            void hideNetworkMenuCommands();
 
            FXMenuCommand* createEdgeMode = nullptr;
 
            FXMenuCommand* moveMode = nullptr;
 
            FXMenuCommand* connectMode = nullptr;
 
            FXMenuCommand* prohibitionMode = nullptr;
 
            FXMenuCommand* TLSMode = nullptr;
 
            FXMenuCommand* additionalMode = nullptr;
 
            FXMenuCommand* crossingMode = nullptr;
 
            FXMenuCommand* TAZMode = nullptr;
 
            FXMenuCommand* shapeMode = nullptr;
 
            FXMenuCommand* wireMode = nullptr;
 
            FXMenuCommand* decalMode = nullptr;
 
        private:
            const ModesMenuCommands* myModesMenuCommandsParent;
 
            NetworkMenuCommands(const NetworkMenuCommands&) = delete;
 
            NetworkMenuCommands& operator=(const NetworkMenuCommands&) = delete;
        };
 
        struct DemandMenuCommands {
 
            DemandMenuCommands(const ModesMenuCommands* modesMenuCommandsParent);
 
            void buildDemandMenuCommands(FXMenuPane* modesMenu);
 
            void showDemandMenuCommands();
 
            void hideDemandMenuCommands();
 
            FXMenuCommand* moveMode = nullptr;
 
            FXMenuCommand* routeMode = nullptr;
 
            FXMenuCommand* routeDistributionMode = nullptr;
 
            FXMenuCommand* vehicleMode = nullptr;
 
            FXMenuCommand* typeMode = nullptr;
 
            FXMenuCommand* typeDistributionMode = nullptr;
 
            FXMenuCommand* stopMode = nullptr;
 
            FXMenuCommand* personMode = nullptr;
 
            FXMenuCommand* personPlanMode = nullptr;
 
            FXMenuCommand* containerMode = nullptr;
 
            FXMenuCommand* containerPlanMode = nullptr;
 
        private:
            const ModesMenuCommands* myModesMenuCommandsParent;
 
            DemandMenuCommands(const DemandMenuCommands&) = delete;
 
            DemandMenuCommands& operator=(const DemandMenuCommands&) = delete;
        };
 
        struct DataMenuCommands {
 
            DataMenuCommands(const ModesMenuCommands* modesMenuCommandsParent);
 
            void buildDataMenuCommands(FXMenuPane* modesMenu);
 
            void showDataMenuCommands();
 
            void hideDataMenuCommands();
 
            FXMenuCommand* edgeData = nullptr;
 
            FXMenuCommand* edgeRelData = nullptr;
 
            FXMenuCommand* TAZRelData = nullptr;
 
            FXMenuCommand* meanData = nullptr;
 
        private:
            const ModesMenuCommands* myModesMenuCommandsParent;
 
            DataMenuCommands(const DataMenuCommands&) = delete;
 
            DataMenuCommands& operator=(const DataMenuCommands&) = delete;
        };
 
        ModesMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildModesMenuCommands(FXMenuPane* modesMenu);
 
        void setDefaultView(Supermode supermode);
 
        void setJuPedSimView(Supermode supermode);
 
        CommonMenuCommands commonMenuCommands;
 
        NetworkMenuCommands networkMenuCommands;
 
        DemandMenuCommands demandMenuCommands;
 
        DataMenuCommands dataMenuCommands;
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        ModesMenuCommands(const ModesMenuCommands&) = delete;
 
        ModesMenuCommands& operator=(const ModesMenuCommands&) = delete;
    };
 
    struct EditMenuCommands {
 
        struct NetworkViewOptions {
 
            NetworkViewOptions(GNEApplicationWindow* applicationWindow);
 
            void buildNetworkViewOptionsMenuChecks(FXMenuPane* editMenu);
 
            void hideNetworkViewOptionsMenuChecks();
 
            void updateShortcuts();
 
            MFXMenuCheckIcon* menuCheckToggleGrid = nullptr;
 
            MFXMenuCheckIcon* menuCheckToggleDrawJunctionShape = nullptr;
 
            MFXMenuCheckIcon* menuCheckDrawSpreadVehicles = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowDemandElements = nullptr;
 
            MFXMenuCheckIcon* menuCheckSelectEdges = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowConnections = nullptr;
 
            MFXMenuCheckIcon* menuCheckHideConnections = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowAdditionalSubElements = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowTAZElements = nullptr;
 
            MFXMenuCheckIcon* menuCheckExtendSelection = nullptr;
 
            MFXMenuCheckIcon* menuCheckChangeAllPhases = nullptr;
 
            MFXMenuCheckIcon* menuCheckMergeAutomatically = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowJunctionBubble = nullptr;
 
            MFXMenuCheckIcon* menuCheckMoveElevation = nullptr;
 
            MFXMenuCheckIcon* menuCheckChainEdges = nullptr;
 
            MFXMenuCheckIcon* menuCheckAutoOppositeEdge = nullptr;
 
            FXMenuSeparator* separator = nullptr;
 
        private:
            GNEApplicationWindow* myApplicationWindow;
 
            NetworkViewOptions(const NetworkViewOptions&) = delete;
 
            NetworkViewOptions& operator=(const NetworkViewOptions&) = delete;
        };
 
        struct DemandViewOptions {
 
            DemandViewOptions(GNEApplicationWindow* applicationWindow);
 
            void buildDemandViewOptionsMenuChecks(FXMenuPane* editMenu);
 
            void hideDemandViewOptionsMenuChecks();
 
            void updateShortcuts();
 
            MFXMenuCheckIcon* menuCheckToggleGrid = nullptr;
 
            MFXMenuCheckIcon* menuCheckToggleDrawJunctionShape = nullptr;
 
            MFXMenuCheckIcon* menuCheckDrawSpreadVehicles = nullptr;
 
            MFXMenuCheckIcon* menuCheckHideShapes = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowAllTrips = nullptr;
 
            MFXMenuCheckIcon* menuCheckHideNonInspectedDemandElements = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowOverlappedRoutes = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowAllPersonPlans = nullptr;
 
            MFXMenuCheckIcon* menuCheckLockPerson = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowAllContainerPlans = nullptr;
 
            MFXMenuCheckIcon* menuCheckLockContainer = nullptr;
 
            FXMenuSeparator* separator = nullptr;
 
        private:
            GNEApplicationWindow* myApplicationWindow;
 
            DemandViewOptions(const DemandViewOptions&) = delete;
 
            DemandViewOptions& operator=(const DemandViewOptions&) = delete;
        };
 
        struct DataViewOptions {
 
            DataViewOptions(GNEApplicationWindow* applicationWindow);
 
            void buildDataViewOptionsMenuChecks(FXMenuPane* editMenu);
 
            void hideDataViewOptionsMenuChecks();
 
            void updateShortcuts();
 
            MFXMenuCheckIcon* menuCheckToggleDrawJunctionShape = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowAdditionals = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowShapes = nullptr;
 
            MFXMenuCheckIcon* menuCheckShowDemandElements = nullptr;
 
            MFXMenuCheckIcon* menuCheckToggleTAZRelDrawing = nullptr;
 
            MFXMenuCheckIcon* menuCheckToggleTAZDrawFill = nullptr;
 
            MFXMenuCheckIcon* menuCheckToggleTAZRelOnlyFrom = nullptr;
 
            MFXMenuCheckIcon* menuCheckToggleTAZRelOnlyTo = nullptr;
 
            FXMenuSeparator* separator = nullptr;
 
        private:
            GNEApplicationWindow* myApplicationWindow;
 
            DataViewOptions(const DataViewOptions&) = delete;
 
            DataViewOptions& operator=(const DataViewOptions&) = delete;
        };
 
        EditMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildUndoRedoMenuCommands(FXMenuPane* editMenu);
 
        void buildViewMenuCommands(FXMenuPane* editMenu);
 
        void buildFrontElementMenuCommand(FXMenuPane* editMenu);
 
        void buildOpenSUMOMenuCommands(FXMenuPane* editMenu);
 
        FXMenuCommand* undoLastChange = nullptr;
 
        FXMenuCommand* redoLastChange = nullptr;
 
        FXMenuCommand* openUndolistDialog = nullptr;
 
        FXMenuCheck* menuCheckAllowUndoRedo = nullptr;
 
        NetworkViewOptions networkViewOptions;
 
        DemandViewOptions demandViewOptions;
 
        DataViewOptions dataViewOptions;
 
        FXMenuCommand* editViewScheme = nullptr;
 
        FXMenuCommand* editViewPort = nullptr;
 
        FXMenuCommand* toggleFrontElement = nullptr;
 
        FXMenuCheck* loadAdditionalsInSUMOGUI = nullptr;
 
        FXMenuCheck* loadDemandInSUMOGUI = nullptr;
 
        FXMenuCommand* openInSUMOGUI = nullptr;
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        EditMenuCommands(const EditMenuCommands&) = delete;
 
        EditMenuCommands& operator=(const EditMenuCommands&) = delete;
    };
 
    struct LockMenuCommands {
 
        LockMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildLockMenuCommands(FXMenuPane* editMenu);
 
        void removeHotkeys();
 
        void showNetworkLockMenuCommands();
 
        void hideNetworkLockMenuCommands();
 
        void showDemandLockMenuCommands();
 
        void hideDemandLockMenuCommands();
 
        void showDataLockMenuCommands();
 
        void hideDataLockMenuCommands();
 
        void lockAll();
 
        void unlockAll();
 
        void editLocking(const GNEAttributeCarrier* AC, const FXbool value);
 
        MFXMenuCheckIcon* menuCheckLockJunctions = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockEdges = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockLanes = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockConnections = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockCrossings = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockWalkingAreas = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockAdditionals = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockTAZs = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockWires = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockPolygons = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockPOIs = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockJpsWalkableAreas = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockJpsObstacles = nullptr;
 
 
        MFXMenuCheckIcon* menuCheckLockRoutes = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockVehicles = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockPersons = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockPersonTrips = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockWalks = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockRides = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockContainers = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockTransports = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockTranships = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockStops = nullptr;
 
 
        MFXMenuCheckIcon* menuCheckLockEdgeDatas = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockEdgeRelDatas = nullptr;
 
        MFXMenuCheckIcon* menuCheckLockEdgeTAZRels = nullptr;
 
 
        MFXMenuCheckIcon* menuCheckLockSelectedElements = nullptr;
 
    protected:
        FXHotKey parseHotKey(const FXwchar character);
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        LockMenuCommands(const LockMenuCommands&) = delete;
 
        LockMenuCommands& operator=(const LockMenuCommands&) = delete;
    };
 
    struct ProcessingMenuCommands {
 
        ProcessingMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildProcessingMenuCommands(FXMenuPane* processingMenu);
 
        void showNetworkProcessingMenuCommands();
 
        void hideNetworkProcessingMenuCommands();
 
        void showDemandProcessingMenuCommands();
 
        void hideDemandProcessingMenuCommands();
 
        void showDataProcessingMenuCommands();
 
        void hideDataProcessingMenuCommands();
 
        void showSeparator();
 
        void hideSeparator();
 
        FXMenuCommand* computeNetwork = nullptr;
 
        FXMenuCommand* computeNetworkVolatile = nullptr;
 
        FXMenuCommand* cleanJunctions = nullptr;
 
        FXMenuCommand* joinJunctions = nullptr;
 
        FXMenuCommand* clearInvalidCrossings = nullptr;
 
        MFXMenuCheckIcon* menuCheckRecomputeDataMode = nullptr;
 
 
        FXMenuCommand* computeDemand = nullptr;
 
        FXMenuCommand* cleanRoutes = nullptr;
 
        FXMenuCommand* joinRoutes = nullptr;
 
        FXMenuCommand* adjustPersonPlans = nullptr;
 
        FXMenuCommand* clearInvalidDemandElements = nullptr;
 
 
 
        FXMenuCommand* optionMenus = nullptr;
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        FXMenuSeparator* myOptionsSeparator = nullptr;
 
        FXMenuSeparator* mySeparatorCheckBox = nullptr;
 
        ProcessingMenuCommands(const ProcessingMenuCommands&) = delete;
 
        ProcessingMenuCommands& operator=(const ProcessingMenuCommands&) = delete;
    };
 
    struct LocateMenuCommands {
 
        LocateMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildLocateMenuCommands(FXMenuPane* locateMenu);
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        LocateMenuCommands(const LocateMenuCommands&) = delete;
 
        LocateMenuCommands& operator=(const LocateMenuCommands&) = delete;
    };
 
    struct ToolsMenuCommands {
 
        ToolsMenuCommands(GNEApplicationWindow* applicationWindow);
 
        ~ToolsMenuCommands();
 
        void buildTools(FXMenuPane* toolsMenu, const std::map<std::string, FXMenuPane*>& menuPaneToolMaps);
 
        long showTool(FXObject* menuCommand);
 
        long runToolDialog(FXObject* menuCommand) const;
 
        long postProcessing(FXObject* menuCommand) const;
 
    private:
        std::vector<GNEPythonTool*> myPythonTools;
 
        GNEPythonToolDialog* myPythonToolDialog = nullptr;
 
        GNEApplicationWindow* myApplicationWindow;
 
        ToolsMenuCommands(const ToolsMenuCommands&) = delete;
 
        ToolsMenuCommands& operator=(const ToolsMenuCommands&) = delete;
    };
 
    struct WindowsMenuCommands {
 
        WindowsMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildWindowsMenuCommands(FXMenuPane* windowsMenu, FXStatusBar* statusbar, GUIMessageWindow* messageWindow);
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        WindowsMenuCommands(const WindowsMenuCommands&) = delete;
 
        WindowsMenuCommands& operator=(const WindowsMenuCommands&) = delete;
    };
 
    struct HelpMenuCommands {
 
        HelpMenuCommands(GNEApplicationWindow* applicationWindow);
 
        void buildHelpMenuCommands(FXMenuPane* helpMenu);
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        HelpMenuCommands(const HelpMenuCommands&) = delete;
 
        HelpMenuCommands& operator=(const HelpMenuCommands&) = delete;
    };
 
    struct SupermodeCommands {
 
        SupermodeCommands(GNEApplicationWindow* applicationWindow);
 
        void buildSupermodeCommands(FXMenuPane* editMenu);
 
        void showSupermodeCommands();
 
        void setDefaultView();
 
        void setJuPedSimView();
 
        FXMenuCommand* networkMode = nullptr;
 
        FXMenuCommand* demandMode = nullptr;
 
        FXMenuCommand* dataMode = nullptr;
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        SupermodeCommands(const SupermodeCommands&) = delete;
 
        SupermodeCommands& operator=(const SupermodeCommands&) = delete;
    };
 
    class GNESumoConfigHandler {
 
    public:
        GNESumoConfigHandler(GNEApplicationWindow* applicationWindow, const std::string& sumoConfigFile);
 
        bool loadSumoConfig();
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        const std::string mySumoConfigFile;
 
        GNESumoConfigHandler(const GNESumoConfigHandler&) = delete;
 
        GNESumoConfigHandler& operator=(const GNESumoConfigHandler&) = delete;
    };
 
    class GNENetconvertConfigHandler {
 
    public:
        GNENetconvertConfigHandler(GNEApplicationWindow* applicationWindow, const std::string& file);
 
        bool loadNetconvertConfig();
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        const std::string myNetconvertConfigFile;
 
        GNENetconvertConfigHandler(const GNENetconvertConfigHandler&) = delete;
 
        GNENetconvertConfigHandler& operator=(const GNENetconvertConfigHandler&) = delete;
    };
 
    class GNENeteditConfigHandler {
 
    public:
        GNENeteditConfigHandler(GNEApplicationWindow* applicationWindow, const std::string& neteditConfigFile);
 
        bool loadNeteditConfig();
 
    private:
        GNEApplicationWindow* myApplicationWindow;
 
        const std::string myNeteditConfigFile;
 
        GNENeteditConfigHandler(const GNENeteditConfigHandler&) = delete;
 
        GNENeteditConfigHandler& operator=(const GNENeteditConfigHandler&) = delete;
    };
 
    class FileBucketHandler {
 
    public:
        FileBucketHandler(GNEApplicationWindow* applicationWindow, OptionsCont& neteditOptions, OptionsCont& sumoOptions);
 
        ~FileBucketHandler();
 
        void registerAC(const GNEAttributeCarrier* AC);
 
        void unregisterAC(const GNEAttributeCarrier* AC);
 
        FileBucket* updateAC(const GNEAttributeCarrier* AC, const std::string& filename);
 
        bool checkFilename(const GNEAttributeCarrier* AC, const std::string& filename) const;
 
        std::string getConfigDirectory() const;
 
        std::string getConfigFilePrefix(const std::string& sufix) const;
 
 
        FileBucket* getDefaultBucket(const FileBucket::Type type) const;
 
        FileBucket* getBucket(const FileBucket::Type type, const std::string& filename, const bool create);
 
        const std::vector<FileBucket*>& getFileBuckets(const FileBucket::Type type) const;
 
 
 
        std::string getDefaultFilename(const FileBucket::Type type) const;
 
        std::string getDefaultFolder(const FileBucket::Type type) const;
 
        void setDefaultFilenameFile(const FileBucket::Type type, const std::string& filename);
 
        bool isFilenameDefined(const FileBucket::Type type) const;
 
        void resetDefaultFilenames();
 
 
        void updateOptions();
 
    private:
        std::string parseFilenames(const std::vector<FileBucket::Type> types) const;
 
        void removeEmptyBuckets();
 
        std::string getPrefix(FileBucket::Type type, const std::vector<std::string> invalidExtensions) const;
 
        GNEApplicationWindow* myApplicationWindow = nullptr;
 
        OptionsCont& myNeteditOptions;
 
        OptionsCont& mySumoOptions;
 
        std::map<FileBucket::Type, std::vector<FileBucket*> > myBuckets;
 
        FileBucketHandler(const FileBucketHandler&) = delete;
 
        FileBucketHandler& operator=(const FileBucketHandler&) = delete;
    };
 
    static bool toggleEditOptionsNetwork(GNEViewNet* viewNet, const MFXCheckableButton* menuCheck,
                                         FXObject* obj, FXSelector sel);
 
    static bool toggleEditOptionsDemand(GNEViewNet* viewNet, const MFXCheckableButton* menuCheck,
                                        FXObject* obj, FXSelector sel);
 
    static bool toggleEditOptionsData(GNEViewNet* viewNet, const MFXCheckableButton* menuCheck,
                                      FXObject* obj, FXSelector sel);
 
    static bool stringEndsWith(const std::string& str, const std::string& suffix);
 
private:
    GNEApplicationWindowHelper(const GNEApplicationWindowHelper&) = delete;
 
    GNEApplicationWindowHelper& operator=(const GNEApplicationWindowHelper&) = delete;
};