src/generic/progdlgg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/progdlgg.cpp
   3 // Purpose:     wxProgressDialog class
   4 // Author:      Karsten Ballueder
   5 // Modified by:
   6 // Created:     09.05.1999
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Karsten Ballueder
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_PROGRESSDLG
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/utils.h"
  31     #include "wx/frame.h"
  32     #include "wx/button.h"
  33     #include "wx/stattext.h"
  34     #include "wx/sizer.h"
  35     #include "wx/event.h"
  36     #include "wx/gauge.h"
  37     #include "wx/intl.h"
  38     #include "wx/dcclient.h"
  39     #include "wx/timer.h"
  40     #include "wx/settings.h"
  41 #endif
  42
  43 #include "wx/progdlg.h"
  44
  45 // ---------------------------------------------------------------------------
  46 // macros
  47 // ---------------------------------------------------------------------------
  48
  49 /* Macro for avoiding #ifdefs when value have to be different depending on size of
  50    device we display on - take it from something like wxDesktopPolicy in the future
  51  */
  52
  53 #if defined(__SMARTPHONE__)
  54     #define wxLARGESMALL(large,small) small
  55 #else
  56     #define wxLARGESMALL(large,small) large
  57 #endif
  58
  59 // ----------------------------------------------------------------------------
  60 // constants
  61 // ----------------------------------------------------------------------------
  62
  63 #define LAYOUT_MARGIN wxLARGESMALL(8,2)
  64
  65 static const int wxID_SKIP = 32000;  // whatever
  66
  67 // ----------------------------------------------------------------------------
  68 // private functions
  69 // ----------------------------------------------------------------------------
  70
  71 // update the label to show the given time (in seconds)
  72 static void SetTimeLabel(unsigned long val, wxStaticText *label);
  73
  74 // ----------------------------------------------------------------------------
  75 // event tables
  76 // ----------------------------------------------------------------------------
  77
  78 BEGIN_EVENT_TABLE(wxProgressDialog, wxDialog)
  79     EVT_BUTTON(wxID_CANCEL, wxProgressDialog::OnCancel)
  80     EVT_BUTTON(wxID_SKIP, wxProgressDialog::OnSkip)
  81
  82     EVT_CLOSE(wxProgressDialog::OnClose)
  83 END_EVENT_TABLE()
  84
  85 IMPLEMENT_CLASS(wxProgressDialog, wxDialog)
  86
  87 // ============================================================================
  88 // wxProgressDialog implementation
  89 // ============================================================================
  90
  91 // ----------------------------------------------------------------------------
  92 // wxProgressDialog creation
  93 // ----------------------------------------------------------------------------
  94
  95 wxProgressDialog::wxProgressDialog(const wxString& title,
  96                                    const wxString& message,
  97                                    int maximum,
  98                                    wxWindow *parent,
  99                                    int style)
 100                 : wxDialog(GetParentForModalDialog(parent), wxID_ANY, title),
 101                   m_skip(false),
 102                   m_delay(3),
 103                   m_hasAbortButton(false),
 104                   m_hasSkipButton(false)
 105 {
 106     // we may disappear at any moment, let the others know about it
 107     SetExtraStyle(GetExtraStyle() | wxWS_EX_TRANSIENT);
 108     m_windowStyle |= style;
 109
 110     m_hasAbortButton = (style & wxPD_CAN_ABORT) != 0;
 111     m_hasSkipButton = (style & wxPD_CAN_SKIP) != 0;
 112
 113 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 114     // we have to remove the "Close" button from the title bar then as it is
 115     // confusing to have it - it doesn't work anyhow
 116     //
 117     // FIXME: should probably have a (extended?) window style for this
 118     if ( !m_hasAbortButton )
 119     {
 120         EnableCloseButton(false);
 121     }
 122 #endif // wxMSW
 123
 124 #if defined(__SMARTPHONE__)
 125     SetLeftMenu();
 126 #endif
 127
 128     m_state = m_hasAbortButton ? Continue : Uncancelable;
 129     m_maximum = maximum;
 130
 131 #if defined(__WXMSW__) || defined(__WXPM__)
 132     // we can't have values > 65,536 in the progress control under Windows, so
 133     // scale everything down
 134     m_factor = m_maximum / 65536 + 1;
 135     m_maximum /= m_factor;
 136 #endif // __WXMSW__
 137
 138     m_parentTop = wxGetTopLevelParent(parent);
 139
 140     wxClientDC dc(this);
 141     dc.SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 142     wxCoord widthText = 0;
 143     dc.GetTextExtent(message, &widthText, NULL, NULL, NULL, NULL);
 144
 145     // top-level sizerTop
 146     wxSizer * const sizerTop = new wxBoxSizer(wxVERTICAL);
 147
 148     m_msg = new wxStaticText(this, wxID_ANY, message);
 149     sizerTop->Add(m_msg, 0, wxLEFT | wxTOP, 2*LAYOUT_MARGIN);
 150
 151     wxSize sizeLabel = m_msg->GetSize();
 152     if ( maximum > 0 )
 153     {
 154         int gauge_style = wxGA_HORIZONTAL;
 155         if ( style & wxPD_SMOOTH )
 156             gauge_style |= wxGA_SMOOTH;
 157         m_gauge = new wxGauge
 158                       (
 159                         this,
 160                         wxID_ANY,
 161                         m_maximum,
 162                         wxDefaultPosition,
 163                         // make the progress bar sufficiently long
 164                         wxSize(wxMin(wxGetClientDisplayRect().width/3, 300), -1),
 165                         gauge_style
 166                       );
 167
 168         sizerTop->Add(m_gauge, 0, wxLEFT | wxRIGHT | wxTOP | wxEXPAND, 2*LAYOUT_MARGIN);
 169         m_gauge->SetValue(0);
 170     }
 171     else
 172     {
 173         m_gauge = NULL;
 174     }
 175
 176     // create the estimated/remaining/total time zones if requested
 177     m_elapsed =
 178     m_estimated =
 179     m_remaining = NULL;
 180     m_display_estimated =
 181     m_last_timeupdate =
 182     m_break = 0;
 183     m_ctdelay = 0;
 184
 185     // if we are going to have at least one label, remember it in this var
 186     wxStaticText *label = NULL;
 187
 188     // also count how many labels we really have
 189     size_t nTimeLabels = 0;
 190
 191     wxSizer * const sizerLabels = new wxFlexGridSizer(2);
 192
 193     if ( style & wxPD_ELAPSED_TIME )
 194     {
 195         nTimeLabels++;
 196
 197         label =
 198         m_elapsed = CreateLabel(_("Elapsed time:"), sizerLabels);
 199     }
 200
 201     if ( style & wxPD_ESTIMATED_TIME )
 202     {
 203         nTimeLabels++;
 204
 205         label =
 206         m_estimated = CreateLabel(_("Estimated time:"), sizerLabels);
 207     }
 208
 209     if ( style & wxPD_REMAINING_TIME )
 210     {
 211         nTimeLabels++;
 212
 213         label =
 214         m_remaining = CreateLabel(_("Remaining time:"), sizerLabels);
 215     }
 216     sizerTop->Add(sizerLabels, 0, wxALIGN_CENTER_HORIZONTAL | wxTOP, LAYOUT_MARGIN);
 217
 218     if ( nTimeLabels > 0 )
 219     {
 220         // set it to the current time
 221         m_timeStart = wxGetCurrentTime();
 222     }
 223
 224 #if defined(__SMARTPHONE__)
 225     if ( m_hasSkipButton )
 226         SetRightMenu(wxID_SKIP, _("Skip"));
 227     if ( m_hasAbortButton )
 228         SetLeftMenu(wxID_CANCEL);
 229 #else
 230     m_btnAbort =
 231     m_btnSkip = NULL;
 232
 233     wxBoxSizer *buttonSizer = new wxBoxSizer(wxHORIZONTAL);
 234
 235     // Windows dialogs usually have buttons in the lower right corner
 236     const int sizerFlags =
 237 #if defined(__WXMSW__) || defined(__WXPM__)
 238                            wxALIGN_RIGHT | wxALL
 239 #else // !MSW
 240                            wxALIGN_CENTER_HORIZONTAL | wxBOTTOM | wxTOP
 241 #endif // MSW/!MSW
 242                            ;
 243
 244     if ( m_hasSkipButton )
 245     {
 246         m_btnSkip = new wxButton(this, wxID_SKIP, _("&Skip"));
 247
 248         buttonSizer->Add(m_btnSkip, 0, sizerFlags, LAYOUT_MARGIN);
 249     }
 250
 251     if ( m_hasAbortButton )
 252     {
 253         m_btnAbort = new wxButton(this, wxID_CANCEL);
 254
 255         buttonSizer->Add(m_btnAbort, 0, sizerFlags, LAYOUT_MARGIN);
 256     }
 257
 258     sizerTop->Add(buttonSizer, 0, sizerFlags, LAYOUT_MARGIN );
 259 #endif // __SMARTPHONE__/!__SMARTPHONE__
 260
 261     SetSizerAndFit(sizerTop);
 262
 263     Centre(wxCENTER_FRAME | wxBOTH);
 264
 265     if ( style & wxPD_APP_MODAL )
 266     {
 267         m_winDisabler = new wxWindowDisabler(this);
 268     }
 269     else
 270     {
 271         if ( m_parentTop )
 272             m_parentTop->Disable();
 273         m_winDisabler = NULL;
 274     }
 275
 276     Show();
 277     Enable();
 278
 279     // this one can be initialized even if the others are unknown for now
 280     //
 281     // NB: do it after calling Layout() to keep the labels correctly aligned
 282     if ( m_elapsed )
 283     {
 284         SetTimeLabel(0, m_elapsed);
 285     }
 286
 287     Update();
 288 }
 289
 290 wxStaticText *
 291 wxProgressDialog::CreateLabel(const wxString& text, wxSizer *sizer)
 292 {
 293     wxStaticText *label = new wxStaticText(this, wxID_ANY, text);
 294     wxStaticText *value = new wxStaticText(this, wxID_ANY, _("unknown"));
 295
 296     // select placement most native or nice on target GUI
 297 #if defined(__SMARTPHONE__)
 298     // value and time to the left in two rows
 299     sizer->Add(label, 1, wxALIGN_LEFT);
 300     sizer->Add(value, 1, wxALIGN_LEFT);
 301 #elif defined(__WXMSW__) || defined(__WXPM__) || defined(__WXMAC__) || defined(__WXGTK20__)
 302     // value and time centered in one row
 303     sizer->Add(label, 1, wxLARGESMALL(wxALIGN_RIGHT,wxALIGN_LEFT) | wxTOP | wxRIGHT, LAYOUT_MARGIN);
 304     sizer->Add(value, 1, wxALIGN_LEFT | wxTOP, LAYOUT_MARGIN);
 305 #else
 306     // value and time to the right in one row
 307     sizer->Add(label);
 308     sizer->Add(value, 0, wxLEFT, LAYOUT_MARGIN);
 309 #endif
 310
 311     return value;
 312 }
 313
 314 // ----------------------------------------------------------------------------
 315 // wxProgressDialog operations
 316 // ----------------------------------------------------------------------------
 317
 318 bool
 319 wxProgressDialog::Update(int value, const wxString& newmsg, bool *skip)
 320 {
 321     wxASSERT_MSG( value == -1 || m_gauge, wxT("cannot update non existent dialog") );
 322
 323 #ifdef __WXMSW__
 324     value /= m_factor;
 325 #endif // __WXMSW__
 326
 327     wxASSERT_MSG( value <= m_maximum, wxT("invalid progress value") );
 328
 329     if ( m_gauge )
 330         m_gauge->SetValue(value);
 331
 332     UpdateMessage(newmsg);
 333
 334     if ( (m_elapsed || m_remaining || m_estimated) && (value != 0) )
 335     {
 336         unsigned long elapsed = wxGetCurrentTime() - m_timeStart;
 337         if (    m_last_timeupdate < elapsed
 338              || value == m_maximum
 339            )
 340         {
 341             m_last_timeupdate = elapsed;
 342             unsigned long estimated = m_break +
 343                   (unsigned long)(( (double) (elapsed-m_break) * m_maximum ) / ((double)value)) ;
 344             if (    estimated > m_display_estimated
 345                  && m_ctdelay >= 0
 346                )
 347             {
 348                 ++m_ctdelay;
 349             }
 350             else if (    estimated < m_display_estimated
 351                       && m_ctdelay <= 0
 352                     )
 353             {
 354                 --m_ctdelay;
 355             }
 356             else
 357             {
 358                 m_ctdelay = 0;
 359             }
 360             if (    m_ctdelay >= m_delay          // enough confirmations for a higher value
 361                  || m_ctdelay <= (m_delay*-1)     // enough confirmations for a lower value
 362                  || value == m_maximum            // to stay consistent
 363                  || elapsed > m_display_estimated // to stay consistent
 364                  || ( elapsed > 0 && elapsed < 4 ) // additional updates in the beginning
 365                )
 366             {
 367                 m_display_estimated = estimated;
 368                 m_ctdelay = 0;
 369             }
 370         }
 371
 372         long display_remaining = m_display_estimated - elapsed;
 373         if ( display_remaining < 0 )
 374         {
 375             display_remaining = 0;
 376         }
 377
 378         SetTimeLabel(elapsed, m_elapsed);
 379         SetTimeLabel(m_display_estimated, m_estimated);
 380         SetTimeLabel(display_remaining, m_remaining);
 381     }
 382
 383     if ( value == m_maximum )
 384     {
 385         if ( m_state == Finished )
 386         {
 387             // ignore multiple calls to Update(m_maximum): it may sometimes be
 388             // troublesome to ensure that Update() is not called twice with the
 389             // same value (e.g. because of the rounding errors) and if we don't
 390             // return now we're going to generate asserts below
 391             return true;
 392         }
 393
 394         // so that we return true below and that out [Cancel] handler knew what
 395         // to do
 396         m_state = Finished;
 397         if( !(GetWindowStyle() & wxPD_AUTO_HIDE) )
 398         {
 399             EnableClose();
 400             DisableSkip();
 401 #if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
 402             EnableCloseButton();
 403 #endif // __WXMSW__
 404
 405             if ( newmsg.empty() )
 406             {
 407                 // also provide the finishing message if the application didn't
 408                 m_msg->SetLabel(_("Done."));
 409             }
 410
 411             wxYieldIfNeeded() ;
 412
 413             (void)ShowModal();
 414         }
 415         else // auto hide
 416         {
 417             // reenable other windows before hiding this one because otherwise
 418             // Windows wouldn't give the focus back to the window which had
 419             // been previously focused because it would still be disabled
 420             ReenableOtherWindows();
 421
 422             Hide();
 423         }
 424     }
 425     else // not at maximum yet
 426     {
 427         return DoAfterUpdate(skip);
 428     }
 429
 430     // update the display in case yielding above didn't do it
 431     Update();
 432
 433     return m_state != Canceled;
 434 }
 435
 436 bool wxProgressDialog::Pulse(const wxString& newmsg, bool *skip)
 437 {
 438     wxASSERT_MSG( m_gauge, wxT("cannot update non existent dialog") );
 439
 440     // show a bit of progress
 441     m_gauge->Pulse();
 442
 443     UpdateMessage(newmsg);
 444
 445     if (m_elapsed || m_remaining || m_estimated)
 446     {
 447         unsigned long elapsed = wxGetCurrentTime() - m_timeStart;
 448
 449         SetTimeLabel(elapsed, m_elapsed);
 450         SetTimeLabel((unsigned long)-1, m_estimated);
 451         SetTimeLabel((unsigned long)-1, m_remaining);
 452     }
 453
 454     return DoAfterUpdate(skip);
 455 }
 456
 457 bool wxProgressDialog::DoAfterUpdate(bool *skip)
 458 {
 459     // we have to yield because not only we want to update the display but
 460     // also to process the clicks on the cancel and skip buttons
 461     wxYieldIfNeeded();
 462
 463     Update();
 464
 465     if ( m_skip && skip && !*skip )
 466     {
 467         *skip = true;
 468         m_skip = false;
 469         EnableSkip();
 470     }
 471
 472     return m_state != Canceled;
 473 }
 474
 475 void wxProgressDialog::Resume()
 476 {
 477     m_state = Continue;
 478     m_ctdelay = m_delay; // force an update of the elapsed/estimated/remaining time
 479     m_break += wxGetCurrentTime()-m_timeStop;
 480
 481     EnableAbort();
 482     EnableSkip();
 483     m_skip = false;
 484 }
 485
 486 bool wxProgressDialog::Show( bool show )
 487 {
 488     // reenable other windows before hiding this one because otherwise
 489     // Windows wouldn't give the focus back to the window which had
 490     // been previously focused because it would still be disabled
 491     if(!show)
 492         ReenableOtherWindows();
 493
 494     return wxDialog::Show(show);
 495 }
 496
 497 // ----------------------------------------------------------------------------
 498 // event handlers
 499 // ----------------------------------------------------------------------------
 500
 501 void wxProgressDialog::OnCancel(wxCommandEvent& event)
 502 {
 503     if ( m_state == Finished )
 504     {
 505         // this means that the count down is already finished and we're being
 506         // shown as a modal dialog - so just let the default handler do the job
 507         event.Skip();
 508     }
 509     else
 510     {
 511         // request to cancel was received, the next time Update() is called we
 512         // will handle it
 513         m_state = Canceled;
 514
 515         // update the buttons state immediately so that the user knows that the
 516         // request has been noticed
 517         DisableAbort();
 518         DisableSkip();
 519
 520         // save the time when the dialog was stopped
 521         m_timeStop = wxGetCurrentTime();
 522     }
 523 }
 524
 525 void wxProgressDialog::OnSkip(wxCommandEvent& WXUNUSED(event))
 526 {
 527     DisableSkip();
 528     m_skip = true;
 529 }
 530
 531 void wxProgressDialog::OnClose(wxCloseEvent& event)
 532 {
 533     if ( m_state == Uncancelable )
 534     {
 535         // can't close this dialog
 536         event.Veto();
 537     }
 538     else if ( m_state == Finished )
 539     {
 540         // let the default handler close the window as we already terminated
 541         event.Skip();
 542     }
 543     else
 544     {
 545         // next Update() will notice it
 546         m_state = Canceled;
 547         DisableAbort();
 548         DisableSkip();
 549
 550         m_timeStop = wxGetCurrentTime();
 551     }
 552 }
 553
 554 // ----------------------------------------------------------------------------
 555 // destruction
 556 // ----------------------------------------------------------------------------
 557
 558 wxProgressDialog::~wxProgressDialog()
 559 {
 560     // normally this should have been already done, but just in case
 561     ReenableOtherWindows();
 562 }
 563
 564 void wxProgressDialog::ReenableOtherWindows()
 565 {
 566     if ( GetWindowStyle() & wxPD_APP_MODAL )
 567     {
 568         delete m_winDisabler;
 569         m_winDisabler = (wxWindowDisabler *)NULL;
 570     }
 571     else
 572     {
 573         if ( m_parentTop )
 574             m_parentTop->Enable();
 575     }
 576 }
 577
 578 // ----------------------------------------------------------------------------
 579 // private functions
 580 // ----------------------------------------------------------------------------
 581
 582 static void SetTimeLabel(unsigned long val, wxStaticText *label)
 583 {
 584     if ( label )
 585     {
 586         wxString s;
 587
 588         if (val != (unsigned long)-1)
 589         {
 590         unsigned long hours = val / 3600;
 591         unsigned long minutes = (val % 3600) / 60;
 592         unsigned long seconds = val % 60;
 593         s.Printf(wxT("%lu:%02lu:%02lu"), hours, minutes, seconds);
 594         }
 595         else
 596         {
 597             s = _("Unknown");
 598         }
 599
 600         if ( s != label->GetLabel() )
 601             label->SetLabel(s);
 602     }
 603 }
 604
 605 void wxProgressDialog::EnableSkip(bool enable)
 606 {
 607     if(m_hasSkipButton)
 608     {
 609 #ifdef __SMARTPHONE__
 610         if(enable)
 611             SetRightMenu(wxID_SKIP, _("Skip"));
 612         else
 613             SetRightMenu();
 614 #else
 615         if(m_btnSkip)
 616             m_btnSkip->Enable(enable);
 617 #endif
 618     }
 619 }
 620
 621 void wxProgressDialog::EnableAbort(bool enable)
 622 {
 623     if(m_hasAbortButton)
 624     {
 625 #ifdef __SMARTPHONE__
 626         if(enable)
 627             SetLeftMenu(wxID_CANCEL); // stock buttons makes Cancel label
 628         else
 629             SetLeftMenu();
 630 #else
 631         if(m_btnAbort)
 632             m_btnAbort->Enable(enable);
 633 #endif
 634     }
 635 }
 636
 637 void wxProgressDialog::EnableClose()
 638 {
 639     if(m_hasAbortButton)
 640     {
 641 #ifdef __SMARTPHONE__
 642         SetLeftMenu(wxID_CANCEL, _("Close"));
 643 #else
 644         if(m_btnAbort)
 645         {
 646             m_btnAbort->Enable();
 647             m_btnAbort->SetLabel(_("Close"));
 648         }
 649 #endif
 650     }
 651 }
 652
 653 void wxProgressDialog::UpdateMessage(const wxString &newmsg)
 654 {
 655     if ( !newmsg.empty() && newmsg != m_msg->GetLabel() )
 656     {
 657         m_msg->SetLabel(newmsg);
 658
 659         wxYieldIfNeeded() ;
 660     }
 661 }
 662
 663 #endif // wxUSE_PROGRESSDLG