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 <utils/common/SUMOTime.h>
#include <utils/foxtools/MFXSynchQue.h>
#include <utils/foxtools/MFXRecentNetworks.h>
#include <utils/foxtools/MFXThreadEvent.h>
#include <utils/foxtools/MFXInterThreadEventClient.h>
#include <utils/geom/Position.h>
#include <utils/gui/div/GUIMessageWindow.h>
#include <utils/gui/windows/GUIMainWindow.h>
#include <utils/shapes/ShapeHandler.h>
#include <utils/options/OptionsCont.h>
#include <utils/tests/InternalTestStep.h>
 
#include "GNEViewNetHelper.h"
 
 
// ===========================================================================
// class declarations
// ===========================================================================
 
class GNEApplicationWindow;
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(OptionsCont& sumoOptions, const std::string& file);

        bool loadSumoConfig();
 
    private:
        OptionsCont& mySumoOptions;

        const std::string myFile;

        GNESumoConfigHandler(const GNESumoConfigHandler&) = delete;

        GNESumoConfigHandler& operator=(const GNESumoConfigHandler&) = delete;
    };

    class GNENeteditConfigHandler {
 
    public:
        GNENeteditConfigHandler(const std::string& file);

        bool loadNeteditConfig();
 
    private:
        const std::string myFile;

        GNENeteditConfigHandler(const GNENeteditConfigHandler&) = delete;

        GNENeteditConfigHandler& operator=(const GNENeteditConfigHandler&) = 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;
};