X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/551f281b794a8f9b04526bd3055b080ec406dff5..77c8efc8c37da6d6a5e2e8022d21d1cd7d76371d:/src/common/dlgcmn.cpp diff --git a/src/common/dlgcmn.cpp b/src/common/dlgcmn.cpp index 7fad04b640..9289aa2d58 100644 --- a/src/common/dlgcmn.cpp +++ b/src/common/dlgcmn.cpp @@ -27,6 +27,7 @@ #include "wx/dialog.h" #ifndef WX_PRECOMP + #include "wx/app.h" #include "wx/button.h" #include "wx/dcclient.h" #include "wx/intl.h" @@ -38,323 +39,266 @@ #include "wx/statline.h" #include "wx/sysopt.h" +#include "wx/module.h" +#include "wx/bookctrl.h" +#include "wx/scrolwin.h" +#include "wx/textwrapper.h" +#include "wx/testing.h" + +#if wxUSE_DISPLAY +#include "wx/display.h" +#endif -#if wxUSE_STATTEXT +extern WXDLLEXPORT_DATA(const char) wxDialogNameStr[] = "dialog"; + +wxModalDialogHook *wxModalDialogHook::ms_instance = NULL; // ---------------------------------------------------------------------------- -// wxTextWrapper +// XTI // ---------------------------------------------------------------------------- -// this class is used to wrap the text on word boundary: wrapping is done by -// calling OnStartLine() and OnOutputLine() functions -class wxTextWrapper -{ -public: - wxTextWrapper() { m_eol = false; } - - // win is used for getting the font, text is the text to wrap, width is the - // max line width or -1 to disable wrapping - void Wrap(wxWindow *win, const wxString& text, int widthMax); - - // we don't need it, but just to avoid compiler warnings - virtual ~wxTextWrapper() { } - -protected: - // line may be empty - virtual void OnOutputLine(const wxString& line) = 0; - - // called at the start of every new line (except the very first one) - virtual void OnNewLine() { } - -private: - // call OnOutputLine() and set m_eol to true - void DoOutputLine(const wxString& line) - { - OnOutputLine(line); - - m_eol = true; - } - - // this function is a destructive inspector: when it returns true it also - // resets the flag to false so calling it again woulnd't return true any - // more - bool IsStartOfNewLine() - { - if ( !m_eol ) - return false; - - m_eol = false; - - return true; - } - - - bool m_eol; -}; - -#endif // wxUSE_STATTEXT +wxDEFINE_FLAGS( wxDialogStyle ) +wxBEGIN_FLAGS( wxDialogStyle ) +// new style border flags, we put them first to +// use them for streaming out +wxFLAGS_MEMBER(wxBORDER_SIMPLE) +wxFLAGS_MEMBER(wxBORDER_SUNKEN) +wxFLAGS_MEMBER(wxBORDER_DOUBLE) +wxFLAGS_MEMBER(wxBORDER_RAISED) +wxFLAGS_MEMBER(wxBORDER_STATIC) +wxFLAGS_MEMBER(wxBORDER_NONE) + +// old style border flags +wxFLAGS_MEMBER(wxSIMPLE_BORDER) +wxFLAGS_MEMBER(wxSUNKEN_BORDER) +wxFLAGS_MEMBER(wxDOUBLE_BORDER) +wxFLAGS_MEMBER(wxRAISED_BORDER) +wxFLAGS_MEMBER(wxSTATIC_BORDER) +wxFLAGS_MEMBER(wxNO_BORDER) + +// standard window styles +wxFLAGS_MEMBER(wxTAB_TRAVERSAL) +wxFLAGS_MEMBER(wxCLIP_CHILDREN) + +// dialog styles +wxFLAGS_MEMBER(wxWS_EX_VALIDATE_RECURSIVELY) +wxFLAGS_MEMBER(wxSTAY_ON_TOP) +wxFLAGS_MEMBER(wxCAPTION) +#if WXWIN_COMPATIBILITY_2_6 +wxFLAGS_MEMBER(wxTHICK_FRAME) +#endif // WXWIN_COMPATIBILITY_2_6 +wxFLAGS_MEMBER(wxSYSTEM_MENU) +wxFLAGS_MEMBER(wxRESIZE_BORDER) +#if WXWIN_COMPATIBILITY_2_6 +wxFLAGS_MEMBER(wxRESIZE_BOX) +#endif // WXWIN_COMPATIBILITY_2_6 +wxFLAGS_MEMBER(wxCLOSE_BOX) +wxFLAGS_MEMBER(wxMAXIMIZE_BOX) +wxFLAGS_MEMBER(wxMINIMIZE_BOX) +wxEND_FLAGS( wxDialogStyle ) + +wxIMPLEMENT_DYNAMIC_CLASS_XTI(wxDialog, wxTopLevelWindow, "wx/dialog.h") + +wxBEGIN_PROPERTIES_TABLE(wxDialog) +wxPROPERTY( Title, wxString, SetTitle, GetTitle, wxString(), \ + 0 /*flags*/, wxT("Helpstring"), wxT("group")) + +wxPROPERTY_FLAGS( WindowStyle, wxDialogStyle, long, SetWindowStyleFlag, \ + GetWindowStyleFlag, wxEMPTY_PARAMETER_VALUE, 0 /*flags*/, \ + wxT("Helpstring"), wxT("group")) // style +wxEND_PROPERTIES_TABLE() + +wxEMPTY_HANDLERS_TABLE(wxDialog) + +wxCONSTRUCTOR_6( wxDialog, wxWindow*, Parent, wxWindowID, Id, \ + wxString, Title, wxPoint, Position, wxSize, Size, long, WindowStyle) // ---------------------------------------------------------------------------- // wxDialogBase // ---------------------------------------------------------------------------- BEGIN_EVENT_TABLE(wxDialogBase, wxTopLevelWindow) - EVT_BUTTON(wxID_OK, wxDialogBase::OnAffirmativeButton) - EVT_BUTTON(wxID_APPLY, wxDialogBase::OnApply) - EVT_BUTTON(wxID_CANCEL, wxDialogBase::OnCancelButton) + EVT_BUTTON(wxID_ANY, wxDialogBase::OnButton) EVT_CLOSE(wxDialogBase::OnCloseWindow) EVT_CHAR_HOOK(wxDialogBase::OnCharHook) - - WX_EVENT_TABLE_CONTROL_CONTAINER(wxDialogBase) END_EVENT_TABLE() -WX_DELEGATE_TO_CONTROL_CONTAINER(wxDialogBase, wxTopLevelWindow) +wxDialogLayoutAdapter* wxDialogBase::sm_layoutAdapter = NULL; +bool wxDialogBase::sm_layoutAdaptation = false; void wxDialogBase::Init() { m_returnCode = 0; m_affirmativeId = wxID_OK; m_escapeId = wxID_ANY; + m_layoutAdaptationLevel = 3; + m_layoutAdaptationDone = FALSE; + m_layoutAdaptationMode = wxDIALOG_ADAPTATION_MODE_DEFAULT; // the dialogs have this flag on by default to prevent the events from the // dialog controls from reaching the parent frame which is usually // undesirable and can lead to unexpected and hard to find bugs SetExtraStyle(GetExtraStyle() | wxWS_EX_BLOCK_EVENTS); - - m_container.SetContainerWindow(this); } -#if wxUSE_STATTEXT - -void wxTextWrapper::Wrap(wxWindow *win, const wxString& text, int widthMax) +wxWindow *wxDialogBase::CheckIfCanBeUsedAsParent(wxWindow *parent) const { - const wxChar *lastSpace = NULL; - wxString line; + if ( !parent ) + return NULL; - const wxChar *lineStart = text.c_str(); - for ( const wxChar *p = lineStart; ; p++ ) + extern WXDLLIMPEXP_DATA_BASE(wxList) wxPendingDelete; + if ( wxPendingDelete.Member(parent) || parent->IsBeingDeleted() ) { - if ( IsStartOfNewLine() ) - { - OnNewLine(); - - lastSpace = NULL; - line.clear(); - lineStart = p; - } - - if ( *p == _T('\n') || *p == _T('\0') ) - { - DoOutputLine(line); - - if ( *p == _T('\0') ) - break; - } - else // not EOL - { - if ( *p == _T(' ') ) - lastSpace = p; - - line += *p; - - if ( widthMax >= 0 && lastSpace ) - { - int width; - win->GetTextExtent(line, &width, NULL); - - if ( width > widthMax ) - { - // remove the last word from this line - line.erase(lastSpace - lineStart, p + 1 - lineStart); - DoOutputLine(line); - - // go back to the last word of this line which we didn't - // output yet - p = lastSpace; - } - } - //else: no wrapping at all or impossible to wrap - } + // this window is being deleted and we shouldn't create any children + // under it + return NULL; } -} -class wxTextSizerWrapper : public wxTextWrapper -{ -public: - wxTextSizerWrapper(wxWindow *win) + if ( parent->HasExtraStyle(wxWS_EX_TRANSIENT) ) { - m_win = win; - m_hLine = 0; + // this window is not being deleted yet but it's going to disappear + // soon so still don't parent this window under it + return NULL; } - wxSizer *CreateSizer(const wxString& text, int widthMax) + if ( !parent->IsShownOnScreen() ) { - m_sizer = new wxBoxSizer(wxVERTICAL); - Wrap(m_win, text, widthMax); - return m_sizer; + // using hidden parent won't work correctly neither + return NULL; } -protected: - virtual void OnOutputLine(const wxString& line) + // FIXME-VC6: this compiler requires an explicit const cast or it fails + // with error C2446 + if ( const_cast(parent) == this ) { - if ( !line.empty() ) - { - m_sizer->Add(new wxStaticText(m_win, wxID_ANY, line)); - } - else // empty line, no need to create a control for it - { - if ( !m_hLine ) - m_hLine = m_win->GetCharHeight(); - - m_sizer->Add(5, m_hLine); - } + // not sure if this can really happen but it doesn't hurt to guard + // against this clearly invalid situation + return NULL; } -private: - wxWindow *m_win; - wxSizer *m_sizer; - int m_hLine; -}; + return parent; +} -wxSizer *wxDialogBase::CreateTextSizer(const wxString& message) +wxWindow * +wxDialogBase::GetParentForModalDialog(wxWindow *parent, long style) const { - // I admit that this is complete bogus, but it makes - // message boxes work for pda screens temporarily.. - int widthMax = -1; - const bool is_pda = wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA; - if (is_pda) - { - widthMax = wxSystemSettings::GetMetric( wxSYS_SCREEN_X ) - 25; - } + // creating a parent-less modal dialog will result (under e.g. wxGTK2) + // in an unfocused dialog, so try to find a valid parent for it unless we + // were explicitly asked not to + if ( style & wxDIALOG_NO_PARENT ) + return NULL; + + // first try the given parent + if ( parent ) + parent = CheckIfCanBeUsedAsParent(wxGetTopLevelParent(parent)); + + // then the currently active window + if ( !parent ) + parent = CheckIfCanBeUsedAsParent( + wxGetTopLevelParent(wxGetActiveWindow())); + + // and finally the application main window + if ( !parent ) + parent = CheckIfCanBeUsedAsParent(wxTheApp->GetTopWindow()); + + return parent; +} - // '&' is used as accel mnemonic prefix in the wxWidgets controls but in - // the static messages created by CreateTextSizer() (used by wxMessageBox, - // for example), we don't want this special meaning, so we need to quote it - wxString text(message); - text.Replace(_T("&"), _T("&&")); +#if wxUSE_STATTEXT +wxSizer *wxDialogBase::CreateTextSizer(const wxString& message) +{ wxTextSizerWrapper wrapper(this); - return wrapper.CreateSizer(text, widthMax); + return CreateTextSizer(message, wrapper); } -class wxLabelWrapper : public wxTextWrapper +wxSizer *wxDialogBase::CreateTextSizer(const wxString& message, + wxTextSizerWrapper& wrapper) { -public: - void WrapLabel(wxWindow *text, int widthMax) - { - m_text.clear(); - Wrap(text, text->GetLabel(), widthMax); - text->SetLabel(m_text); - } - -protected: - virtual void OnOutputLine(const wxString& line) - { - m_text += line; - } - - virtual void OnNewLine() + // I admit that this is complete bogus, but it makes + // message boxes work for pda screens temporarily.. + int widthMax = -1; + const bool is_pda = wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA; + if (is_pda) { - m_text += _T('\n'); + widthMax = wxSystemSettings::GetMetric( wxSYS_SCREEN_X ) - 25; } -private: - wxString m_text; -}; - -// NB: don't "factor out" the scope operator, SGI MIPSpro 7.3 (but not 7.4) -// gets confused if it doesn't immediately follow the class name -void -#if defined(__WXGTK__) && !defined(__WXUNIVERSAL__) -wxStaticText:: -#else -wxStaticTextBase:: -#endif -Wrap(int width) -{ - wxLabelWrapper wrapper; - wrapper.WrapLabel(this, width); + return wrapper.CreateSizer(message, widthMax); } #endif // wxUSE_STATTEXT -wxSizer *wxDialogBase::CreateButtonSizer( long flags, bool separated, wxCoord distance ) +wxSizer *wxDialogBase::CreateButtonSizer(long flags) { #ifdef __SMARTPHONE__ - wxUnusedVar(separated); - wxUnusedVar(distance); - wxDialog* dialog = (wxDialog*) this; - if (flags & wxOK){ + if ( flags & wxOK ) dialog->SetLeftMenu(wxID_OK); - } - if (flags & wxCANCEL){ + if ( flags & wxCANCEL ) dialog->SetRightMenu(wxID_CANCEL); - } - if (flags & wxYES){ + if ( flags & wxYES ) dialog->SetLeftMenu(wxID_YES); - } - if (flags & wxNO){ - dialog->SetLeftMenu(wxID_NO); - } - wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL); - return sizer; + if ( flags & wxNO ) + dialog->SetRightMenu(wxID_NO); + return NULL; #else // !__SMARTPHONE__ +#if wxUSE_BUTTON + #ifdef __POCKETPC__ - // PocketPC guidelines recommend for Ok/Cancel dialogs to use - // OK button located inside caption bar and implement Cancel functionality - // through Undo outside dialog. As native behaviour this will be default - // here but can be easily replaced with real wxButtons - // with "wince.dialog.real-ok-cancel" option set to 1 - if ( ((flags & ~(wxCANCEL|wxNO_DEFAULT))== wxOK) && - (wxSystemOptions::GetOptionInt(wxT("wince.dialog.real-ok-cancel"))==0) - ) - { - wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL); - return sizer; + // PocketPC guidelines recommend for Ok/Cancel dialogs to use OK button + // located inside caption bar and implement Cancel functionality through + // Undo outside dialog. As native behaviour this will be default here but + // can be replaced with real wxButtons by setting the option below to 1 + if ( (flags & ~(wxCANCEL|wxNO_DEFAULT)) != wxOK || + wxSystemOptions::GetOptionInt(wxT("wince.dialog.real-ok-cancel")) ) +#endif // __POCKETPC__ + { + return CreateStdDialogButtonSizer(flags); } +#ifdef __POCKETPC__ + return NULL; #endif // __POCKETPC__ -#if wxUSE_BUTTON - - wxSizer* buttonSizer = CreateStdDialogButtonSizer( flags ); - - // Mac Human Interface Guidelines recommend not to use static lines as grouping elements -#if wxUSE_STATLINE && !defined(__WXMAC__) - if(!separated) - return buttonSizer; - - wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL ); - topsizer->Add( new wxStaticLine( this, wxID_ANY ), 0, wxEXPAND | wxBOTTOM, distance ); - topsizer->Add( buttonSizer, 0, wxEXPAND ); - return topsizer; - -#else // !wxUSE_STATLINE +#else // !wxUSE_BUTTON + wxUnusedVar(flags); - wxUnusedVar(separated); - wxUnusedVar(distance); - return buttonSizer; + return NULL; +#endif // wxUSE_BUTTON/!wxUSE_BUTTON -#endif // wxUSE_STATLINE/!wxUSE_STATLINE +#endif // __SMARTPHONE__/!__SMARTPHONE__ +} -#else // !wxUSE_BUTTON +wxSizer *wxDialogBase::CreateSeparatedSizer(wxSizer *sizer) +{ + // Mac Human Interface Guidelines recommend not to use static lines as + // grouping elements +#if wxUSE_STATLINE && !defined(__WXMAC__) + wxBoxSizer *topsizer = new wxBoxSizer(wxVERTICAL); + topsizer->Add(new wxStaticLine(this), + wxSizerFlags().Expand().DoubleBorder(wxBOTTOM)); + topsizer->Add(sizer, wxSizerFlags().Expand()); + sizer = topsizer; +#endif // wxUSE_STATLINE - wxUnusedVar(separated); - wxUnusedVar(distance); - wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL); return sizer; +} -#endif // wxUSE_BUTTON/!wxUSE_BUTTON +wxSizer *wxDialogBase::CreateSeparatedButtonSizer(long flags) +{ + wxSizer *sizer = CreateButtonSizer(flags); + if ( !sizer ) + return NULL; -#endif // __SMARTPHONE__/!__SMARTPHONE__ + return CreateSeparatedSizer(sizer); } #if wxUSE_BUTTON @@ -367,27 +311,44 @@ wxStdDialogButtonSizer *wxDialogBase::CreateStdDialogButtonSizer( long flags ) wxButton *yes = NULL; wxButton *no = NULL; - if (flags & wxOK){ + if (flags & wxOK) + { ok = new wxButton(this, wxID_OK); sizer->AddButton(ok); } - if (flags & wxCANCEL){ + if (flags & wxCANCEL) + { wxButton *cancel = new wxButton(this, wxID_CANCEL); sizer->AddButton(cancel); } - if (flags & wxYES){ + if (flags & wxYES) + { yes = new wxButton(this, wxID_YES); sizer->AddButton(yes); } - if (flags & wxNO){ + if (flags & wxNO) + { no = new wxButton(this, wxID_NO); sizer->AddButton(no); } - if (flags & wxHELP){ + if (flags & wxAPPLY) + { + wxButton *apply = new wxButton(this, wxID_APPLY); + sizer->AddButton(apply); + } + + if (flags & wxCLOSE) + { + wxButton *close = new wxButton(this, wxID_CLOSE); + sizer->AddButton(close); + } + + if (flags & wxHELP) + { wxButton *help = new wxButton(this, wxID_HELP); sizer->AddButton(help); } @@ -427,87 +388,38 @@ wxStdDialogButtonSizer *wxDialogBase::CreateStdDialogButtonSizer( long flags ) #endif // wxUSE_BUTTON // ---------------------------------------------------------------------------- -// escape/affirmatives button handling +// standard buttons handling // ---------------------------------------------------------------------------- +void wxDialogBase::EndDialog(int rc) +{ + if ( IsModal() ) + EndModal(rc); + else + Hide(); +} + void wxDialogBase::AcceptAndClose() { if ( Validate() && TransferDataFromWindow() ) { - EndDialog(wxID_OK); + EndDialog(m_affirmativeId); } } void wxDialogBase::SetAffirmativeId(int affirmativeId) { - if ( affirmativeId == m_affirmativeId ) - return; - - // disconnect the handler for the old affirmative button - if ( m_affirmativeId != wxID_NONE && m_affirmativeId != wxID_OK ) - { - if ( !Disconnect - ( - m_affirmativeId, - wxEVT_COMMAND_BUTTON_CLICKED, - wxCommandEventHandler(wxDialogBase::OnAffirmativeButton) - ) ) - { - wxFAIL_MSG( _T("failed to disconnect old ok handler") ); - } - } - //else: wxID_OK is always handled - - // connect the handler to the new button - if ( affirmativeId != wxID_NONE ) - { - Connect(m_affirmativeId, - wxEVT_COMMAND_BUTTON_CLICKED, - wxCommandEventHandler(wxDialogBase::OnAffirmativeButton)); - } - //else: no affirmative button - m_affirmativeId = affirmativeId; } void wxDialogBase::SetEscapeId(int escapeId) { - if ( escapeId == m_escapeId ) - return; - - if ( m_escapeId != wxID_ANY && - m_escapeId != wxID_CANCEL && - m_escapeId != wxID_ANY ) - { - if ( !Disconnect - ( - m_escapeId, - wxEVT_COMMAND_BUTTON_CLICKED, - wxCommandEventHandler(wxDialogBase::OnCancelButton) - ) ) - { - wxFAIL_MSG( _T("failed to disconnect old cancel handler") ); - } - } - //else: wxID_CANCEL is always handled - - // connect the handler to the new button - if ( escapeId != wxID_NONE ) - { - Connect(m_escapeId, - wxEVT_COMMAND_BUTTON_CLICKED, - wxCommandEventHandler(wxDialogBase::OnCancelButton)); - } - m_escapeId = escapeId; } -// ---------------------------------------------------------------------------- -// event handling stuff -// ---------------------------------------------------------------------------- - bool wxDialogBase::EmulateButtonClickIfPresent(int id) { +#if wxUSE_BUTTON wxButton *btn = wxDynamicCast(FindWindow(id), wxButton); if ( !btn || !btn->IsEnabled() || !btn->IsShown() ) @@ -518,84 +430,131 @@ bool wxDialogBase::EmulateButtonClickIfPresent(int id) btn->GetEventHandler()->ProcessEvent(event); return true; +#else // !wxUSE_BUTTON + wxUnusedVar(id); + return false; +#endif // wxUSE_BUTTON/!wxUSE_BUTTON } -void wxDialogBase::EndDialog(int rc) +bool wxDialogBase::SendCloseButtonClickEvent() { - if ( IsModal() ) - EndModal(rc); - else - Hide(); + int idCancel = GetEscapeId(); + switch ( idCancel ) + { + case wxID_NONE: + // The user doesn't want this dialog to close "implicitly". + break; + + case wxID_ANY: + // this value is special: it means translate Esc to wxID_CANCEL + // but if there is no such button, then fall back to wxID_OK + if ( EmulateButtonClickIfPresent(wxID_CANCEL) ) + return true; + idCancel = GetAffirmativeId(); + // fall through + + default: + // translate Esc to button press for the button with given id + if ( EmulateButtonClickIfPresent(idCancel) ) + return true; + } + + return false; } bool wxDialogBase::IsEscapeKey(const wxKeyEvent& event) { - // for most platforms, Esc key is used to close the dialogs - return event.GetKeyCode() == WXK_ESCAPE && - event.GetModifiers() == wxMOD_NONE; + // For most platforms, Esc key is used to close the dialogs. + // + // Notice that we intentionally don't check for modifiers here, Shift-Esc, + // Alt-Esc and so on still close the dialog, typically. + return event.GetKeyCode() == WXK_ESCAPE; } void wxDialogBase::OnCharHook(wxKeyEvent& event) { - if ( event.GetKeyCode() == WXK_ESCAPE ) + if ( IsEscapeKey(event) ) { - int idCancel = GetEscapeId(); - switch ( idCancel ) + if ( SendCloseButtonClickEvent() ) { - case wxID_NONE: - // don't handle Esc specially at all - break; - - case wxID_ANY: - // this value is special: it means translate Esc to wxID_CANCEL - // but if there is no such button, then fall back to wxID_OK - if ( EmulateButtonClickIfPresent(wxID_CANCEL) ) - return; - idCancel = wxID_OK; - // fall through - - default: - // translate Esc to button press for the button with given id - if ( EmulateButtonClickIfPresent(idCancel) ) - return; + // Skip the call to event.Skip() below, we did handle this key. + return; } } event.Skip(); } -void wxDialogBase::OnAffirmativeButton(wxCommandEvent& WXUNUSED(event)) +void wxDialogBase::OnButton(wxCommandEvent& event) { - AcceptAndClose(); + const int id = event.GetId(); + if ( id == GetAffirmativeId() ) + { + AcceptAndClose(); + } + else if ( id == wxID_APPLY ) + { + if ( Validate() ) + TransferDataFromWindow(); + + // TODO: disable the Apply button until things change again + } + else if ( id == GetEscapeId() || + (id == wxID_CANCEL && GetEscapeId() == wxID_ANY) ) + { + EndDialog(wxID_CANCEL); + } + else // not a standard button + { + event.Skip(); + } } -void wxDialogBase::OnApply(wxCommandEvent& WXUNUSED(event)) +// ---------------------------------------------------------------------------- +// compatibility methods for supporting the modality API +// ---------------------------------------------------------------------------- + +wxDEFINE_EVENT( wxEVT_WINDOW_MODAL_DIALOG_CLOSED , wxWindowModalDialogEvent ); + +IMPLEMENT_DYNAMIC_CLASS(wxWindowModalDialogEvent, wxCommandEvent) + +void wxDialogBase::ShowWindowModal () +{ + ShowModal(); + SendWindowModalDialogEvent ( wxEVT_WINDOW_MODAL_DIALOG_CLOSED ); +} + +void wxDialogBase::SendWindowModalDialogEvent ( wxEventType type ) { - if ( Validate() ) - TransferDataFromWindow(); + wxWindowModalDialogEvent event ( type, GetId()); + event.SetEventObject(this); - // TODO probably need to disable the Apply button until things change again + if ( !GetEventHandler()->ProcessEvent(event) ) + { + // the event is not propagated upwards to the parent automatically + // because the dialog is a top level window, so do it manually as + // in 9 cases of 10 the message must be processed by the dialog + // owner and not the dialog itself + (void)GetParent()->GetEventHandler()->ProcessEvent(event); + } } -void wxDialogBase::OnCancelButton(wxCommandEvent& WXUNUSED(event)) + +wxDialogModality wxDialogBase::GetModality() const { - EndDialog(wxID_CANCEL); + return IsModal() ? wxDIALOG_MODALITY_APP_MODAL : wxDIALOG_MODALITY_NONE; } +// ---------------------------------------------------------------------------- +// other event handlers +// ---------------------------------------------------------------------------- + void wxDialogBase::OnCloseWindow(wxCloseEvent& WXUNUSED(event)) { // We'll send a Cancel message by default, which may close the dialog. - // Check for looping if the Cancel event handler calls Close(). - - // Note that if a cancel button and handler aren't present in the dialog, - // nothing will happen when you close the dialog via the window manager, or - // via Close(). We wouldn't want to destroy the dialog by default, since - // the dialog may have been created on the stack. However, this does mean - // that calling dialog->Close() won't delete the dialog unless the handler - // for wxID_CANCEL does so. So use Destroy() if you want to be sure to - // destroy the dialog. The default OnCancel (above) simply ends a modal - // dialog, and hides a modeless dialog. + // Check for looping if the Cancel event handler calls Close(). + // // VZ: this is horrible and MT-unsafe. Can't we reuse some of these global // lists here? don't dare to change it now, but should be done later! static wxList closing; @@ -605,15 +564,448 @@ void wxDialogBase::OnCloseWindow(wxCloseEvent& WXUNUSED(event)) closing.Append(this); - wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); - cancelEvent.SetEventObject( this ); - GetEventHandler()->ProcessEvent(cancelEvent); // This may close the dialog + if ( !SendCloseButtonClickEvent() ) + { + // If the handler didn't close the dialog (e.g. because there is no + // button with matching id) we still want to close it when the user + // clicks the "x" button in the title bar, otherwise we shouldn't even + // have put it there. + // + // Notice that using wxID_CLOSE might have been a better choice but we + // use wxID_CANCEL for compatibility reasons. + EndDialog(wxID_CANCEL); + } closing.DeleteObject(this); } -void wxDialogBase::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event)) +void wxDialogBase::OnSysColourChanged(wxSysColourChangedEvent& event) +{ +#ifndef __WXGTK__ + SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)); + Refresh(); +#endif + + event.Skip(); +} + +/// Do the adaptation +bool wxDialogBase::DoLayoutAdaptation() +{ + if (GetLayoutAdapter()) + { + wxWindow* focusWindow = wxFindFocusDescendant(this); // from event.h + if (GetLayoutAdapter()->DoLayoutAdaptation((wxDialog*) this)) + { + if (focusWindow) + focusWindow->SetFocus(); + return true; + } + else + return false; + } + else + return false; +} + +/// Can we do the adaptation? +bool wxDialogBase::CanDoLayoutAdaptation() +{ + // Check if local setting overrides the global setting + bool layoutEnabled = (GetLayoutAdaptationMode() == wxDIALOG_ADAPTATION_MODE_ENABLED) || (IsLayoutAdaptationEnabled() && (GetLayoutAdaptationMode() != wxDIALOG_ADAPTATION_MODE_DISABLED)); + + return (layoutEnabled && !m_layoutAdaptationDone && GetLayoutAdaptationLevel() != 0 && GetLayoutAdapter() != NULL && GetLayoutAdapter()->CanDoLayoutAdaptation((wxDialog*) this)); +} + +/// Set scrolling adapter class, returning old adapter +wxDialogLayoutAdapter* wxDialogBase::SetLayoutAdapter(wxDialogLayoutAdapter* adapter) +{ + wxDialogLayoutAdapter* oldLayoutAdapter = sm_layoutAdapter; + sm_layoutAdapter = adapter; + return oldLayoutAdapter; +} + +/*! + * Standard adapter + */ + +IMPLEMENT_CLASS(wxDialogLayoutAdapter, wxObject) + +IMPLEMENT_CLASS(wxStandardDialogLayoutAdapter, wxDialogLayoutAdapter) + +// Allow for caption size on wxWidgets < 2.9 +#if defined(__WXGTK__) && !wxCHECK_VERSION(2,9,0) +#define wxEXTRA_DIALOG_HEIGHT 30 +#else +#define wxEXTRA_DIALOG_HEIGHT 0 +#endif + +/// Indicate that adaptation should be done +bool wxStandardDialogLayoutAdapter::CanDoLayoutAdaptation(wxDialog* dialog) +{ + if (dialog->GetSizer()) + { + wxSize windowSize, displaySize; + return MustScroll(dialog, windowSize, displaySize) != 0; + } + else + return false; +} + +bool wxStandardDialogLayoutAdapter::DoLayoutAdaptation(wxDialog* dialog) +{ + if (dialog->GetSizer()) + { +#if wxUSE_BOOKCTRL + wxBookCtrlBase* bookContentWindow = wxDynamicCast(dialog->GetContentWindow(), wxBookCtrlBase); + + if (bookContentWindow) + { + // If we have a book control, make all the pages (that use sizers) scrollable + wxWindowList windows; + for (size_t i = 0; i < bookContentWindow->GetPageCount(); i++) + { + wxWindow* page = bookContentWindow->GetPage(i); + + wxScrolledWindow* scrolledWindow = wxDynamicCast(page, wxScrolledWindow); + if (scrolledWindow) + windows.Append(scrolledWindow); + else if (!scrolledWindow && page->GetSizer()) + { + // Create a scrolled window and reparent + scrolledWindow = CreateScrolledWindow(page); + wxSizer* oldSizer = page->GetSizer(); + + wxSizer* newSizer = new wxBoxSizer(wxVERTICAL); + newSizer->Add(scrolledWindow,1, wxEXPAND, 0); + + page->SetSizer(newSizer, false /* don't delete the old sizer */); + + scrolledWindow->SetSizer(oldSizer); + + ReparentControls(page, scrolledWindow); + + windows.Append(scrolledWindow); + } + } + + FitWithScrolling(dialog, windows); + } + else +#endif // wxUSE_BOOKCTRL + { +#if wxUSE_BUTTON + // If we have an arbitrary dialog, create a scrolling area for the main content, and a button sizer + // for the main buttons. + wxScrolledWindow* scrolledWindow = CreateScrolledWindow(dialog); + + int buttonSizerBorder = 0; + + // First try to find a wxStdDialogButtonSizer + wxSizer* buttonSizer = FindButtonSizer(true /* find std button sizer */, dialog, dialog->GetSizer(), buttonSizerBorder); + + // Next try to find a wxBoxSizer containing the controls + if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_STANDARD_SIZER) + buttonSizer = FindButtonSizer(false /* find ordinary sizer */, dialog, dialog->GetSizer(), buttonSizerBorder); + + // If we still don't have a button sizer, collect any 'loose' buttons in the layout + if (!buttonSizer && dialog->GetLayoutAdaptationLevel() > wxDIALOG_ADAPTATION_ANY_SIZER) + { + int count = 0; + wxStdDialogButtonSizer* stdButtonSizer = new wxStdDialogButtonSizer; + buttonSizer = stdButtonSizer; + + FindLooseButtons(dialog, stdButtonSizer, dialog->GetSizer(), count); + if (count > 0) + stdButtonSizer->Realize(); + else + { + wxDELETE(buttonSizer); + } + } + + if (buttonSizerBorder == 0) + buttonSizerBorder = 5; + + ReparentControls(dialog, scrolledWindow, buttonSizer); + + wxBoxSizer* newTopSizer = new wxBoxSizer(wxVERTICAL); + wxSizer* oldSizer = dialog->GetSizer(); + + dialog->SetSizer(newTopSizer, false /* don't delete old sizer */); + + newTopSizer->Add(scrolledWindow, 1, wxEXPAND|wxALL, 0); + if (buttonSizer) + newTopSizer->Add(buttonSizer, 0, wxEXPAND|wxALL, buttonSizerBorder); + + scrolledWindow->SetSizer(oldSizer); + + FitWithScrolling(dialog, scrolledWindow); +#endif // wxUSE_BUTTON + } + } + + dialog->SetLayoutAdaptationDone(true); + return true; +} + +// Create the scrolled window +wxScrolledWindow* wxStandardDialogLayoutAdapter::CreateScrolledWindow(wxWindow* parent) +{ + wxScrolledWindow* scrolledWindow = new wxScrolledWindow(parent, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTAB_TRAVERSAL|wxVSCROLL|wxHSCROLL|wxBORDER_NONE); + return scrolledWindow; +} + +#if wxUSE_BUTTON + +/// Find and remove the button sizer, if any +wxSizer* wxStandardDialogLayoutAdapter::FindButtonSizer(bool stdButtonSizer, wxDialog* dialog, wxSizer* sizer, int& retBorder, int accumlatedBorder) +{ + for ( wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst(); + node; node = node->GetNext() ) + { + wxSizerItem *item = node->GetData(); + wxSizer *childSizer = item->GetSizer(); + + if ( childSizer ) + { + int newBorder = accumlatedBorder; + if (item->GetFlag() & wxALL) + newBorder += item->GetBorder(); + + if (stdButtonSizer) // find wxStdDialogButtonSizer + { + wxStdDialogButtonSizer* buttonSizer = wxDynamicCast(childSizer, wxStdDialogButtonSizer); + if (buttonSizer) + { + sizer->Detach(childSizer); + retBorder = newBorder; + return buttonSizer; + } + } + else // find a horizontal box sizer containing standard buttons + { + wxBoxSizer* buttonSizer = wxDynamicCast(childSizer, wxBoxSizer); + if (buttonSizer && IsOrdinaryButtonSizer(dialog, buttonSizer)) + { + sizer->Detach(childSizer); + retBorder = newBorder; + return buttonSizer; + } + } + + wxSizer* s = FindButtonSizer(stdButtonSizer, dialog, childSizer, retBorder, newBorder); + if (s) + return s; + } + } + return NULL; +} + +/// Check if this sizer contains standard buttons, and so can be repositioned in the dialog +bool wxStandardDialogLayoutAdapter::IsOrdinaryButtonSizer(wxDialog* dialog, wxBoxSizer* sizer) +{ + if (sizer->GetOrientation() != wxHORIZONTAL) + return false; + + for ( wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst(); + node; node = node->GetNext() ) + { + wxSizerItem *item = node->GetData(); + wxButton *childButton = wxDynamicCast(item->GetWindow(), wxButton); + + if (childButton && IsStandardButton(dialog, childButton)) + return true; + } + return false; +} + +/// Check if this is a standard button +bool wxStandardDialogLayoutAdapter::IsStandardButton(wxDialog* dialog, wxButton* button) +{ + wxWindowID id = button->GetId(); + + return (id == wxID_OK || id == wxID_CANCEL || id == wxID_YES || id == wxID_NO || id == wxID_SAVE || + id == wxID_APPLY || id == wxID_HELP || id == wxID_CONTEXT_HELP || dialog->IsMainButtonId(id)); +} + +/// Find 'loose' main buttons in the existing layout and add them to the standard dialog sizer +bool wxStandardDialogLayoutAdapter::FindLooseButtons(wxDialog* dialog, wxStdDialogButtonSizer* buttonSizer, wxSizer* sizer, int& count) +{ + wxSizerItemList::compatibility_iterator node = sizer->GetChildren().GetFirst(); + while (node) + { + wxSizerItemList::compatibility_iterator next = node->GetNext(); + wxSizerItem *item = node->GetData(); + wxSizer *childSizer = item->GetSizer(); + wxButton *childButton = wxDynamicCast(item->GetWindow(), wxButton); + + if (childButton && IsStandardButton(dialog, childButton)) + { + sizer->Detach(childButton); + buttonSizer->AddButton(childButton); + count ++; + } + + if (childSizer) + FindLooseButtons(dialog, buttonSizer, childSizer, count); + + node = next; + } + return true; +} + +#endif // wxUSE_BUTTON + +/// Reparent the controls to the scrolled window +void wxStandardDialogLayoutAdapter::ReparentControls(wxWindow* parent, wxWindow* reparentTo, wxSizer* buttonSizer) +{ + DoReparentControls(parent, reparentTo, buttonSizer); +} + +void wxStandardDialogLayoutAdapter::DoReparentControls(wxWindow* parent, wxWindow* reparentTo, wxSizer* buttonSizer) +{ + wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst(); + while (node) + { + wxWindowList::compatibility_iterator next = node->GetNext(); + + wxWindow *win = node->GetData(); + + // Don't reparent the scrolled window or buttons in the button sizer + if (win != reparentTo && (!buttonSizer || !buttonSizer->GetItem(win))) + { + win->Reparent(reparentTo); +#ifdef __WXMSW__ + // Restore correct tab order + ::SetWindowPos((HWND) win->GetHWND(), HWND_BOTTOM, -1, -1, -1, -1, SWP_NOMOVE|SWP_NOSIZE); +#endif + } + + node = next; + } +} + +/// Find whether scrolling will be necessary for the dialog, returning wxVERTICAL, wxHORIZONTAL or both +int wxStandardDialogLayoutAdapter::MustScroll(wxDialog* dialog, wxSize& windowSize, wxSize& displaySize) { - SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE)); - Refresh(); + return DoMustScroll(dialog, windowSize, displaySize); } + +/// Find whether scrolling will be necessary for the dialog, returning wxVERTICAL, wxHORIZONTAL or both +int wxStandardDialogLayoutAdapter::DoMustScroll(wxDialog* dialog, wxSize& windowSize, wxSize& displaySize) +{ + wxSize minWindowSize = dialog->GetSizer()->GetMinSize(); + windowSize = dialog->GetSize(); + windowSize = wxSize(wxMax(windowSize.x, minWindowSize.x), wxMax(windowSize.y, minWindowSize.y)); +#if wxUSE_DISPLAY + displaySize = wxDisplay(wxDisplay::GetFromWindow(dialog)).GetClientArea().GetSize(); +#else + displaySize = wxGetClientDisplayRect().GetSize(); +#endif + + int flags = 0; + + if (windowSize.y >= (displaySize.y - wxEXTRA_DIALOG_HEIGHT)) + flags |= wxVERTICAL; + if (windowSize.x >= displaySize.x) + flags |= wxHORIZONTAL; + + return flags; +} + +// A function to fit the dialog around its contents, and then adjust for screen size. +// If scrolled windows are passed, scrolling is enabled in the required orientation(s). +bool wxStandardDialogLayoutAdapter::FitWithScrolling(wxDialog* dialog, wxWindowList& windows) +{ + return DoFitWithScrolling(dialog, windows); +} + +// A function to fit the dialog around its contents, and then adjust for screen size. +// If a scrolled window is passed, scrolling is enabled in the required orientation(s). +bool wxStandardDialogLayoutAdapter::FitWithScrolling(wxDialog* dialog, wxScrolledWindow* scrolledWindow) +{ + return DoFitWithScrolling(dialog, scrolledWindow); +} + +// A function to fit the dialog around its contents, and then adjust for screen size. +// If a scrolled window is passed, scrolling is enabled in the required orientation(s). +bool wxStandardDialogLayoutAdapter::DoFitWithScrolling(wxDialog* dialog, wxScrolledWindow* scrolledWindow) +{ + wxWindowList windows; + windows.Append(scrolledWindow); + return DoFitWithScrolling(dialog, windows); +} + +bool wxStandardDialogLayoutAdapter::DoFitWithScrolling(wxDialog* dialog, wxWindowList& windows) +{ + wxSizer* sizer = dialog->GetSizer(); + if (!sizer) + return false; + + sizer->SetSizeHints(dialog); + + wxSize windowSize, displaySize; + int scrollFlags = DoMustScroll(dialog, windowSize, displaySize); + int scrollBarSize = 20; + + if (scrollFlags) + { + int scrollBarExtraX = 0, scrollBarExtraY = 0; + bool resizeHorizontally = (scrollFlags & wxHORIZONTAL) != 0; + bool resizeVertically = (scrollFlags & wxVERTICAL) != 0; + + if (windows.GetCount() != 0) + { + // Allow extra for a scrollbar, assuming we resizing in one direction only. + if ((resizeVertically && !resizeHorizontally) && (windowSize.x < (displaySize.x - scrollBarSize))) + scrollBarExtraX = scrollBarSize; + if ((resizeHorizontally && !resizeVertically) && (windowSize.y < (displaySize.y - scrollBarSize))) + scrollBarExtraY = scrollBarSize; + } + + wxWindowList::compatibility_iterator node = windows.GetFirst(); + while (node) + { + wxWindow *win = node->GetData(); + wxScrolledWindow* scrolledWindow = wxDynamicCast(win, wxScrolledWindow); + if (scrolledWindow) + { + scrolledWindow->SetScrollRate(resizeHorizontally ? 10 : 0, resizeVertically ? 10 : 0); + + if (scrolledWindow->GetSizer()) + scrolledWindow->GetSizer()->Fit(scrolledWindow); + } + + node = node->GetNext(); + } + + wxSize limitTo = windowSize + wxSize(scrollBarExtraX, scrollBarExtraY); + if (resizeVertically) + limitTo.y = displaySize.y - wxEXTRA_DIALOG_HEIGHT; + if (resizeHorizontally) + limitTo.x = displaySize.x; + + dialog->SetMinSize(limitTo); + dialog->SetSize(limitTo); + + dialog->SetSizeHints( limitTo.x, limitTo.y, dialog->GetMaxWidth(), dialog->GetMaxHeight() ); + } + + return true; +} + +/*! + * Module to initialise standard adapter + */ + +class wxDialogLayoutAdapterModule: public wxModule +{ + DECLARE_DYNAMIC_CLASS(wxDialogLayoutAdapterModule) +public: + wxDialogLayoutAdapterModule() {} + virtual void OnExit() { delete wxDialogBase::SetLayoutAdapter(NULL); } + virtual bool OnInit() { wxDialogBase::SetLayoutAdapter(new wxStandardDialogLayoutAdapter); return true; } +}; + +IMPLEMENT_DYNAMIC_CLASS(wxDialogLayoutAdapterModule, wxModule)