Slic3r::GUI::PluginProgressDialog Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PluginProgressDialog.hpp>

Inheritance diagram for Slic3r::GUI::PluginProgressDialog:

Collaboration diagram for Slic3r::GUI::PluginProgressDialog:

Public Types
using	CloseHandler = std::function<void()>
enum	State {   Uncancelable = -1 , Canceled , Continue , Finished ,   Dismissed }

Public Member Functions
	PluginProgressDialog (wxWindow *parent, const wxString &title, const wxString &message, int maximum, int style, CloseHandler on_destroyed=nullptr)
	~PluginProgressDialog () override
bool	pulse (const wxString &message=wxEmptyString)
bool	update (int value, const wxString &message=wxEmptyString)
void	start_pulse (int interval_ms, const wxString &message=wxEmptyString)
void	stop_pulse ()
void	close ()
bool	is_open () const
void	OnPaint (wxPaintEvent &evt)
virtual void	DoSetSize (int x, int y, int width, int height, int sizeFlags=wxSIZE_AUTO) override
bool	Create (const wxString &title, const wxString &message, int maximum=100, wxWindow *parent=NULL, int style=wxPD_APP_MODAL|wxPD_AUTO_HIDE)
virtual bool	Update (int value, const wxString &newmsg=wxEmptyString, bool *skip=NULL)
virtual void	Update () wxOVERRIDE
virtual bool	Pulse (const wxString &newmsg=wxEmptyString, bool *skip=NULL)
bool	WasCanceled () const
virtual void	Resume ()
virtual int	GetValue () const
virtual int	GetRange () const
virtual wxString	GetMessage () const
virtual void	SetRange (int maximum)
virtual bool	WasCancelled () const
virtual bool	WasSkipped () const
virtual void	OnCancel ()
virtual bool	Show (bool show=true) wxOVERRIDE

Static Public Member Functions
static PluginProgressDialog *	create_dialog (wxWindow *parent, const wxString &title, const wxString &message, int maximum, int style, CloseHandler on_destroyed)
static bool	pulse (PluginProgressDialog *dialog, const wxString &message=wxEmptyString)
static bool	update (PluginProgressDialog *dialog, int value, const wxString &message=wxEmptyString)
static void	start_pulse (PluginProgressDialog *dialog, int interval_ms, const wxString &message=wxEmptyString)
static void	stop_pulse (PluginProgressDialog *dialog)
static void	request_close (PluginProgressDialog *dialog)

Public Attributes
int	m_mode = 0
bool	m_adaptive = {false}
wxSizer *	m_sizer_main = {nullptr}
wxPanel *	m_top_line = {nullptr}
wxSimplebook *	m_simplebook = {nullptr}
wxPanel *	m_panel_2line = {nullptr}
wxPanel *	m_panel_1line = {nullptr}
Button *	m_button_cancel = {nullptr}
wxScrolledWindow *	m_msg_scrolledWindow = {nullptr}

Protected Member Functions
void	OnCancel (wxCommandEvent &)
void	SetMaximum (int maximum)
bool	HasPDFlag (int flag) const
int	GetPDStyle () const
void	SetPDStyle (int pdStyle)
void	set_panel_height (int height)
void	UpdateTimeEstimates (int value, unsigned long &elapsedTime, unsigned long &estimatedTime, unsigned long &remainingTime)
void	EnsureActiveEventLoopExists ()
void	OnSkip (wxCommandEvent &)
void	OnClose (wxCloseEvent &)
void	DisableOtherWindows ()
void	ReenableOtherWindows ()
void	SetTopParent (wxWindow *parent)
wxString	FormatString (wxString title)
wxWindow *	GetTopParent () const

Static Protected Member Functions
static wxString	GetElapsedLabel ()
static wxString	GetEstimatedLabel ()
static wxString	GetRemainingLabel ()
static wxString	GetFormattedTime (unsigned long timeInSec)

Protected Attributes
State	m_state
int	m_maximum
unsigned long	m_timeStart
unsigned long	m_timeStop
unsigned long	m_break

Private Member Functions
void	on_timer (wxTimerEvent &event)
void	Init ()
wxStaticText *	CreateLabel (const wxString &text, wxSizer *sizer)
void	UpdateMessage (const wxString &newmsg)
bool	DoBeforeUpdate (bool *skip)
void	DoAfterUpdate ()
void	EnableClose ()
void	EnableSkip (bool enable=true)
void	EnableAbort (bool enable=true)
void	DisableSkip ()
void	DisableAbort ()
	wxDECLARE_NO_COPY_CLASS (ProgressDialog)

Static Private Member Functions
static void	SetTimeLabel (unsigned long val, wxStaticText *label)

Private Attributes
bool	m_open {true}
wxString	m_pulse_message
std::unique_ptr< wxTimer >	m_timer
CloseHandler	m_on_destroyed
wxGauge *	m_gauge
wxStaticText *	m_msg
wxStaticText *	m_msg_2line
wxStaticText *	m_elapsed
wxStaticText *	m_estimated
wxStaticText *	m_remaining
wxWindowRef	m_parentTop
int	m_pdStyle
bool	m_skip
wxButton *	m_btnAbort
wxButton *	m_btnSkip
unsigned long	m_last_timeupdate
int	m_delay
int	m_ctdelay
unsigned long	m_display_estimated
wxWindowDisabler *	m_winDisabler
wxEventLoop *	m_tempEventLoop

Detailed Description

Member Typedef Documentation

CloseHandler

using Slic3r::GUI::PluginProgressDialog::CloseHandler = std::function<void()>

Member Enumeration Documentation

State

enum Slic3r::GUI::ProgressDialog::State

inherited

Enumerator
Uncancelable
Canceled
Continue
Finished
Dismissed

               {
        Uncancelable = -1, // dialog can't be canceled
        Canceled,          // can be cancelled and, in fact, was
        Continue,          // can be cancelled but wasn't
        Finished,          // finished, waiting to be removed from screen
        Dismissed          // was closed by user after finishing
    };

Constructor & Destructor Documentation

PluginProgressDialog()

Slic3r::GUI::PluginProgressDialog::PluginProgressDialog	(	wxWindow *	parent,
		const wxString &	title,
		const wxString &	message,
		int	maximum,
		int	style,
		CloseHandler	on_destroyed = nullptr )

    : ProgressDialog(title, message, maximum, parent, style)
    , m_pulse_message(message)
    , m_on_destroyed(std::move(on_destroyed))
{
    // The base ProgressDialog already binds wxEVT_CLOSE_WINDOW (its OnClose vetoes
    // a non-cancelable dialog and marks a cancelable one Canceled). We deliberately
    // don't add a second handler: a user-initiated close surfaces to the plugin as
    // update()/pulse() returning false, and programmatic close() calls Destroy()
    // directly, so no extra wiring is needed here.
}

References Slic3r::GUI::ProgressDialog::ProgressDialog(), m_on_destroyed, m_pulse_message, and style.

Referenced by create_dialog(), pulse(), request_close(), start_pulse(), stop_pulse(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

~PluginProgressDialog()

Slic3r::GUI::PluginProgressDialog::~PluginProgressDialog ( )

override

{
    stop_pulse();
 
    if (m_on_destroyed)
        m_on_destroyed();
}

References m_on_destroyed, and stop_pulse().

Here is the call graph for this function:

Member Function Documentation

close()

void Slic3r::GUI::PluginProgressDialog::close

(

)

{
    if (!m_open)
        return;
 
    m_open = false;
    stop_pulse();
    Destroy();
}

References m_open, and stop_pulse().

Referenced by request_close().

Here is the call graph for this function:

Here is the caller graph for this function:

Create()

bool Slic3r::GUI::ProgressDialog::Create ( const wxString & title, const wxString & message, int maximum = 100, wxWindow * parent = NULL, int style = wxPD_APP_MODAL | wxPD_AUTO_HIDE )

inherited

{
    SetFont(wxGetApp().normal_font());
    SetTopParent(parent);
 
    m_pdStyle = style;
 
    if (!wxDialog::Create(m_parentTop, wxID_ANY, title, wxDefaultPosition, wxDefaultSize, GetWindowStyle())) return false;
    SetBackgroundColour(PROGRESSDIALOG_DEF_BK);
 
    /* SetSize(DESIGN_RESOUTION_PROGRESS_SIZE);
     SetMinSize(DESIGN_RESOUTION_PROGRESS_SIZE);
     SetMaxSize(DESIGN_RESOUTION_PROGRESS_SIZE);*/
 
    SetMaximum(maximum);
    EnsureActiveEventLoopExists();
 
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
    if (!HasPDFlag(wxPD_CAN_ABORT)) { EnableCloseButton(false); }
#endif // wxMSW
 
    m_state = HasPDFlag(wxPD_CAN_ABORT) ? Continue : Uncancelable;
 
    wxBoxSizer *m_sizer_main = new wxBoxSizer(wxVERTICAL);
 
    m_top_line = new wxPanel(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, 0);
    m_top_line->SetBackgroundColour(wxColour(166, 169, 170));
 
    m_sizer_main->Add(m_top_line, 0, wxEXPAND, 0);
    m_sizer_main->Add(0, 0, 0, wxTOP, FromDIP(24));
 
    if (!m_adaptive) {
        m_simplebook = new wxSimplebook(this, wxID_ANY, wxDefaultPosition, PROGRESSDIALOG_SIMPLEBOOK_SIZE, 0);
 
        m_panel_1line = new wxPanel(m_simplebook, wxID_ANY, wxDefaultPosition, PROGRESSDIALOG_SIMPLEBOOK_SIZE, 0);
        m_panel_1line->SetMaxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE);
        m_panel_1line->SetBackgroundColour(PROGRESSDIALOG_DEF_BK);
        m_simplebook->AddPage(m_panel_1line, wxEmptyString, false);
 
        m_panel_2line = new wxPanel(m_simplebook, wxID_ANY, wxDefaultPosition, PROGRESSDIALOG_SIMPLEBOOK_SIZE, 0);
        m_panel_2line->SetMaxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE);
        m_panel_2line->SetBackgroundColour(PROGRESSDIALOG_DEF_BK);
        m_simplebook->AddPage(m_panel_2line, wxEmptyString, false);
 
        wxBoxSizer *sizer_1line = new wxBoxSizer(wxHORIZONTAL);
        m_msg                   = new wxStaticText(m_panel_1line, wxID_ANY, wxEmptyString, wxDefaultPosition, PROGRESSDIALOG_SIMPLEBOOK_SIZE, 0);
        m_msg->Wrap(-1);
        m_msg->SetFont(::Label::Body_14);
        m_msg->SetForegroundColour(PROGRESSDIALOG_GREY_700);
        sizer_1line->Add(m_msg, 0, wxALIGN_CENTER, 0);
        m_panel_1line->SetSizer(sizer_1line);
        m_panel_1line->Layout();
        sizer_1line->Fit(m_panel_1line);
 
        wxBoxSizer *sizer_2line = new wxBoxSizer(wxVERTICAL);
        m_msg_2line             = new wxStaticText(m_panel_2line, wxID_ANY, wxEmptyString, wxDefaultPosition, PROGRESSDIALOG_SIMPLEBOOK_SIZE, 0);
        m_msg_2line->Wrap(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x);
        m_msg_2line->SetFont(::Label::Body_14);
        m_msg_2line->SetForegroundColour(PROGRESSDIALOG_GREY_700);
        m_msg_2line->SetMaxSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, -1));
        sizer_2line->Add(m_msg_2line, 1, wxALL, 0);
        m_panel_2line->SetSizer(sizer_2line);
        m_panel_2line->Layout();
        sizer_2line->Fit(m_panel_2line);
 
        m_sizer_main->Add(m_simplebook, 1, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(28));
    } else {
        m_msg_scrolledWindow = new wxScrolledWindow( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxVSCROLL );
        m_msg_scrolledWindow->SetScrollRate(0, FromDIP(20));
        wxBoxSizer* m_msg_sizer= new wxBoxSizer(wxVERTICAL);
 
        m_msg = new wxStaticText(m_msg_scrolledWindow, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, -1), 0);
        m_msg->Wrap(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x);
        m_msg->SetFont(::Label::Body_14);
        m_msg->SetForegroundColour(PROGRESSDIALOG_GREY_700);
 
        m_msg_sizer->Add(m_msg, 0, wxEXPAND | wxALL, 0);
        m_msg_scrolledWindow->SetSizer(m_msg_sizer);
        m_msg_scrolledWindow->Layout();
        m_msg_sizer->Fit(m_msg_scrolledWindow);
        m_sizer_main->Add(m_msg_scrolledWindow, 0, wxEXPAND | wxALL, FromDIP(28));
    }
 
 
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, 0);
 
    int gauge_style = wxGA_HORIZONTAL;
    if (style & wxPD_SMOOTH) gauge_style |= wxGA_SMOOTH;
    gauge_style |= wxGA_PROGRESS;
 
#ifdef __WXMSW__
    maximum /= m_factor;
#endif
 
    if (!HasPDFlag(wxPD_NO_PROGRESS)) {
        m_gauge = new wxGauge(this, wxID_ANY, maximum, wxDefaultPosition, PROGRESSDIALOG_GAUGE_SIZE, gauge_style);
#ifdef __WXGTK__
        SetGaugeColor(m_gauge, 
            StateColor::darkModeColorFor(wxColour("#009688")).GetAsString(), 
            StateColor::darkModeColorFor(wxColour("#D9D9D9")).GetAsString()
        );
        m_gauge->SetValue(0);
#else
        m_gauge->Pulse(); // colors not applied without this. probably it switches to a dc painted version of progressbar
        m_gauge->SetValue(0);
        m_gauge->SetForegroundColour(wxColour("#009688"));
        m_gauge->SetBackgroundColour(wxColour("#D9D9D9"));
        wxGetApp().UpdateDarkUI(m_gauge);
#endif
        m_sizer_main->Add(m_gauge, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(28));
    }
 
    // Optional elapsed/estimated/remaining time labels, created only when the
    // caller opts in via the wxPD_*_TIME style flags (so callers that don't set
    // them are unaffected). Update()/Pulse() already refresh these once non-null.
    if (HasPDFlag(wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME | wxPD_REMAINING_TIME)) {
        wxFlexGridSizer *sizer_times = new wxFlexGridSizer(2, FromDIP(2), FromDIP(8));
        if (HasPDFlag(wxPD_ELAPSED_TIME))   m_elapsed   = CreateLabel(GetElapsedLabel(), sizer_times);
        if (HasPDFlag(wxPD_ESTIMATED_TIME)) m_estimated = CreateLabel(GetEstimatedLabel(), sizer_times);
        if (HasPDFlag(wxPD_REMAINING_TIME)) m_remaining = CreateLabel(GetRemainingLabel(), sizer_times);
        m_sizer_main->Add(sizer_times, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP | wxLEFT | wxRIGHT, FromDIP(12));
    }
 
#ifdef __WXMSW__
    //m_block_left = new wxWindow(m_gauge, wxID_ANY, wxPoint(0, 0), wxSize(FromDIP(2), PROGRESSDIALOG_GAUGE_SIZE.y * 2));
    //m_block_left->SetBackgroundColour(PROGRESSDIALOG_DEF_BK);
    //m_block_right = new wxWindow(m_gauge, wxID_ANY, wxPoint(PROGRESSDIALOG_GAUGE_SIZE.x - 2, 0), wxSize(FromDIP(2), PROGRESSDIALOG_GAUGE_SIZE.y * 2));
    //m_block_right->SetBackgroundColour(PROGRESSDIALOG_DEF_BK);
#endif
    wxBoxSizer *m_sizer_bottom = new wxBoxSizer(wxHORIZONTAL);
 
    m_sizer_bottom->Add(0, 0, 1, wxEXPAND, 0);
 
    if (HasPDFlag(wxPD_CAN_ABORT)) {
        m_button_cancel = new Button(this, _L("Cancel"));
        m_button_cancel->SetStyle(ButtonStyle::Regular, ButtonType::Choice);
        m_button_cancel->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent &event) {
            if (m_state == Finished) {
                event.Skip();
            } else {
                m_state = Canceled;
                DisableAbort();
                m_button_cancel->Enable(false);
                DisableSkip();
                OnCancel();
                m_timeStop = wxGetCurrentTime();
            }
        });
        m_sizer_bottom->Add(m_button_cancel, 0, wxALL, 0);
    }
 
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(16));
    m_sizer_main->Add(m_sizer_bottom, 0, wxEXPAND | wxLEFT | wxRIGHT, FromDIP(28));
    m_sizer_main->Add(0, 0, 0, wxEXPAND | wxTOP, FromDIP(10));
 
    wxGetApp().UpdateDlgDarkUI(this);
 
    SetSizer(m_sizer_main);
    Layout();
    Fit();
    Centre(wxCENTER_FRAME | wxBOTH);
    DisableOtherWindows();
    FormatString(message);
 
    Show();
    Enable();
    if (m_elapsed) { SetTimeLabel(0, m_elapsed); }
 
    Update();
    return true;
 
    //
    //    sizerTop = new wxBoxSizer(wxVERTICAL);
    //    auto def_size_width = wxMin(wxGetClientDisplayRect().width / 3, 305);
    //
    //    wxStaticLine *m_staticline2 = new wxStaticLine(this, wxID_ANY, wxDefaultPosition, wxSize(def_size_width, 1), wxLI_HORIZONTAL);
    //    sizerTop->Add(m_staticline2, 0, wxEXPAND, 0);
    //    auto m_block_top = new wxWindow(this, wxID_ANY, wxDefaultPosition, wxSize(def_size_width, 20));
    //    m_block_top->SetBackgroundColour(wxColor(DESIGN_RESOUTION_DEF_BK_COLOR));
    //    sizerTop->Add(m_block_top, 0, wxEXPAND);
    //
    //    m_message_area = new wxWindow(this, wxID_ANY, wxDefaultPosition, wxSize(def_size_width, 38));
    //    m_message_area->SetBackgroundColour(DESIGN_RESOUTION_DEF_BK_COLOR);
    //    sizerTop->Add(m_message_area, 0, wxLEFT | wxRIGHT | wxBottom | wxEXPAND, 2 * LAYOUT_MARGIN);
    //
    //    m_msg = new wxStaticText(m_message_area, wxID_ANY, wxString(""), wxPoint(0, 10), wxSize(def_size_width, 20), wxST_ELLIPSIZE_END);
    //    m_msg->SetForegroundColour(wxColour(107, 107, 107));
    //    m_msg->SetBackgroundColour(DESIGN_RESOUTION_DEF_BK_COLOR);
    //    m_msg->SetMinSize(wxSize(def_size_width, 20));
    //    m_msg->SetMaxSize(wxSize(def_size_width, 20));
    //
    //    m_msg_2line = new wxStaticText(m_message_area, wxID_ANY, wxString(""), wxPoint(0, 0), wxSize(def_size_width, 40), wxST_ELLIPSIZE_END);
    //    m_msg_2line->SetForegroundColour(wxColour(107, 107, 107));
    //    m_msg_2line->SetBackgroundColour(DESIGN_RESOUTION_DEF_BK_COLOR);
    //    m_msg_2line->SetMinSize(wxSize(def_size_width, 40));
    //    m_msg_2line->SetMaxSize(wxSize(def_size_width, 40));
    //
    //    auto block_left = new wxWindow(m_gauge, -1, wxPoint(0, 0), wxSize(2, m_gauge->GetSize().GetHeight()));
    //    block_left->SetBackgroundColour(wxColor(255, 255, 255));
    //
    //    auto block_right = new wxWindow(m_gauge, -1, wxPoint(m_gauge->GetSize().GetWidth() - 2, 0), wxSize(2, m_gauge->GetSize().GetHeight()));
    //    block_right->SetBackgroundColour(wxColor(255, 255, 255));
    //
    //    sizerTop->Add(m_gauge, 0, wxLEFT | wxRIGHT | wxBottom, 2 * LAYOUT_MARGIN);
    //    m_gauge->SetValue(0);
    //
    //    m_elapsed = m_estimated = m_remaining = NULL;
    //    size_t nTimeLabels                    = 0;
    //
    //    wxSizer *const sizerLabels = new wxFlexGridSizer(2);
    //
    //    if (style & wxPD_ELAPSED_TIME) {
    //        nTimeLabels++;
    //
    //        m_elapsed = CreateLabel(GetElapsedLabel(), sizerLabels);
    //    }
    //
    //    if (style & wxPD_ESTIMATED_TIME) {
    //        nTimeLabels++;
    //
    //        m_estimated = CreateLabel(GetEstimatedLabel(), sizerLabels);
    //    }
    //
    //    if (style & wxPD_REMAINING_TIME) {
    //        nTimeLabels++;
    //
    //        m_remaining = CreateLabel(GetRemainingLabel(), sizerLabels);
    //    }
    //    sizerTop->Add(sizerLabels, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP | wxBottom, LAYOUT_MARGIN);
    //
    //    wxStdDialogButtonSizer *buttonSizer = wxDialog::CreateStdDialogButtonSizer(0);
    //
    //    const int borderFlags = wxALL;
    //
    //    std::string icon_path = (boost::format("%1%/images/common_dialog_confirm.png") % resources_dir()).str();
    //    /*m_btnAbort            = new wxBitmapButton(this, wxID_ANY, wxNullBitmap, wxDefaultPosition, wxSize(52, 24), wxBU_AUTODRAW | wxBORDER_NONE);
    //    m_btnAbort->SetBitmap(wxBitmap(icon_path, wxBITMAP_TYPE_ANY));
    //    m_btnAbort->SetBitmapDisabled(wxBitmap(icon_path, wxBITMAP_TYPE_ANY));
    //    m_btnAbort->SetBitmapPressed(wxBitmap(icon_path, wxBITMAP_TYPE_ANY));
    //    m_btnAbort->SetBitmapFocus(wxBitmap(icon_path, wxBITMAP_TYPE_ANY));
    //    m_btnAbort->SetBitmapCurrent(wxBitmap(icon_path, wxBITMAP_TYPE_ANY));*/
    //
    //     m_btnAbort = new wxButton(this, wxID_CANCEL, wxString(""), wxDefaultPosition, wxSize(52,24));
    //
    //     wxStaticBitmap *m_bitmatAbort = new wxStaticBitmap(m_btnAbort, wxID_ANY, wxBitmap(icon_path, wxBITMAP_TYPE_ANY), wxDefaultPosition, wxSize(52, 24), 0);
    //     wxStaticText *textAbort = new wxStaticText(m_btnAbort, wxID_ANY, _T("Cancel"), wxPoint(5, 3), wxSize(42, 19));
    //     textAbort->SetBa
    //     ckgroundColour(wxColor(0, 150, 136));
    //     textAbort->SetForegroundColour(DESIGN_RESOUTION_DEF_BK_COLOR);
    //
    //     textAbort->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent &event) {
    //        if (m_state == Finished) {
    //            event.Skip();
    //        } else {
    //            m_state = Canceled;
    //            //DisableAbort();
    //            DisableSkip();
    //            m_timeStop = wxGetCurrentTime();
    //        }
    //    });
    //
    //     wxSizerFlags sizerFlags = wxSizerFlags().Border(borderFlags, LAYOUT_MARGIN);
    //    wxWindow *m_button_sizer = new wxWindow(this, wxID_ANY, wxDefaultPosition, wxSize(def_size_width, 26));
    //    m_button_sizer->SetBackgroundColour(DESIGN_RESOUTION_DEF_BK_COLOR);
    //
    //    if (HasPDFlag(wxPD_CAN_SKIP)) {
    //        m_btnSkip = new wxButton(this, wxID_SKIP, wxGetTranslation("&Skip"));
    //        m_btnSkip->Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ProgressDialog::OnSkip, this);
    //        buttonSizer->SetNegativeButton(m_btnSkip);
    //    }
    //
    //    if (HasPDFlag(wxPD_CAN_ABORT)) {
    //        /*m_btnAbort = new wxButton(this, wxID_CANCEL);
    //        buttonSizer->SetCancelButton(m_btnAbort);
    //        m_btnAbort->Bind(wxEVT_COMMAND_BUTTON_CLICKED, &ProgressDialog::OnCancel, this);*/
    //
    //        m_button_calcel = new Button(m_button_sizer, _T("Cancel"));
    //        m_button_calcel->SetTextColor(wxColour(107, 107, 107));
    //        m_button_calcel->SetSize(60, 24);
    //        m_button_calcel->SetPosition(wxPoint(m_button_sizer->GetSize().GetWidth() - m_button_calcel->GetSize().GetWidth(), 0));
    //
    //        m_button_calcel->Bind(wxEVT_LEFT_DOWN, [this](wxMouseEvent &event) {
    //            if (m_state == Finished) {
    //                event.Skip();
    //            } else {
    //                m_state = Canceled;
    //                 DisableAbort();
    //                m_button_calcel->Enable(false);
    //                DisableSkip();
    //                m_timeStop = wxGetCurrentTime();
    //            }
    //        });
    //    }
    //
    //    if (!HasPDFlag(wxPD_CAN_SKIP | wxPD_CAN_ABORT)) buttonSizer->AddSpacer(LAYOUT_MARGIN);
    //
    //    sizerTop->Add(m_button_sizer, 1, wxEXPAND, 0);
    //
    //    auto m_block_bottom = new wxWindow(this, wxID_ANY, wxDefaultPosition, wxSize(def_size_width, 15));
    //    m_block_bottom->SetBackgroundColour(DESIGN_RESOUTION_DEF_BK_COLOR);
    //    sizerTop->Add(m_block_bottom, 0, wxEXPAND);
    //
    //    SetSizerAndFit(sizerTop);
    //    FormatString(message);
    //
    //    Centre(wxCENTER_FRAME | wxBOTH);
    //
    //    DisableOtherWindows();
    //
    //    Show();
    //    Enable();
    //    if (m_elapsed) { SetTimeLabel(0, m_elapsed); }
    //
    //    Update();
    //    return true;
}

References _L, Label::Body_14, Canceled, Choice, Continue, CreateLabel(), StateColor::darkModeColorFor(), DisableAbort(), DisableOtherWindows(), DisableSkip(), Slic3r::Enable, EnsureActiveEventLoopExists(), Finished, FormatString(), GetElapsedLabel(), GetEstimatedLabel(), GetRemainingLabel(), HasPDFlag(), m_adaptive, m_button_cancel, m_elapsed, m_estimated, m_gauge, m_msg, m_msg_2line, m_msg_scrolledWindow, m_panel_1line, m_panel_2line, m_parentTop, m_pdStyle, m_remaining, m_simplebook, m_sizer_main, m_state, m_timeStop, m_top_line, OnCancel(), PROGRESSDIALOG_DEF_BK, PROGRESSDIALOG_GAUGE_SIZE, PROGRESSDIALOG_GREY_700, PROGRESSDIALOG_SIMPLEBOOK_SIZE, Regular, SetMaximum(), SetTimeLabel(), SetTopParent(), Show(), style, Uncancelable, Update(), wxGauge, Slic3r::GUI::wxMouseEvent, wxPD_NO_PROGRESS, and wxStaticText.

Referenced by ProgressDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

create_dialog()

PluginProgressDialog * Slic3r::GUI::PluginProgressDialog::create_dialog ( wxWindow * parent, const wxString & title, const wxString & message, int maximum, int style, CloseHandler on_destroyed )

static

{
    return new PluginProgressDialog(parent, title, message, maximum, style, std::move(on_destroyed));
}

References PluginProgressDialog(), and style.

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::ui_create_progress_dialog().

Here is the call graph for this function:

Here is the caller graph for this function:

CreateLabel()

wxStaticText * Slic3r::GUI::ProgressDialog::CreateLabel ( const wxString & text, wxSizer * sizer )

privateinherited

{
    wxStaticText *label = new wxStaticText(this, wxID_ANY, text);
    wxStaticText *value = new wxStaticText(this, wxID_ANY, _L("unknown"));
 
    // Match the message label's look so the times theme with the rest of the
    // dialog: PROGRESSDIALOG_GREY_700 is a key in the dark-mode colour map, so
    // UpdateDlgDarkUI() (called at the end of Create()) remaps it in dark mode.
    for (wxStaticText *st : {label, value}) {
        st->SetFont(::Label::Body_13);
        st->SetForegroundColour(PROGRESSDIALOG_GREY_700);
    }
 
    // select placement most native or nice on target GUI
#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXGTK20__)
    // value and time centered in one row
    sizer->Add(label, 1, wxALIGN_RIGHT | wxTOP | wxRIGHT, LAYOUT_MARGIN);
    sizer->Add(value, 1, wxALIGN_LEFT | wxTOP, LAYOUT_MARGIN);
#else
    // value and time to the right in one row
    sizer->Add(label);
    sizer->Add(value, 0, wxLEFT, LAYOUT_MARGIN);
#endif
 
    return value;
}

References _L, Label::Body_13, LAYOUT_MARGIN, PROGRESSDIALOG_GREY_700, and wxStaticText.

Referenced by Create().

Here is the caller graph for this function:

DisableAbort()

void Slic3r::GUI::ProgressDialog::DisableAbort ( )

inlineprivateinherited

{ EnableAbort(false); }

References EnableAbort().

Referenced by Create(), OnCancel(), and OnClose().

Here is the call graph for this function:

Here is the caller graph for this function:

DisableOtherWindows()

void Slic3r::GUI::ProgressDialog::DisableOtherWindows ( )

protectedinherited

{
    if (HasPDFlag(wxPD_APP_MODAL)) {
#if defined(__WXOSX__)
        if (m_parentTop) m_parentTop->Disable();
        m_winDisabler = NULL;
#else
        m_winDisabler = new wxWindowDisabler(this);
#endif
    } else {
        if (m_parentTop) m_parentTop->Disable();
        m_winDisabler = NULL;
    }
 
}

References HasPDFlag(), m_parentTop, m_winDisabler, and wxWindowDisabler.

Referenced by Create().

Here is the call graph for this function:

Here is the caller graph for this function:

DisableSkip()

void Slic3r::GUI::ProgressDialog::DisableSkip ( )

inlineprivateinherited

{ EnableSkip(false); }

References EnableSkip().

Referenced by Create(), OnCancel(), OnClose(), OnSkip(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

DoAfterUpdate()

void Slic3r::GUI::ProgressDialog::DoAfterUpdate ( )

privateinherited

{
    // allow the window to repaint:
    // NOTE: since we yield only for UI events with this call, there
    //       should be no side-effects
    wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI | wxEVT_CATEGORY_USER_INPUT);
}

Referenced by Pulse(), and Update().

Here is the caller graph for this function:

DoBeforeUpdate()

bool Slic3r::GUI::ProgressDialog::DoBeforeUpdate ( bool * skip )

privateinherited

{
    // we have to yield because not only we want to update the display but
    // also to process the clicks on the cancel and skip buttons
    // NOTE: using YieldFor() this call shouldn't give re-entrancy problems
    //       for event handlers not interested to UI/user-input events.
    wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI | wxEVT_CATEGORY_USER_INPUT);
 
    Update();
 
    if (m_skip && skip && !*skip) {
        *skip  = true;
        m_skip = false;
        EnableSkip();
    }
 
    return m_state != Canceled;
}

References Canceled, EnableSkip(), m_skip, m_state, and Update().

Referenced by Pulse(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

DoSetSize()

void Slic3r::GUI::ProgressDialog::DoSetSize ( int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO )

overridevirtualinherited

{
    //if (m_button_cancel != nullptr) { m_button_cancel->SetMinSize(PROGRESSDIALOG_CANCEL_BUTTON_SIZE); }
 
#ifdef __WXMSW__
    //if (m_block_left != nullptr && m_block_right != nullptr) {
    //    m_block_left->SetPosition(wxPoint(0, 0));
    //    m_block_right->SetPosition(wxPoint(PROGRESSDIALOG_GAUGE_SIZE.x - 2, 0));
    //}
#endif
    wxDialog::DoSetSize(x, y, width, height, sizeFlags);
}

EnableAbort()

void Slic3r::GUI::ProgressDialog::EnableAbort ( bool enable = true )

privateinherited

{
    if (HasPDFlag(wxPD_CAN_ABORT)) {
        if (m_btnAbort) m_btnAbort->Enable(enable);
    }
}

References HasPDFlag(), and m_btnAbort.

Referenced by DisableAbort(), and Resume().

Here is the call graph for this function:

Here is the caller graph for this function:

EnableClose()

void Slic3r::GUI::ProgressDialog::EnableClose ( )

privateinherited

{
    if (HasPDFlag(wxPD_CAN_ABORT)) {
        if (m_btnAbort) {
            m_btnAbort->Enable();
            m_btnAbort->SetLabel(wxGetTranslation("Close"));
        }
    }
}

References HasPDFlag(), and m_btnAbort.

Referenced by Update().

Here is the call graph for this function:

Here is the caller graph for this function:

EnableSkip()

void Slic3r::GUI::ProgressDialog::EnableSkip ( bool enable = true )

privateinherited

{
    if (HasPDFlag(wxPD_CAN_SKIP)) {
        if (m_btnSkip) m_btnSkip->Enable(enable);
    }
}

References HasPDFlag(), and m_btnSkip.

Referenced by DisableSkip(), DoBeforeUpdate(), and Resume().

Here is the call graph for this function:

Here is the caller graph for this function:

EnsureActiveEventLoopExists()

void Slic3r::GUI::ProgressDialog::EnsureActiveEventLoopExists ( )

protectedinherited

{
    if (!wxEventLoopBase::GetActive()) {
        m_tempEventLoop = new wxEventLoop;
        wxEventLoop::SetActive(m_tempEventLoop);
    }
}

References m_tempEventLoop, and wxEventLoop.

Referenced by Create().

Here is the caller graph for this function:

FormatString()

wxString Slic3r::GUI::ProgressDialog::FormatString ( wxString title )

protectedinherited

{
    if (!m_adaptive) {
        auto current_width = 0;
        m_mode             = 0;
        for (int i = 0; i < title.length(); i++) {
            current_width = m_msg->GetTextExtent(title.SubString(0, i)).x;
            if (current_width > PROGRESSDIALOG_GAUGE_SIZE.x) {
                m_mode = 1;
                // title.insert(i - 1, "\n");
                break;
            }
        }
        // set mode
        if (m_mode == 0) {
            m_simplebook->SetSelection(0);
            m_msg->SetLabel(title);
        } else {
            wxSize content_size = m_msg->GetTextExtent(title);
            int resized_height = (int(content_size.x / PROGRESSDIALOG_GAUGE_SIZE.x) + 1) * content_size.y;
            set_panel_height(resized_height);
            m_simplebook->SetSelection(1);
            m_msg_2line->SetLabel(title);
        }
    } else {
        m_msg->SetLabel(title);
        m_msg->SetMaxSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x + 5, -1));
        m_msg->SetMinSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x  + 5, -1));
        m_msg->Wrap(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x  + 5);
        m_msg->Layout();
        m_msg->Fit();
 
        m_msg_scrolledWindow->SetSize(wxSize(FromDIP(m_msg->GetSize().x + 5), FromDIP(150)));
        m_msg_scrolledWindow->SetMinSize(wxSize(FromDIP(m_msg->GetSize().x + 5), FromDIP(150)));
        m_msg_scrolledWindow->SetMaxSize(wxSize(FromDIP(m_msg->GetSize().x + 5), FromDIP(150)));
       // m_msg_scrolledWindow->Layout();
        m_msg_scrolledWindow->Fit();
    }
 
    
    //Fit();
    return title;
}

References m_adaptive, m_mode, m_msg, m_msg_2line, m_msg_scrolledWindow, m_simplebook, PROGRESSDIALOG_GAUGE_SIZE, PROGRESSDIALOG_SIMPLEBOOK_SIZE, and set_panel_height().

Referenced by Create(), and UpdateMessage().

Here is the call graph for this function:

Here is the caller graph for this function:

GetElapsedLabel()

wxString Slic3r::GUI::ProgressDialog::GetElapsedLabel ( )

inlinestaticprotectedinherited

{ return _L("Elapsed time:"); }

References _L.

Referenced by Create().

Here is the caller graph for this function:

GetEstimatedLabel()

wxString Slic3r::GUI::ProgressDialog::GetEstimatedLabel ( )

inlinestaticprotectedinherited

{ return _L("Estimated time:"); }

References _L.

Referenced by Create().

Here is the caller graph for this function:

GetFormattedTime()

wxString Slic3r::GUI::ProgressDialog::GetFormattedTime ( unsigned long timeInSec )

staticprotectedinherited

{
    wxString timeAsHMS;
 
    if (timeInSec == (unsigned long) -1) {
        timeAsHMS = wxGetTranslation("Unknown");
    } else {
        unsigned hours   = timeInSec / 3600;
        unsigned minutes = (timeInSec % 3600) / 60;
        unsigned seconds = timeInSec % 60;
        timeAsHMS.Printf("%u:%02u:%02u", hours, minutes, seconds);
    }
 
    return timeAsHMS;
}

Referenced by SetTimeLabel().

Here is the caller graph for this function:

GetMessage()

wxString Slic3r::GUI::ProgressDialog::GetMessage ( ) const

virtualinherited

{ return m_msg->GetLabel(); }

References m_msg.

GetPDStyle()

int Slic3r::GUI::ProgressDialog::GetPDStyle ( ) const

inlineprotectedinherited

{ return m_pdStyle; }

References m_pdStyle.

GetRange()

int Slic3r::GUI::ProgressDialog::GetRange ( ) const

virtualinherited

{ return m_maximum; }

References m_maximum.

GetRemainingLabel()

wxString Slic3r::GUI::ProgressDialog::GetRemainingLabel ( )

inlinestaticprotectedinherited

{ return _L("Remaining time:"); }

References _L.

Referenced by Create().

Here is the caller graph for this function:

GetTopParent()

wxWindow * Slic3r::GUI::ProgressDialog::GetTopParent ( ) const

inlineprotectedinherited

{ return m_parentTop; }

References m_parentTop.

GetValue()

int Slic3r::GUI::ProgressDialog::GetValue ( ) const

virtualinherited

{
    wxCHECK_MSG(m_gauge, -1, "dialog should be fully created");
 
    return m_gauge->GetValue();
}

References m_gauge.

HasPDFlag()

bool Slic3r::GUI::ProgressDialog::HasPDFlag ( int flag ) const

inlineprotectedinherited

{ return (m_pdStyle & flag) != 0; }

References m_pdStyle.

Referenced by Create(), DisableOtherWindows(), EnableAbort(), EnableClose(), EnableSkip(), ReenableOtherWindows(), Update(), WasCancelled(), and WasSkipped().

Here is the caller graph for this function:

Init()

void Slic3r::GUI::ProgressDialog::Init ( )

privateinherited

{
    // we may disappear at any moment, let the others know about it
    SetExtraStyle(GetExtraStyle() | wxWS_EX_TRANSIENT);
 
    // Initialize all our members that we always use (even when we don't
    // create a valid window in this class).
 
    m_pdStyle   = 0;
    m_parentTop = NULL;
 
    m_gauge   = NULL;
    m_msg     = NULL;
    m_elapsed = m_estimated = m_remaining = NULL;
 
    m_state   = Uncancelable;
    m_maximum = 0;
 
    m_timeStart = wxGetCurrentTime();
    m_timeStop  = (unsigned long) -1;
    m_break     = 0;
 
    m_skip = false;
 
    m_btnAbort = NULL;
    m_btnSkip  = NULL;
 
    m_display_estimated = m_last_timeupdate = m_ctdelay = 0;
 
    m_delay = 3;
 
    m_winDisabler   = NULL;
    m_tempEventLoop = NULL;
 
    SetWindowStyle(wxDEFAULT_DIALOG_STYLE);
}

References m_break, m_btnAbort, m_btnSkip, m_ctdelay, m_delay, m_display_estimated, m_elapsed, m_estimated, m_gauge, m_last_timeupdate, m_maximum, m_msg, m_parentTop, m_pdStyle, m_remaining, m_skip, m_state, m_tempEventLoop, m_timeStart, m_timeStop, m_winDisabler, and Uncancelable.

Referenced by ProgressDialog(), and ProgressDialog().

Here is the caller graph for this function:

is_open()

bool Slic3r::GUI::PluginProgressDialog::is_open ( ) const

inline

{ return m_open; }

References m_open.

on_timer()

void Slic3r::GUI::PluginProgressDialog::on_timer ( wxTimerEvent & event )

private

{
    if (m_open)
        Pulse(m_pulse_message);
}

References m_open, m_pulse_message, and Slic3r::GUI::ProgressDialog::Pulse().

Referenced by start_pulse(), and stop_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

OnCancel() [1/2]

virtual void Slic3r::GUI::ProgressDialog::OnCancel ( )

inlinevirtualinherited

Reimplemented in Slic3r::GUI::MediaProgressDialog.

{};

Referenced by Create(), OnCancel(), and OnClose().

Here is the caller graph for this function:

OnCancel() [2/2]

void Slic3r::GUI::ProgressDialog::OnCancel ( wxCommandEvent & event )

protectedinherited

{
    if (m_state == Finished) {
        // this means that the count down is already finished and we're being
        // shown as a modal dialog - so just let the default handler do the job
        event.Skip();
    } else {
        // request to cancel was received, the next time Update() is called we
        // will handle it
        m_state = Canceled;
 
        // update the buttons state immediately so that the user knows that the
        // request has been noticed
        DisableAbort();
        DisableSkip();
 
        OnCancel();
 
        // save the time when the dialog was stopped
        m_timeStop = wxGetCurrentTime();
    }
}

References Canceled, DisableAbort(), DisableSkip(), Finished, m_state, m_timeStop, and OnCancel().

Here is the call graph for this function:

OnClose()

void Slic3r::GUI::ProgressDialog::OnClose ( wxCloseEvent & event )

protectedinherited

{
    if (m_state == Uncancelable) {
        // can't close this dialog
        event.Veto();
    } else if (m_state == Finished) {
        // let the default handler close the window as we already terminated
        event.Skip();
    } else {
        // next Update() will notice it
        m_state = Canceled;
        DisableAbort();
        DisableSkip();
        OnCancel();
 
        m_timeStop = wxGetCurrentTime();
    }
}

References Canceled, DisableAbort(), DisableSkip(), Finished, m_state, m_timeStop, OnCancel(), and Uncancelable.

Referenced by ProgressDialog().

Here is the call graph for this function:

Here is the caller graph for this function:

OnPaint()

void Slic3r::GUI::ProgressDialog::OnPaint ( wxPaintEvent & evt )

inherited

{}

Referenced by ProgressDialog().

Here is the caller graph for this function:

OnSkip()

void Slic3r::GUI::ProgressDialog::OnSkip ( wxCommandEvent & )

protectedinherited

{
    DisableSkip();
    m_skip = true;
}

References DisableSkip(), and m_skip.

Here is the call graph for this function:

Pulse()

bool Slic3r::GUI::ProgressDialog::Pulse ( const wxString & newmsg = wxEmptyString, bool * skip = NULL )

virtualinherited

{
    if (!DoBeforeUpdate(skip)) return false;
 
    wxCHECK_MSG(m_msg || m_gauge, false, "dialog should be fully created");
 
    // show a bit of progress
    if (m_gauge) m_gauge->Pulse();
 
    UpdateMessage(newmsg);
 
    if (m_elapsed || m_remaining || m_estimated) {
        unsigned long elapsed = wxGetCurrentTime() - m_timeStart;
 
        SetTimeLabel(elapsed, m_elapsed);
        SetTimeLabel((unsigned long) -1, m_estimated);
        SetTimeLabel((unsigned long) -1, m_remaining);
    }
 
    DoAfterUpdate();
 
    return m_state != Canceled;
}

References Canceled, DoAfterUpdate(), DoBeforeUpdate(), m_elapsed, m_estimated, m_gauge, m_msg, m_remaining, m_state, m_timeStart, SetTimeLabel(), and UpdateMessage().

Referenced by Slic3r::GUI::PluginProgressDialog::on_timer(), Slic3r::GUI::PluginProgressDialog::pulse(), and Slic3r::GUI::GUI_App::recreate_GUI().

Here is the call graph for this function:

Here is the caller graph for this function:

pulse() [1/2]

bool Slic3r::GUI::PluginProgressDialog::pulse

(

const wxString &

message = wxEmptyString

)

{
    if (!m_open)
        return false;
 
    if (!message.empty())
        m_pulse_message = message;
 
    return Pulse(message);
}

References m_open, m_pulse_message, and Slic3r::GUI::ProgressDialog::Pulse().

Here is the call graph for this function:

pulse() [2/2]

bool Slic3r::GUI::PluginProgressDialog::pulse ( PluginProgressDialog * dialog, const wxString & message = wxEmptyString )

static

{
    return dialog != nullptr ? dialog->pulse(message) : false;
}

References PluginProgressDialog(), and pulse().

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_pulse(), and pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

ReenableOtherWindows()

void Slic3r::GUI::ProgressDialog::ReenableOtherWindows ( )

protectedinherited

{
    if (HasPDFlag(wxPD_APP_MODAL)) {
#if defined(__WXOSX__)
        if (m_parentTop) m_parentTop->Enable();
#else
        wxDELETE(m_winDisabler);
#endif
    } else {
        if (m_parentTop) m_parentTop->Enable();
    }
}

References HasPDFlag(), m_parentTop, and m_winDisabler.

Referenced by ~ProgressDialog(), Show(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

request_close()

void Slic3r::GUI::PluginProgressDialog::request_close ( PluginProgressDialog * dialog )

static

{
    if (dialog != nullptr)
        dialog->close();
}

References PluginProgressDialog(), and close().

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_close().

Here is the call graph for this function:

Here is the caller graph for this function:

Resume()

void Slic3r::GUI::ProgressDialog::Resume ( )

virtualinherited

{
    m_state   = Continue;
    m_ctdelay = m_delay; // force an update of the elapsed/estimated/remaining time
    m_break += wxGetCurrentTime() - m_timeStop;
 
    EnableAbort();
    m_button_cancel->Enable(true);
    EnableSkip();
    m_skip = false;
}

References Continue, EnableAbort(), EnableSkip(), m_break, m_button_cancel, m_ctdelay, m_delay, m_skip, m_state, and m_timeStop.

Here is the call graph for this function:

set_panel_height()

void Slic3r::GUI::ProgressDialog::set_panel_height ( int height )

protectedinherited

                                                {
    m_simplebook->SetSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, height));
    m_simplebook->SetMinSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, height));
    m_panel_2line->SetSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, height));
    m_panel_2line->SetMinSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, height));
    m_msg_2line->SetSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, height));
    m_msg_2line->SetMinSize(wxSize(PROGRESSDIALOG_SIMPLEBOOK_SIZE.x, height));
}

References m_msg_2line, m_panel_2line, m_simplebook, and PROGRESSDIALOG_SIMPLEBOOK_SIZE.

Referenced by FormatString().

Here is the caller graph for this function:

SetMaximum()

void Slic3r::GUI::ProgressDialog::SetMaximum ( int maximum )

protectedinherited

{
    m_maximum = maximum;
 
#if defined(__WXMSW__)
    // we can't have values > 65,536 in the progress control under Windows, so
    // scale everything down
    m_factor = m_maximum / 65536 + 1;
    m_maximum /= m_factor;
#endif // __WXMSW__
}

References m_maximum.

Referenced by Create(), and SetRange().

Here is the caller graph for this function:

SetPDStyle()

void Slic3r::GUI::ProgressDialog::SetPDStyle ( int pdStyle )

inlineprotectedinherited

{ m_pdStyle = pdStyle; }

References m_pdStyle.

SetRange()

void Slic3r::GUI::ProgressDialog::SetRange ( int maximum )

virtualinherited

{
    wxCHECK_RET(m_gauge, "dialog should be fully created");
 
    wxCHECK_RET(maximum > 0, "Invalid range");
 
    m_gauge->SetRange(maximum);
 
    SetMaximum(maximum);
}

References m_gauge, and SetMaximum().

Here is the call graph for this function:

SetTimeLabel()

void Slic3r::GUI::ProgressDialog::SetTimeLabel ( unsigned long val, wxStaticText * label )

staticprivateinherited

{
    if (label) {
        wxString s;
 
        if (val != (unsigned long) -1) {
            s = GetFormattedTime(val);
        } else {
            s = wxGetTranslation("Unknown");
        }
 
        if (s != label->GetLabel()) label->SetLabel(s);
    }
}

References GetFormattedTime(), and wxStaticText.

Referenced by Create(), Pulse(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

SetTopParent()

void Slic3r::GUI::ProgressDialog::SetTopParent ( wxWindow * parent )

protectedinherited

{
    m_parent    = parent;
    m_parentTop = parent;
}

References m_parentTop.

Referenced by Create().

Here is the caller graph for this function:

Show()

bool Slic3r::GUI::ProgressDialog::Show ( bool show = true )

virtualinherited

{
    // reenable other windows before hiding this one because otherwise
    // Windows wouldn't give the focus back to the window which had
    // been previously focused because it would still be disabled
    if (!show) ReenableOtherWindows();
    return wxDialog::Show(show);
}

References ReenableOtherWindows().

Referenced by Create().

Here is the call graph for this function:

Here is the caller graph for this function:

start_pulse() [1/2]

void Slic3r::GUI::PluginProgressDialog::start_pulse	(	int	interval_ms,
		const wxString &	message = wxEmptyString )

{
    if (!m_open)
        return;
 
    if (!message.empty())
        m_pulse_message = message;
 
    stop_pulse();
 
    m_timer = std::make_unique<wxTimer>(this);
    Bind(wxEVT_TIMER, &PluginProgressDialog::on_timer, this, m_timer->GetId());
    m_timer->Start(interval_ms > 0 ? interval_ms : 1);
}

References m_open, m_pulse_message, m_timer, on_timer(), and stop_pulse().

Here is the call graph for this function:

start_pulse() [2/2]

void Slic3r::GUI::PluginProgressDialog::start_pulse ( PluginProgressDialog * dialog, int interval_ms, const wxString & message = wxEmptyString )

static

{
    if (dialog != nullptr)
        dialog->start_pulse(interval_ms, message);
}

References PluginProgressDialog(), and start_pulse().

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_start_pulse(), and start_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_pulse() [1/2]

void Slic3r::GUI::PluginProgressDialog::stop_pulse

(

)

{
    if (!m_timer)
        return;
 
    Unbind(wxEVT_TIMER, &PluginProgressDialog::on_timer, this, m_timer->GetId());
    m_timer->Stop();
    m_timer.reset();
}

References m_timer, and on_timer().

Referenced by ~PluginProgressDialog(), close(), Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_stop_pulse(), and start_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_pulse() [2/2]

void Slic3r::GUI::PluginProgressDialog::stop_pulse ( PluginProgressDialog * dialog )

static

{
    if (dialog != nullptr)
        dialog->stop_pulse();
}

References PluginProgressDialog(), and stop_pulse().

Referenced by stop_pulse().

Here is the call graph for this function:

Here is the caller graph for this function:

Update() [1/2]

virtual void Slic3r::GUI::ProgressDialog::Update ( )

inlinevirtualinherited

{ wxDialog::Update(); }

Referenced by Create(), DoBeforeUpdate(), Update(), and Slic3r::GUI::PluginProgressDialog::update().

Here is the caller graph for this function:

Update() [2/2]

bool Slic3r::GUI::ProgressDialog::Update ( int value, const wxString & newmsg = wxEmptyString, bool * skip = NULL )

virtualinherited

{
    if (!DoBeforeUpdate(skip)) return false;
 
    wxCHECK_MSG(m_msg || m_gauge, false, "dialog should be fully created");
 
#ifdef __WXMSW__
    value /= m_factor;
#endif // __WXMSW__
 
    wxASSERT_MSG(value <= m_maximum, wxT("invalid progress value"));
    if (m_gauge)
        m_gauge->SetValue(value);
 
    UpdateMessage(newmsg);
 
    if ((m_elapsed || m_remaining || m_estimated) && (value != 0)) {
        unsigned long elapsed;
        unsigned long display_remaining;
 
        UpdateTimeEstimates(value, elapsed, m_display_estimated, display_remaining);
 
        SetTimeLabel(elapsed, m_elapsed);
        SetTimeLabel(m_display_estimated, m_estimated);
        SetTimeLabel(display_remaining, m_remaining);
    }
 
    if (value == m_maximum) {
        if (m_state == Finished) {
            // ignore multiple calls to Update(m_maximum): it may sometimes be
            // troublesome to ensure that Update() is not called twice with the
            // same value (e.g. because of the rounding errors) and if we don't
            // return now we're going to generate asserts below
            return true;
        }
 
        // so that we return true below and that out [Cancel] handler knew what
        // to do
        m_state = Finished;
        if (!HasPDFlag(wxPD_AUTO_HIDE)) {
            EnableClose();
            DisableSkip();
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
            EnableCloseButton();
#endif // __WXMSW__
 
            if (newmsg.empty()) {
                // also provide the finishing message if the application didn't
                m_msg->SetLabel(_L("Done."));
            }
 
            // allow the window to repaint:
            // NOTE: since we yield only for UI events with this call, there
            //       should be no side-effects
            wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI | wxEVT_CATEGORY_USER_INPUT);
 
            // NOTE: this call results in a new event loop being created
            //       and to a call to ProcessPendingEvents() (which may generate
            //       unwanted re-entrancies).
            (void) ShowModal();
        } else // auto hide
        {
            // reenable other windows before hiding this one because otherwise
            // Windows wouldn't give the focus back to the window which had
            // been previously focused because it would still be disabled
            ReenableOtherWindows();
 
            Hide();
        }
    } else // not at maximum yet
    {
        DoAfterUpdate();
    }
 
    // update the display in case yielding above didn't do it
    Update();
 
    return m_state != Canceled;
}

References _L, Canceled, DisableSkip(), DoAfterUpdate(), DoBeforeUpdate(), EnableClose(), Finished, HasPDFlag(), m_display_estimated, m_elapsed, m_estimated, m_gauge, m_maximum, m_msg, m_remaining, m_state, ReenableOtherWindows(), SetTimeLabel(), Update(), UpdateMessage(), and UpdateTimeEstimates().

Referenced by Slic3r::GUI::MediaFilePanel::doAction(), Slic3r::fix_model_with_cgal_gui(), Slic3r::GUI::ObjectList::fix_through_cgal(), Slic3r::GUI::ScoreDialog::get_button_sizer(), Slic3r::GUI::Plater::import_model_id(), Slic3r::GUI::Plater::priv::load_files(), Slic3r::GUI::ObjectList::load_modifier(), Slic3r::GUI::GUI_App::on_user_login_handle(), and Slic3r::GUI::GUI_App::recreate_GUI().

Here is the call graph for this function:

Here is the caller graph for this function:

update() [1/2]

bool Slic3r::GUI::PluginProgressDialog::update	(	int	value,
		const wxString &	message = wxEmptyString )

{
    if (!m_open)
        return false;
 
    if (!message.empty())
        m_pulse_message = message;
 
    return Update(value, message);
}

References m_open, m_pulse_message, and Slic3r::GUI::ProgressDialog::Update().

Here is the call graph for this function:

update() [2/2]

bool Slic3r::GUI::PluginProgressDialog::update ( PluginProgressDialog * dialog, int value, const wxString & message = wxEmptyString )

static

{
    return dialog != nullptr ? dialog->update(value, message) : false;
}

References PluginProgressDialog(), and update().

Referenced by Slic3r::anonymous_namespace{PluginHostUi.cpp}::progress_update(), and update().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateMessage()

void Slic3r::GUI::ProgressDialog::UpdateMessage ( const wxString & newmsg )

privateinherited

{
    if (!newmsg.empty() && newmsg != m_msg->GetLabel()) {
        const wxSize sizeOld = m_msg->GetSize();
 
        FormatString(newmsg);
        Fit();
        // m_msg->SetLabel(newmsg);
 
        if (m_msg->GetSize().x > sizeOld.x) {
            // Resize the dialog to fit its new, longer contents instead of
            // just truncating it.
            Fit();
        }
 
        // allow the window to repaint:
        // NOTE: since we yield only for UI events with this call, there
        //       should be no side-effects
        wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_UI | wxEVT_CATEGORY_USER_INPUT);
    }
}

References FormatString(), and m_msg.

Referenced by Pulse(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateTimeEstimates()

void Slic3r::GUI::ProgressDialog::UpdateTimeEstimates ( int value, unsigned long & elapsedTime, unsigned long & estimatedTime, unsigned long & remainingTime )

protectedinherited

{
    unsigned long elapsed = wxGetCurrentTime() - m_timeStart;
    if (value != 0 && (m_last_timeupdate < elapsed || value == m_maximum)) {
        m_last_timeupdate       = elapsed;
        unsigned long estimated = m_break + (unsigned long) (((double) (elapsed - m_break) * m_maximum) / ((double) value));
        if (estimated > m_display_estimated && m_ctdelay >= 0) {
            ++m_ctdelay;
        } else if (estimated < m_display_estimated && m_ctdelay <= 0) {
            --m_ctdelay;
        } else {
            m_ctdelay = 0;
        }
        if (m_ctdelay >= m_delay             // enough confirmations for a higher value
            || m_ctdelay <= (m_delay * -1)   // enough confirmations for a lower value
            || value == m_maximum            // to stay consistent
            || elapsed > m_display_estimated // to stay consistent
            || (elapsed > 0 && elapsed < 4)  // additional updates in the beginning
        ) {
            m_display_estimated = estimated;
            m_ctdelay           = 0;
        }
    }
 
    if (value != 0) {
        long display_remaining = m_display_estimated - elapsed;
        if (display_remaining < 0) { display_remaining = 0; }
 
        estimatedTime = m_display_estimated;
        remainingTime = display_remaining;
    }
 
    elapsedTime = elapsed;
}

References m_break, m_ctdelay, m_delay, m_display_estimated, m_last_timeupdate, m_maximum, and m_timeStart.

Referenced by Update().

Here is the caller graph for this function:

WasCanceled()

bool Slic3r::GUI::ProgressDialog::WasCanceled ( ) const

inherited

{ return m_state == Canceled; }

References Canceled, and m_state.

WasCancelled()

bool Slic3r::GUI::ProgressDialog::WasCancelled ( ) const

virtualinherited

{ return HasPDFlag(wxPD_CAN_ABORT) && m_state == Canceled; }

References Canceled, HasPDFlag(), and m_state.

Referenced by Slic3r::GUI::Plater::priv::load_files().

Here is the call graph for this function:

Here is the caller graph for this function:

WasSkipped()

bool Slic3r::GUI::ProgressDialog::WasSkipped ( ) const

virtualinherited

{ return HasPDFlag(wxPD_CAN_SKIP) && m_skip; }

References HasPDFlag(), and m_skip.

Here is the call graph for this function:

wxDECLARE_NO_COPY_CLASS()

Slic3r::GUI::ProgressDialog::wxDECLARE_NO_COPY_CLASS ( ProgressDialog )

privateinherited

References ProgressDialog().

Here is the call graph for this function:

Member Data Documentation

m_adaptive

bool Slic3r::GUI::ProgressDialog::m_adaptive = {false}

inherited

{false};

Referenced by ProgressDialog(), Create(), and FormatString().

m_break

unsigned long Slic3r::GUI::ProgressDialog::m_break

protectedinherited

Referenced by Init(), Resume(), and UpdateTimeEstimates().

m_btnAbort

wxButton* Slic3r::GUI::ProgressDialog::m_btnAbort

privateinherited

Referenced by EnableAbort(), EnableClose(), and Init().

m_btnSkip

wxButton* Slic3r::GUI::ProgressDialog::m_btnSkip

privateinherited

Referenced by EnableSkip(), and Init().

m_button_cancel

Button* Slic3r::GUI::ProgressDialog::m_button_cancel = {nullptr}

inherited

{nullptr};

Referenced by Create(), and Resume().

m_ctdelay

int Slic3r::GUI::ProgressDialog::m_ctdelay

privateinherited

Referenced by Init(), Resume(), and UpdateTimeEstimates().

m_delay

int Slic3r::GUI::ProgressDialog::m_delay

privateinherited

Referenced by Init(), Resume(), and UpdateTimeEstimates().

m_display_estimated

unsigned long Slic3r::GUI::ProgressDialog::m_display_estimated

privateinherited

Referenced by Init(), Update(), and UpdateTimeEstimates().

m_elapsed

wxStaticText* Slic3r::GUI::ProgressDialog::m_elapsed

privateinherited

Referenced by Create(), Init(), Pulse(), and Update().

m_estimated

wxStaticText * Slic3r::GUI::ProgressDialog::m_estimated

privateinherited

Referenced by Create(), Init(), Pulse(), and Update().

m_gauge

wxGauge* Slic3r::GUI::ProgressDialog::m_gauge

privateinherited

Referenced by Create(), GetValue(), Init(), Pulse(), SetRange(), and Update().

m_last_timeupdate

unsigned long Slic3r::GUI::ProgressDialog::m_last_timeupdate

privateinherited

Referenced by Init(), and UpdateTimeEstimates().

m_maximum

int Slic3r::GUI::ProgressDialog::m_maximum

protectedinherited

Referenced by GetRange(), Init(), SetMaximum(), Update(), and UpdateTimeEstimates().

m_mode

int Slic3r::GUI::ProgressDialog::m_mode = 0

inherited

Referenced by FormatString().

m_msg

wxStaticText* Slic3r::GUI::ProgressDialog::m_msg

privateinherited

Referenced by Create(), FormatString(), GetMessage(), Init(), Pulse(), Update(), and UpdateMessage().

m_msg_2line

wxStaticText* Slic3r::GUI::ProgressDialog::m_msg_2line

privateinherited

Referenced by Create(), FormatString(), and set_panel_height().

m_msg_scrolledWindow

wxScrolledWindow* Slic3r::GUI::ProgressDialog::m_msg_scrolledWindow = {nullptr}

inherited

{nullptr};

Referenced by Create(), and FormatString().

m_on_destroyed

CloseHandler Slic3r::GUI::PluginProgressDialog::m_on_destroyed

private

Referenced by PluginProgressDialog(), and ~PluginProgressDialog().

m_open

bool Slic3r::GUI::PluginProgressDialog::m_open {true}

private

{true};

Referenced by close(), is_open(), on_timer(), pulse(), start_pulse(), and update().

m_panel_1line

wxPanel* Slic3r::GUI::ProgressDialog::m_panel_1line = {nullptr}

inherited

{nullptr};

Referenced by Create().

m_panel_2line

wxPanel* Slic3r::GUI::ProgressDialog::m_panel_2line = {nullptr}

inherited

{nullptr};

Referenced by Create(), and set_panel_height().

m_parentTop

wxWindowRef Slic3r::GUI::ProgressDialog::m_parentTop

privateinherited

Referenced by Create(), DisableOtherWindows(), GetTopParent(), Init(), ReenableOtherWindows(), and SetTopParent().

m_pdStyle

int Slic3r::GUI::ProgressDialog::m_pdStyle

privateinherited

Referenced by Create(), GetPDStyle(), HasPDFlag(), Init(), and SetPDStyle().

m_pulse_message

wxString Slic3r::GUI::PluginProgressDialog::m_pulse_message

private

Referenced by PluginProgressDialog(), on_timer(), pulse(), start_pulse(), and update().

m_remaining

wxStaticText * Slic3r::GUI::ProgressDialog::m_remaining

privateinherited

Referenced by Create(), Init(), Pulse(), and Update().

m_simplebook

wxSimplebook* Slic3r::GUI::ProgressDialog::m_simplebook = {nullptr}

inherited

{nullptr};

Referenced by Create(), FormatString(), and set_panel_height().

m_sizer_main

wxSizer* Slic3r::GUI::ProgressDialog::m_sizer_main = {nullptr}

inherited

{nullptr};

Referenced by Create().

m_skip

bool Slic3r::GUI::ProgressDialog::m_skip

privateinherited

Referenced by DoBeforeUpdate(), Init(), OnSkip(), Resume(), and WasSkipped().

m_state

State Slic3r::GUI::ProgressDialog::m_state

protectedinherited

Referenced by Create(), DoBeforeUpdate(), Init(), OnCancel(), OnClose(), Pulse(), Resume(), Update(), WasCanceled(), and WasCancelled().

m_tempEventLoop

wxEventLoop* Slic3r::GUI::ProgressDialog::m_tempEventLoop

privateinherited

Referenced by ~ProgressDialog(), EnsureActiveEventLoopExists(), and Init().

m_timer

std::unique_ptr<wxTimer> Slic3r::GUI::PluginProgressDialog::m_timer

private

Referenced by start_pulse(), and stop_pulse().

m_timeStart

unsigned long Slic3r::GUI::ProgressDialog::m_timeStart

protectedinherited

Referenced by Init(), Pulse(), and UpdateTimeEstimates().

m_timeStop

unsigned long Slic3r::GUI::ProgressDialog::m_timeStop

protectedinherited

Referenced by Create(), Init(), OnCancel(), OnClose(), and Resume().

m_top_line

wxPanel* Slic3r::GUI::ProgressDialog::m_top_line = {nullptr}

inherited

{nullptr};

Referenced by Create().

m_winDisabler

wxWindowDisabler* Slic3r::GUI::ProgressDialog::m_winDisabler

privateinherited

Referenced by DisableOtherWindows(), Init(), and ReenableOtherWindows().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PluginProgressDialog.hpp
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/PluginProgressDialog.cpp