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     //
 466     // Notice that we intentionally don't check for modifiers here, Shift-Esc,
 467     // Alt-Esc and so on still close the dialog, typically.
 468     return event.GetKeyCode() == WXK_ESCAPE;
 469 }
 470
 471 void wxDialogBase::OnCharHook(wxKeyEvent& event)
 472 {
 473     if ( IsEscapeKey(event) )
 474     {
 475         if ( SendCloseButtonClickEvent() )
 476         {
 477             // Skip the call to event.Skip() below, we did handle this key.
 478             return;
 479         }
 480     }
 481
 482     event.Skip();
 483 }
 484
 485 void wxDialogBase::OnButton(wxCommandEvent& event)
 486 {
 487     const int id = event.GetId();
 488     if ( id == GetAffirmativeId() )
 489     {
 490         AcceptAndClose();
 491     }
 492     else if ( id == wxID_APPLY )
 493     {
 494         if ( Validate() )
 495             TransferDataFromWindow();
 496
 497         // TODO: disable the Apply button until things change again
 498     }
 499     else if ( id == GetEscapeId() ||
 500                 (id == wxID_CANCEL && GetEscapeId() == wxID_ANY) )
 501     {
 502         EndDialog(wxID_CANCEL);
 503     }
 504     else // not a standard button
 505     {
 506         event.Skip();
 507     }
 508 }
 509
 510 // ----------------------------------------------------------------------------
 511 // compatibility methods for supporting the modality API
 512 // ----------------------------------------------------------------------------
 513
 514 wxDEFINE_EVENT( wxEVT_WINDOW_MODAL_DIALOG_CLOSED , wxWindowModalDialogEvent  );
 515
 516 IMPLEMENT_DYNAMIC_CLASS(wxWindowModalDialogEvent, wxCommandEvent)
 517
 518 void wxDialogBase::ShowWindowModal ()
 519 {
 520     ShowModal();
 521     SendWindowModalDialogEvent ( wxEVT_WINDOW_MODAL_DIALOG_CLOSED  );
 522 }
 523
 524 void wxDialogBase::SendWindowModalDialogEvent ( wxEventType type )
 525 {
 526     wxWindowModalDialogEvent event ( type, GetId());
 527     event.SetEventObject(this);
 528
 529     if ( !GetEventHandler()->ProcessEvent(event) )
 530     {
 531         // the event is not propagated upwards to the parent automatically
 532         // because the dialog is a top level window, so do it manually as
 533         // in 9 cases of 10 the message must be processed by the dialog
 534         // owner and not the dialog itself
 535         (void)GetParent()->GetEventHandler()->ProcessEvent(event);
 536     }
 537 }
 538
 539
 540 wxDialogModality wxDialogBase::GetModality() const
 541 {
 542     return IsModal() ? wxDIALOG_MODALITY_APP_MODAL : wxDIALOG_MODALITY_NONE;
 543 }
 544
 545 // ----------------------------------------------------------------------------
 546 // other event handlers
 547 // ----------------------------------------------------------------------------
 548
 549 void wxDialogBase::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 550 {
 551     // We'll send a Cancel message by default, which may close the dialog.
 552
 553     // Check for looping if the Cancel event handler calls Close().
 554     //
 555     // VZ: this is horrible and MT-unsafe. Can't we reuse some of these global
 556     //     lists here? don't dare to change it now, but should be done later!
 557     static wxList closing;
 558
 559     if ( closing.Member(this) )
 560         return;
 561
 562     closing.Append(this);
 563
 564     if ( !SendCloseButtonClickEvent() )
 565     {
 566         // If the handler didn't close the dialog (e.g. because there is no
 567         // button with matching id) we still want to close it when the user
 568         // clicks the "x" button in the title bar, otherwise we shouldn't even
 569         // have put it there.
 570         //
 571         // Notice that using wxID_CLOSE might have been a better choice but we
 572         // use wxID_CANCEL for compatibility reasons.
 573         EndDialog(wxID_CANCEL);
 574     }
 575
 576     closing.DeleteObject(this);
 577 }
 578
 579 void wxDialogBase::OnSysColourChanged(wxSysColourChangedEvent& event)
 580 {
 581 #ifndef __WXGTK__
 582     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
 583     Refresh();
 584 #endif
 585
 586     event.Skip();
 587 }
 588
 589 /// Do the adaptation
 590 bool wxDialogBase::DoLayoutAdaptation()
 591 {
 592     if (GetLayoutAdapter())
 593     {
 594         wxWindow* focusWindow = wxFindFocusDescendant(this); // from event.h
 595         if (GetLayoutAdapter()->DoLayoutAdaptation((wxDialog*) this))
 596         {
 597             if (focusWindow)
 598                 focusWindow->SetFocus();
 599             return true;
 600         }
 601         else
 602             return false;
 603     }
 604     else
 605         return false;
 606 }
 607
 608 /// Can we do the adaptation?
 609 bool wxDialogBase::CanDoLayoutAdaptation()
 610 {
 611     // Check if local setting overrides the global setting
 612     bool layoutEnabled = (GetLayoutAdaptationMode() == wxDIALOG_ADAPTATION_MODE_ENABLED) || (IsLayoutAdaptationEnabled() && (GetLayoutAdaptationMode() != wxDIALOG_ADAPTATION_MODE_DISABLED));
 613
 614     return (layoutEnabled && !m_layoutAdaptationDone && GetLayoutAdaptationLevel() != 0 && GetLayoutAdapter() != NULL && GetLayoutAdapter()->CanDoLayoutAdaptation((wxDialog*) this));
 615 }
 616
 617 /// Set scrolling adapter class, returning old adapter
 618 wxDialogLayoutAdapter* wxDialogBase::SetLayoutAdapter(wxDialogLayoutAdapter* adapter)
 619 {
 620     wxDialogLayoutAdapter* oldLayoutAdapter = sm_layoutAdapter;
 621     sm_layoutAdapter = adapter;
 622     return oldLayoutAdapter;
 623 }
 624
 625 /*!
 626  * Standard adapter
 627  */
 628
 629 IMPLEMENT_CLASS(wxDialogLayoutAdapter, wxObject)
 630
 631 IMPLEMENT_CLASS(wxStandardDialogLayoutAdapter, wxDialogLayoutAdapter)
 632
 633 // Allow for caption size on wxWidgets < 2.9
 634 #if defined(__WXGTK__) && !wxCHECK_VERSION(2,9,0)
 635 #define wxEXTRA_DIALOG_HEIGHT 30
 636 #else
 637 #define wxEXTRA_DIALOG_HEIGHT 0
 638 #endif
 639
 640 /// Indicate that adaptation should be done
 641 bool wxStandardDialogLayoutAdapter::CanDoLayoutAdaptation(wxDialog* dialog)
 642 {
 643     if (dialog->GetSizer())
 644     {
 645         wxSize windowSize, displaySize;
 646         return MustScroll(dialog, windowSize, displaySize) != 0;
 647     }
 648     else
 649         return false;
 650 }
 651
 652 bool wxStandardDialogLayoutAdapter::DoLayoutAdaptation(wxDialog* dialog)
 653 {
 654     if (dialog->GetSizer())
 655     {
 656 #if wxUSE_BOOKCTRL
 657         wxBookCtrlBase* bookContentWindow = wxDynamicCast(dialog->GetContentWindow(), wxBookCtrlBase);
 658
 659         if (bookContentWindow)
 660         {
 661             // If we have a book control, make all the pages (that use sizers) scrollable
 662             wxWindowList windows;
 663             for (size_t i = 0; i < bookContentWindow->GetPageCount(); i++)
 664             {
 665                 wxWindow* page = bookContentWindow->GetPage(i);
 666
 667                 wxScrolledWindow* scrolledWindow = wxDynamicCast(page, wxScrolledWindow);
 668                 if (scrolledWindow)
 669                     windows.Append(scrolledWindow);
 670                 else if (!scrolledWindow && page->GetSizer())
 671                 {
 672                     // Create a scrolled window and reparent
 673                     scrolledWindow = CreateScrolledWindow(page);
 674                     wxSizer* oldSizer = page->GetSizer();
 675
 676                     wxSizer* newSizer = new wxBoxSizer(wxVERTICAL);
 677                     newSizer->Add(scrolledWindow,1, wxEXPAND, 0);
 678
 679                     page->SetSizer(newSizer, false /* don't delete the old sizer */);
 680
 681                     scrolledWindow->SetSizer(oldSizer);
 682
 683                     ReparentControls(page, scrolledWindow);
 684
 685                     windows.Append(scrolledWindow);
 686                 }
 687             }
 688
 689             FitWithScrolling(dialog, windows);
 690         }
 691         else
 692 #endif // wxUSE_BOOKCTRL
 693         {
 694 #if wxUSE_BUTTON
 695             // If we have an arbitrary dialog, create a scrolling area for the main content, and a button sizer
 696             // for the main buttons.
 697             wxScrolledWindow* scrolledWindow = CreateScrolledWindow(dialog);
 698
 699             int buttonSizerBorder = 0;
 700
 701             // First try to find a wxStdDialogButtonSizer
 702             wxSizer* buttonSizer = FindButtonSizer(true /* find std button sizer */, dialog, dialog->GetSizer(), buttonSizerBorder);
 703
 704             // Next try to find a wxBoxSizer containing the controls
 705             if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_STANDARD_SIZER)
 706                 buttonSizer = FindButtonSizer(false /* find ordinary sizer */, dialog, dialog->GetSizer(), buttonSizerBorder);
 707
 708             // If we still don't have a button sizer, collect any 'loose' buttons in the layout
 709             if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_ANY_SIZER)
 710             {
 711                 int count = 0;
 712                 wxStdDialogButtonSizer* stdButtonSizer = new wxStdDialogButtonSizer;
 713                 buttonSizer = stdButtonSizer;
 714
 715                 FindLooseButtons(dialog, stdButtonSizer, dialog->GetSizer(), count);
 716                 if (count > 0)
 717                     stdButtonSizer->Realize();
 718                 else
 719                 {
 720                     wxDELETE(buttonSizer);
 721                 }
 722             }
 723
 724             if (buttonSizerBorder == 0)
 725                 buttonSizerBorder = 5;
 726
 727             ReparentControls(dialog, scrolledWindow, buttonSizer);
 728
 729             wxBoxSizer* newTopSizer = new wxBoxSizer(wxVERTICAL);
 730             wxSizer* oldSizer = dialog->GetSizer();
 731
 732             dialog->SetSizer(newTopSizer, false /* don't delete old sizer */);
 733
 734             newTopSizer->Add(scrolledWindow, 1, wxEXPAND|wxALL, 0);
 735             if (buttonSizer)
 736                 newTopSizer->Add(buttonSizer, 0, wxEXPAND|wxALL, buttonSizerBorder);
 737
 738             scrolledWindow->SetSizer(oldSizer);
 739
 740             FitWithScrolling(dialog, scrolledWindow);
 741 #endif // wxUSE_BUTTON
 742         }
 743     }
 744
 745     dialog->SetLayoutAdaptationDone(true);
 746     return true;
 747 }
 748
 749 // Create the scrolled window
 750 wxScrolledWindow* wxStandardDialogLayoutAdapter::CreateScrolledWindow(wxWindow* parent)
 751 {
 752     wxScrolledWindow* scrolledWindow = new wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL|wxVSCROLL|wxHSCROLL|wxBORDER_NONE);
 753     return scrolledWindow;
 754 }
 755
 756 #if wxUSE_BUTTON
 757
 758 /// Find and remove the button sizer, if any
 759 wxSizer* wxStandardDialogLayoutAdapter::FindButtonSizer(bool stdButtonSizer, wxDialog* dialog, wxSizer* sizer, int& retBorder, int accumlatedBorder)
 760 {
 761     for ( wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst();
 762           node; node = node->GetNext() )
 763     {
 764         wxSizerItem *item = node->GetData();
 765         wxSizer *childSizer = item->GetSizer();
 766
 767         if ( childSizer )
 768         {
 769             int newBorder = accumlatedBorder;
 770             if (item->GetFlag() & wxALL)
 771                 newBorder += item->GetBorder();
 772
 773             if (stdButtonSizer) // find wxStdDialogButtonSizer
 774             {
 775                 wxStdDialogButtonSizer* buttonSizer = wxDynamicCast(childSizer, wxStdDialogButtonSizer);
 776                 if (buttonSizer)
 777                 {
 778                     sizer->Detach(childSizer);
 779                     retBorder = newBorder;
 780                     return buttonSizer;
 781                 }
 782             }
 783             else // find a horizontal box sizer containing standard buttons
 784             {
 785                 wxBoxSizer* buttonSizer = wxDynamicCast(childSizer, wxBoxSizer);
 786                 if (buttonSizer && IsOrdinaryButtonSizer(dialog, buttonSizer))
 787                 {
 788                     sizer->Detach(childSizer);
 789                     retBorder = newBorder;
 790                     return buttonSizer;
 791                 }
 792             }
 793
 794             wxSizer* s = FindButtonSizer(stdButtonSizer, dialog, childSizer, retBorder, newBorder);
 795             if (s)
 796                 return s;
 797         }
 798     }
 799     return NULL;
 800 }
 801
 802 /// Check if this sizer contains standard buttons, and so can be repositioned in the dialog
 803 bool wxStandardDialogLayoutAdapter::IsOrdinaryButtonSizer(wxDialog* dialog, wxBoxSizer* sizer)
 804 {
 805     if (sizer->GetOrientation() != wxHORIZONTAL)
 806         return false;
 807
 808     for ( wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst();
 809           node; node = node->GetNext() )
 810     {
 811         wxSizerItem *item = node->GetData();
 812         wxButton *childButton = wxDynamicCast(item->GetWindow(), wxButton);
 813
 814         if (childButton && IsStandardButton(dialog, childButton))
 815             return true;
 816     }
 817     return false;
 818 }
 819
 820 /// Check if this is a standard button
 821 bool wxStandardDialogLayoutAdapter::IsStandardButton(wxDialog* dialog, wxButton* button)
 822 {
 823     wxWindowID id = button->GetId();
 824
 825     return (id == wxID_OK || id == wxID_CANCEL || id == wxID_YES || id == wxID_NO || id == wxID_SAVE ||
 826             id == wxID_APPLY || id == wxID_HELP || id == wxID_CONTEXT_HELP || dialog->IsMainButtonId(id));
 827 }
 828
 829 /// Find 'loose' main buttons in the existing layout and add them to the standard dialog sizer
 830 bool wxStandardDialogLayoutAdapter::FindLooseButtons(wxDialog* dialog, wxStdDialogButtonSizer* buttonSizer, wxSizer* sizer, int& count)
 831 {
 832     wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst();
 833     while (node)
 834     {
 835         wxSizerItemList::compatibility_iterator next = node->GetNext();
 836         wxSizerItem *item = node->GetData();
 837         wxSizer *childSizer = item->GetSizer();
 838         wxButton *childButton = wxDynamicCast(item->GetWindow(), wxButton);
 839
 840         if (childButton && IsStandardButton(dialog, childButton))
 841         {
 842             sizer->Detach(childButton);
 843             buttonSizer->AddButton(childButton);
 844             count ++;
 845         }
 846
 847         if (childSizer)
 848             FindLooseButtons(dialog, buttonSizer, childSizer, count);
 849
 850         node = next;
 851     }
 852     return true;
 853 }
 854
 855 #endif // wxUSE_BUTTON
 856
 857 /// Reparent the controls to the scrolled window
 858 void wxStandardDialogLayoutAdapter::ReparentControls(wxWindow* parent, wxWindow* reparentTo, wxSizer* buttonSizer)
 859 {
 860     DoReparentControls(parent, reparentTo, buttonSizer);
 861 }
 862
 863 void wxStandardDialogLayoutAdapter::DoReparentControls(wxWindow* parent, wxWindow* reparentTo, wxSizer* buttonSizer)
 864 {
 865     wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst();
 866     while (node)
 867     {
 868         wxWindowList::compatibility_iterator next = node->GetNext();
 869
 870         wxWindow *win = node->GetData();
 871
 872         // Don't reparent the scrolled window or buttons in the button sizer
 873         if (win != reparentTo && (!buttonSizer || !buttonSizer->GetItem(win)))
 874         {
 875             win->Reparent(reparentTo);
 876 #ifdef __WXMSW__
 877             // Restore correct tab order
 878             ::SetWindowPos((HWND) win->GetHWND(), HWND_BOTTOM, -1, -1, -1, -1, SWP_NOMOVE|SWP_NOSIZE);
 879 #endif
 880         }
 881
 882         node = next;
 883     }
 884 }
 885
 886 /// Find whether scrolling will be necessary for the dialog, returning wxVERTICAL, wxHORIZONTAL or both
 887 int wxStandardDialogLayoutAdapter::MustScroll(wxDialog* dialog, wxSize& windowSize, wxSize& displaySize)
 888 {
 889     return DoMustScroll(dialog, windowSize, displaySize);
 890 }
 891
 892 /// Find whether scrolling will be necessary for the dialog, returning wxVERTICAL, wxHORIZONTAL or both
 893 int wxStandardDialogLayoutAdapter::DoMustScroll(wxDialog* dialog, wxSize& windowSize, wxSize& displaySize)
 894 {
 895     wxSize minWindowSize = dialog->GetSizer()->GetMinSize();
 896     windowSize = dialog->GetSize();
 897     windowSize = wxSize(wxMax(windowSize.x, minWindowSize.x), wxMax(windowSize.y, minWindowSize.y));
 898 #if wxUSE_DISPLAY
 899     displaySize = wxDisplay(wxDisplay::GetFromWindow(dialog)).GetClientArea().GetSize();
 900 #else
 901     displaySize = wxGetClientDisplayRect().GetSize();
 902 #endif
 903
 904     int flags = 0;
 905
 906     if (windowSize.y >= (displaySize.y - wxEXTRA_DIALOG_HEIGHT))
 907         flags |= wxVERTICAL;
 908     if (windowSize.x >= displaySize.x)
 909         flags |= wxHORIZONTAL;
 910
 911     return flags;
 912 }
 913
 914 // A function to fit the dialog around its contents, and then adjust for screen size.
 915 // If scrolled windows are passed, scrolling is enabled in the required orientation(s).
 916 bool wxStandardDialogLayoutAdapter::FitWithScrolling(wxDialog* dialog, wxWindowList& windows)
 917 {
 918     return DoFitWithScrolling(dialog, windows);
 919 }
 920
 921 // A function to fit the dialog around its contents, and then adjust for screen size.
 922 // If a scrolled window is passed, scrolling is enabled in the required orientation(s).
 923 bool wxStandardDialogLayoutAdapter::FitWithScrolling(wxDialog* dialog, wxScrolledWindow* scrolledWindow)
 924 {
 925     return DoFitWithScrolling(dialog, scrolledWindow);
 926 }
 927
 928 // A function to fit the dialog around its contents, and then adjust for screen size.
 929 // If a scrolled window is passed, scrolling is enabled in the required orientation(s).
 930 bool wxStandardDialogLayoutAdapter::DoFitWithScrolling(wxDialog* dialog, wxScrolledWindow* scrolledWindow)
 931 {
 932     wxWindowList windows;
 933     windows.Append(scrolledWindow);
 934     return DoFitWithScrolling(dialog, windows);
 935 }
 936
 937 bool wxStandardDialogLayoutAdapter::DoFitWithScrolling(wxDialog* dialog, wxWindowList& windows)
 938 {
 939     wxSizer* sizer = dialog->GetSizer();
 940     if (!sizer)
 941         return false;
 942
 943     sizer->SetSizeHints(dialog);
 944
 945     wxSize windowSize, displaySize;
 946     int scrollFlags = DoMustScroll(dialog, windowSize, displaySize);
 947     int scrollBarSize = 20;
 948
 949     if (scrollFlags)
 950     {
 951         int scrollBarExtraX = 0, scrollBarExtraY = 0;
 952         bool resizeHorizontally = (scrollFlags & wxHORIZONTAL) != 0;
 953         bool resizeVertically = (scrollFlags & wxVERTICAL) != 0;
 954
 955         if (windows.GetCount() != 0)
 956         {
 957             // Allow extra for a scrollbar, assuming we resizing in one direction only.
 958             if ((resizeVertically && !resizeHorizontally) && (windowSize.x < (displaySize.x - scrollBarSize)))
 959                 scrollBarExtraX = scrollBarSize;
 960             if ((resizeHorizontally && !resizeVertically) && (windowSize.y < (displaySize.y - scrollBarSize)))
 961                 scrollBarExtraY = scrollBarSize;
 962         }
 963
 964         wxWindowList::compatibility_iterator node = windows.GetFirst();
 965         while (node)
 966         {
 967             wxWindow *win = node->GetData();
 968             wxScrolledWindow* scrolledWindow = wxDynamicCast(win, wxScrolledWindow);
 969             if (scrolledWindow)
 970             {
 971                 scrolledWindow->SetScrollRate(resizeHorizontally ? 10 : 0, resizeVertically ? 10 : 0);
 972
 973                 if (scrolledWindow->GetSizer())
 974                     scrolledWindow->GetSizer()->Fit(scrolledWindow);
 975             }
 976
 977             node = node->GetNext();
 978         }
 979
 980         wxSize limitTo = windowSize + wxSize(scrollBarExtraX, scrollBarExtraY);
 981         if (resizeVertically)
 982             limitTo.y = displaySize.y - wxEXTRA_DIALOG_HEIGHT;
 983         if (resizeHorizontally)
 984             limitTo.x = displaySize.x;
 985
 986         dialog->SetMinSize(limitTo);
 987         dialog->SetSize(limitTo);
 988
 989         dialog->SetSizeHints( limitTo.x, limitTo.y, dialog->GetMaxWidth(), dialog->GetMaxHeight() );
 990     }
 991
 992     return true;
 993 }
 994
 995 /*!
 996  * Module to initialise standard adapter
 997  */
 998
 999 class wxDialogLayoutAdapterModule: public wxModule
1000 {
1001     DECLARE_DYNAMIC_CLASS(wxDialogLayoutAdapterModule)
1002 public:
1003     wxDialogLayoutAdapterModule() {}
1004     virtual void OnExit() { delete wxDialogBase::SetLayoutAdapter(NULL); }
1005     virtual bool OnInit() { wxDialogBase::SetLayoutAdapter(new wxStandardDialogLayoutAdapter); return true; }
1006 };
1007
1008 IMPLEMENT_DYNAMIC_CLASS(wxDialogLayoutAdapterModule, wxModule)