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