main.h

/*
 * Copyright 2007-2025, RTE (https://www.rte-france.com)
 * See AUTHORS.txt
 * SPDX-License-Identifier: MPL-2.0
 * This file is part of Antares-Simulator,
 * Adequacy and Performance assessment for interconnected energy networks.
 *
 * Antares_Simulator is free software: you can redistribute it and/or modify
 * it under the terms of the Mozilla Public Licence 2.0 as published by
 * the Mozilla Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * Antares_Simulator is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * Mozilla Public Licence 2.0 for more details.
 *
 * You should have received a copy of the Mozilla Public Licence 2.0
 * along with Antares_Simulator. If not, see <https://opensource.org/license/mpl-2-0/>.
 */
#ifndef __ANTARES_APPLICATION_MAIN_MAIN_H__
#define __ANTARES_APPLICATION_MAIN_MAIN_H__
 
#include <list>
#include <ui/common/component/frame/local-frame.h>
#include <ui/common/wx-wrapper.h>
#include <wx/aui/aui.h>
 
#include <yuni/yuni.h>
 
#include <antares/study/output.h>
#include <antares/study/study.h>
#include "antares/config/config.h"
 
#include "../../toolbox/components/datagrid/selectionoperation.h"
#include "../../toolbox/components/map/settings.h"
#include "../../toolbox/components/notebook/notebook.h"
#include "fwd.h"
 
namespace Antares::Forms
{
// Internal data of the main form, to reduce dependencies and (re)compile time
// Forward declaration
class MainFormData;
 
class ApplWnd final: public Component::Frame::WxLocalFrame, public Yuni::IEventObserver<ApplWnd>
{
public:
    static ApplWnd* Instance();
 
public:
 
    ApplWnd();
    virtual ~ApplWnd();
 
 
 
    wxString openStudyFolder(bool autoLoad = true);
 
    void startAntares();
 
    wxMenuItem* menuRecentFiles() const;
 
    void requestUpdateGUIAfterStudyIO(const bool studyOpened);
 
    Component::MainPanel* mainPanel() const;
 
    void hideAllComponentsRelatedToTheStudy();
 
    Map::Component* map() const;
 
    Component::Datagrid::Selection::IOperator* gridOperatorSelectedCells() const;
 
    void gridOperatorSelectedCells(Component::Datagrid::Selection::IOperator* v);
 
    void gridOperatorSelectedCellsUpdateResult(wxGrid* grid);
 
    void disableGridOperatorIfGrid(wxGrid* grid);
 
 
    void title();
    void title(const wxString& s);
 
    bool wouldYouLikeToSaveTheStudy();
 
    void loadUserNotes();
    void saveUserNotes();
 
    void loadSets();
    void saveSets();
 
    void saveStudy();
    void saveStudyAs(const Yuni::String& path, bool copyoutput, bool copyuserdata, bool copylogs);
    void exportMap(const Yuni::String& path,
                   bool transparentBackground,
                   const wxColour& backgroundColor,
                   const std::list<uint16_t>& layers,
                   int nbSplitParts,
                   Antares::Map::mapImageFormat format);
 
    void selectSystem();
 
    void createAllComponentsNeededByTheMainNotebook();
 
    void showStudyLogs();
    void refreshStudyLogs();
 
    void evtOnViewOutput(wxCommandEvent& evt);
    void evtOnOpenOutputInExplorer(wxCommandEvent& evt);
 
 
    void beginUpdateLogs() const;
    void endUpdateLogs() const;
    void connectLogCallback();
 
    void selectAllDefaultPages();
 
    void refreshMenuInput();
    void refreshMenuOutput();
 
    void refreshMenuOptions(Data::Study::Ptr study);
 
    void forceFocus();
    void delayForceFocus();
 
    void resetDragAndDrop();
 
    void forceRefresh();
 
    wxAuiManager& AUIManager()
    {
        return pAUIManager;
    }
 
    const wxAuiManager& AUIManager() const
    {
        return pAUIManager;
    }
 
    void resetDefaultStatusBarText();
 
    void launchConstraintsBuilder(const Yuni::String& filename);
 
 
 
    bool isScenarioBuilderOpened() const;
 
    void backgroundTimerStop() const;
 
 
 
    uint mainNotebookCurrentEquipmentPage() const;
 
    void backToInputData();
 
 
 
    void copyToClipboard();
 
    void pasteFromClipboard(bool showDialog = false);
 
    void pasteFromClipboard(const Yuni::String& text, bool showDialog);
 
 
 
    void showWIP();
    void hideWIP();
    bool isInWIPMode() const;
 
 
    MainFormData* data();
    const MainFormData* data() const;
    void viewLatestOutput();
 
public:
    Yuni::Event<void()> onApplicationQuit;
 
private:
 
    void internalInitialize();
 
    void installUserLicense(bool online = false);
 
    void prepareStudyIconFile();
 
    wxMenuBar* createMenu();
    wxMenu* createPopupMenuOperatorsOnGrid();
 
    wxMenu* createMenuFiles();
    wxMenu* createMenuEdit();
    wxMenu* createMenuView();
    wxMenu* createMenuInput();
    wxMenu* createMenuOutput();
    wxMenu* createMenuSimulation();
    wxMenu* createMenuOptions();
    wxMenu* createMenuTools();
    wxMenu* createMenuWindow();
    wxMenu* createMenuHelp();
 
    void evtOnExecuteQueueEvent(wxCommandEvent&);
 
    void createNBSimulation();
    void createNBNotes();
    void createNBLoad();
    void createNBSolar();
    void createNBHydro();
    void createNBWind();
    void createNBThermal();
    void createNBRenewable();
    void createNBDSM();
    void createNBMisc();
    void createNBInterconnections();
    void createNBBindingConstraints();
    void createNBNodalOptimization();
    void createNBScenarioBuilder();
    void createNBOutputViewer();
    void createNBSets();
 
 
    void createLogs();
    void destroyLogsViewer();
    void destroyLogs();
 
 
    void evtOnContextMenuStatusBar(wxContextMenuEvent& evt);
    void evtOnContextMenuChangeOperator(wxCommandEvent& evt);
    void evtOnContextMenuMap(int x, int y);
 
 
    void evtOnWizard(wxCommandEvent& evt);
    void evtOnQuit(wxCommandEvent& evt);
    void evtOnNewStudy(wxCommandEvent& evt);
    void evtOnOpenStudy(wxCommandEvent& evt);
    void evtOnOpenRecentsToggleShowPaths(wxCommandEvent& evt);
    void evtOnOpenRecentsClearHistory(wxCommandEvent& evt);
    void evtOnDropDownRecents(wxAuiToolBarEvent& evt);
    void evtOnCloseStudy(wxCommandEvent& evt);
    void evtOnQuickOpenStudy(wxCommandEvent& evt);
    void evtOnSave(wxCommandEvent& evt);
    void evtOnSaveAs(wxCommandEvent& evt);
    void evtOnExportMap(wxCommandEvent& evt);
    void evtOnFullscreen(wxCommandEvent& evt);
    void evtOnInspector(wxCommandEvent& evt);
    void evtOnOpenStudyFolderInExplorer(wxCommandEvent& evt);
 
 
    void evtOnViewSystem(wxCommandEvent& evt);
    void evtOnViewAllSystem(wxCommandEvent& evt);
    void evtOnViewSimulation(wxCommandEvent& evt);
    void evtOnViewNotes(wxCommandEvent& evt);
    void evtOnViewLoad(wxCommandEvent& evt);
    void evtOnViewSolar(wxCommandEvent& evt);
    void evtOnViewWind(wxCommandEvent& evt);
    void evtOnViewRenewable(wxCommandEvent& evt);
    void evtOnViewHydro(wxCommandEvent& evt);
    void evtOnViewThermal(wxCommandEvent& evt);
    void evtOnViewReservesDSM(wxCommandEvent& evt);
    void evtOnViewMiscGen(wxCommandEvent& evt);
    void evtOnViewInterconnections(wxCommandEvent& evt);
    void evtOnViewBindingConstraints(wxCommandEvent& evt);
    void evtOnViewNodalOptimization(wxCommandEvent& evt);
 
 
    void evtOnSetStudyInfos(wxCommandEvent& evt);
    void evtOnStudySessions(wxCommandEvent& evt);
    void evtOnEditMapSelectAll(wxCommandEvent& evt);
    void evtOnEditMapUnselectAll(wxCommandEvent& evt);
    void evtOnEditMapReverseSelection(wxCommandEvent& evt);
    void evtOnEditCopy(wxCommandEvent& evt);
    void evtOnEditPaste(wxCommandEvent& evt);
    void evtOnEditPasteSpecial(wxCommandEvent& evt);
    void onMapDblClick(Map::Component& sender);
 
 
    void evtOnRunSimulation(wxCommandEvent& evt);
    void evtOnRunTSGenerators(wxCommandEvent& evt);
    void evtOnRunTSGeneratorsDelayed();
 
    void evtOnRunConstraintsBuilder(wxCommandEvent& evt);
    void evtOnRunConstraintsBuilderDelayed();
 
 
    void evtOnMemoryUsedByTheStudy(wxCommandEvent& evt);
 
 
    void evtOnOptionsTempFolder(wxCommandEvent& evt);
    void evtOnOptionsSelectOutput(wxCommandEvent& evt);
    void evtOnOptionsSelectAreasTrimming(wxCommandEvent& evt);
    void evtOnOptionsSelectLinksTrimming(wxCommandEvent& evt);
    void evtOnOptionsDistricts(wxCommandEvent& evt);
    void evtOnOptionsMCPlaylist(wxCommandEvent& evt);
    void evtOnOptionsMCScenarioBuilder(wxCommandEvent& evt);
    void evtOnOptionsOptimizationPrefs(wxCommandEvent& evt);
    void evtOnOptionsAdvanced(wxCommandEvent& evt);
    void evtOnOptionsAdequacyPatchOptions(wxCommandEvent& evt);
    void evtOnOptionsAdequacyPatchAreas(wxCommandEvent& evt);
 
 
    void evtOnStudyLogs(wxCommandEvent& evt);
    void evtOnRaiseWindow(wxCommandEvent& evt);
 
 
    // void evtOnHelpVisitRTEWebsite(wxCommandEvent& evt);
    void evtOnHelpAbout(wxCommandEvent& evt);
    void evtOnHelpPDFSystemMapEditorReferenceGuide(wxCommandEvent& evt);
    void evtOnHelpPDFExamplesLibrary(wxCommandEvent& evt);
    void evtOnHelpOnlineDocumentation(wxCommandEvent& evt);
 
 
 
    void evtOnMenuOpen(wxMenuEvent& evt);
    void evtOnMenuClose(wxMenuEvent& evt);
 
    void evtOnUpdateGUIAfterStudyIO(bool opened);
 
    void onMainNotebookPageChanging(Component::Notebook::Page& page);
    void onSectionNotebookPageChanging(Component::Notebook::Page& page);
    void onScenarioBuilderNotebookPageChanging(Component::Notebook::Page& page);
    void onOutputNotebookPageChanging(Component::Notebook::Page& page);
 
    void onSystemParametersChanged();
 
    // Renewable generation modelling changed, some pages have to be hidden or disabled
    void onRenewableGenerationModellingChanged(bool init);
    void refreshHomePageOnRenewableModellingChanged(bool aggregated, bool init);
    void refreshScenarioBuilderPagOnRenewableModellingChanged(bool aggregated);
    void refreshInputMenuOnRenewableModellingChanged(bool aggregated);
 
    void evtOnUpdateInterfaceAfterLoadedStudy(wxCommandEvent& evt);
 
    void evtOnFrameClose(wxCloseEvent& evt);
 
    void internalFrameClose();
 
    void evtLaunchConstraintsBuilder(wxCommandEvent& evt);
 
    void onMouseMoved(wxMouseEvent& evt);
 
    void onLogMessageDeferred(int level, const std::string& message);
    void onLogMessage(wxCommandEvent& evt);
 
    void onStudyLoaded();
 
    void purgeAllTemporaryObjects();
 
    virtual void updateOpenWindowsMenu();
    virtual bool excludeFromMenu();
 
private:
    using StudyPtr = Data::Study*;
 
private:
    wxPanel* pBigDaddy;
    wxAuiManager pAUIManager;
    wxSizer* pMainSizer;
    wxMenuBar* pMenu;
    wxMenu* pMenuFile;
    wxMenuItem* pMenuFileRecents;
    wxMenu* pMenuEdit;
    wxMenu* pMenuView;
    wxMenu* pMenuInput;
    wxMenuItem* pMenuInputCreation;
    wxMenuItem* pMenuInputLastSaved;
    wxMenu* pMenuOutput;
    wxMenu* pMenuSimulation;
    wxMenu* pMenuOptions;
    wxMenuItem* pMenuGeographicTrimming;
    wxMenuItem* pMenuAdequacyPatch;
    wxMenu* pMenuWindow;
    wxMenu* pMenuTools;
    wxMenu* pMenuHelp;
 
    wxMenu* pPopupMenuOperatorsGrid;
 
    Map::Component* pMainMap;
    Component::Notebook* pNotebook;
    Component::Notebook* pScenarioBuilderNotebook;
    Component::Notebook* pOutputViewerNotebook;
    Component::Notebook* pSectionNotebook;
 
    Component::MainPanel* pMainPanel;
 
    Component::Notebook::Page* pageLoadTimeSeries;
    Component::Notebook::Page* pageLoadPrepro;
    Component::Notebook::Page* pageLoadCorrelation;
 
    Component::Notebook::Page* pageSolarTimeSeries;
    Component::Notebook::Page* pageSolarPrepro;
    Component::Notebook::Page* pageSolarCorrelation;
 
    Component::Notebook::Page* pageHydroTimeSeries;
    Component::Notebook::Page* pageHydroPrepro;
    Component::Notebook::Page* pageHydroCorrelation;
    Component::Notebook::Page* pageHydroAllocation;
 
    Component::Notebook::Page* pageWindTimeSeries;
    Component::Notebook::Page* pageWindPrepro;
    Component::Notebook::Page* pageWindPreproDailyProfile;
    Component::Notebook::Page* pageWindCorrelation;
 
    Component::Notebook::Page* pageThermalClusterList;
    Component::Notebook::Page* pageThermalTimeSeries;
    Component::Notebook::Page* pageThermalTimeSeriesFuelCost;
    Component::Notebook::Page* pageThermalTimeSeriesCO2Cost;
    Component::Notebook::Page* pageThermalPrepro;
    Component::Notebook::Page* pageThermalCommon;
 
    Component::Notebook::Page* pageRenewableClusterList;
    Component::Notebook::Page* pageRenewableCommon;
 
    Component::Notebook::Page* pageLinksSummary = nullptr;
    Component::Notebook::Page* pageLinksParameters = nullptr;
    Component::Notebook::Page* pageLinksNTC = nullptr;
 
    Component::Notebook::Page* pageNodalOptim;
 
    Window::BindingConstraint* pWndBindingConstraints;
 
    // Secnario buider pages
    Component::Notebook::Page* pScenarioBuilderMainPage;
    Component::Notebook::Page* pageScBuilderLoad;
    Component::Notebook::Page* pageScBuilderThermal;
    Component::Notebook::Page* pageScBuilderHydro;
    Component::Notebook::Page* pageScBuilderWind;
    Component::Notebook::Page* pageScBuilderSolar;
    Component::Notebook::Page* pageScBuilderNTC;
    Component::Notebook::Page* pageScBuilderRenewable;
    Component::Notebook::Page* pageScBuilderHydroInitialLevels;
    Component::Notebook::Page* pageScBuilderHydroFinalLevels;
 
    Component::Datagrid::Selection::IOperator* pGridSelectionOperator;
    wxGrid* pGridSelectionAttachedGrid;
 
    wxMenu* pMapContextMenu;
 
    Window::Notes* pUserNotes;
 
    Window::Sets* pSets;
 
    bool pMainNotebookAlreadyHasItsComponents;
 
    wxTimer* pLogFlusherTimer;
 
    Window::StudyLogs* pWndLogs;
 
    bool pGuiReady;
 
    uint pUpdateCountLocker;
 
    MainFormData* pData;
 
    uint pCurrentEquipmentPage;
 
    // Pointer to latest output
    Data::Output::Ptr latestOutput = nullptr;
 
    // friends
    template<class WindowT>
    friend class Disabler;
    friend class MainFormData;
    friend class Window::StudyLogs;
 
    // Event table
    DECLARE_EVENT_TABLE()
 
}; // class ApplWnd
 
extern Yuni::String StudyToLoadAtStartup;
 
} // namespace Antares::Forms
 
#include "disabler.h"
#include "main.hxx"
 
#endif // __ANTARES_APPLICATION_MAIN_MAIN_H__