X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/f79fd1e54b4533507c6de798eecfdde765a3fc4e..7ddb15416407390de67cc26b04e91ea99a521f57:/src/generic/progdlgg.cpp diff --git a/src/generic/progdlgg.cpp b/src/generic/progdlgg.cpp index f987808944..7f48ba31f3 100644 --- a/src/generic/progdlgg.cpp +++ b/src/generic/progdlgg.cpp @@ -1,17 +1,21 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: progdlgg.h -// Purpose: wxProgressDialog class -// Author: Karsten Ballüder +// Name: src/generic/progdlgg.cpp +// Purpose: wxGenericProgressDialog class +// Author: Karsten Ballueder // Modified by: // Created: 09.05.1999 // RCS-ID: $Id$ -// Copyright: (c) Karsten Ballüder -// Licence: wxWindows license +// Copyright: (c) Karsten Ballueder +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "progdlgg.h" -#endif +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -20,271 +24,806 @@ #pragma hdrstop #endif +#if wxUSE_PROGRESSDLG + #ifndef WX_PRECOMP #include "wx/utils.h" #include "wx/frame.h" #include "wx/button.h" #include "wx/stattext.h" - #include "wx/layout.h" + #include "wx/sizer.h" #include "wx/event.h" #include "wx/gauge.h" #include "wx/intl.h" - #include "wx/settings.h" #include "wx/dcclient.h" + #include "wx/timer.h" + #include "wx/settings.h" + #include "wx/app.h" #endif -#if wxUSE_PROGRESSDLG +#include "wx/progdlg.h" +#include "wx/evtloop.h" + +// --------------------------------------------------------------------------- +// macros +// --------------------------------------------------------------------------- + +/* Macro for avoiding #ifdefs when value have to be different depending on size of + device we display on - take it from something like wxDesktopPolicy in the future + */ + +#if defined(__SMARTPHONE__) + #define wxLARGESMALL(large,small) small +#else + #define wxLARGESMALL(large,small) large +#endif + +// ---------------------------------------------------------------------------- +// constants +// ---------------------------------------------------------------------------- + +#define LAYOUT_MARGIN wxLARGESMALL(8,2) + +static const int wxID_SKIP = 32000; // whatever + +// ---------------------------------------------------------------------------- +// event tables +// ---------------------------------------------------------------------------- + +BEGIN_EVENT_TABLE(wxGenericProgressDialog, wxDialog) + EVT_BUTTON(wxID_CANCEL, wxGenericProgressDialog::OnCancel) + EVT_BUTTON(wxID_SKIP, wxGenericProgressDialog::OnSkip) + + EVT_CLOSE(wxGenericProgressDialog::OnClose) +END_EVENT_TABLE() + +// ============================================================================ +// wxGenericProgressDialog implementation +// ============================================================================ + +wxIMPLEMENT_CLASS(wxProgressDialog, wxDialog) + +// ---------------------------------------------------------------------------- +// wxGenericProgressDialog creation +// ---------------------------------------------------------------------------- + +void wxGenericProgressDialog::Init() +{ + // 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; + +#if !defined(__SMARTPHONE__) + m_btnAbort = + m_btnSkip = NULL; +#endif + + m_display_estimated = + m_last_timeupdate = + m_ctdelay = 0; + + m_delay = 3; + + m_winDisabler = NULL; + m_tempEventLoop = NULL; +} + +wxGenericProgressDialog::wxGenericProgressDialog() + : wxDialog() +{ + Init(); +} + +wxGenericProgressDialog::wxGenericProgressDialog(const wxString& title, + const wxString& message, + int maximum, + wxWindow *parent, + int style) + : wxDialog() +{ + Init(); -#include "wx/generic/progdlgg.h" + Create( title, message, maximum, parent, style ); +} + +void wxGenericProgressDialog::SetTopParent(wxWindow* parent) +{ + m_parentTop = GetParentForModalDialog(parent, GetWindowStyle()); +} + +bool wxGenericProgressDialog::Create( const wxString& title, + const wxString& message, + int maximum, + wxWindow *parent, + int style ) +{ + SetTopParent(parent); + + m_parentTop = wxGetTopLevelParent(parent); + m_pdStyle = style; + + wxWindow* const + realParent = GetParentForModalDialog(parent, GetWindowStyle()); + + if (!wxDialog::Create(realParent, wxID_ANY, title)) + return false; + + SetMaximum(maximum); + + // We need a running event loop in order to update the dialog and be able + // to process clicks on its buttons, so ensure that there is one running + // even if this means we have to start it ourselves (this happens most + // commonly during the program initialization, e.g. for the progress + // dialogs shown from overridden wxApp::OnInit()). + if ( !wxEventLoopBase::GetActive() ) + { + m_tempEventLoop = new wxEventLoop; + wxEventLoop::SetActive(m_tempEventLoop); + } + +#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__) + // we have to remove the "Close" button from the title bar then as it is + // confusing to have it - it doesn't work anyhow + // + // FIXME: should probably have a (extended?) window style for this + if ( !HasPDFlag(wxPD_CAN_ABORT) ) + { + EnableCloseButton(false); + } +#endif // wxMSW + +#if defined(__SMARTPHONE__) + SetLeftMenu(); +#endif + + m_state = HasPDFlag(wxPD_CAN_ABORT) ? Continue : Uncancelable; + + // top-level sizerTop + wxSizer * const sizerTop = new wxBoxSizer(wxVERTICAL); + + m_msg = new wxStaticText(this, wxID_ANY, message); + sizerTop->Add(m_msg, 0, wxLEFT | wxTOP, 2*LAYOUT_MARGIN); + + int gauge_style = wxGA_HORIZONTAL; + if ( style & wxPD_SMOOTH ) + gauge_style |= wxGA_SMOOTH; + +#ifdef __WXMSW__ + maximum /= m_factor; +#endif + + m_gauge = new wxGauge + ( + this, + wxID_ANY, + maximum, + wxDefaultPosition, + // make the progress bar sufficiently long + wxSize(wxMin(wxGetClientDisplayRect().width/3, 300), -1), + gauge_style + ); + + sizerTop->Add(m_gauge, 0, wxLEFT | wxRIGHT | wxTOP | wxEXPAND, 2*LAYOUT_MARGIN); + m_gauge->SetValue(0); + + // create the estimated/remaining/total time zones if requested + m_elapsed = + m_estimated = + m_remaining = NULL; + + // also count how many labels we really have + size_t nTimeLabels = 0; + + wxSizer * const sizerLabels = new wxFlexGridSizer(2); + + if ( style & wxPD_ELAPSED_TIME ) + { + nTimeLabels++; + + m_elapsed = CreateLabel(GetElapsedLabel(), sizerLabels); + } -#define LAYOUT_X_MARGIN 8 -#define LAYOUT_Y_MARGIN 8 + 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, LAYOUT_MARGIN); + +#if defined(__SMARTPHONE__) + if ( HasPDFlag(wxPD_CAN_SKIP) ) + SetRightMenu(wxID_SKIP, _("Skip")); + if ( HasPDFlag(wxPD_CAN_ABORT) ) + SetLeftMenu(wxID_CANCEL); +#else + m_btnAbort = + m_btnSkip = NULL; + + wxBoxSizer *buttonSizer = new wxBoxSizer(wxHORIZONTAL); + + // Windows dialogs usually have buttons in the lower right corner + const int sizerFlags = +#if defined(__WXMSW__) || defined(__WXPM__) || defined(__WXOSX__) + wxALIGN_RIGHT | wxALL +#else // !MSW + wxALIGN_CENTER_HORIZONTAL | wxBOTTOM | wxTOP +#endif // MSW/!MSW + ; + + if ( HasPDFlag(wxPD_CAN_SKIP) ) + { + m_btnSkip = new wxButton(this, wxID_SKIP, _("&Skip")); + + buttonSizer->Add(m_btnSkip, 0, sizerFlags, LAYOUT_MARGIN); + } + + if ( HasPDFlag(wxPD_CAN_ABORT) ) + { + m_btnAbort = new wxButton(this, wxID_CANCEL); + + buttonSizer->Add(m_btnAbort, 0, sizerFlags, LAYOUT_MARGIN); + } + + if ( !HasPDFlag(wxPD_CAN_SKIP | wxPD_CAN_ABORT) ) + buttonSizer->AddSpacer(LAYOUT_MARGIN); + + sizerTop->Add(buttonSizer, 0, sizerFlags, LAYOUT_MARGIN ); +#endif // __SMARTPHONE__/!__SMARTPHONE__ + + SetSizerAndFit(sizerTop); + + Centre(wxCENTER_FRAME | wxBOTH); + + DisableOtherWindows(); + + Show(); + Enable(); + + // this one can be initialized even if the others are unknown for now + // + // NB: do it after calling Layout() to keep the labels correctly aligned + if ( m_elapsed ) + { + SetTimeLabel(0, m_elapsed); + } + + Update(); + return true; +} -// wxTextEntryDialog +void wxGenericProgressDialog::UpdateTimeEstimates(int value, + unsigned long &elapsedTime, + unsigned long &estimatedTime, + unsigned long &remainingTime) +{ + 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; +} -#if !USE_SHARED_LIBRARY - BEGIN_EVENT_TABLE(wxProgressDialog, wxFrame) - EVT_BUTTON(-1, wxProgressDialog::OnCancel) - EVT_CLOSE(wxProgressDialog::OnClose) - END_EVENT_TABLE() +// static +wxString wxGenericProgressDialog::GetFormattedTime(unsigned long timeInSec) +{ + wxString timeAsHMS; + + if ( timeInSec == (unsigned long)-1 ) + { + timeAsHMS = _("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; +} - IMPLEMENT_CLASS(wxProgressDialog, wxFrame) +wxStaticText * +wxGenericProgressDialog::CreateLabel(const wxString& text, wxSizer *sizer) +{ + wxStaticText *label = new wxStaticText(this, wxID_ANY, text); + wxStaticText *value = new wxStaticText(this, wxID_ANY, _("unknown")); + + // select placement most native or nice on target GUI +#if defined(__SMARTPHONE__) + // value and time to the left in two rows + sizer->Add(label, 1, wxALIGN_LEFT); + sizer->Add(value, 1, wxALIGN_LEFT); +#elif defined(__WXMSW__) || defined(__WXPM__) || defined(__WXMAC__) || defined(__WXGTK20__) + // value and time centered in one row + sizer->Add(label, 1, wxLARGESMALL(wxALIGN_RIGHT,wxALIGN_LEFT) | 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 -wxProgressDialog::wxProgressDialog(wxString const &title, - wxString const &message, - int maximum, - wxWindow *parent, - int style) -{ - wxWindow *lastWindow = NULL; - bool hasAbortButton = (style & wxPD_CAN_ABORT) != 0; - m_state = hasAbortButton ? Continue : Uncancelable; - m_disableParentOnly = (style & wxPD_APP_MODAL) == 0; - m_parent = parent; - m_maximum = maximum; - - m_elapsed = m_estimated = m_remaining = NULL; - if ((style & (wxPD_ELAPSED_TIME | wxPD_ESTIMATED_TIME | wxPD_REMAINING_TIME)) != 0) m_time = new wxTime; - else m_time = NULL; - - wxFrame::Create(m_parent, -1, title, wxDefaultPosition, - wxDefaultSize, wxDEFAULT_DIALOG_STYLE); - SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); - - wxLayoutConstraints *c; - - wxClientDC dc(this); - dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_DEFAULT_GUI_FONT)); - long widthText; - dc.GetTextExtent(message, &widthText, NULL); - - m_msg = new wxStaticText(this, -1, message); - c = new wxLayoutConstraints; - c->left.SameAs(this, wxLeft, 10); - c->top.SameAs(this, wxTop, 10); - c->width.AsIs(); - c->height.AsIs(); - m_msg->SetConstraints(c); - lastWindow = m_msg; - - if ( maximum > 0 ) - { - m_gauge = new wxGauge(this, -1, maximum, - wxDefaultPosition, wxDefaultSize, - wxGA_HORIZONTAL | wxRAISED_BORDER); - c = new wxLayoutConstraints; - c->left.SameAs(this, wxLeft, 2*LAYOUT_X_MARGIN); - c->top.Below(m_msg, 2*LAYOUT_Y_MARGIN); - c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN); - c->height.AsIs(); - m_gauge->SetConstraints(c); - m_gauge->SetValue(0); - lastWindow = m_gauge; - } - else - m_gauge = (wxGauge *)NULL; - - - if ( style & wxPD_ELAPSED_TIME ) - { - m_elapsed = new wxStaticText(this, -1, ""); - c = new wxLayoutConstraints; - c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN); - c->top.Below(lastWindow, LAYOUT_Y_MARGIN); - c->width.Absolute(60); - c->height.AsIs(); - m_elapsed->SetConstraints(c); - - wxStaticText *dummy = new wxStaticText(this, -1, _T("Elapsed time : ")); - c = new wxLayoutConstraints; - c->right.LeftOf(m_elapsed); - c->top.SameAs(m_elapsed, wxTop, 0); - c->width.AsIs(); - c->height.AsIs(); - dummy->SetConstraints(c); - - lastWindow = m_elapsed; - } - - if ( style & wxPD_ESTIMATED_TIME ) - { - m_estimated = new wxStaticText(this, -1, ""); - c = new wxLayoutConstraints; - c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN); - c->top.Below(lastWindow, 0); - c->width.Absolute(60); - c->height.AsIs(); - m_estimated->SetConstraints(c); - - wxStaticText *dummy = new wxStaticText(this, -1, _T("Estimated time : ")); - c = new wxLayoutConstraints; - c->right.LeftOf(m_estimated); - c->top.SameAs(m_estimated, wxTop, 0); - c->width.AsIs(); - c->height.AsIs(); - dummy->SetConstraints(c); - - lastWindow = m_estimated; - } - - if ( style & wxPD_REMAINING_TIME ) - { - m_remaining = new wxStaticText(this, -1, ""); - c = new wxLayoutConstraints; - c->right.SameAs(this, wxRight, 2*LAYOUT_X_MARGIN); - c->top.Below(lastWindow, 0); - c->width.Absolute(60); - c->height.AsIs(); - m_remaining->SetConstraints(c); - - wxStaticText *dummy = new wxStaticText(this, -1, _T("Remaining time : ")); - c = new wxLayoutConstraints; - c->right.LeftOf(m_remaining); - c->top.SameAs(m_remaining, wxTop, 0); - c->width.AsIs(); - c->height.AsIs(); - dummy->SetConstraints(c); - - lastWindow = m_remaining; - } - - if ( hasAbortButton ) - { - m_btnAbort = new wxButton(this, -1, _("Cancel")); - c = new wxLayoutConstraints; - c->centreX.SameAs(this, wxCentreX); - c->top.Below(lastWindow, 2*LAYOUT_Y_MARGIN); - c->width.AsIs(); - c->height.AsIs(); - m_btnAbort->SetConstraints(c); - } - else - m_btnAbort = (wxButton *)NULL; - - SetAutoLayout(TRUE); - Layout(); - - // calc the height of the dialog - Fit(); - // and set the width from it - unfortunately, Fit() makes the dialog way too - // wide under Windows, so try to find a reasonable value for the width, not - // too big and not too small - wxSize size = GetClientSize(); - size.x = wxMax(3*widthText/2, 2*size.y); - SetClientSize(size); - - Show(TRUE); - Centre(wxCENTER_FRAME | wxBOTH); - - if(m_disableParentOnly) - m_parent->Enable(FALSE); - else - wxEnableTopLevelWindows(FALSE); - - Enable(TRUE); // enable this window - wxYield(); + return value; } +// ---------------------------------------------------------------------------- +// wxGenericProgressDialog operations +// ---------------------------------------------------------------------------- bool -wxProgressDialog::Update(int value, const wxString& newmsg) +wxGenericProgressDialog::Update(int value, const wxString& newmsg, bool *skip) +{ + if ( !DoBeforeUpdate(skip) ) + return false; + + wxCHECK_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") ); + + 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(_("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); + + // 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; +} + +bool wxGenericProgressDialog::Pulse(const wxString& newmsg, bool *skip) +{ + if ( !DoBeforeUpdate(skip) ) + return false; + + wxCHECK_MSG( m_gauge, false, "dialog should be fully created" ); + + // show a bit of progress + 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; +} + +bool wxGenericProgressDialog::DoBeforeUpdate(bool *skip) +{ + // 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; +} + +void wxGenericProgressDialog::DoAfterUpdate() +{ + // 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); +} + +void wxGenericProgressDialog::Resume() +{ + m_state = Continue; + m_ctdelay = m_delay; // force an update of the elapsed/estimated/remaining time + m_break += wxGetCurrentTime()-m_timeStop; + + EnableAbort(); + EnableSkip(); + m_skip = false; +} + +bool wxGenericProgressDialog::Show( bool show ) +{ + // 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); +} + +int wxGenericProgressDialog::GetValue() const +{ + wxCHECK_MSG( m_gauge, -1, "dialog should be fully created" ); + + return m_gauge->GetValue(); +} + +int wxGenericProgressDialog::GetRange() const +{ + return m_maximum; +} + +wxString wxGenericProgressDialog::GetMessage() const { - wxASSERT_MSG( value == -1 || m_gauge, _T("cannot update non existent dialog") ); - wxASSERT_MSG( value <= m_maximum, _T("invalid progress value") ); + return m_msg->GetLabel(); +} + +void wxGenericProgressDialog::SetRange(int maximum) +{ + wxCHECK_RET( m_gauge, "dialog should be fully created" ); + + wxCHECK_RET( maximum > 0, "Invalid range" ); + + m_gauge->SetRange(maximum); + SetMaximum(maximum); +} - if( m_gauge ) - m_gauge->SetValue(value + 1); +void wxGenericProgressDialog::SetMaximum(int maximum) +{ + m_maximum = maximum; - if( !newmsg.IsEmpty() ) - m_msg->SetLabel(newmsg); +#if defined(__WXMSW__) || defined(__WXPM__) + // we can't have values > 65,536 in the progress control under Windows, so + // scale everything down + m_factor = m_maximum / 65536 + 1; +#endif // __WXMSW__ +} - if ( (m_elapsed || m_remaining || m_estimated) && (value != 0) ) - { - wxTime timenow; - wxTime diff = timenow - *m_time; - unsigned long secs = diff.GetSecond() + 60 * diff.GetMinute() + 60 * 60 * diff.GetHour(); - unsigned long estim = secs * m_maximum / value; - unsigned long remai = estim - secs; - wxString s; - if (m_elapsed) - { - s.Printf("%i:%02i:%02i", diff.GetHour(), diff.GetMinute(), diff.GetSecond()); - if (s != m_elapsed->GetLabel()) m_elapsed->SetLabel(s); - } - if (m_estimated) - { - s.Printf("%i:%02i:%02i", estim / (60 * 60), (estim / 60) % 60, estim % 60); - if (s != m_estimated->GetLabel()) m_estimated->SetLabel(s); - } - if (m_remaining) - { - s.Printf("%i:%02i:%02i", remai / (60 * 60), (remai / 60) % 60, remai % 60); - if (s != m_remaining->GetLabel()) m_remaining->SetLabel(s); - } - } +bool wxGenericProgressDialog::WasCancelled() const +{ + return HasPDFlag(wxPD_CAN_ABORT) && m_state == Canceled; +} + +bool wxGenericProgressDialog::WasSkipped() const +{ + return HasPDFlag(wxPD_CAN_SKIP) && m_skip; +} - if ( (value == m_maximum - 1) && !(GetWindowStyleFlag() & wxPD_AUTO_HIDE) ) - { - if ( m_btnAbort ) - { - // tell the user what he should do... - m_btnAbort->SetLabel(_("Close")); - } +// static +void wxGenericProgressDialog::SetTimeLabel(unsigned long val, + wxStaticText *label) +{ + if ( label ) + { + wxString s; + + if (val != (unsigned long)-1) + { + s = GetFormattedTime(val); + } + else + { + s = _("Unknown"); + } + + if ( s != label->GetLabel() ) + label->SetLabel(s); + } +} - if ( !newmsg ) - { - // also provide the finishing message if the application didn't - m_msg->SetLabel(_("Done.")); - } +// ---------------------------------------------------------------------------- +// event handlers +// ---------------------------------------------------------------------------- - m_state = Finished; +void wxGenericProgressDialog::OnCancel(wxCommandEvent& event) +{ + 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(); + + // save the time when the dialog was stopped + m_timeStop = wxGetCurrentTime(); + } +} - // so that we return TRUE below - m_state = Finished; - } - wxYield(); - return m_state != Canceled; +void wxGenericProgressDialog::OnSkip(wxCommandEvent& WXUNUSED(event)) +{ + DisableSkip(); + m_skip = true; } -void wxProgressDialog::OnClose(wxCloseEvent& event) +void wxGenericProgressDialog::OnClose(wxCloseEvent& event) { - if ( m_state == Uncancelable ) - event.Veto(TRUE); - else - m_state = Canceled; + 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(); + + m_timeStop = wxGetCurrentTime(); + } } +// ---------------------------------------------------------------------------- +// destruction +// ---------------------------------------------------------------------------- -wxProgressDialog::~wxProgressDialog() +wxGenericProgressDialog::~wxGenericProgressDialog() { - if ( m_disableParentOnly ) - m_parent->Enable(TRUE); - else - wxEnableTopLevelWindows(TRUE); - if (m_time) delete m_time; + // normally this should have been already done, but just in case + ReenableOtherWindows(); + + if ( m_tempEventLoop ) + { + wxEventLoopBase::SetActive(NULL); + delete m_tempEventLoop; + } } +void wxGenericProgressDialog::DisableOtherWindows() +{ + if ( HasPDFlag(wxPD_APP_MODAL) ) + { + m_winDisabler = new wxWindowDisabler(this); + } + else + { + if ( m_parentTop ) + m_parentTop->Disable(); + m_winDisabler = NULL; + } +} + +void wxGenericProgressDialog::ReenableOtherWindows() +{ + if ( HasPDFlag(wxPD_APP_MODAL) ) + { + wxDELETE(m_winDisabler); + } + else + { + if ( m_parentTop ) + m_parentTop->Enable(); + } +} + +// ---------------------------------------------------------------------------- +// private functions +// ---------------------------------------------------------------------------- + +void wxGenericProgressDialog::EnableSkip(bool enable) +{ + if ( HasPDFlag(wxPD_CAN_SKIP) ) + { +#ifdef __SMARTPHONE__ + if(enable) + SetRightMenu(wxID_SKIP, _("Skip")); + else + SetRightMenu(); +#else + if(m_btnSkip) + m_btnSkip->Enable(enable); +#endif + } +} + +void wxGenericProgressDialog::EnableAbort(bool enable) +{ + if( HasPDFlag(wxPD_CAN_ABORT) ) + { +#ifdef __SMARTPHONE__ + if(enable) + SetLeftMenu(wxID_CANCEL); // stock buttons makes Cancel label + else + SetLeftMenu(); +#else + if(m_btnAbort) + m_btnAbort->Enable(enable); #endif + } +} + +void wxGenericProgressDialog::EnableClose() +{ + if(HasPDFlag(wxPD_CAN_ABORT)) + { +#ifdef __SMARTPHONE__ + SetLeftMenu(wxID_CANCEL, _("Close")); +#else + if(m_btnAbort) + { + m_btnAbort->Enable(); + m_btnAbort->SetLabel(_("Close")); + } +#endif + } +} + +void wxGenericProgressDialog::UpdateMessage(const wxString &newmsg) +{ + if ( !newmsg.empty() && newmsg != m_msg->GetLabel() ) + { + m_msg->SetLabel(newmsg); + + // 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); + } +} + +#endif // wxUSE_PROGRESSDLG