src/generic/wizard.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 // RCS-ID:      $Id$
  12 // Copyright:   (c) 1999 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
  13 // Licence:     wxWindows licence
  14 ///////////////////////////////////////////////////////////////////////////////
  15
  16 // ============================================================================
  17 // declarations
  18 // ============================================================================
  19
  20 // ----------------------------------------------------------------------------
  21 // headers
  22 // ----------------------------------------------------------------------------
  23
  24 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  25     #pragma implementation "wizardg.h"
  26 #endif
  27
  28 // For compilers that support precompilation, includes "wx.h".
  29 #include "wx/wxprec.h"
  30
  31 #ifdef __BORLANDC__
  32     #pragma hdrstop
  33 #endif
  34
  35 #if wxUSE_WIZARDDLG
  36
  37 #ifndef WX_PRECOMP
  38     #include "wx/dynarray.h"
  39     #include "wx/intl.h"
  40     #include "wx/statbmp.h"
  41     #include "wx/button.h"
  42 #endif //WX_PRECOMP
  43
  44 #include "wx/statline.h"
  45 #include "wx/sizer.h"
  46
  47 #include "wx/wizard.h"
  48
  49 // ----------------------------------------------------------------------------
  50 // wxWizardSizer
  51 // ----------------------------------------------------------------------------
  52
  53 class wxWizardSizer : public wxSizer
  54 {
  55 public:
  56     wxWizardSizer(wxWizard *owner);
  57
  58     void RecalcSizes();
  59     wxSize CalcMin();
  60
  61     wxSize GetMaxChildSize();
  62     int Border() const;
  63
  64 private:
  65     wxSize SiblingSize(wxSizerItem *child);
  66
  67     wxWizard *m_owner;
  68     bool m_childSizeValid;
  69     wxSize m_childSize;
  70 };
  71
  72 // ----------------------------------------------------------------------------
  73 // event tables and such
  74 // ----------------------------------------------------------------------------
  75
  76 DEFINE_EVENT_TYPE(wxEVT_WIZARD_PAGE_CHANGED)
  77 DEFINE_EVENT_TYPE(wxEVT_WIZARD_PAGE_CHANGING)
  78 DEFINE_EVENT_TYPE(wxEVT_WIZARD_CANCEL)
  79 DEFINE_EVENT_TYPE(wxEVT_WIZARD_FINISHED)
  80 DEFINE_EVENT_TYPE(wxEVT_WIZARD_HELP)
  81
  82 BEGIN_EVENT_TABLE(wxWizard, wxDialog)
  83     EVT_BUTTON(wxID_CANCEL, wxWizard::OnCancel)
  84     EVT_BUTTON(wxID_BACKWARD, wxWizard::OnBackOrNext)
  85     EVT_BUTTON(wxID_FORWARD, wxWizard::OnBackOrNext)
  86     EVT_BUTTON(wxID_HELP, wxWizard::OnHelp)
  87
  88     EVT_WIZARD_PAGE_CHANGED(wxID_ANY, wxWizard::OnWizEvent)
  89     EVT_WIZARD_PAGE_CHANGING(wxID_ANY, wxWizard::OnWizEvent)
  90     EVT_WIZARD_CANCEL(wxID_ANY, wxWizard::OnWizEvent)
  91     EVT_WIZARD_FINISHED(wxID_ANY, wxWizard::OnWizEvent)
  92     EVT_WIZARD_HELP(wxID_ANY, wxWizard::OnWizEvent)
  93 END_EVENT_TABLE()
  94
  95 IMPLEMENT_DYNAMIC_CLASS(wxWizard, wxDialog)
  96
  97 /*
  98     TODO PROPERTIES :
  99     wxWizard
 100         extstyle
 101         title
 102 */
 103
 104 IMPLEMENT_ABSTRACT_CLASS(wxWizardPage, wxPanel)
 105 IMPLEMENT_DYNAMIC_CLASS(wxWizardPageSimple, wxWizardPage)
 106 IMPLEMENT_DYNAMIC_CLASS(wxWizardEvent, wxNotifyEvent)
 107
 108 // ============================================================================
 109 // implementation
 110 // ============================================================================
 111
 112 // ----------------------------------------------------------------------------
 113 // wxWizardPage
 114 // ----------------------------------------------------------------------------
 115
 116 void wxWizardPage::Init()
 117 {
 118     m_bitmap = wxNullBitmap;
 119 }
 120
 121 wxWizardPage::wxWizardPage(wxWizard *parent,
 122                            const wxBitmap& bitmap,
 123                            const wxChar *resource)
 124 {
 125     Create(parent, bitmap, resource);
 126 }
 127
 128 bool wxWizardPage::Create(wxWizard *parent,
 129                           const wxBitmap& bitmap,
 130                           const wxChar *resource)
 131 {
 132     if ( !wxPanel::Create(parent, wxID_ANY) )
 133         return false;
 134
 135     if ( resource != NULL )
 136     {
 137 #if wxUSE_WX_RESOURCES
 138 #if 0
 139        if ( !LoadFromResource(this, resource) )
 140         {
 141             wxFAIL_MSG(wxT("wxWizardPage LoadFromResource failed!!!!"));
 142         }
 143 #endif
 144 #endif // wxUSE_RESOURCES
 145     }
 146
 147     m_bitmap = bitmap;
 148
 149     // initially the page is hidden, it's shown only when it becomes current
 150     Hide();
 151
 152     return true;
 153 }
 154
 155 // ----------------------------------------------------------------------------
 156 // wxWizardPageSimple
 157 // ----------------------------------------------------------------------------
 158
 159 wxWizardPage *wxWizardPageSimple::GetPrev() const
 160 {
 161     return m_prev;
 162 }
 163
 164 wxWizardPage *wxWizardPageSimple::GetNext() const
 165 {
 166     return m_next;
 167 }
 168
 169 // ----------------------------------------------------------------------------
 170 // wxWizardSizer
 171 // ----------------------------------------------------------------------------
 172
 173 wxWizardSizer::wxWizardSizer(wxWizard *owner)
 174     : m_owner(owner)
 175 {
 176     m_childSizeValid = false;
 177 }
 178
 179 void wxWizardSizer::RecalcSizes()
 180 {
 181     // Effect of this function depends on m_owner->m_page and
 182     // it should be called whenever it changes (wxWizard::ShowPage)
 183     if ( m_owner->m_page )
 184     {
 185         m_owner->m_page->SetSize(m_position.x,m_position.y, m_size.x,m_size.y);
 186     }
 187 }
 188
 189 wxSize wxWizardSizer::CalcMin()
 190 {
 191     return m_owner->GetPageSize();
 192 }
 193
 194 wxSize wxWizardSizer::GetMaxChildSize()
 195 {
 196 #if !defined(__WXDEBUG__)
 197     if ( m_childSizeValid )
 198         return m_childSize;
 199 #endif
 200
 201     wxSize maxOfMin;
 202     wxSizerItemList::compatibility_iterator childNode;
 203
 204     for(childNode = m_children.GetFirst(); childNode;
 205         childNode = childNode->GetNext())
 206     {
 207         wxSizerItem *child = childNode->GetData();
 208         maxOfMin.IncTo(child->CalcMin());
 209         maxOfMin.IncTo(SiblingSize(child));
 210     }
 211
 212 #ifdef __WXDEBUG__
 213     if ( m_childSizeValid && m_childSize != maxOfMin )
 214     {
 215         wxFAIL_MSG( _T("Size changed in wxWizard::GetPageAreaSizer()")
 216                     _T("after RunWizard().\n")
 217                     _T("Did you forget to call GetSizer()->Fit(this) ")
 218                     _T("for some page?")) ;
 219
 220         return m_childSize;
 221     }
 222 #endif // __WXDEBUG__
 223
 224     if ( m_owner->m_started )
 225     {
 226         m_childSizeValid = true;
 227         m_childSize = maxOfMin;
 228     }
 229
 230     return maxOfMin;
 231 }
 232
 233 int wxWizardSizer::Border() const
 234 {
 235     if ( m_owner->m_calledSetBorder )
 236         return m_owner->m_border;
 237
 238     return m_children.IsEmpty() ? 5 : 0;
 239 }
 240
 241 wxSize wxWizardSizer::SiblingSize(wxSizerItem *child)
 242 {
 243     wxSize maxSibling;
 244
 245     if ( child->IsWindow() )
 246     {
 247         wxWizardPage *page = wxDynamicCast(child->GetWindow(), wxWizardPage);
 248         if ( page )
 249         {
 250             for ( wxWizardPage *sibling = page->GetNext();
 251                   sibling;
 252                   sibling = sibling->GetNext() )
 253             {
 254                 if ( sibling->GetSizer() )
 255                 {
 256                     maxSibling.IncTo(sibling->GetSizer()->CalcMin());
 257                 }
 258             }
 259         }
 260     }
 261
 262     return maxSibling;
 263 }
 264
 265 // ----------------------------------------------------------------------------
 266 // generic wxWizard implementation
 267 // ----------------------------------------------------------------------------
 268
 269 void wxWizard::Init()
 270 {
 271     m_posWizard = wxDefaultPosition;
 272     m_page = (wxWizardPage *)NULL;
 273     m_btnPrev = m_btnNext = NULL;
 274     m_statbmp = NULL;
 275     m_sizerBmpAndPage = NULL;
 276     m_sizerPage = NULL;
 277     m_calledSetBorder = false;
 278     m_border = 0;
 279     m_started = false;
 280 }
 281
 282 bool wxWizard::Create(wxWindow *parent,
 283                       int id,
 284                       const wxString& title,
 285                       const wxBitmap& bitmap,
 286                       const wxPoint& pos,
 287                       long style)
 288 {
 289     bool result = wxDialog::Create(parent,id,title,pos,wxDefaultSize,style);
 290
 291     m_posWizard = pos;
 292     m_bitmap = bitmap ;
 293
 294     DoCreateControls();
 295
 296     return result;
 297 }
 298
 299 void wxWizard::AddBitmapRow(wxBoxSizer *mainColumn)
 300 {
 301     m_sizerBmpAndPage = new wxBoxSizer(wxHORIZONTAL);
 302     mainColumn->Add(
 303         m_sizerBmpAndPage,
 304         1, // Vertically stretchable
 305         wxEXPAND // Horizonal stretching, no border
 306     );
 307     mainColumn->Add(0,5,
 308         0, // No vertical stretching
 309         wxEXPAND // No border, (mostly useless) horizontal stretching
 310     );
 311
 312 #if wxUSE_STATBMP
 313     if ( m_bitmap.Ok() )
 314     {
 315         m_statbmp = new wxStaticBitmap(this, wxID_ANY, m_bitmap);
 316         m_sizerBmpAndPage->Add(
 317             m_statbmp,
 318             0, // No horizontal stretching
 319             wxALL, // Border all around, top alignment
 320             5 // Border width
 321         );
 322         m_sizerBmpAndPage->Add(
 323             5,0,
 324             0, // No horizontal stretching
 325             wxEXPAND // No border, (mostly useless) vertical stretching
 326         );
 327     }
 328 #endif
 329
 330     // Added to m_sizerBmpAndPage in FinishLayout
 331     m_sizerPage = new wxWizardSizer(this);
 332 }
 333
 334 void wxWizard::AddStaticLine(wxBoxSizer *mainColumn)
 335 {
 336 #if wxUSE_STATLINE
 337     mainColumn->Add(
 338         new wxStaticLine(this, wxID_ANY),
 339         0, // Vertically unstretchable
 340         wxEXPAND | wxALL, // Border all around, horizontally stretchable
 341         5 // Border width
 342     );
 343     mainColumn->Add(0,5,
 344         0, // No vertical stretching
 345         wxEXPAND // No border, (mostly useless) horizontal stretching
 346     );
 347 #else
 348     (void)mainColumn;
 349 #endif // wxUSE_STATLINE
 350 }
 351
 352 void wxWizard::AddBackNextPair(wxBoxSizer *buttonRow)
 353 {
 354     wxASSERT_MSG( m_btnNext && m_btnPrev,
 355                   _T("You must create the buttons before calling ")
 356                   _T("wxWizard::AddBackNextPair") );
 357
 358     // margin between Back and Next buttons
 359 #ifdef __WXMAC__
 360     static const int BACKNEXT_MARGIN = 10;
 361 #else
 362     static const int BACKNEXT_MARGIN = 0;
 363 #endif
 364
 365     wxBoxSizer *backNextPair = new wxBoxSizer(wxHORIZONTAL);
 366     buttonRow->Add(
 367         backNextPair,
 368         0, // No horizontal stretching
 369         wxALL, // Border all around
 370         5 // Border width
 371     );
 372
 373     backNextPair->Add(m_btnPrev);
 374     backNextPair->Add(BACKNEXT_MARGIN,0,
 375         0, // No horizontal stretching
 376         wxEXPAND // No border, (mostly useless) vertical stretching
 377     );
 378     backNextPair->Add(m_btnNext);
 379 }
 380
 381 void wxWizard::AddButtonRow(wxBoxSizer *mainColumn)
 382 {
 383     // the order in which the buttons are created determines the TAB order - at least under MSWindows...
 384     // although the 'back' button appears before the 'next' button, a more userfriendly tab order is
 385     // to activate the 'next' button first (create the next button before the back button).
 386     // The reason is: The user will repeatedly enter information in the wizard pages and then wants to
 387     // press 'next'. If a user uses mostly the keyboard, he would have to skip the 'back' button
 388     // everytime. This is annoying. There is a second reason: RETURN acts as TAB. If the 'next'
 389     // button comes first in the TAB order, the user can enter information very fast using the RETURN
 390     // key to TAB to the next entry field and page. This would not be possible, if the 'back' button
 391     // was created before the 'next' button.
 392
 393     wxBoxSizer *buttonRow = new wxBoxSizer(wxHORIZONTAL);
 394 #ifdef __WXMAC__
 395     if (GetExtraStyle() & wxWIZARD_EX_HELPBUTTON)
 396         mainColumn->Add(
 397             buttonRow,
 398             0, // Vertically unstretchable
 399             wxGROW|wxALIGN_CENTRE
 400             );
 401     else
 402 #endif
 403     mainColumn->Add(
 404         buttonRow,
 405         0, // Vertically unstretchable
 406         wxALIGN_RIGHT // Right aligned, no border
 407     );
 408
 409     // Desired TAB order is 'next', 'cancel', 'help', 'back'. This makes the 'back' button the last control on the page.
 410     // Create the buttons in the right order...
 411     wxButton *btnHelp=0;
 412 #ifdef __WXMAC__
 413     if (GetExtraStyle() & wxWIZARD_EX_HELPBUTTON)
 414         btnHelp=new wxButton(this, wxID_HELP, _("&Help"));
 415 #endif
 416
 417     m_btnNext = new wxButton(this, wxID_FORWARD, _("&Next >"));
 418     wxButton *btnCancel=new wxButton(this, wxID_CANCEL, _("&Cancel"));
 419 #ifndef __WXMAC__
 420     if (GetExtraStyle() & wxWIZARD_EX_HELPBUTTON)
 421         btnHelp=new wxButton(this, wxID_HELP, _("&Help"));
 422 #endif
 423     m_btnPrev = new wxButton(this, wxID_BACKWARD, _("< &Back"));
 424
 425     if (btnHelp)
 426     {
 427         buttonRow->Add(
 428             btnHelp,
 429             0, // Horizontally unstretchable
 430             wxALL, // Border all around, top aligned
 431             5 // Border width
 432             );
 433 #ifdef __WXMAC__
 434         // Put stretchable space between help button and others
 435         buttonRow->Add(0, 0, 1, wxALIGN_CENTRE, 0);
 436 #endif
 437     }
 438
 439     AddBackNextPair(buttonRow);
 440
 441     buttonRow->Add(
 442         btnCancel,
 443         0, // Horizontally unstretchable
 444         wxALL, // Border all around, top aligned
 445         5 // Border width
 446     );
 447 }
 448
 449 void wxWizard::DoCreateControls()
 450 {
 451     // do nothing if the controls were already created
 452     if ( WasCreated() )
 453         return;
 454
 455     // wxWindow::SetSizer will be called at end
 456     wxBoxSizer *windowSizer = new wxBoxSizer(wxVERTICAL);
 457
 458     wxBoxSizer *mainColumn = new wxBoxSizer(wxVERTICAL);
 459     windowSizer->Add(
 460         mainColumn,
 461         1, // Vertical stretching
 462         wxALL | wxEXPAND, // Border all around, horizontal stretching
 463         5 // Border width
 464     );
 465
 466     AddBitmapRow(mainColumn);
 467     AddStaticLine(mainColumn);
 468     AddButtonRow(mainColumn);
 469
 470     // wxWindow::SetSizer should be followed by wxWindow::Fit, but
 471     // this is done in FinishLayout anyway so why duplicate it
 472     SetSizer(windowSizer);
 473 }
 474
 475 void wxWizard::SetPageSize(const wxSize& size)
 476 {
 477     wxCHECK_RET(!m_started,wxT("wxWizard::SetPageSize after RunWizard"));
 478     m_sizePage = size;
 479 }
 480
 481 void wxWizard::FinishLayout()
 482 {
 483     m_sizerBmpAndPage->Add(
 484         m_sizerPage,
 485         1, // Horizontal stretching
 486         wxEXPAND | wxALL, // Vertically stretchable
 487         m_sizerPage->Border()
 488     );
 489
 490     GetSizer()->SetSizeHints(this);
 491     if ( m_posWizard == wxDefaultPosition )
 492         CentreOnScreen();
 493 }
 494
 495 void wxWizard::FitToPage(const wxWizardPage *page)
 496 {
 497     wxCHECK_RET(!m_started,wxT("wxWizard::FitToPage after RunWizard"));
 498
 499     while ( page )
 500     {
 501         wxSize size = page->GetBestSize();
 502
 503         m_sizePage.IncTo(size);
 504
 505         page = page->GetNext();
 506     }
 507 }
 508
 509 bool wxWizard::ShowPage(wxWizardPage *page, bool goingForward)
 510 {
 511     wxASSERT_MSG( page != m_page, wxT("this is useless") );
 512
 513     // we'll use this to decide whether we have to change the label of this
 514     // button or not (initially the label is "Next")
 515     bool btnLabelWasNext = true;
 516
 517     // Modified 10-20-2001 Robert Cavanaugh.
 518     // Fixed bug for displaying a new bitmap
 519     // in each *consecutive* page
 520
 521     // flag to indicate if this page uses a new bitmap
 522     bool bmpIsDefault = true;
 523
 524     // use these labels to determine if we need to change the bitmap
 525     // for this page
 526     wxBitmap bmpPrev, bmpCur;
 527
 528     // check for previous page
 529     if ( m_page )
 530     {
 531         // send the event to the old page
 532         wxWizardEvent event(wxEVT_WIZARD_PAGE_CHANGING, GetId(), goingForward, m_page);
 533         if ( m_page->GetEventHandler()->ProcessEvent(event) &&
 534              !event.IsAllowed() )
 535         {
 536             // vetoed by the page
 537             return false;
 538         }
 539
 540         m_page->Hide();
 541
 542         btnLabelWasNext = HasNextPage(m_page);
 543
 544         // Get the bitmap of the previous page (if it exists)
 545         if ( m_page->GetBitmap().Ok() )
 546         {
 547             bmpPrev = m_page->GetBitmap();
 548         }
 549     }
 550
 551     // set the new page
 552     m_page = page;
 553
 554     // is this the end?
 555     if ( !m_page )
 556     {
 557         // terminate successfully
 558         EndModal(wxID_OK);
 559
 560         // and notify the user code (this is especially useful for modeless
 561         // wizards)
 562         wxWizardEvent event(wxEVT_WIZARD_FINISHED, GetId(), false, 0);
 563         (void)GetEventHandler()->ProcessEvent(event);
 564
 565         return true;
 566     }
 567
 568     // position and show the new page
 569     (void)m_page->TransferDataToWindow();
 570
 571     // wxWizardSizer::RecalcSizes wants to be called when m_page changes
 572     m_sizerPage->RecalcSizes();
 573
 574     // check if bitmap needs to be updated
 575     // update default flag as well
 576     if ( m_page->GetBitmap().Ok() )
 577     {
 578         bmpCur = m_page->GetBitmap();
 579         bmpIsDefault = false;
 580     }
 581
 582 #if wxUSE_STATBMP
 583     // change the bitmap if:
 584     // 1) a default bitmap was selected in constructor
 585     // 2) this page was constructed with a bitmap
 586     // 3) this bitmap is not the previous bitmap
 587     if ( m_statbmp && (bmpCur != bmpPrev) )
 588     {
 589         wxBitmap bmp;
 590         if ( bmpIsDefault )
 591             bmp = m_bitmap;
 592         else
 593             bmp = m_page->GetBitmap();
 594         m_statbmp->SetBitmap(bmp);
 595     }
 596 #endif
 597
 598     // and update the buttons state
 599     m_btnPrev->Enable(HasPrevPage(m_page));
 600
 601     bool hasNext = HasNextPage(m_page);
 602     if ( btnLabelWasNext != hasNext )
 603     {
 604         // need to update
 605         if (btnLabelWasNext)
 606             m_btnNext->SetLabel(_("&Finish"));
 607         else
 608             m_btnNext->SetLabel(_("&Next >"));
 609     }
 610     m_btnNext->SetDefault();
 611     // nothing to do: the label was already correct
 612
 613     // send the change event to the new page now
 614     wxWizardEvent event(wxEVT_WIZARD_PAGE_CHANGED, GetId(), goingForward, m_page);
 615     (void)m_page->GetEventHandler()->ProcessEvent(event);
 616
 617     // and finally show it
 618     m_page->Show();
 619     m_page->SetFocus();
 620
 621     return true;
 622 }
 623
 624 bool wxWizard::RunWizard(wxWizardPage *firstPage)
 625 {
 626     wxCHECK_MSG( firstPage, false, wxT("can't run empty wizard") );
 627
 628     // Set before FinishLayout to enable wxWizardSizer::GetMaxChildSize
 629     m_started = true;
 630
 631     // This cannot be done sooner, because user can change layout options
 632     // up to this moment
 633     FinishLayout();
 634
 635     // can't return false here because there is no old page
 636     (void)ShowPage(firstPage, true /* forward */);
 637
 638     return ShowModal() == wxID_OK;
 639 }
 640
 641 wxWizardPage *wxWizard::GetCurrentPage() const
 642 {
 643     return m_page;
 644 }
 645
 646 wxSize wxWizard::GetPageSize() const
 647 {
 648     wxSize pageSize(GetManualPageSize());
 649     pageSize.IncTo(m_sizerPage->GetMaxChildSize());
 650     return pageSize;
 651 }
 652
 653 wxSizer *wxWizard::GetPageAreaSizer() const
 654 {
 655     return m_sizerPage;
 656 }
 657
 658 void wxWizard::SetBorder(int border)
 659 {
 660     wxCHECK_RET(!m_started,wxT("wxWizard::SetBorder after RunWizard"));
 661
 662     m_calledSetBorder = true;
 663     m_border = border;
 664 }
 665
 666 wxSize wxWizard::GetManualPageSize() const
 667 {
 668     // default width and height of the page
 669     static const int DEFAULT_PAGE_WIDTH = 270;
 670     static const int DEFAULT_PAGE_HEIGHT = 290;
 671
 672     wxSize totalPageSize(DEFAULT_PAGE_WIDTH,DEFAULT_PAGE_HEIGHT);
 673
 674     totalPageSize.IncTo(m_sizePage);
 675
 676     if ( m_statbmp )
 677     {
 678         totalPageSize.IncTo(wxSize(0, m_bitmap.GetHeight()));
 679     }
 680
 681     return totalPageSize;
 682 }
 683
 684 void wxWizard::OnCancel(wxCommandEvent& WXUNUSED(eventUnused))
 685 {
 686     // this function probably can never be called when we don't have an active
 687     // page, but a small extra check won't hurt
 688     wxWindow *win = m_page ? (wxWindow *)m_page : (wxWindow *)this;
 689
 690     wxWizardEvent event(wxEVT_WIZARD_CANCEL, GetId(), false, m_page);
 691     if ( !win->GetEventHandler()->ProcessEvent(event) || event.IsAllowed() )
 692     {
 693         // no objections - close the dialog
 694         EndModal(wxID_CANCEL);
 695     }
 696     //else: request to Cancel ignored
 697 }
 698
 699 void wxWizard::OnBackOrNext(wxCommandEvent& event)
 700 {
 701     wxASSERT_MSG( (event.GetEventObject() == m_btnNext) ||
 702                   (event.GetEventObject() == m_btnPrev),
 703                   wxT("unknown button") );
 704
 705     // ask the current page first: notice that we do it before calling
 706     // GetNext/Prev() because the data transfered from the controls of the page
 707     // may change the value returned by these methods
 708     if ( m_page && (!m_page->Validate() || !m_page->TransferDataFromWindow()) )
 709     {
 710         // the page data is incorrect, don't do anything
 711         return;
 712     }
 713
 714     bool forward = event.GetEventObject() == m_btnNext;
 715
 716     wxWizardPage *page;
 717     if ( forward )
 718     {
 719         page = m_page->GetNext();
 720     }
 721     else // back
 722     {
 723         page = m_page->GetPrev();
 724
 725         wxASSERT_MSG( page, wxT("\"<Back\" button should have been disabled") );
 726     }
 727
 728     // just pass to the new page (or may be not - but we don't care here)
 729     (void)ShowPage(page, forward);
 730 }
 731
 732 void wxWizard::OnHelp(wxCommandEvent& WXUNUSED(event))
 733 {
 734     // this function probably can never be called when we don't have an active
 735     // page, but a small extra check won't hurt
 736     if(m_page != NULL)
 737     {
 738         // Create and send the help event to the specific page handler
 739         // event data contains the active page so that context-sensitive
 740         // help is possible
 741         wxWizardEvent eventHelp(wxEVT_WIZARD_HELP, GetId(), true, m_page);
 742         (void)m_page->GetEventHandler()->ProcessEvent(eventHelp);
 743     }
 744 }
 745
 746 void wxWizard::OnWizEvent(wxWizardEvent& event)
 747 {
 748     // the dialogs have wxWS_EX_BLOCK_EVENTS style on by default but we want to
 749     // propagate wxEVT_WIZARD_XXX to the parent (if any), so do it manually
 750     if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS) )
 751     {
 752         // the event will be propagated anyhow
 753         event.Skip();
 754         return;
 755     }
 756
 757     wxWindow *parent = GetParent();
 758
 759     if ( !parent || !parent->GetEventHandler()->ProcessEvent(event) )
 760     {
 761         event.Skip();
 762     }
 763 }
 764
 765 // ----------------------------------------------------------------------------
 766 // our public interface
 767 // ----------------------------------------------------------------------------
 768
 769 #if WXWIN_COMPATIBILITY_2_2
 770
 771 /* static */
 772 wxWizard *wxWizardBase::Create(wxWindow *parent,
 773                                int id,
 774                                const wxString& title,
 775                                const wxBitmap& bitmap,
 776                                const wxPoint& pos,
 777                                const wxSize& WXUNUSED(size))
 778 {
 779     return new wxWizard(parent, id, title, bitmap, pos);
 780 }
 781
 782 #endif // WXWIN_COMPATIBILITY_2_2
 783
 784 // ----------------------------------------------------------------------------
 785 // wxWizardEvent
 786 // ----------------------------------------------------------------------------
 787
 788 wxWizardEvent::wxWizardEvent(wxEventType type, int id, bool direction, wxWizardPage* page)
 789              : wxNotifyEvent(type, id)
 790 {
 791     // Modified 10-20-2001 Robert Cavanaugh
 792     // add the active page to the event data
 793     m_direction = direction;
 794     m_page = page;
 795 }
 796
 797 #endif // wxUSE_WIZARDDLG