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