output.h

/*
** Copyright 2007-2024, 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_WINDOWS_OUTPUT_OUTPUT_H__
#define __ANTARES_WINDOWS_OUTPUT_OUTPUT_H__
 
#include <mutex>
#include <ui/common/component/panel.h>
#include "../../application/study.h"
#include "../../toolbox/components/button.h"
#include <wx/treectrl.h>
#include <wx/splitter.h>
#include <wx/sizer.h>
#include "layer.h"
#include "fwd.h"
#include <antares/study/fwd.h>
#include <wx/statbmp.h>
#include <wx/scrolwin.h>
#include "panel.h"
#include <ui/common/component/spotlight.h>
 
namespace Antares
{
namespace Window
{
namespace OutputViewer
{
class Component : public Antares::Component::Panel, public Yuni::IEventObserver<Component>
{
public:
    using Content = Antares::Private::OutputViewerData::Content;
 
public:
    static void ConvertVarNameToID(Yuni::String& id, const Yuni::String& name);
 
public:
 
 
    Component(wxWindow* parent, bool parentIsStandaloneWindow = false);
    virtual ~Component();
 
    void clear();
 
    void update(const Data::Output::List& list, const Data::Output::Ptr& selection);
 
    void updateLayerList();
 
    void copyFrom(const Component& source);
 
    void scrollAllPanels(wxScrolledWindow* component);
 
    void selectCellAllPanels(uint x, uint y);
 
    void refreshAllTabs();
    void refreshAllPanels();
    void refreshAllPanelsWithVirtualLayer();
 
    void refreshPanel(uint index);
 
private:
    class Tab
    {
    public:
        using Ptr = std::shared_ptr<Tab>;
        using Vector = std::vector<Ptr>;
 
    public:
 
 
        explicit Tab(Component& comparent);
        ~Tab();
 
        void updateAreaOrLinkName(SelectionType selection, const Yuni::String& text);
 
    public:
        Component& component;
        Antares::Component::Panel* support;
        Antares::Component::Button* btnOutput;
        Antares::Component::Button* btnCustomSelection;
        Antares::Component::Button* btnItem;
        wxSizer* btnSizer;
    };
 
private:
    void outputSelectionsClear();
 
    void createAllControlsIfNeeded();
    void onStudyClosed();
    void internalUpdate();
    void backToInputData(void*);
    void allYearsOrYearByYearSelector(Antares::Component::Button&, wxMenu& menu, void*);
    void dropDownAllVariables(Antares::Component::Button&, wxMenu&, void*);
    void incrementYearByYear(void*);
    void decrementYearByYear(void*);
    void goToASpecificYear(void*);
 
    void openNewWindow(void*);
    void updateFromExternalEvent(const Data::Output::List&, const Data::Output::Ptr selection);
 
    void onDropDownOutputs(Antares::Component::Button&, wxMenu& menu, void*);
    void onDropDownComparison(Antares::Component::Button&, wxMenu& menu, void*);
    void onDropDownDetachMenu(Antares::Component::Button&, wxMenu& menu, void*);
 
    void selectAnotherOutput(const Data::Output::Ptr& selectedOutput);
    void removeOutput(Layer* layer);
 
    void onDetachCurrentLayer(wxCommandEvent& evt);
 
    uint outputSelectionsAdd(Data::Output::Ptr output);
    void createNewVirtualLayer(LayerType type);
 
    void onSelectDataLevel(void*);
    void onSelectTimeLevel(void*);
 
    void onToggleSidebar(void*);
 
    const char* imageForLayerPlaceOrder(const Layer* so) const;
    const char* imageForLayerPlaceOrder(const Data::Output::Ptr& so) const;
    int imageIndexForOutput(const Data::Output::Ptr& output) const;
    void createSubMenuForSwitchingOrders(wxMenu* menu, const Layer* currentLayer) const;
    void rebuildIndexes();
 
    void refreshCurrentYear();
 
    void displayMiniFrame(wxWindow* parent,
                          Antares::Component::Spotlight::IProvider::Ptr provider,
                          int width = 340,
                          bool searchInput = true,
                          bool groups = true);
 
    void bugFixResetSashPosition();
 
    void mergeOutputs();
    void stopMerging();
 
    void treeDataClear();
    void treeDataWaiting();
    void treeDataUpdate();
    void treeDataUpdateWL(const Content& content);
    bool checkAreaIsCommonToAllOutputs(const Data::AreaName& name);
    bool checkLinkIsCommonToAllOutputs(const Data::AreaLinkName& name);
    void checkYearByYearMode();
    void noSimulationData();
    void updateAreaOrLinkName();
 
    void updateGlobalSelection();
 
    void updateButtonView();
 
    void emptyCache();
 
    void closeSubFrames();
 
private:
    using Button = Antares::Component::Button;
    using WxPanelVector = std::vector<wxPanel*>;
 
private:
    Data::Output::List pOutputs;
    Layer::Vector pSelections;
    Yuni::String pCurrentAreaOrLink;
    SelectionType pCurrentSelectionType;
    LevelOfDetails pCurrentLOD;
    uint pCurrentYear;
    uint pYearsLimits[2];
    bool pHasYearByYear;
    bool pHasConcatenedDataset;
    Yuni::String pCurrentVariable;
    Yuni::String pCurrentVariableID;
 
    Antares::Private::OutputViewerData::ThermalNameSetPerArea* pCurrentClusters;
 
    Tab::Vector pTabs;
    WxPanelVector pBtnPanelAllOutputs;
    wxSizer* pSizerForBtnOutputs;
    wxWindow* pWindowForBtnOutputs;
    Antares::Private::OutputViewerData::Panel::Vector pPanelAllOutputs;
    wxSizer* pSizerForPanelOutputs;
    wxWindow* pWindowForPanelOutputs;
    Yuni::Event<void(wxScrolledWindow*)> pOnScrollAllPanels;
    Yuni::Event<void(uint, uint)> pOnSelectCellAllPanels;
 
    Button* pBtnAllYears;
 
    wxSizer* pSizerYearsToolbar;
    wxSizer* pSizerYearByYearToolbar;
    wxSizer* pSizerVariables;
 
    wxSizer* pSizerToolbar;
 
    Layer* pCurrentLayerForMenu;
    wxWindow* pLblAreaOrLinkName;
 
    Antares::Component::Spotlight* pSpotlight;
 
    bool pControlsAlreadyCreated;
 
    wxSplitterWindow* pSplitter;
    wxWindow* pSplitterWindow1;
    wxWindow* pSplitterWindow2;
    bool pSidebarCollapsed;
    int pOldSidebarWidth;
    Button* pBtnExpandCollapseSidebar;
 
    wxWindow* pParentWindow;
 
    wxWindow* pLabelItemName;
    Button* pBtnValues;
    Button* pBtnDetails;
    Button* pBtnDetailsRes;
    Button* pBtnID;
 
    Button* pBtnHourly;
    Button* pBtnDaily;
    Button* pBtnWeekly;
    Button* pBtnMonthly;
    Button* pBtnAnnual;
 
    Button* pBtnCurrentYearNumber;
    Button* pBtnVariables;
 
 
    std::mutex pMutex;
    Antares::Private::OutputViewerData::JobVector pJobs;
    // The access to this variable must be protected with pMutex
    // This variable is used to build the list of areas / links once
    // prepared.
    Antares::Private::OutputViewerData::ContentMap pAlreadyPreparedContents;
    // The access to this variable must be protected with pMutex
    uint pJobsRemaining;
 
    bool pOpenedInANewWindow;
 
    bool pASelectionHasAlreadyBeenMade;
 
    // friends !
    friend class Antares::Private::OutputViewerData::Job;
    friend class Antares::Private::OutputViewerData::Panel;
    friend class Tab;
    friend class SpotlightProvider;
    friend class SpotlightProviderGlobalSelection;
    friend class SpotlightProviderMCAll;
    friend class Provider::Variables;
    friend class Provider::Outputs;
    friend class Provider::Comparison;
 
}; // class Component
 
} // namespace OutputViewer
} // namespace Window
} // namespace Antares
 
#endif // __ANTARES_WINDOWS_OUTPUT_OUTPUT_H__