job.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_TOOLBOX_JOB_H__
#define __ANTARES_TOOLBOX_JOB_H__
 
#include <antares/logs/logs.h>
#include <yuni/core/slist/slist.h>
#include <yuni/thread/thread.h>
#include <yuni/thread/timer.h>
 
#include <wx/dialog.h>
#include <wx/frame.h>
#include <wx/animate.h>
#include <wx/stattext.h>
#include <wx/timer.h>
#include <wx/stattext.h>
#include <wx/regex.h>
#include "../components/progressbar.h"
#include "../create.h"
#include <ui/common/component/panel.h>
 
#include <mutex>
#include <atomic>
#include <list>
 
namespace Antares
{
namespace Toolbox
{
namespace Jobs
{
// Forward declarations
class JobThread;
class TimerElapsedTime;
class TimerRemainingTime;
class PartList;
 
class Job : public wxDialog, public Yuni::IEventObserver<Job>
{
public:
 
 
    Job(const wxString& title, const wxString& subTitle, const char* icon);
    virtual ~Job();
 
 
    bool displayProgression() const
    {
        return pDisplayProgression;
    }
    void displayProgression(const bool v)
    {
        pDisplayProgression = v;
    }
 
 
    bool canCancel() const
    {
        return pCanCancel;
    }
    void canCancel(const bool v)
    {
        pCanCancel = v;
    }
 
 
    bool result() const
    {
        return pResult;
    }
    void result(const bool v)
    {
        pResult = v;
    }
 
 
 
    bool isRunning() const
    {
        return !(!pJobIsRunning);
    }
 
    bool run();
 
    void stop();
 
protected:
    virtual bool executeTask() = 0; // Please override
 
    void updateTheProgressValue(double progress);
 
    void updateTheMessage(const wxString& msg, bool mustBeInterpreted = true);
 
    virtual void onBeforeRunning()
    {
    }
 
    virtual bool onRunQuery()
    {
        return true;
    }
 
    virtual void onCancel()
    { /* do nothing */
    }
 
    void stopAllGuiComponents();
 
    void manageLogLevelMessage(enum LogLevel lvl, const wxString& msg);
 
protected:
    void onCancel(void*);
 
    void evtOnClose(wxCloseEvent& evt);
 
    void onLogMessage(int, const std::string& message);
 
protected:
    wxSizer* createMainPnl(wxWindow* parent);
 
    wxSizer* createPnlButtons(wxWindow* parent);
 
    wxSizer* createPnlLoading(wxWindow* parent);
 
    void displayGauge(const bool visible = true);
 
    void displayMessage(const wxString& line);
 
    void onUIUpdateProgression(uint value);
    void onUIUpdateMessage();
    void onUIUpdateLabelErrors();
 
    void onUIUpdateElapsedTime(const Yuni::String& text);
    void onUIUpdateRemainingTime(const Yuni::String& text);
 
    void evtOnInit(wxInitDialogEvent& event);
 
    void deleteAllThreads();
 
    void recomputeWindowSize();
 
    void disableAllComponents();
 
private:
    const wxString& pTitle;
    const wxString& pSubTitle;
    const char* pIcon;
    bool pDisplayProgression;
    bool pCanCancel;
    bool pResult;
    long pMemoryFootprint;
 
    wxSizer* pGaugeSizer;
    wxSizer* pGaugeParentSizer;
    wxSizer* pRemainingSizer;
    Component::ProgressBar* pGauge;
    wxSizer* pCancelSizer;
    wxStaticText* pProgrText;
    wxStaticText* pProgrSubText;
    wxStaticText* pElapsedTimeText;
    wxStaticText* pRemainingTimeText;
    wxStaticText* pReadWriteStats;
    Yuni::String::ListPtr pWarningList;
    Yuni::String::ListPtr pErrorList;
 
    std::atomic<int> pJobIsRunning;
    std::atomic<int> pGUICanUpdate;
 
    // Event table
    DECLARE_EVENT_TABLE()
 
private:
    TimerElapsedTime* pTimerElapsedTime;
    // (only if a progress is available)
    TimerRemainingTime* pTimerRemainingTime;
 
    mutable Yuni::Thread::IThread::Ptr pThread;
    wxAnimationCtrl* pAnim;
    wxStaticText* pLblErrors;
    wxString pLastNoticeMessage;
    wxButton* pBtnCancel;
 
    wxRegEx pLogRegex;
    wxString pLogEntryLevelTmp;
    wxString pLogEntryTmp;
 
    bool pCatchLogEvents;
 
    wxString pMessage;
    wxString pSubMessage;
 
    std::mutex pMutex;
    std::mutex pErrorMutex;
 
    PartList* pPartList;
 
    wxColour pDefaultBGColor;
    Component::Panel* pPanelButtons;
    Component::Panel* pPanelHeader;
 
    wxWindow* pWndCancelOperation;
 
    wxTimer* pTimerMessageUpdater;
    wxTimer* pTimerReadWriteStats;
 
    // Our friends !
    friend class JobThread;
    friend class TimerElapsedTime;
    friend class TimerRemainingTime;
 
}; // class Job
 
} // namespace Jobs
} // namespace Toolbox
} // namespace Antares
 
#endif // __ANTARES_TOOLBOX_JOB_H__