]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/common/dlgcmn.cpp
Improve wxCheckListBox appearance under Vista/Win7.
[wxWidgets.git] / src / common / dlgcmn.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: src/common/dlgcmn.cpp
3// Purpose: common (to all ports) wxDialog functions
4// Author: Vadim Zeitlin
5// Modified by:
6// Created: 28.06.99
7// RCS-ID: $Id$
8// Copyright: (c) Vadim Zeitlin
9// Licence: wxWindows licence
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
24 #pragma hdrstop
25#endif
26
27#include "wx/dialog.h"
28
29#ifndef WX_PRECOMP
30 #include "wx/app.h"
31 #include "wx/button.h"
32 #include "wx/dcclient.h"
33 #include "wx/intl.h"
34 #include "wx/settings.h"
35 #include "wx/stattext.h"
36 #include "wx/sizer.h"
37 #include "wx/containr.h"
38#endif
39
40#include "wx/statline.h"
41#include "wx/sysopt.h"
42#include "wx/module.h"
43#include "wx/bookctrl.h"
44#include "wx/scrolwin.h"
45#include "wx/textwrapper.h"
46
47#if wxUSE_DISPLAY
48#include "wx/display.h"
49#endif
50
51// ----------------------------------------------------------------------------
52// wxDialogBase
53// ----------------------------------------------------------------------------
54
55BEGIN_EVENT_TABLE(wxDialogBase, wxTopLevelWindow)
56 EVT_BUTTON(wxID_ANY, wxDialogBase::OnButton)
57
58 EVT_CLOSE(wxDialogBase::OnCloseWindow)
59
60 EVT_CHAR_HOOK(wxDialogBase::OnCharHook)
61END_EVENT_TABLE()
62
63wxDialogLayoutAdapter* wxDialogBase::sm_layoutAdapter = NULL;
64bool wxDialogBase::sm_layoutAdaptation = false;
65
66void wxDialogBase::Init()
67{
68 m_returnCode = 0;
69 m_affirmativeId = wxID_OK;
70 m_escapeId = wxID_ANY;
71 m_layoutAdaptationLevel = 3;
72 m_layoutAdaptationDone = FALSE;
73 m_layoutAdaptationMode = wxDIALOG_ADAPTATION_MODE_DEFAULT;
74
75 // the dialogs have this flag on by default to prevent the events from the
76 // dialog controls from reaching the parent frame which is usually
77 // undesirable and can lead to unexpected and hard to find bugs
78 SetExtraStyle(GetExtraStyle() | wxWS_EX_BLOCK_EVENTS);
79}
80
81wxWindow *wxDialogBase::CheckIfCanBeUsedAsParent(wxWindow *parent) const
82{
83 if ( !parent )
84 return NULL;
85
86 extern WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete;
87 if ( wxPendingDelete.Member(parent) || parent->IsBeingDeleted() )
88 {
89 // this window is being deleted and we shouldn't create any children
90 // under it
91 return NULL;
92 }
93
94 if ( parent->HasExtraStyle(wxWS_EX_TRANSIENT) )
95 {
96 // this window is not being deleted yet but it's going to disappear
97 // soon so still don't parent this window under it
98 return NULL;
99 }
100
101 if ( !parent->IsShownOnScreen() )
102 {
103 // using hidden parent won't work correctly neither
104 return NULL;
105 }
106
107 // FIXME-VC6: this compiler requires an explicit const cast or it fails
108 // with error C2446
109 if ( const_cast<const wxWindow *>(parent) == this )
110 {
111 // not sure if this can really happen but it doesn't hurt to guard
112 // against this clearly invalid situation
113 return NULL;
114 }
115
116 return parent;
117}
118
119wxWindow *wxDialogBase::GetParentForModalDialog(wxWindow *parent) const
120{
121 // creating a parent-less modal dialog will result (under e.g. wxGTK2)
122 // in an unfocused dialog, so try to find a valid parent for it unless we
123 // were explicitly asked not to
124 if ( HasFlag(wxDIALOG_NO_PARENT) )
125 return NULL;
126
127 // first try the given parent
128 if ( parent )
129 parent = CheckIfCanBeUsedAsParent(wxGetTopLevelParent(parent));
130
131 // then the currently active window
132 if ( !parent )
133 parent = CheckIfCanBeUsedAsParent(
134 wxGetTopLevelParent(wxGetActiveWindow()));
135
136 // and finally the application main window
137 if ( !parent )
138 parent = CheckIfCanBeUsedAsParent(wxTheApp->GetTopWindow());
139
140 return parent;
141}
142
143#if wxUSE_STATTEXT
144
145class wxTextSizerWrapper : public wxTextWrapper
146{
147public:
148 wxTextSizerWrapper(wxWindow *win)
149 {
150 m_win = win;
151 m_hLine = 0;
152 }
153
154 wxSizer *CreateSizer(const wxString& text, int widthMax)
155 {
156 m_sizer = new wxBoxSizer(wxVERTICAL);
157 Wrap(m_win, text, widthMax);
158 return m_sizer;
159 }
160
161protected:
162 virtual void OnOutputLine(const wxString& line)
163 {
164 if ( !line.empty() )
165 {
166 m_sizer->Add(new wxStaticText(m_win, wxID_ANY, line));
167 }
168 else // empty line, no need to create a control for it
169 {
170 if ( !m_hLine )
171 m_hLine = m_win->GetCharHeight();
172
173 m_sizer->Add(5, m_hLine);
174 }
175 }
176
177private:
178 wxWindow *m_win;
179 wxSizer *m_sizer;
180 int m_hLine;
181};
182
183wxSizer *wxDialogBase::CreateTextSizer(const wxString& message)
184{
185 // I admit that this is complete bogus, but it makes
186 // message boxes work for pda screens temporarily..
187 int widthMax = -1;
188 const bool is_pda = wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA;
189 if (is_pda)
190 {
191 widthMax = wxSystemSettings::GetMetric( wxSYS_SCREEN_X ) - 25;
192 }
193
194 // '&' is used as accel mnemonic prefix in the wxWidgets controls but in
195 // the static messages created by CreateTextSizer() (used by wxMessageBox,
196 // for example), we don't want this special meaning, so we need to quote it
197 wxString text(message);
198 text.Replace(wxT("&"), wxT("&&"));
199
200 wxTextSizerWrapper wrapper(this);
201
202 return wrapper.CreateSizer(text, widthMax);
203}
204
205#endif // wxUSE_STATTEXT
206
207wxSizer *wxDialogBase::CreateButtonSizer(long flags)
208{
209#ifdef __SMARTPHONE__
210 wxDialog* dialog = (wxDialog*) this;
211 if ( flags & wxOK )
212 dialog->SetLeftMenu(wxID_OK);
213
214 if ( flags & wxCANCEL )
215 dialog->SetRightMenu(wxID_CANCEL);
216
217 if ( flags & wxYES )
218 dialog->SetLeftMenu(wxID_YES);
219
220 if ( flags & wxNO )
221 dialog->SetRightMenu(wxID_NO);
222
223 return NULL;
224#else // !__SMARTPHONE__
225
226#if wxUSE_BUTTON
227
228#ifdef __POCKETPC__
229 // PocketPC guidelines recommend for Ok/Cancel dialogs to use OK button
230 // located inside caption bar and implement Cancel functionality through
231 // Undo outside dialog. As native behaviour this will be default here but
232 // can be replaced with real wxButtons by setting the option below to 1
233 if ( (flags & ~(wxCANCEL|wxNO_DEFAULT)) != wxOK ||
234 wxSystemOptions::GetOptionInt(wxT("wince.dialog.real-ok-cancel")) )
235#endif // __POCKETPC__
236 {
237 return CreateStdDialogButtonSizer(flags);
238 }
239#ifdef __POCKETPC__
240 return NULL;
241#endif // __POCKETPC__
242
243#else // !wxUSE_BUTTON
244 wxUnusedVar(flags);
245
246 return NULL;
247#endif // wxUSE_BUTTON/!wxUSE_BUTTON
248
249#endif // __SMARTPHONE__/!__SMARTPHONE__
250}
251
252wxSizer *wxDialogBase::CreateSeparatedButtonSizer(long flags)
253{
254 wxSizer *sizer = CreateButtonSizer(flags);
255 if ( !sizer )
256 return NULL;
257
258 // Mac Human Interface Guidelines recommend not to use static lines as
259 // grouping elements
260#if wxUSE_STATLINE && !defined(__WXMAC__)
261 wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);
262 topsizer->Add(new wxStaticLine(this),
263 wxSizerFlags().Expand().DoubleBorder(wxBOTTOM));
264 topsizer->Add(sizer, wxSizerFlags().Expand());
265 sizer = topsizer;
266#endif // wxUSE_STATLINE
267
268 return sizer;
269}
270
271#if wxUSE_BUTTON
272
273wxStdDialogButtonSizer *wxDialogBase::CreateStdDialogButtonSizer( long flags )
274{
275 wxStdDialogButtonSizer *sizer = new wxStdDialogButtonSizer();
276
277 wxButton *ok = NULL;
278 wxButton *yes = NULL;
279 wxButton *no = NULL;
280
281 if (flags & wxOK)
282 {
283 ok = new wxButton(this, wxID_OK);
284 sizer->AddButton(ok);
285 }
286
287 if (flags & wxCANCEL)
288 {
289 wxButton *cancel = new wxButton(this, wxID_CANCEL);
290 sizer->AddButton(cancel);
291 }
292
293 if (flags & wxYES)
294 {
295 yes = new wxButton(this, wxID_YES);
296 sizer->AddButton(yes);
297 }
298
299 if (flags & wxNO)
300 {
301 no = new wxButton(this, wxID_NO);
302 sizer->AddButton(no);
303 }
304
305 if (flags & wxAPPLY)
306 {
307 wxButton *apply = new wxButton(this, wxID_APPLY);
308 sizer->AddButton(apply);
309 }
310
311 if (flags & wxCLOSE)
312 {
313 wxButton *close = new wxButton(this, wxID_CLOSE);
314 sizer->AddButton(close);
315 }
316
317 if (flags & wxHELP)
318 {
319 wxButton *help = new wxButton(this, wxID_HELP);
320 sizer->AddButton(help);
321 }
322
323 if (flags & wxNO_DEFAULT)
324 {
325 if (no)
326 {
327 no->SetDefault();
328 no->SetFocus();
329 }
330 }
331 else
332 {
333 if (ok)
334 {
335 ok->SetDefault();
336 ok->SetFocus();
337 }
338 else if (yes)
339 {
340 yes->SetDefault();
341 yes->SetFocus();
342 }
343 }
344
345 if (flags & wxOK)
346 SetAffirmativeId(wxID_OK);
347 else if (flags & wxYES)
348 SetAffirmativeId(wxID_YES);
349
350 sizer->Realize();
351
352 return sizer;
353}
354
355#endif // wxUSE_BUTTON
356
357// ----------------------------------------------------------------------------
358// standard buttons handling
359// ----------------------------------------------------------------------------
360
361void wxDialogBase::EndDialog(int rc)
362{
363 if ( IsModal() )
364 EndModal(rc);
365 else
366 Hide();
367}
368
369void wxDialogBase::AcceptAndClose()
370{
371 if ( Validate() && TransferDataFromWindow() )
372 {
373 EndDialog(m_affirmativeId);
374 }
375}
376
377void wxDialogBase::SetAffirmativeId(int affirmativeId)
378{
379 m_affirmativeId = affirmativeId;
380}
381
382void wxDialogBase::SetEscapeId(int escapeId)
383{
384 m_escapeId = escapeId;
385}
386
387bool wxDialogBase::EmulateButtonClickIfPresent(int id)
388{
389#if wxUSE_BUTTON
390 wxButton *btn = wxDynamicCast(FindWindow(id), wxButton);
391
392 if ( !btn || !btn->IsEnabled() || !btn->IsShown() )
393 return false;
394
395 wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, id);
396 event.SetEventObject(btn);
397 btn->GetEventHandler()->ProcessEvent(event);
398
399 return true;
400#else // !wxUSE_BUTTON
401 wxUnusedVar(id);
402 return false;
403#endif // wxUSE_BUTTON/!wxUSE_BUTTON
404}
405
406bool wxDialogBase::IsEscapeKey(const wxKeyEvent& event)
407{
408 // for most platforms, Esc key is used to close the dialogs
409 return event.GetKeyCode() == WXK_ESCAPE &&
410 event.GetModifiers() == wxMOD_NONE;
411}
412
413void wxDialogBase::OnCharHook(wxKeyEvent& event)
414{
415 if ( event.GetKeyCode() == WXK_ESCAPE )
416 {
417 int idCancel = GetEscapeId();
418 switch ( idCancel )
419 {
420 case wxID_NONE:
421 // don't handle Esc specially at all
422 break;
423
424 case wxID_ANY:
425 // this value is special: it means translate Esc to wxID_CANCEL
426 // but if there is no such button, then fall back to wxID_OK
427 if ( EmulateButtonClickIfPresent(wxID_CANCEL) )
428 return;
429 idCancel = GetAffirmativeId();
430 // fall through
431
432 default:
433 // translate Esc to button press for the button with given id
434 if ( EmulateButtonClickIfPresent(idCancel) )
435 return;
436 }
437 }
438
439 event.Skip();
440}
441
442void wxDialogBase::OnButton(wxCommandEvent& event)
443{
444 const int id = event.GetId();
445 if ( id == GetAffirmativeId() )
446 {
447 AcceptAndClose();
448 }
449 else if ( id == wxID_APPLY )
450 {
451 if ( Validate() )
452 TransferDataFromWindow();
453
454 // TODO: disable the Apply button until things change again
455 }
456 else if ( id == GetEscapeId() ||
457 (id == wxID_CANCEL && GetEscapeId() == wxID_ANY) )
458 {
459 EndDialog(wxID_CANCEL);
460 }
461 else // not a standard button
462 {
463 event.Skip();
464 }
465}
466
467// ----------------------------------------------------------------------------
468// compatibility methods for supporting the modality API
469// ----------------------------------------------------------------------------
470
471wxDEFINE_EVENT( wxEVT_WINDOW_MODAL_DIALOG_CLOSED , wxWindowModalDialogEvent );
472
473IMPLEMENT_DYNAMIC_CLASS(wxWindowModalDialogEvent, wxCommandEvent)
474
475bool wxDialogBase::ShowWindowModal ()
476{
477 ShowModal();
478 SendWindowModalDialogEvent ( wxEVT_WINDOW_MODAL_DIALOG_CLOSED );
479 return true;
480}
481
482void wxDialogBase::SendWindowModalDialogEvent ( wxEventType type )
483{
484 wxCommandEvent event ( type, GetId());
485 event.SetEventObject(this);
486
487 if ( !GetEventHandler()->ProcessEvent(event) )
488 {
489 // the event is not propagated upwards to the parent automatically
490 // because the dialog is a top level window, so do it manually as
491 // in 9 cases of 10 the message must be processed by the dialog
492 // owner and not the dialog itself
493 (void)GetParent()->GetEventHandler()->ProcessEvent(event);
494 }
495}
496
497
498wxDialogModality wxDialogBase::GetModality() const
499{
500 return IsModal() ? wxDIALOG_MODALITY_APP_MODAL : wxDIALOG_MODALITY_NONE;
501}
502
503// ----------------------------------------------------------------------------
504// other event handlers
505// ----------------------------------------------------------------------------
506
507void wxDialogBase::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
508{
509 // We'll send a Cancel message by default, which may close the dialog.
510 // Check for looping if the Cancel event handler calls Close().
511
512 // Note that if a cancel button and handler aren't present in the dialog,
513 // nothing will happen when you close the dialog via the window manager, or
514 // via Close(). We wouldn't want to destroy the dialog by default, since
515 // the dialog may have been created on the stack. However, this does mean
516 // that calling dialog->Close() won't delete the dialog unless the handler
517 // for wxID_CANCEL does so. So use Destroy() if you want to be sure to
518 // destroy the dialog. The default OnCancel (above) simply ends a modal
519 // dialog, and hides a modeless dialog.
520
521 int idCancel = GetEscapeId();
522 if ( idCancel == wxID_NONE )
523 return;
524 if ( idCancel == wxID_ANY )
525 idCancel = wxID_CANCEL;
526
527 // VZ: this is horrible and MT-unsafe. Can't we reuse some of these global
528 // lists here? don't dare to change it now, but should be done later!
529 static wxList closing;
530
531 if ( closing.Member(this) )
532 return;
533
534 closing.Append(this);
535
536 wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, idCancel);
537 cancelEvent.SetEventObject( this );
538 GetEventHandler()->ProcessEvent(cancelEvent); // This may close the dialog
539
540 closing.DeleteObject(this);
541}
542
543void wxDialogBase::OnSysColourChanged(wxSysColourChangedEvent& event)
544{
545#ifndef __WXGTK__
546 SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
547 Refresh();
548#endif
549
550 event.Skip();
551}
552
553/// Do the adaptation
554bool wxDialogBase::DoLayoutAdaptation()
555{
556 if (GetLayoutAdapter())
557 {
558 wxWindow* focusWindow = wxFindFocusDescendant(this); // from event.h
559 if (GetLayoutAdapter()->DoLayoutAdaptation((wxDialog*) this))
560 {
561 if (focusWindow)
562 focusWindow->SetFocus();
563 return true;
564 }
565 else
566 return false;
567 }
568 else
569 return false;
570}
571
572/// Can we do the adaptation?
573bool wxDialogBase::CanDoLayoutAdaptation()
574{
575 // Check if local setting overrides the global setting
576 bool layoutEnabled = (GetLayoutAdaptationMode() == wxDIALOG_ADAPTATION_MODE_ENABLED) || (IsLayoutAdaptationEnabled() && (GetLayoutAdaptationMode() != wxDIALOG_ADAPTATION_MODE_DISABLED));
577
578 return (layoutEnabled && !m_layoutAdaptationDone && GetLayoutAdaptationLevel() != 0 && GetLayoutAdapter() != NULL && GetLayoutAdapter()->CanDoLayoutAdaptation((wxDialog*) this));
579}
580
581/// Set scrolling adapter class, returning old adapter
582wxDialogLayoutAdapter* wxDialogBase::SetLayoutAdapter(wxDialogLayoutAdapter* adapter)
583{
584 wxDialogLayoutAdapter* oldLayoutAdapter = sm_layoutAdapter;
585 sm_layoutAdapter = adapter;
586 return oldLayoutAdapter;
587}
588
589/*!
590 * Standard adapter
591 */
592
593IMPLEMENT_CLASS(wxDialogLayoutAdapter, wxObject)
594
595IMPLEMENT_CLASS(wxStandardDialogLayoutAdapter, wxDialogLayoutAdapter)
596
597// Allow for caption size on wxWidgets < 2.9
598#if defined(__WXGTK__) && !wxCHECK_VERSION(2,9,0)
599#define wxEXTRA_DIALOG_HEIGHT 30
600#else
601#define wxEXTRA_DIALOG_HEIGHT 0
602#endif
603
604/// Indicate that adaptation should be done
605bool wxStandardDialogLayoutAdapter::CanDoLayoutAdaptation(wxDialog* dialog)
606{
607 if (dialog->GetSizer())
608 {
609 wxSize windowSize, displaySize;
610 return MustScroll(dialog, windowSize, displaySize) != 0;
611 }
612 else
613 return false;
614}
615
616bool wxStandardDialogLayoutAdapter::DoLayoutAdaptation(wxDialog* dialog)
617{
618 if (dialog->GetSizer())
619 {
620#if wxUSE_BOOKCTRL
621 wxBookCtrlBase* bookContentWindow = wxDynamicCast(dialog->GetContentWindow(), wxBookCtrlBase);
622
623 if (bookContentWindow)
624 {
625 // If we have a book control, make all the pages (that use sizers) scrollable
626 wxWindowList windows;
627 for (size_t i = 0; i < bookContentWindow->GetPageCount(); i++)
628 {
629 wxWindow* page = bookContentWindow->GetPage(i);
630
631 wxScrolledWindow* scrolledWindow = wxDynamicCast(page, wxScrolledWindow);
632 if (scrolledWindow)
633 windows.Append(scrolledWindow);
634 else if (!scrolledWindow && page->GetSizer())
635 {
636 // Create a scrolled window and reparent
637 scrolledWindow = CreateScrolledWindow(page);
638 wxSizer* oldSizer = page->GetSizer();
639
640 wxSizer* newSizer = new wxBoxSizer(wxVERTICAL);
641 newSizer->Add(scrolledWindow,1, wxEXPAND, 0);
642
643 page->SetSizer(newSizer, false /* don't delete the old sizer */);
644
645 scrolledWindow->SetSizer(oldSizer);
646
647 ReparentControls(page, scrolledWindow);
648
649 windows.Append(scrolledWindow);
650 }
651 }
652
653 FitWithScrolling(dialog, windows);
654 }
655 else
656#endif // wxUSE_BOOKCTRL
657 {
658 // If we have an arbitrary dialog, create a scrolling area for the main content, and a button sizer
659 // for the main buttons.
660 wxScrolledWindow* scrolledWindow = CreateScrolledWindow(dialog);
661
662 int buttonSizerBorder = 0;
663
664 // First try to find a wxStdDialogButtonSizer
665 wxSizer* buttonSizer = FindButtonSizer(true /* find std button sizer */, dialog, dialog->GetSizer(), buttonSizerBorder);
666
667 // Next try to find a wxBoxSizer containing the controls
668 if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_STANDARD_SIZER)
669 buttonSizer = FindButtonSizer(false /* find ordinary sizer */, dialog, dialog->GetSizer(), buttonSizerBorder);
670
671 // If we still don't have a button sizer, collect any 'loose' buttons in the layout
672 if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_ANY_SIZER)
673 {
674 int count = 0;
675 wxStdDialogButtonSizer* stdButtonSizer = new wxStdDialogButtonSizer;
676 buttonSizer = stdButtonSizer;
677
678 FindLooseButtons(dialog, stdButtonSizer, dialog->GetSizer(), count);
679 if (count > 0)
680 stdButtonSizer->Realize();
681 else
682 {
683 delete buttonSizer;
684 buttonSizer = NULL;
685 }
686 }
687
688 if (buttonSizerBorder == 0)
689 buttonSizerBorder = 5;
690
691 ReparentControls(dialog, scrolledWindow, buttonSizer);
692
693 wxBoxSizer* newTopSizer = new wxBoxSizer(wxVERTICAL);
694 wxSizer* oldSizer = dialog->GetSizer();
695
696 dialog->SetSizer(newTopSizer, false /* don't delete old sizer */);
697
698 newTopSizer->Add(scrolledWindow, 1, wxEXPAND|wxALL, 0);
699 if (buttonSizer)
700 newTopSizer->Add(buttonSizer, 0, wxEXPAND|wxALL, buttonSizerBorder);
701
702 scrolledWindow->SetSizer(oldSizer);
703
704 FitWithScrolling(dialog, scrolledWindow);
705 }
706 }
707
708 dialog->SetLayoutAdaptationDone(true);
709 return true;
710}
711
712// Create the scrolled window
713wxScrolledWindow* wxStandardDialogLayoutAdapter::CreateScrolledWindow(wxWindow* parent)
714{
715 wxScrolledWindow* scrolledWindow = new wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL|wxVSCROLL|wxHSCROLL|wxBORDER_NONE);
716 return scrolledWindow;
717}
718
719/// Find and remove the button sizer, if any
720wxSizer* wxStandardDialogLayoutAdapter::FindButtonSizer(bool stdButtonSizer, wxDialog* dialog, wxSizer* sizer, int& retBorder, int accumlatedBorder)
721{
722 for ( wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst();
723 node; node = node->GetNext() )
724 {
725 wxSizerItem *item = node->GetData();
726 wxSizer *childSizer = item->GetSizer();
727
728 if ( childSizer )
729 {
730 int newBorder = accumlatedBorder;
731 if (item->GetFlag() & wxALL)
732 newBorder += item->GetBorder();
733
734 if (stdButtonSizer) // find wxStdDialogButtonSizer
735 {
736 wxStdDialogButtonSizer* buttonSizer = wxDynamicCast(childSizer, wxStdDialogButtonSizer);
737 if (buttonSizer)
738 {
739 sizer->Detach(childSizer);
740 retBorder = newBorder;
741 return buttonSizer;
742 }
743 }
744 else // find a horizontal box sizer containing standard buttons
745 {
746 wxBoxSizer* buttonSizer = wxDynamicCast(childSizer, wxBoxSizer);
747 if (buttonSizer && IsOrdinaryButtonSizer(dialog, buttonSizer))
748 {
749 sizer->Detach(childSizer);
750 retBorder = newBorder;
751 return buttonSizer;
752 }
753 }
754
755 wxSizer* s = FindButtonSizer(stdButtonSizer, dialog, childSizer, retBorder, newBorder);
756 if (s)
757 return s;
758 }
759 }
760 return NULL;
761}
762
763/// Check if this sizer contains standard buttons, and so can be repositioned in the dialog
764bool wxStandardDialogLayoutAdapter::IsOrdinaryButtonSizer(wxDialog* dialog, wxBoxSizer* sizer)
765{
766 if (sizer->GetOrientation() != wxHORIZONTAL)
767 return false;
768
769 for ( wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst();
770 node; node = node->GetNext() )
771 {
772 wxSizerItem *item = node->GetData();
773 wxButton *childButton = wxDynamicCast(item->GetWindow(), wxButton);
774
775 if (childButton && IsStandardButton(dialog, childButton))
776 return true;
777 }
778 return false;
779}
780
781/// Check if this is a standard button
782bool wxStandardDialogLayoutAdapter::IsStandardButton(wxDialog* dialog, wxButton* button)
783{
784 wxWindowID id = button->GetId();
785
786 return (id == wxID_OK || id == wxID_CANCEL || id == wxID_YES || id == wxID_NO || id == wxID_SAVE ||
787 id == wxID_APPLY || id == wxID_HELP || id == wxID_CONTEXT_HELP || dialog->IsMainButtonId(id));
788}
789
790/// Find 'loose' main buttons in the existing layout and add them to the standard dialog sizer
791bool wxStandardDialogLayoutAdapter::FindLooseButtons(wxDialog* dialog, wxStdDialogButtonSizer* buttonSizer, wxSizer* sizer, int& count)
792{
793 wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst();
794 while (node)
795 {
796 wxSizerItemList::compatibility_iterator next = node->GetNext();
797 wxSizerItem *item = node->GetData();
798 wxSizer *childSizer = item->GetSizer();
799 wxButton *childButton = wxDynamicCast(item->GetWindow(), wxButton);
800
801 if (childButton && IsStandardButton(dialog, childButton))
802 {
803 sizer->Detach(childButton);
804 buttonSizer->AddButton(childButton);
805 count ++;
806 }
807
808 if (childSizer)
809 FindLooseButtons(dialog, buttonSizer, childSizer, count);
810
811 node = next;
812 }
813 return true;
814}
815
816/// Reparent the controls to the scrolled window
817void wxStandardDialogLayoutAdapter::ReparentControls(wxWindow* parent, wxWindow* reparentTo, wxSizer* buttonSizer)
818{
819 DoReparentControls(parent, reparentTo, buttonSizer);
820}
821
822void wxStandardDialogLayoutAdapter::DoReparentControls(wxWindow* parent, wxWindow* reparentTo, wxSizer* buttonSizer)
823{
824 wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();
825 while (node)
826 {
827 wxWindowList::compatibility_iterator next = node->GetNext();
828
829 wxWindow *win = node->GetData();
830
831 // Don't reparent the scrolled window or buttons in the button sizer
832 if (win != reparentTo && (!buttonSizer || !buttonSizer->GetItem(win)))
833 {
834 win->Reparent(reparentTo);
835#ifdef __WXMSW__
836 // Restore correct tab order
837 ::SetWindowPos((HWND) win->GetHWND(), HWND_BOTTOM, -1, -1, -1, -1, SWP_NOMOVE|SWP_NOSIZE);
838#endif
839 }
840
841 node = next;
842 }
843}
844
845/// Find whether scrolling will be necessary for the dialog, returning wxVERTICAL, wxHORIZONTAL or both
846int wxStandardDialogLayoutAdapter::MustScroll(wxDialog* dialog, wxSize& windowSize, wxSize& displaySize)
847{
848 return DoMustScroll(dialog, windowSize, displaySize);
849}
850
851/// Find whether scrolling will be necessary for the dialog, returning wxVERTICAL, wxHORIZONTAL or both
852int wxStandardDialogLayoutAdapter::DoMustScroll(wxDialog* dialog, wxSize& windowSize, wxSize& displaySize)
853{
854 wxSize minWindowSize = dialog->GetSizer()->GetMinSize();
855 windowSize = dialog->GetSize();
856 windowSize = wxSize(wxMax(windowSize.x, minWindowSize.x), wxMax(windowSize.y, minWindowSize.y));
857#if wxUSE_DISPLAY
858 displaySize = wxDisplay(wxDisplay::GetFromWindow(dialog)).GetClientArea().GetSize();
859#else
860 displaySize = wxGetClientDisplayRect().GetSize();
861#endif
862
863 int flags = 0;
864
865 if (windowSize.y >= (displaySize.y - wxEXTRA_DIALOG_HEIGHT))
866 flags |= wxVERTICAL;
867 if (windowSize.x >= displaySize.x)
868 flags |= wxHORIZONTAL;
869
870 return flags;
871}
872
873// A function to fit the dialog around its contents, and then adjust for screen size.
874// If scrolled windows are passed, scrolling is enabled in the required orientation(s).
875bool wxStandardDialogLayoutAdapter::FitWithScrolling(wxDialog* dialog, wxWindowList& windows)
876{
877 return DoFitWithScrolling(dialog, windows);
878}
879
880// A function to fit the dialog around its contents, and then adjust for screen size.
881// If a scrolled window is passed, scrolling is enabled in the required orientation(s).
882bool wxStandardDialogLayoutAdapter::FitWithScrolling(wxDialog* dialog, wxScrolledWindow* scrolledWindow)
883{
884 return DoFitWithScrolling(dialog, scrolledWindow);
885}
886
887// A function to fit the dialog around its contents, and then adjust for screen size.
888// If a scrolled window is passed, scrolling is enabled in the required orientation(s).
889bool wxStandardDialogLayoutAdapter::DoFitWithScrolling(wxDialog* dialog, wxScrolledWindow* scrolledWindow)
890{
891 wxWindowList windows;
892 windows.Append(scrolledWindow);
893 return DoFitWithScrolling(dialog, windows);
894}
895
896bool wxStandardDialogLayoutAdapter::DoFitWithScrolling(wxDialog* dialog, wxWindowList& windows)
897{
898 wxSizer* sizer = dialog->GetSizer();
899 if (!sizer)
900 return false;
901
902 sizer->SetSizeHints(dialog);
903
904 wxSize windowSize, displaySize;
905 int scrollFlags = DoMustScroll(dialog, windowSize, displaySize);
906 int scrollBarSize = 20;
907
908 if (scrollFlags)
909 {
910 int scrollBarExtraX = 0, scrollBarExtraY = 0;
911 bool resizeHorizontally = (scrollFlags & wxHORIZONTAL) != 0;
912 bool resizeVertically = (scrollFlags & wxVERTICAL) != 0;
913
914 if (windows.GetCount() != 0)
915 {
916 // Allow extra for a scrollbar, assuming we resizing in one direction only.
917 if ((resizeVertically && !resizeHorizontally) && (windowSize.x < (displaySize.x - scrollBarSize)))
918 scrollBarExtraX = scrollBarSize;
919 if ((resizeHorizontally && !resizeVertically) && (windowSize.y < (displaySize.y - scrollBarSize)))
920 scrollBarExtraY = scrollBarSize;
921 }
922
923 wxWindowList::compatibility_iterator node = windows.GetFirst();
924 while (node)
925 {
926 wxWindow *win = node->GetData();
927 wxScrolledWindow* scrolledWindow = wxDynamicCast(win, wxScrolledWindow);
928 if (scrolledWindow)
929 {
930 scrolledWindow->SetScrollRate(resizeHorizontally ? 10 : 0, resizeVertically ? 10 : 0);
931
932 if (scrolledWindow->GetSizer())
933 scrolledWindow->GetSizer()->Fit(scrolledWindow);
934 }
935
936 node = node->GetNext();
937 }
938
939 wxSize limitTo = windowSize + wxSize(scrollBarExtraX, scrollBarExtraY);
940 if (resizeVertically)
941 limitTo.y = displaySize.y - wxEXTRA_DIALOG_HEIGHT;
942 if (resizeHorizontally)
943 limitTo.x = displaySize.x;
944
945 dialog->SetMinSize(limitTo);
946 dialog->SetSize(limitTo);
947
948 dialog->SetSizeHints( limitTo.x, limitTo.y, dialog->GetMaxWidth(), dialog->GetMaxHeight() );
949 }
950
951 return true;
952}
953
954/*!
955 * Module to initialise standard adapter
956 */
957
958class wxDialogLayoutAdapterModule: public wxModule
959{
960 DECLARE_DYNAMIC_CLASS(wxDialogLayoutAdapterModule)
961public:
962 wxDialogLayoutAdapterModule() {}
963 virtual void OnExit() { delete wxDialogBase::SetLayoutAdapter(NULL); }
964 virtual bool OnInit() { wxDialogBase::SetLayoutAdapter(new wxStandardDialogLayoutAdapter); return true; }
965};
966
967IMPLEMENT_DYNAMIC_CLASS(wxDialogLayoutAdapterModule, wxModule)