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