src/generic/wizard.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/generic/wizard.cpp
   3 // Purpose:     generic implementation of wxWizard class
   4 // Author:      Vadim Zeitlin
   5 // Modified by: Robert Cavanaugh
   6 //              1) Added capability for wxWizardPage to accept resources
   7 //              2) Added "Help" button handler stub
   8 //              3) Fixed ShowPage() bug on displaying bitmaps
   9 //              Robert Vazan (sizers)
  10 // Created:     15.08.99
  11 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  12 // Licence:     wxWindows licence
  13 ///////////////////////////////////////////////////////////////////////////////
  14
  15 // ============================================================================
  16 // declarations
  17 // ============================================================================
  18
  19 // ----------------------------------------------------------------------------
  20 // headers
  21 // ----------------------------------------------------------------------------
  22
  23 // For compilers that support precompilation, includes "wx.h".
  24 #include "wx/wxprec.h"
  25
  26 #ifdef __BORLANDC__
  27     #pragma hdrstop
  28 #endif
  29
  30 #if wxUSE_WIZARDDLG
  31
  32 #ifndef WX_PRECOMP
  33     #include "wx/dynarray.h"
  34     #include "wx/intl.h"
  35     #include "wx/statbmp.h"
  36     #include "wx/button.h"
  37     #include "wx/settings.h"
  38     #include "wx/sizer.h"
  39 #endif //WX_PRECOMP
  40
  41 #include "wx/statline.h"
  42
  43 #include "wx/scrolwin.h"
  44 #include "wx/wizard.h"
  45 #include "wx/dcmemory.h"
  46
  47 // ----------------------------------------------------------------------------
  48 // wxWizardSizer
  49 // ----------------------------------------------------------------------------
  50
  51 class wxWizardSizer : public wxSizer
  52 {
  53 public:
  54     wxWizardSizer(wxWizard *owner);
  55
  56     virtual wxSizerItem *Insert(size_t index, wxSizerItem *item);
  57
  58     virtual void RecalcSizes();
  59     virtual wxSize CalcMin();
  60
  61     // get the max size of all wizard pages
  62     wxSize GetMaxChildSize();
  63
  64     // return the border which can be either set using wxWizard::SetBorder() or
  65     // have default value
  66     int GetBorder() const;
  67
  68     // hide the pages which we temporarily "show" when they're added to this
  69     // sizer (see Insert())
  70     void HidePages();
  71
  72 private:
  73     wxSize SiblingSize(wxSizerItem *child);
  74
  75     wxWizard *m_owner;
  76     wxSize m_childSize;
  77 };
  78
  79 // ----------------------------------------------------------------------------
  80 // event tables and such
  81 // ----------------------------------------------------------------------------
  82
  83 wxDEFINE_EVENT( wxEVT_WIZARD_PAGE_CHANGED, wxWizardEvent );
  84 wxDEFINE_EVENT( wxEVT_WIZARD_PAGE_CHANGING, wxWizardEvent );
  85 wxDEFINE_EVENT( wxEVT_WIZARD_BEFORE_PAGE_CHANGED, wxWizardEvent );
  86 wxDEFINE_EVENT( wxEVT_WIZARD_CANCEL, wxWizardEvent );
  87 wxDEFINE_EVENT( wxEVT_WIZARD_FINISHED, wxWizardEvent );
  88 wxDEFINE_EVENT( wxEVT_WIZARD_HELP, wxWizardEvent );
  89 wxDEFINE_EVENT( wxEVT_WIZARD_PAGE_SHOWN, wxWizardEvent );
  90
  91 BEGIN_EVENT_TABLE(wxWizard, wxDialog)
  92     EVT_BUTTON(wxID_CANCEL, wxWizard::OnCancel)
  93     EVT_BUTTON(wxID_BACKWARD, wxWizard::OnBackOrNext)
  94     EVT_BUTTON(wxID_FORWARD, wxWizard::OnBackOrNext)
  95     EVT_BUTTON(wxID_HELP, wxWizard::OnHelp)
  96
  97     EVT_WIZARD_PAGE_CHANGED(wxID_ANY, wxWizard::OnWizEvent)
  98     EVT_WIZARD_PAGE_CHANGING(wxID_ANY, wxWizard::OnWizEvent)
  99     EVT_WIZARD_CANCEL(wxID_ANY, wxWizard::OnWizEvent)
 100     EVT_WIZARD_FINISHED(wxID_ANY, wxWizard::OnWizEvent)
 101     EVT_WIZARD_HELP(wxID_ANY, wxWizard::OnWizEvent)
 102 END_EVENT_TABLE()
 103
 104 IMPLEMENT_DYNAMIC_CLASS(wxWizard, wxDialog)
 105
 106 /*
 107     TODO PROPERTIES :
 108     wxWizard
 109         extstyle
 110         title
 111 */
 112
 113 IMPLEMENT_ABSTRACT_CLASS(wxWizardPage, wxPanel)
 114 IMPLEMENT_DYNAMIC_CLASS(wxWizardPageSimple, wxWizardPage)
 115 IMPLEMENT_DYNAMIC_CLASS(wxWizardEvent, wxNotifyEvent)
 116
 117 // ============================================================================
 118 // implementation
 119 // ============================================================================
 120
 121 // ----------------------------------------------------------------------------
 122 // wxWizardPage
 123 // ----------------------------------------------------------------------------
 124
 125 void wxWizardPage::Init()
 126 {
 127     m_bitmap = wxNullBitmap;
 128 }
 129
 130 wxWizardPage::wxWizardPage(wxWizard *parent,
 131                            const wxBitmap& bitmap)
 132 {
 133     Create(parent, bitmap);
 134 }
 135
 136 bool wxWizardPage::Create(wxWizard *parent,
 137                           const wxBitmap& bitmap)
 138 {
 139     if ( !wxPanel::Create(parent, wxID_ANY) )
 140         return false;
 141
 142     m_bitmap = bitmap;
 143
 144     // initially the page is hidden, it's shown only when it becomes current
 145     Hide();
 146
 147     return true;
 148 }
 149
 150 // ----------------------------------------------------------------------------
 151 // wxWizardPageSimple
 152 // ----------------------------------------------------------------------------
 153
 154 wxWizardPage *wxWizardPageSimple::GetPrev() const
 155 {
 156     return m_prev;
 157 }
 158
 159 wxWizardPage *wxWizardPageSimple::GetNext() const
 160 {
 161     return m_next;
 162 }
 163
 164 // ----------------------------------------------------------------------------
 165 // wxWizardSizer
 166 // ----------------------------------------------------------------------------
 167
 168 wxWizardSizer::wxWizardSizer(wxWizard *owner)
 169              : m_owner(owner),
 170                m_childSize(wxDefaultSize)
 171 {
 172 }
 173
 174 wxSizerItem *wxWizardSizer::Insert(size_t index, wxSizerItem *item)
 175 {
 176     m_owner->m_usingSizer = true;
 177
 178     if ( item->IsWindow() )
 179     {
 180         // we must pretend that the window is shown as otherwise it wouldn't be
 181         // taken into account for the layout -- but avoid really showing it, so
 182         // just set the internal flag instead of calling wxWindow::Show()
 183         item->GetWindow()->wxWindowBase::Show();
 184     }
 185
 186     return wxSizer::Insert(index, item);
 187 }
 188
 189 void wxWizardSizer::HidePages()
 190 {
 191     for ( wxSizerItemList::compatibility_iterator node = GetChildren().GetFirst();
 192           node;
 193           node = node->GetNext() )
 194     {
 195         wxSizerItem * const item = node->GetData();
 196         if ( item->IsWindow() )
 197             item->GetWindow()->wxWindowBase::Show(false);
 198     }
 199 }
 200
 201 void wxWizardSizer::RecalcSizes()
 202 {
 203     // Effect of this function depends on m_owner->m_page and
 204     // it should be called whenever it changes (wxWizard::ShowPage)
 205     if ( m_owner->m_page )
 206     {
 207         m_owner->m_page->SetSize(wxRect(m_position, m_size));
 208     }
 209 }
 210
 211 wxSize wxWizardSizer::CalcMin()
 212 {
 213     return m_owner->GetPageSize();
 214 }
 215
 216 wxSize wxWizardSizer::GetMaxChildSize()
 217 {
 218     wxSize maxOfMin;
 219
 220     for ( wxSizerItemList::compatibility_iterator childNode = m_children.GetFirst();
 221           childNode;
 222           childNode = childNode->GetNext() )
 223     {
 224         wxSizerItem *child = childNode->GetData();
 225         maxOfMin.IncTo(child->CalcMin());
 226         maxOfMin.IncTo(SiblingSize(child));
 227     }
 228
 229     if ( m_owner->m_started )
 230     {
 231         m_childSize = maxOfMin;
 232     }
 233
 234     return maxOfMin;
 235 }
 236
 237 int wxWizardSizer::GetBorder() const
 238 {
 239     return m_owner->m_border;
 240 }
 241
 242 wxSize wxWizardSizer::SiblingSize(wxSizerItem *child)
 243 {
 244     wxSize maxSibling;
 245
 246     if ( child->IsWindow() )
 247     {
 248         wxWizardPage *page = wxDynamicCast(child->GetWindow(), wxWizardPage);
 249         if ( page )
 250         {
 251             for ( wxWizardPage *sibling = page->GetNext();
 252                   sibling;
 253                   sibling = sibling->GetNext() )
 254             {
 255                 if ( sibling->GetSizer() )
 256                 {
 257                     maxSibling.IncTo(sibling->GetSizer()->CalcMin());
 258                 }
 259             }
 260         }
 261     }
 262
 263     return maxSibling;
 264 }
 265
 266 // ----------------------------------------------------------------------------
 267 // generic wxWizard implementation
 268 // ----------------------------------------------------------------------------
 269
 270 void wxWizard::Init()
 271 {
 272     m_posWizard = wxDefaultPosition;
 273     m_page = NULL;
 274     m_btnPrev = m_btnNext = NULL;
 275     m_statbmp = NULL;
 276     m_sizerBmpAndPage = NULL;
 277     m_sizerPage = NULL;
 278     m_border = 5;
 279     m_started = false;
 280     m_wasModal = false;
 281     m_usingSizer = false;
 282     m_bitmapBackgroundColour = *wxWHITE;
 283     m_bitmapPlacement = 0;
 284     m_bitmapMinimumWidth = 115;
 285 }
 286
 287 bool wxWizard::Create(wxWindow *parent,
 288                       int id,
 289                       const wxString& title,
 290                       const wxBitmap& bitmap,
 291                       const wxPoint& pos,
 292                       long style)
 293 {
 294     bool result = wxDialog::Create(parent,id,title,pos,wxDefaultSize,style);
 295
 296     m_posWizard = pos;
 297     m_bitmap = bitmap ;
 298
 299     DoCreateControls();
 300
 301     return result;
 302 }
 303
 304 wxWizard::~wxWizard()
 305 {
 306     // normally we don't have to delete this sizer as it's deleted by the
 307     // associated window but if we never used it or didn't set it as the window
 308     // sizer yet, do delete it manually
 309     if ( !m_usingSizer || !m_started )
 310         delete m_sizerPage;
 311 }
 312
 313 void wxWizard::AddBitmapRow(wxBoxSizer *mainColumn)
 314 {
 315     m_sizerBmpAndPage = new wxBoxSizer(wxHORIZONTAL);
 316     mainColumn->Add(
 317         m_sizerBmpAndPage,
 318         1, // Vertically stretchable
 319         wxEXPAND // Horizontal stretching, no border
 320     );
 321     mainColumn->Add(0,5,
 322         0, // No vertical stretching
 323         wxEXPAND // No border, (mostly useless) horizontal stretching
 324     );
 325
 326 #if wxUSE_STATBMP
 327     if ( m_bitmap.IsOk() )
 328     {
 329         wxSize bitmapSize(wxDefaultSize);
 330         if (GetBitmapPlacement())
 331             bitmapSize.x = GetMinimumBitmapWidth();
 332
 333         m_statbmp = new wxStaticBitmap(this, wxID_ANY, m_bitmap, wxDefaultPosition, bitmapSize);
 334         m_sizerBmpAndPage->Add(
 335             m_statbmp,
 336             0, // No horizontal stretching
 337             wxALL, // Border all around, top alignment
 338             5 // Border width
 339         );
 340         m_sizerBmpAndPage->Add(
 341             5,0,
 342             0, // No horizontal stretching
 343             wxEXPAND // No border, (mostly useless) vertical stretching
 344         );
 345     }
 346 #endif
 347
 348     // Added to m_sizerBmpAndPage later
 349     m_sizerPage = new wxWizardSizer(this);
 350 }
 351
 352 void wxWizard::AddStaticLine(wxBoxSizer *mainColumn)
 353 {
 354 #if wxUSE_STATLINE
 355     mainColumn->Add(
 356         new wxStaticLine(this, wxID_ANY),
 357         0, // Vertically unstretchable
 358         wxEXPAND | wxALL, // Border all around, horizontally stretchable
 359         5 // Border width
 360     );
 361     mainColumn->Add(0,5,
 362         0, // No vertical stretching
 363         wxEXPAND // No border, (mostly useless) horizontal stretching
 364     );
 365 #else
 366     (void)mainColumn;
 367 #endif // wxUSE_STATLINE
 368 }
 369
 370 void wxWizard::AddBackNextPair(wxBoxSizer *buttonRow)
 371 {
 372     wxASSERT_MSG( m_btnNext && m_btnPrev,
 373                   wxT("You must create the buttons before calling ")
 374                   wxT("wxWizard::AddBackNextPair") );
 375
 376     wxBoxSizer *backNextPair = new wxBoxSizer(wxHORIZONTAL);
 377     buttonRow->Add(
 378         backNextPair,
 379         0, // No horizontal stretching
 380         wxALL, // Border all around
 381         5 // Border width
 382     );
 383
 384     backNextPair->Add(m_btnPrev);
 385     backNextPair->Add(10, 0,
 386         0, // No horizontal stretching
 387         wxEXPAND // No border, (mostly useless) vertical stretching
 388     );
 389     backNextPair->Add(m_btnNext);
 390 }
 391
 392 void wxWizard::AddButtonRow(wxBoxSizer *mainColumn)
 393 {
 394     // the order in which the buttons are created determines the TAB order - at least under MSWindows...
 395     // although the 'back' button appears before the 'next' button, a more userfriendly tab order is
 396     // to activate the 'next' button first (create the next button before the back button).
 397     // The reason is: The user will repeatedly enter information in the wizard pages and then wants to
 398     // press 'next'. If a user uses mostly the keyboard, he would have to skip the 'back' button
 399     // every time. This is annoying. There is a second reason: RETURN acts as TAB. If the 'next'
 400     // button comes first in the TAB order, the user can enter information very fast using the RETURN
 401     // key to TAB to the next entry field and page. This would not be possible, if the 'back' button
 402     // was created before the 'next' button.
 403
 404     bool isPda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
 405     int buttonStyle = isPda ? wxBU_EXACTFIT : 0;
 406
 407     wxBoxSizer *buttonRow = new wxBoxSizer(wxHORIZONTAL);
 408 #ifdef __WXMAC__
 409     if (GetExtraStyle() & wxWIZARD_EX_HELPBUTTON)
 410         mainColumn->Add(
 411             buttonRow,
 412             0, // Vertically unstretchable
 413             wxGROW|wxALIGN_CENTRE
 414             );
 415     else
 416 #endif
 417     mainColumn->Add(
 418         buttonRow,
 419         0, // Vertically unstretchable
 420         wxALIGN_RIGHT // Right aligned, no border
 421     );
 422
 423     // Desired TAB order is 'next', 'cancel', 'help', 'back'. This makes the 'back' button the last control on the page.
 424     // Create the buttons in the right order...
 425     wxButton *btnHelp=0;
 426 #ifdef __WXMAC__
 427     if (GetExtraStyle() & wxWIZARD_EX_HELPBUTTON)
 428         btnHelp=new wxButton(this, wxID_HELP, wxEmptyString, wxDefaultPosition, wxDefaultSize, buttonStyle);
 429 #endif
 430
 431     m_btnNext = new wxButton(this, wxID_FORWARD, _("&Next >"));
 432     wxButton *btnCancel=new wxButton(this, wxID_CANCEL, _("&Cancel"), wxDefaultPosition, wxDefaultSize, buttonStyle);
 433 #ifndef __WXMAC__
 434     if (GetExtraStyle() & wxWIZARD_EX_HELPBUTTON)
 435         btnHelp=new wxButton(this, wxID_HELP, _("&Help"), wxDefaultPosition, wxDefaultSize, buttonStyle);
 436 #endif
 437     m_btnPrev = new wxButton(this, wxID_BACKWARD, _("< &Back"), wxDefaultPosition, wxDefaultSize, buttonStyle);
 438
 439     if (btnHelp)
 440     {
 441         buttonRow->Add(
 442             btnHelp,
 443             0, // Horizontally unstretchable
 444             wxALL, // Border all around, top aligned
 445             5 // Border width
 446             );
 447 #ifdef __WXMAC__
 448         // Put stretchable space between help button and others
 449         buttonRow->Add(0, 0, 1, wxALIGN_CENTRE, 0);
 450 #endif
 451     }
 452
 453     AddBackNextPair(buttonRow);
 454
 455     buttonRow->Add(
 456         btnCancel,
 457         0, // Horizontally unstretchable
 458         wxALL, // Border all around, top aligned
 459         5 // Border width
 460     );
 461 }
 462
 463 void wxWizard::DoCreateControls()
 464 {
 465     // do nothing if the controls were already created
 466     if ( WasCreated() )
 467         return;
 468
 469     bool isPda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);
 470
 471     // Horizontal stretching, and if not PDA, border all around
 472     int mainColumnSizerFlags = isPda ? wxEXPAND : wxALL|wxEXPAND ;
 473
 474     // wxWindow::SetSizer will be called at end
 475     wxBoxSizer *windowSizer = new wxBoxSizer(wxVERTICAL);
 476
 477     wxBoxSizer *mainColumn = new wxBoxSizer(wxVERTICAL);
 478     windowSizer->Add(
 479         mainColumn,
 480         1, // Vertical stretching
 481         mainColumnSizerFlags,
 482         5 // Border width
 483     );
 484
 485     AddBitmapRow(mainColumn);
 486
 487     if (!isPda)
 488         AddStaticLine(mainColumn);
 489
 490     AddButtonRow(mainColumn);
 491
 492     SetSizer(windowSizer);
 493 }
 494
 495 void wxWizard::SetPageSize(const wxSize& size)
 496 {
 497     wxCHECK_RET(!m_started, wxT("wxWizard::SetPageSize after RunWizard"));
 498     m_sizePage = size;
 499 }
 500
 501 void wxWizard::FitToPage(const wxWizardPage *page)
 502 {
 503     wxCHECK_RET(!m_started, wxT("wxWizard::FitToPage after RunWizard"));
 504
 505     while ( page )
 506     {
 507         wxSize size = page->GetBestSize();
 508
 509         m_sizePage.IncTo(size);
 510
 511         page = page->GetNext();
 512     }
 513 }
 514
 515 bool wxWizard::ShowPage(wxWizardPage *page, bool goingForward)
 516 {
 517     wxASSERT_MSG( page != m_page, wxT("this is useless") );
 518
 519     wxSizerFlags flags(1);
 520     flags.Border(wxALL, m_border).Expand();
 521
 522     if ( !m_started )
 523     {
 524         if ( m_usingSizer )
 525         {
 526             m_sizerBmpAndPage->Add(m_sizerPage, flags);
 527
 528             // now that our layout is computed correctly, hide the pages
 529             // artificially shown in wxWizardSizer::Insert() back again
 530             m_sizerPage->HidePages();
 531         }
 532     }
 533
 534
 535     // remember the old bitmap (if any) to compare with the new one later
 536     wxBitmap bmpPrev;
 537
 538     // check for previous page
 539     if ( m_page )
 540     {
 541         // send the event to the old page
 542         wxWizardEvent event(wxEVT_WIZARD_PAGE_CHANGING, GetId(),
 543                             goingForward, m_page);
 544         if ( m_page->GetEventHandler()->ProcessEvent(event) &&
 545              !event.IsAllowed() )
 546         {
 547             // vetoed by the page
 548             return false;
 549         }
 550
 551         m_page->Hide();
 552
 553         bmpPrev = m_page->GetBitmap();
 554
 555         if ( !m_usingSizer )
 556             m_sizerBmpAndPage->Detach(m_page);
 557     }
 558
 559     // is this the end?
 560     if ( !page )
 561     {
 562         // terminate successfully
 563         if ( IsModal() )
 564         {
 565             EndModal(wxID_OK);
 566         }
 567         else
 568         {
 569             SetReturnCode(wxID_OK);
 570             Hide();
 571         }
 572
 573         // and notify the user code (this is especially useful for modeless
 574         // wizards)
 575         wxWizardEvent event(wxEVT_WIZARD_FINISHED, GetId(), false, m_page);
 576         (void)GetEventHandler()->ProcessEvent(event);
 577
 578         m_page = NULL;
 579
 580         return true;
 581     }
 582
 583     // notice that we change m_page only here so that wxEVT_WIZARD_FINISHED
 584     // event above could still use the correct (i.e. old) value of m_page
 585     m_page = page;
 586
 587     // position and show the new page
 588     (void)m_page->TransferDataToWindow();
 589
 590     if ( m_usingSizer )
 591     {
 592         // wxWizardSizer::RecalcSizes wants to be called when m_page changes
 593         m_sizerPage->RecalcSizes();
 594     }
 595     else // pages are not managed by the sizer
 596     {
 597         m_sizerBmpAndPage->Add(m_page, flags);
 598         m_sizerBmpAndPage->SetItemMinSize(m_page, GetPageSize());
 599     }
 600
 601 #if wxUSE_STATBMP
 602     // update the bitmap if:it changed
 603     wxBitmap bmp;
 604     if ( m_statbmp )
 605     {
 606         bmp = m_page->GetBitmap();
 607         if ( !bmp.IsOk() )
 608             bmp = m_bitmap;
 609
 610         if ( !bmpPrev.IsOk() )
 611             bmpPrev = m_bitmap;
 612
 613         if (!GetBitmapPlacement())
 614         {
 615             if ( !bmp.IsSameAs(bmpPrev) )
 616                 m_statbmp->SetBitmap(bmp);
 617         }
 618     }
 619 #endif // wxUSE_STATBMP
 620
 621
 622     // and update the buttons state
 623     m_btnPrev->Enable(HasPrevPage(m_page));
 624
 625     const bool hasNext = HasNextPage(m_page);
 626     const wxString label = hasNext ? _("&Next >") : _("&Finish");
 627     if ( label != m_btnNext->GetLabel() )
 628         m_btnNext->SetLabel(label);
 629
 630     m_btnNext->SetDefault();
 631
 632
 633     // send the change event to the new page now
 634     wxWizardEvent event(wxEVT_WIZARD_PAGE_CHANGED, GetId(), goingForward, m_page);
 635     (void)m_page->GetEventHandler()->ProcessEvent(event);
 636
 637     // and finally show it
 638     m_page->Show();
 639     m_page->SetFocus();
 640
 641     if ( !m_usingSizer )
 642         m_sizerBmpAndPage->Layout();
 643
 644     if ( !m_started )
 645     {
 646         m_started = true;
 647
 648         DoWizardLayout();
 649     }
 650
 651     if (GetBitmapPlacement() && m_statbmp)
 652     {
 653         ResizeBitmap(bmp);
 654
 655         if ( !bmp.IsSameAs(bmpPrev) )
 656             m_statbmp->SetBitmap(bmp);
 657
 658         if (m_usingSizer)
 659             m_sizerPage->RecalcSizes();
 660     }
 661
 662     wxWizardEvent pageShownEvent(wxEVT_WIZARD_PAGE_SHOWN, GetId(),
 663         goingForward, m_page);
 664     m_page->GetEventHandler()->ProcessEvent(pageShownEvent);
 665
 666     return true;
 667 }
 668
 669 /// Do fit, and adjust to screen size if necessary
 670 void wxWizard::DoWizardLayout()
 671 {
 672     if ( wxSystemSettings::GetScreenType() > wxSYS_SCREEN_PDA )
 673     {
 674         if (CanDoLayoutAdaptation())
 675             DoLayoutAdaptation();
 676         else
 677             GetSizer()->SetSizeHints(this);
 678
 679         if ( m_posWizard == wxDefaultPosition )
 680             CentreOnScreen();
 681     }
 682
 683     SetLayoutAdaptationDone(true);
 684 }
 685
 686 bool wxWizard::RunWizard(wxWizardPage *firstPage)
 687 {
 688     wxCHECK_MSG( firstPage, false, wxT("can't run empty wizard") );
 689
 690     // can't return false here because there is no old page
 691     (void)ShowPage(firstPage, true /* forward */);
 692
 693     m_wasModal = true;
 694
 695     return ShowModal() == wxID_OK;
 696 }
 697
 698 wxWizardPage *wxWizard::GetCurrentPage() const
 699 {
 700     return m_page;
 701 }
 702
 703 wxSize wxWizard::GetPageSize() const
 704 {
 705     // default width and height of the page
 706     int DEFAULT_PAGE_WIDTH,
 707         DEFAULT_PAGE_HEIGHT;
 708     if ( wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA )
 709     {
 710         // Make the default page size small enough to fit on screen
 711         DEFAULT_PAGE_WIDTH = wxSystemSettings::GetMetric(wxSYS_SCREEN_X) / 2;
 712         DEFAULT_PAGE_HEIGHT = wxSystemSettings::GetMetric(wxSYS_SCREEN_Y) / 2;
 713     }
 714     else // !PDA
 715     {
 716         DEFAULT_PAGE_WIDTH =
 717         DEFAULT_PAGE_HEIGHT = 270;
 718     }
 719
 720     // start with default minimal size
 721     wxSize pageSize(DEFAULT_PAGE_WIDTH, DEFAULT_PAGE_HEIGHT);
 722
 723     // make the page at least as big as specified by user
 724     pageSize.IncTo(m_sizePage);
 725
 726     if ( m_statbmp )
 727     {
 728         // make the page at least as tall as the bitmap
 729         pageSize.IncTo(wxSize(0, m_bitmap.GetHeight()));
 730     }
 731
 732     if ( m_usingSizer )
 733     {
 734         // make it big enough to contain all pages added to the sizer
 735         pageSize.IncTo(m_sizerPage->GetMaxChildSize());
 736     }
 737
 738     return pageSize;
 739 }
 740
 741 wxSizer *wxWizard::GetPageAreaSizer() const
 742 {
 743     return m_sizerPage;
 744 }
 745
 746 void wxWizard::SetBorder(int border)
 747 {
 748     wxCHECK_RET(!m_started, wxT("wxWizard::SetBorder after RunWizard"));
 749
 750     m_border = border;
 751 }
 752
 753 void wxWizard::OnCancel(wxCommandEvent& WXUNUSED(eventUnused))
 754 {
 755     // this function probably can never be called when we don't have an active
 756     // page, but a small extra check won't hurt
 757     wxWindow *win = m_page ? (wxWindow *)m_page : (wxWindow *)this;
 758
 759     wxWizardEvent event(wxEVT_WIZARD_CANCEL, GetId(), false, m_page);
 760     if ( !win->GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
 761     {
 762         // no objections - close the dialog
 763         if(IsModal())
 764         {
 765             EndModal(wxID_CANCEL);
 766         }
 767         else
 768         {
 769             SetReturnCode(wxID_CANCEL);
 770             Hide();
 771         }
 772     }
 773     //else: request to Cancel ignored
 774 }
 775
 776 void wxWizard::OnBackOrNext(wxCommandEvent& event)
 777 {
 778     wxASSERT_MSG( (event.GetEventObject() == m_btnNext) ||
 779                   (event.GetEventObject() == m_btnPrev),
 780                   wxT("unknown button") );
 781
 782     wxCHECK_RET( m_page, wxT("should have a valid current page") );
 783
 784     // ask the current page first: notice that we do it before calling
 785     // GetNext/Prev() because the data transferred from the controls of the page
 786     // may change the value returned by these methods
 787     if ( !m_page->Validate() || !m_page->TransferDataFromWindow() )
 788     {
 789         // the page data is incorrect, don't do anything
 790         return;
 791     }
 792
 793     bool forward = event.GetEventObject() == m_btnNext;
 794
 795     // Give the application a chance to set state which may influence GetNext()/GetPrev()
 796     wxWizardEvent eventPreChanged(wxEVT_WIZARD_BEFORE_PAGE_CHANGED, GetId(), forward, m_page);
 797     (void)m_page->GetEventHandler()->ProcessEvent(eventPreChanged);
 798
 799     if (!eventPreChanged.IsAllowed())
 800         return;
 801
 802     wxWizardPage *page;
 803     if ( forward )
 804     {
 805         page = m_page->GetNext();
 806     }
 807     else // back
 808     {
 809         page = m_page->GetPrev();
 810
 811         wxASSERT_MSG( page, wxT("\"<Back\" button should have been disabled") );
 812     }
 813
 814     // just pass to the new page (or maybe not - but we don't care here)
 815     (void)ShowPage(page, forward);
 816 }
 817
 818 void wxWizard::OnHelp(wxCommandEvent& WXUNUSED(event))
 819 {
 820     // this function probably can never be called when we don't have an active
 821     // page, but a small extra check won't hurt
 822     if(m_page != NULL)
 823     {
 824         // Create and send the help event to the specific page handler
 825         // event data contains the active page so that context-sensitive
 826         // help is possible
 827         wxWizardEvent eventHelp(wxEVT_WIZARD_HELP, GetId(), true, m_page);
 828         (void)m_page->GetEventHandler()->ProcessEvent(eventHelp);
 829     }
 830 }
 831
 832 void wxWizard::OnWizEvent(wxWizardEvent& event)
 833 {
 834     // the dialogs have wxWS_EX_BLOCK_EVENTS style on by default but we want to
 835     // propagate wxEVT_WIZARD_XXX to the parent (if any), so do it manually
 836     if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS) )
 837     {
 838         // the event will be propagated anyhow
 839         event.Skip();
 840     }
 841     else
 842     {
 843         wxWindow *parent = GetParent();
 844
 845         if ( !parent || !parent->GetEventHandler()->ProcessEvent(event) )
 846         {
 847             event.Skip();
 848         }
 849     }
 850
 851     if ( ( !m_wasModal ) &&
 852          event.IsAllowed() &&
 853          ( event.GetEventType() == wxEVT_WIZARD_FINISHED ||
 854            event.GetEventType() == wxEVT_WIZARD_CANCEL
 855          )
 856        )
 857     {
 858         Destroy();
 859     }
 860 }
 861
 862 void wxWizard::SetBitmap(const wxBitmap& bitmap)
 863 {
 864     m_bitmap = bitmap;
 865     if (m_statbmp)
 866         m_statbmp->SetBitmap(m_bitmap);
 867 }
 868
 869 // ----------------------------------------------------------------------------
 870 // wxWizardEvent
 871 // ----------------------------------------------------------------------------
 872
 873 wxWizardEvent::wxWizardEvent(wxEventType type, int id, bool direction, wxWizardPage* page)
 874              : wxNotifyEvent(type, id)
 875 {
 876     // Modified 10-20-2001 Robert Cavanaugh
 877     // add the active page to the event data
 878     m_direction = direction;
 879     m_page = page;
 880 }
 881
 882 /// Do the adaptation
 883 bool wxWizard::DoLayoutAdaptation()
 884 {
 885     wxWindowList windows;
 886     wxWindowList pages;
 887
 888     // Make all the pages (that use sizers) scrollable
 889     for ( wxSizerItemList::compatibility_iterator node = m_sizerPage->GetChildren().GetFirst(); node; node = node->GetNext() )
 890     {
 891         wxSizerItem * const item = node->GetData();
 892         if ( item->IsWindow() )
 893         {
 894             wxWizardPage* page = wxDynamicCast(item->GetWindow(), wxWizardPage);
 895             if (page)
 896             {
 897                 while (page)
 898                 {
 899                     if (!pages.Find(page) && page->GetSizer())
 900                     {
 901                         // Create a scrolled window and reparent
 902                         wxScrolledWindow* scrolledWindow = new wxScrolledWindow(page, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL|wxVSCROLL|wxHSCROLL|wxBORDER_NONE);
 903                         wxSizer* oldSizer = page->GetSizer();
 904
 905                         wxSizer* newSizer = new wxBoxSizer(wxVERTICAL);
 906                         newSizer->Add(scrolledWindow,1, wxEXPAND, 0);
 907
 908                         page->SetSizer(newSizer, false /* don't delete the old sizer */);
 909
 910                         scrolledWindow->SetSizer(oldSizer);
 911
 912                         wxStandardDialogLayoutAdapter::DoReparentControls(page, scrolledWindow);
 913
 914                         pages.Append(page);
 915                         windows.Append(scrolledWindow);
 916                     }
 917                     page = page->GetNext();
 918                 }
 919             }
 920         }
 921     }
 922
 923     wxStandardDialogLayoutAdapter::DoFitWithScrolling(this, windows);
 924
 925     // Size event doesn't get sent soon enough on wxGTK
 926     DoLayout();
 927
 928     SetLayoutAdaptationDone(true);
 929
 930     return true;
 931 }
 932
 933 bool wxWizard::ResizeBitmap(wxBitmap& bmp)
 934 {
 935     if (!GetBitmapPlacement())
 936         return false;
 937
 938     if (bmp.IsOk())
 939     {
 940         wxSize pageSize = m_sizerPage->GetSize();
 941         if (pageSize == wxSize(0,0))
 942             pageSize = GetPageSize();
 943         int bitmapWidth = wxMax(bmp.GetWidth(), GetMinimumBitmapWidth());
 944         int bitmapHeight = pageSize.y;
 945
 946         if (!m_statbmp->GetBitmap().IsOk() || m_statbmp->GetBitmap().GetHeight() != bitmapHeight)
 947         {
 948             wxBitmap bitmap(bitmapWidth, bitmapHeight);
 949             {
 950                 wxMemoryDC dc;
 951                 dc.SelectObject(bitmap);
 952                 dc.SetBackground(wxBrush(m_bitmapBackgroundColour));
 953                 dc.Clear();
 954
 955                 if (GetBitmapPlacement() & wxWIZARD_TILE)
 956                 {
 957                     TileBitmap(wxRect(0, 0, bitmapWidth, bitmapHeight), dc, bmp);
 958                 }
 959                 else
 960                 {
 961                     int x, y;
 962
 963                     if (GetBitmapPlacement() & wxWIZARD_HALIGN_LEFT)
 964                         x = 0;
 965                     else if (GetBitmapPlacement() & wxWIZARD_HALIGN_RIGHT)
 966                         x = bitmapWidth - bmp.GetWidth();
 967                     else
 968                         x = (bitmapWidth - bmp.GetWidth())/2;
 969
 970                     if (GetBitmapPlacement() & wxWIZARD_VALIGN_TOP)
 971                         y = 0;
 972                     else if (GetBitmapPlacement() & wxWIZARD_VALIGN_BOTTOM)
 973                         y = bitmapHeight - bmp.GetHeight();
 974                     else
 975                         y = (bitmapHeight - bmp.GetHeight())/2;
 976
 977                     dc.DrawBitmap(bmp, x, y, true);
 978                     dc.SelectObject(wxNullBitmap);
 979                 }
 980             }
 981
 982             bmp = bitmap;
 983         }
 984     }
 985
 986     return true;
 987 }
 988
 989 bool wxWizard::TileBitmap(const wxRect& rect, wxDC& dc, const wxBitmap& bitmap)
 990 {
 991     int w = bitmap.GetWidth();
 992     int h = bitmap.GetHeight();
 993
 994     wxMemoryDC dcMem;
 995
 996     dcMem.SelectObjectAsSource(bitmap);
 997
 998     int i, j;
 999     for (i = rect.x; i < rect.x + rect.width; i += w)
1000     {
1001         for (j = rect.y; j < rect.y + rect.height; j+= h)
1002             dc.Blit(i, j, bitmap.GetWidth(), bitmap.GetHeight(), & dcMem, 0, 0);
1003     }
1004     dcMem.SelectObject(wxNullBitmap);
1005
1006     return true;
1007 }
1008
1009 #endif // wxUSE_WIZARDDLG