src/common/dlgcmn.cpp

   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
  55 BEGIN_EVENT_TABLE(wxDialogBase, wxTopLevelWindow)
  56     EVT_BUTTON(wxID_ANY, wxDialogBase::OnButton)
  57
  58     EVT_CLOSE(wxDialogBase::OnCloseWindow)
  59
  60     EVT_CHAR_HOOK(wxDialogBase::OnCharHook)
  61 END_EVENT_TABLE()
  62
  63 wxDialogLayoutAdapter* wxDialogBase::sm_layoutAdapter = NULL;
  64 bool wxDialogBase::sm_layoutAdaptation = false;
  65
  66 void 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
  81 wxWindow *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
 119 wxWindow *
 120 wxDialogBase::GetParentForModalDialog(wxWindow *parent, long style) const
 121 {
 122     // creating a parent-less modal dialog will result (under e.g. wxGTK2)
 123     // in an unfocused dialog, so try to find a valid parent for it unless we
 124     // were explicitly asked not to
 125     if ( style & wxDIALOG_NO_PARENT )
 126         return NULL;
 127
 128     // first try the given parent
 129     if ( parent )
 130         parent = CheckIfCanBeUsedAsParent(wxGetTopLevelParent(parent));
 131
 132     // then the currently active window
 133     if ( !parent )
 134         parent = CheckIfCanBeUsedAsParent(
 135                     wxGetTopLevelParent(wxGetActiveWindow()));
 136
 137     // and finally the application main window
 138     if ( !parent )
 139         parent = CheckIfCanBeUsedAsParent(wxTheApp->GetTopWindow());
 140
 141     return parent;
 142 }
 143
 144 #if wxUSE_STATTEXT
 145
 146 class wxTextSizerWrapper : public wxTextWrapper
 147 {
 148 public:
 149     wxTextSizerWrapper(wxWindow *win)
 150     {
 151         m_win = win;
 152         m_hLine = 0;
 153     }
 154
 155     wxSizer *CreateSizer(const wxString& text, int widthMax)
 156     {
 157         m_sizer = new wxBoxSizer(wxVERTICAL);
 158         Wrap(m_win, text, widthMax);
 159         return m_sizer;
 160     }
 161
 162 protected:
 163     virtual void OnOutputLine(const wxString& line)
 164     {
 165         if ( !line.empty() )
 166         {
 167             m_sizer->Add(new wxStaticText(m_win, wxID_ANY, line));
 168         }
 169         else // empty line, no need to create a control for it
 170         {
 171             if ( !m_hLine )
 172                 m_hLine = m_win->GetCharHeight();
 173
 174             m_sizer->Add(5, m_hLine);
 175         }
 176     }
 177
 178 private:
 179     wxWindow *m_win;
 180     wxSizer *m_sizer;
 181     int m_hLine;
 182 };
 183
 184 wxSizer *wxDialogBase::CreateTextSizer(const wxString& message)
 185 {
 186     // I admit that this is complete bogus, but it makes
 187     // message boxes work for pda screens temporarily..
 188     int widthMax = -1;
 189     const bool is_pda = wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA;
 190     if (is_pda)
 191     {
 192         widthMax = wxSystemSettings::GetMetric( wxSYS_SCREEN_X ) - 25;
 193     }
 194
 195     // '&' is used as accel mnemonic prefix in the wxWidgets controls but in
 196     // the static messages created by CreateTextSizer() (used by wxMessageBox,
 197     // for example), we don't want this special meaning, so we need to quote it
 198     wxString text(message);
 199     text.Replace(wxT("&"), wxT("&&"));
 200
 201     wxTextSizerWrapper wrapper(this);
 202
 203     return wrapper.CreateSizer(text, widthMax);
 204 }
 205
 206 #endif // wxUSE_STATTEXT
 207
 208 wxSizer *wxDialogBase::CreateButtonSizer(long flags)
 209 {
 210 #ifdef __SMARTPHONE__
 211     wxDialog* dialog = (wxDialog*) this;
 212     if ( flags & wxOK )
 213         dialog->SetLeftMenu(wxID_OK);
 214
 215     if ( flags & wxCANCEL )
 216         dialog->SetRightMenu(wxID_CANCEL);
 217
 218     if ( flags & wxYES )
 219         dialog->SetLeftMenu(wxID_YES);
 220
 221     if ( flags & wxNO )
 222         dialog->SetRightMenu(wxID_NO);
 223
 224     return NULL;
 225 #else // !__SMARTPHONE__
 226
 227 #if wxUSE_BUTTON
 228
 229 #ifdef __POCKETPC__
 230     // PocketPC guidelines recommend for Ok/Cancel dialogs to use OK button
 231     // located inside caption bar and implement Cancel functionality through
 232     // Undo outside dialog. As native behaviour this will be default here but
 233     // can be replaced with real wxButtons by setting the option below to 1
 234     if ( (flags & ~(wxCANCEL|wxNO_DEFAULT)) != wxOK ||
 235             wxSystemOptions::GetOptionInt(wxT("wince.dialog.real-ok-cancel")) )
 236 #endif // __POCKETPC__
 237     {
 238         return CreateStdDialogButtonSizer(flags);
 239     }
 240 #ifdef __POCKETPC__
 241     return NULL;
 242 #endif // __POCKETPC__
 243
 244 #else // !wxUSE_BUTTON
 245     wxUnusedVar(flags);
 246
 247     return NULL;
 248 #endif // wxUSE_BUTTON/!wxUSE_BUTTON
 249
 250 #endif // __SMARTPHONE__/!__SMARTPHONE__
 251 }
 252
 253 wxSizer *wxDialogBase::CreateSeparatedButtonSizer(long flags)
 254 {
 255     wxSizer *sizer = CreateButtonSizer(flags);
 256     if ( !sizer )
 257         return NULL;
 258
 259     // Mac Human Interface Guidelines recommend not to use static lines as
 260     // grouping elements
 261 #if wxUSE_STATLINE && !defined(__WXMAC__)
 262     wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL);
 263     topsizer->Add(new wxStaticLine(this),
 264                    wxSizerFlags().Expand().DoubleBorder(wxBOTTOM));
 265     topsizer->Add(sizer, wxSizerFlags().Expand());
 266     sizer = topsizer;
 267 #endif // wxUSE_STATLINE
 268
 269     return sizer;
 270 }
 271
 272 #if wxUSE_BUTTON
 273
 274 wxStdDialogButtonSizer *wxDialogBase::CreateStdDialogButtonSizer( long flags )
 275 {
 276     wxStdDialogButtonSizer *sizer = new wxStdDialogButtonSizer();
 277
 278     wxButton *ok = NULL;
 279     wxButton *yes = NULL;
 280     wxButton *no = NULL;
 281
 282     if (flags & wxOK)
 283     {
 284         ok = new wxButton(this, wxID_OK);
 285         sizer->AddButton(ok);
 286     }
 287
 288     if (flags & wxCANCEL)
 289     {
 290         wxButton *cancel = new wxButton(this, wxID_CANCEL);
 291         sizer->AddButton(cancel);
 292     }
 293
 294     if (flags & wxYES)
 295     {
 296         yes = new wxButton(this, wxID_YES);
 297         sizer->AddButton(yes);
 298     }
 299
 300     if (flags & wxNO)
 301     {
 302         no = new wxButton(this, wxID_NO);
 303         sizer->AddButton(no);
 304     }
 305
 306     if (flags & wxAPPLY)
 307     {
 308         wxButton *apply = new wxButton(this, wxID_APPLY);
 309         sizer->AddButton(apply);
 310     }
 311
 312     if (flags & wxCLOSE)
 313     {
 314         wxButton *close = new wxButton(this, wxID_CLOSE);
 315         sizer->AddButton(close);
 316     }
 317
 318     if (flags & wxHELP)
 319     {
 320         wxButton *help = new wxButton(this, wxID_HELP);
 321         sizer->AddButton(help);
 322     }
 323
 324     if (flags & wxNO_DEFAULT)
 325     {
 326         if (no)
 327         {
 328             no->SetDefault();
 329             no->SetFocus();
 330         }
 331     }
 332     else
 333     {
 334         if (ok)
 335         {
 336             ok->SetDefault();
 337             ok->SetFocus();
 338         }
 339         else if (yes)
 340         {
 341             yes->SetDefault();
 342             yes->SetFocus();
 343         }
 344     }
 345
 346     if (flags & wxOK)
 347         SetAffirmativeId(wxID_OK);
 348     else if (flags & wxYES)
 349         SetAffirmativeId(wxID_YES);
 350
 351     sizer->Realize();
 352
 353     return sizer;
 354 }
 355
 356 #endif // wxUSE_BUTTON
 357
 358 // ----------------------------------------------------------------------------
 359 // standard buttons handling
 360 // ----------------------------------------------------------------------------
 361
 362 void wxDialogBase::EndDialog(int rc)
 363 {
 364     if ( IsModal() )
 365         EndModal(rc);
 366     else
 367         Hide();
 368 }
 369
 370 void wxDialogBase::AcceptAndClose()
 371 {
 372     if ( Validate() && TransferDataFromWindow() )
 373     {
 374         EndDialog(m_affirmativeId);
 375     }
 376 }
 377
 378 void wxDialogBase::SetAffirmativeId(int affirmativeId)
 379 {
 380     m_affirmativeId = affirmativeId;
 381 }
 382
 383 void wxDialogBase::SetEscapeId(int escapeId)
 384 {
 385     m_escapeId = escapeId;
 386 }
 387
 388 bool wxDialogBase::EmulateButtonClickIfPresent(int id)
 389 {
 390 #if wxUSE_BUTTON
 391     wxButton *btn = wxDynamicCast(FindWindow(id), wxButton);
 392
 393     if ( !btn || !btn->IsEnabled() || !btn->IsShown() )
 394         return false;
 395
 396     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, id);
 397     event.SetEventObject(btn);
 398     btn->GetEventHandler()->ProcessEvent(event);
 399
 400     return true;
 401 #else // !wxUSE_BUTTON
 402     wxUnusedVar(id);
 403     return false;
 404 #endif // wxUSE_BUTTON/!wxUSE_BUTTON
 405 }
 406
 407 bool wxDialogBase::IsEscapeKey(const wxKeyEvent& event)
 408 {
 409     // for most platforms, Esc key is used to close the dialogs
 410     return event.GetKeyCode() == WXK_ESCAPE &&
 411                 event.GetModifiers() == wxMOD_NONE;
 412 }
 413
 414 void wxDialogBase::OnCharHook(wxKeyEvent& event)
 415 {
 416     if ( event.GetKeyCode() == WXK_ESCAPE )
 417     {
 418         int idCancel = GetEscapeId();
 419         switch ( idCancel )
 420         {
 421             case wxID_NONE:
 422                 // don't handle Esc specially at all
 423                 break;
 424
 425             case wxID_ANY:
 426                 // this value is special: it means translate Esc to wxID_CANCEL
 427                 // but if there is no such button, then fall back to wxID_OK
 428                 if ( EmulateButtonClickIfPresent(wxID_CANCEL) )
 429                     return;
 430                 idCancel = GetAffirmativeId();
 431                 // fall through
 432
 433             default:
 434                 // translate Esc to button press for the button with given id
 435                 if ( EmulateButtonClickIfPresent(idCancel) )
 436                     return;
 437         }
 438     }
 439
 440     event.Skip();
 441 }
 442
 443 void wxDialogBase::OnButton(wxCommandEvent& event)
 444 {
 445     const int id = event.GetId();
 446     if ( id == GetAffirmativeId() )
 447     {
 448         AcceptAndClose();
 449     }
 450     else if ( id == wxID_APPLY )
 451     {
 452         if ( Validate() )
 453             TransferDataFromWindow();
 454
 455         // TODO: disable the Apply button until things change again
 456     }
 457     else if ( id == GetEscapeId() ||
 458                 (id == wxID_CANCEL && GetEscapeId() == wxID_ANY) )
 459     {
 460         EndDialog(wxID_CANCEL);
 461     }
 462     else // not a standard button
 463     {
 464         event.Skip();
 465     }
 466 }
 467
 468 // ----------------------------------------------------------------------------
 469 // compatibility methods for supporting the modality API
 470 // ----------------------------------------------------------------------------
 471
 472 wxDEFINE_EVENT( wxEVT_WINDOW_MODAL_DIALOG_CLOSED , wxWindowModalDialogEvent  );
 473
 474 IMPLEMENT_DYNAMIC_CLASS(wxWindowModalDialogEvent, wxCommandEvent)
 475
 476 void wxDialogBase::ShowWindowModal ()
 477 {
 478     ShowModal();
 479     SendWindowModalDialogEvent ( wxEVT_WINDOW_MODAL_DIALOG_CLOSED  );
 480 }
 481
 482 void wxDialogBase::SendWindowModalDialogEvent ( wxEventType type )
 483 {
 484     wxWindowModalDialogEvent 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
 498 wxDialogModality wxDialogBase::GetModality() const
 499 {
 500     return IsModal() ? wxDIALOG_MODALITY_APP_MODAL : wxDIALOG_MODALITY_NONE;
 501 }
 502
 503 // ----------------------------------------------------------------------------
 504 // other event handlers
 505 // ----------------------------------------------------------------------------
 506
 507 void 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
 543 void 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
 554 bool 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?
 573 bool 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
 582 wxDialogLayoutAdapter* 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
 593 IMPLEMENT_CLASS(wxDialogLayoutAdapter, wxObject)
 594
 595 IMPLEMENT_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
 605 bool 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
 616 bool 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
 713 wxScrolledWindow* 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
 720 wxSizer* 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
 764 bool 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
 782 bool 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
 791 bool 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
 817 void wxStandardDialogLayoutAdapter::ReparentControls(wxWindow* parent, wxWindow* reparentTo, wxSizer* buttonSizer)
 818 {
 819     DoReparentControls(parent, reparentTo, buttonSizer);
 820 }
 821
 822 void 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
 846 int 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
 852 int 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).
 875 bool 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).
 882 bool 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).
 889 bool wxStandardDialogLayoutAdapter::DoFitWithScrolling(wxDialog* dialog, wxScrolledWindow* scrolledWindow)
 890 {
 891     wxWindowList windows;
 892     windows.Append(scrolledWindow);
 893     return DoFitWithScrolling(dialog, windows);
 894 }
 895
 896 bool 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
 958 class wxDialogLayoutAdapterModule: public wxModule
 959 {
 960     DECLARE_DYNAMIC_CLASS(wxDialogLayoutAdapterModule)
 961 public:
 962     wxDialogLayoutAdapterModule() {}
 963     virtual void OnExit() { delete wxDialogBase::SetLayoutAdapter(NULL); }
 964     virtual bool OnInit() { wxDialogBase::SetLayoutAdapter(new wxStandardDialogLayoutAdapter); return true; }
 965 };
 966
 967 IMPLEMENT_DYNAMIC_CLASS(wxDialogLayoutAdapterModule, wxModule)