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