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