X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/2bda0e173844e8e0f8acf4e8ad8b5c26e5c6fe5d..404b319a85dadd7decf7a5a5331020520031a41c:/src/msw/msgdlg.cpp?ds=inline diff --git a/src/msw/msgdlg.cpp b/src/msw/msgdlg.cpp index a3f4628ae1..edff0a0f5a 100644 --- a/src/msw/msgdlg.cpp +++ b/src/msw/msgdlg.cpp @@ -1,138 +1,891 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: msgdlg.cpp +// Name: src/msw/msgdlg.cpp // Purpose: wxMessageDialog // Author: Julian Smart // Modified by: // Created: 04/01/98 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart and Markus Holzem -// Licence: wxWindows license +// Copyright: (c) Julian Smart +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// -#ifdef __GNUG__ -#pragma implementation "msgdlg.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" #ifdef __BORLANDC__ -#pragma hdrstop + #pragma hdrstop +#endif + +#if wxUSE_MSGDLG + +// there is no hook support under CE so we can't use the code for message box +// positioning there +#ifndef __WXWINCE__ + #define wxUSE_MSGBOX_HOOK 1 +#else + #define wxUSE_MSGBOX_HOOK 0 #endif #ifndef WX_PRECOMP -#include -#include "wx/defs.h" -#include "wx/utils.h" -#include "wx/dialog.h" -#include "wx/msgdlg.h" + #include "wx/msgdlg.h" + #include "wx/app.h" + #include "wx/intl.h" + #include "wx/utils.h" + #include "wx/msw/private.h" + #if wxUSE_MSGBOX_HOOK + #include "wx/hashmap.h" + #endif #endif -#include "wx/msw/private.h" +#include "wx/ptr_scpd.h" +#include "wx/dynlib.h" +#include "wx/msw/private/button.h" +#include "wx/msw/private/metrics.h" +#include "wx/msw/private/msgdlg.h" +#include "wx/testing.h" -#include -#include -#include +#if wxUSE_MSGBOX_HOOK + #include "wx/fontutil.h" + #include "wx/textbuf.h" + #include "wx/display.h" +#endif -#define wxDIALOG_DEFAULT_X 300 -#define wxDIALOG_DEFAULT_Y 300 +// For MB_TASKMODAL +#ifdef __WXWINCE__ + #include "wx/msw/wince/missing.h" +#endif + +// Interestingly, this symbol currently seems to be absent from Platform SDK +// headers but it is documented at MSDN. +#ifndef TDF_SIZE_TO_CONTENT + #define TDF_SIZE_TO_CONTENT 0x1000000 +#endif + +using namespace wxMSWMessageDialog; -#if !USE_SHARED_LIBRARY IMPLEMENT_CLASS(wxMessageDialog, wxDialog) + +#if wxUSE_MSGBOX_HOOK + +// there can potentially be one message box per thread so we use a hash map +// with thread ids as keys and (currently shown) message boxes as values +// +// TODO: replace this with wxTLS once it's available +WX_DECLARE_HASH_MAP(unsigned long, wxMessageDialog *, + wxIntegerHash, wxIntegerEqual, + wxMessageDialogMap); + +// the order in this array is the one in which buttons appear in the +// message box +const wxMessageDialog::ButtonAccessors wxMessageDialog::ms_buttons[] = +{ + { IDYES, &wxMessageDialog::GetYesLabel }, + { IDNO, &wxMessageDialog::GetNoLabel }, + { IDOK, &wxMessageDialog::GetOKLabel }, + { IDCANCEL, &wxMessageDialog::GetCancelLabel }, +}; + +namespace +{ + +wxMessageDialogMap& HookMap() +{ + static wxMessageDialogMap s_Map; + + return s_Map; +} + +/* + All this code is used for adjusting the message box layout when we mess + with its contents. It's rather complicated because we try hard to avoid + assuming much about the standard layout details and so, instead of just + laying out everything ourselves (which would have been so much simpler!) + we try to only modify the existing controls positions by offsetting them + from their default ones in the hope that this will continue to work with + the future Windows versions. + */ + +// convert the given RECT from screen to client coordinates in place +void ScreenRectToClient(HWND hwnd, RECT& rc) +{ + // map from desktop (i.e. screen) coordinates to ones of this window + // + // notice that a RECT is laid out as 2 consecutive POINTs so the cast is + // valid + ::MapWindowPoints(HWND_DESKTOP, hwnd, reinterpret_cast(&rc), 2); +} + +// set window position to the given rect +inline void SetWindowRect(HWND hwnd, const RECT& rc) +{ + ::MoveWindow(hwnd, + rc.left, rc.top, + rc.right - rc.left, rc.bottom - rc.top, + FALSE); +} + +// set window position expressed in screen coordinates, whether the window is +// child or top level +void MoveWindowToScreenRect(HWND hwnd, RECT rc) +{ + ScreenRectToClient(::GetParent(hwnd), rc); + + SetWindowRect(hwnd, rc); +} + +// helper of AdjustButtonLabels(): move the given window by dx +// +// works for both child and top level windows +void OffsetWindow(HWND hwnd, int dx) +{ + RECT rc = wxGetWindowRect(hwnd); + + rc.left += dx; + rc.right += dx; + + MoveWindowToScreenRect(hwnd, rc); +} + +} // anonymous namespace + +/* static */ +WXLRESULT wxCALLBACK +wxMessageDialog::HookFunction(int code, WXWPARAM wParam, WXLPARAM lParam) +{ + // Find the thread-local instance of wxMessageDialog + const DWORD tid = ::GetCurrentThreadId(); + wxMessageDialogMap::iterator node = HookMap().find(tid); + wxCHECK_MSG( node != HookMap().end(), false, + wxT("bogus thread id in wxMessageDialog::Hook") ); + + wxMessageDialog * const wnd = node->second; + + const HHOOK hhook = (HHOOK)wnd->m_hook; + const LRESULT rc = ::CallNextHookEx(hhook, code, wParam, lParam); + + if ( code == HCBT_ACTIVATE ) + { + // we won't need this hook any longer + ::UnhookWindowsHookEx(hhook); + wnd->m_hook = NULL; + HookMap().erase(tid); + + wnd->SetHWND((HWND)wParam); + + // replace the static text with an edit control if the message box is + // too big to fit the display + wnd->ReplaceStaticWithEdit(); + + // update the labels if necessary: we need to do it before centering + // the dialog as this can change its size + if ( wnd->HasCustomLabels() ) + wnd->AdjustButtonLabels(); + + // centre the message box on its parent if requested + if ( wnd->GetMessageDialogStyle() & wxCENTER ) + wnd->Center(); // center on parent + //else: default behaviour, center on screen + + // there seems to be no reason to leave it set + wnd->SetHWND(NULL); + } + + return rc; +} + +void wxMessageDialog::ReplaceStaticWithEdit() +{ + // check if the message box fits the display + int nDisplay = wxDisplay::GetFromWindow(this); + if ( nDisplay == wxNOT_FOUND ) + nDisplay = 0; + const wxRect rectDisplay = wxDisplay(nDisplay).GetClientArea(); + + if ( rectDisplay.Contains(GetRect()) ) + { + // nothing to do + return; + } + + + // find the static control to replace: normally there are two of them, the + // icon and the text itself so search for all of them and ignore the icon + // ones + HWND hwndStatic = ::FindWindowEx(GetHwnd(), NULL, wxT("STATIC"), NULL); + if ( ::GetWindowLong(hwndStatic, GWL_STYLE) & SS_ICON ) + hwndStatic = ::FindWindowEx(GetHwnd(), hwndStatic, wxT("STATIC"), NULL); + + if ( !hwndStatic ) + { + wxLogDebug("Failed to find the static text control in message box."); + return; + } + + // set the right font for GetCharHeight() call below + wxWindowBase::SetFont(GetMessageFont()); + + // put the new edit control at the same place + RECT rc = wxGetWindowRect(hwndStatic); + ScreenRectToClient(GetHwnd(), rc); + + // but make it less tall so that the message box fits on the screen: we try + // to make the message box take no more than 7/8 of the screen to leave + // some space above and below it + const int hText = (7*rectDisplay.height)/8 - + ( + 2*::GetSystemMetrics(SM_CYFIXEDFRAME) + + ::GetSystemMetrics(SM_CYCAPTION) + + 5*GetCharHeight() // buttons + margins + ); + const int dh = (rc.bottom - rc.top) - hText; // vertical space we save + rc.bottom -= dh; + + // and it also must be wider as it needs a vertical scrollbar (in order + // to preserve the word wrap, otherwise the number of lines would change + // and we want the control to look as similar as possible to the original) + // + // NB: you would have thought that 2*SM_CXEDGE would be enough but it + // isn't, somehow, and the text control breaks lines differently from + // the static one so fudge by adding some extra space + const int dw = ::GetSystemMetrics(SM_CXVSCROLL) + + 4*::GetSystemMetrics(SM_CXEDGE); + rc.right += dw; + + + // chop of the trailing new line(s) from the message box text, they are + // ignored by the static control but result in extra lines and hence extra + // scrollbar position in the edit one + wxString text(wxGetWindowText(hwndStatic)); + for ( wxString::reverse_iterator i = text.rbegin(); i != text.rend(); ++i ) + { + if ( *i != '\n' ) + { + // found last non-newline char, remove anything after it if + // necessary and stop in any case + if ( i != text.rbegin() ) + text.erase(i.base() + 1, text.end()); + break; + } + } + + // do create the new control + HWND hwndEdit = ::CreateWindow + ( + wxT("EDIT"), + wxTextBuffer::Translate(text).t_str(), + WS_CHILD | WS_VSCROLL | WS_VISIBLE | + ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL, + rc.left, rc.top, + rc.right - rc.left, rc.bottom - rc.top, + GetHwnd(), + NULL, + wxGetInstance(), + NULL + ); + + if ( !hwndEdit ) + { + wxLogDebug("Creation of replacement edit control failed in message box"); + return; + } + + // copy the font from the original control + LRESULT hfont = ::SendMessage(hwndStatic, WM_GETFONT, 0, 0); + ::SendMessage(hwndEdit, WM_SETFONT, hfont, 0); + + // and get rid of it + ::DestroyWindow(hwndStatic); + + + // shrink and centre the message box vertically and widen it box to account + // for the extra scrollbar + RECT rcBox = wxGetWindowRect(GetHwnd()); + const int hMsgBox = rcBox.bottom - rcBox.top - dh; + rcBox.top = (rectDisplay.height - hMsgBox)/2; + rcBox.bottom = rcBox.top + hMsgBox + (rectDisplay.height - hMsgBox)%2; + rcBox.left -= dw/2; + rcBox.right += dw - dw/2; + SetWindowRect(GetHwnd(), rcBox); + + // and adjust all the buttons positions + for ( unsigned n = 0; n < WXSIZEOF(ms_buttons); n++ ) + { + const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id); + if ( !hwndBtn ) + continue; // it's ok, not all buttons are always present + + RECT rc = wxGetWindowRect(hwndBtn); + rc.top -= dh; + rc.bottom -= dh; + rc.left += dw/2; + rc.right += dw/2; + MoveWindowToScreenRect(hwndBtn, rc); + } +} + +void wxMessageDialog::AdjustButtonLabels() +{ + // changing the button labels is the easy part but we also need to ensure + // that the buttons are big enough for the label strings and increase their + // size (and maybe the size of the message box itself) if they are not + + // TODO-RTL: check whether this works correctly in RTL + + // we want to use this font in GetTextExtent() calls below but we don't + // want to send WM_SETFONT to the message box, who knows how is it going to + // react to it (right now it doesn't seem to do anything but what if this + // changes) + wxWindowBase::SetFont(GetMessageFont()); + + // first iteration: find the widest button and update the buttons labels + int wBtnOld = 0, // current buttons width + wBtnNew = 0; // required new buttons width + RECT rcBtn; // stores the button height and y positions + unsigned numButtons = 0; // total number of buttons in the message box + unsigned n; + for ( n = 0; n < WXSIZEOF(ms_buttons); n++ ) + { + const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id); + if ( !hwndBtn ) + continue; // it's ok, not all buttons are always present + + numButtons++; + + const wxString label = (this->*ms_buttons[n].getter)(); + const wxSize sizeLabel = wxWindowBase::GetTextExtent(label); + + // check if the button is big enough for this label + const RECT rc = wxGetWindowRect(hwndBtn); + if ( !wBtnOld ) + { + // initialize wBtnOld using the first button width, all the other + // ones should have the same one + wBtnOld = rc.right - rc.left; + + rcBtn = rc; // remember for use below when we reposition the buttons + } + else + { + wxASSERT_MSG( wBtnOld == rc.right - rc.left, + "all buttons are supposed to be of same width" ); + } + + const int widthNeeded = wxMSWButton::GetFittingSize(this, sizeLabel).x; + if ( widthNeeded > wBtnNew ) + wBtnNew = widthNeeded; + + ::SetWindowText(hwndBtn, label.t_str()); + } + + if ( wBtnNew <= wBtnOld ) + { + // all buttons fit, nothing else to do + return; + } + + // resize the message box to be wider if needed + const int wBoxOld = wxGetClientRect(GetHwnd()).right; + + const int CHAR_WIDTH = GetCharWidth(); + const int MARGIN_OUTER = 2*CHAR_WIDTH; // margin between box and buttons + const int MARGIN_INNER = CHAR_WIDTH; // margin between buttons + + RECT rcBox = wxGetWindowRect(GetHwnd()); + + const int wAllButtons = numButtons*(wBtnNew + MARGIN_INNER) - MARGIN_INNER; + int wBoxNew = 2*MARGIN_OUTER + wAllButtons; + if ( wBoxNew > wBoxOld ) + { + const int dw = wBoxNew - wBoxOld; + rcBox.left -= dw/2; + rcBox.right += dw - dw/2; + + SetWindowRect(GetHwnd(), rcBox); + + // surprisingly, we don't need to resize the static text control, it + // seems to adjust itself to the new size, at least under Windows 2003 + // (TODO: test if this happens on older Windows versions) + } + else // the current width is big enough + { + wBoxNew = wBoxOld; + } + + + // finally position all buttons + + // notice that we have to take into account the difference between window + // and client width + rcBtn.left = (rcBox.left + rcBox.right - wxGetClientRect(GetHwnd()).right + + wBoxNew - wAllButtons) / 2; + rcBtn.right = rcBtn.left + wBtnNew; + + for ( n = 0; n < WXSIZEOF(ms_buttons); n++ ) + { + const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id); + if ( !hwndBtn ) + continue; + + MoveWindowToScreenRect(hwndBtn, rcBtn); + + rcBtn.left += wBtnNew + MARGIN_INNER; + rcBtn.right += wBtnNew + MARGIN_INNER; + } +} + +#endif // wxUSE_MSGBOX_HOOK + +/* static */ +wxFont wxMessageDialog::GetMessageFont() +{ + const NONCLIENTMETRICS& ncm = wxMSWImpl::GetNonClientMetrics(); + return wxNativeFontInfo(ncm.lfMessageFont); +} + +int wxMessageDialog::ShowMessageBox() +{ + if ( !wxTheApp->GetTopWindow() ) + { + // when the message box is shown from wxApp::OnInit() (i.e. before the + // message loop is entered), this must be done or the next message box + // will never be shown - just try putting 2 calls to wxMessageBox() in + // OnInit() to see it + while ( wxTheApp->Pending() ) + wxTheApp->Dispatch(); + } + + // use the top level window as parent if none specified + m_parent = GetParentForModalDialog(); + HWND hWnd = m_parent ? GetHwndOf(m_parent) : NULL; + +#if wxUSE_INTL + // native message box always uses the current user locale but the program + // may be using a different one and in this case we need to manually + // translate the default button labels (if they're non default we have no + // way to translate them and so we must assume they were already + // translated) to avoid mismatch between the language of the message box + // text and its buttons + wxLocale * const loc = wxGetLocale(); + if ( loc && loc->GetLanguage() != wxLocale::GetSystemLanguage() ) + { + if ( m_dialogStyle & wxYES_NO && + (GetCustomYesLabel().empty() && GetCustomNoLabel().empty()) ) + + { + // use the strings with mnemonics here as the native message box + // does + SetYesNoLabels(_("&Yes"), _("&No")); + } + + // we may or not have the Ok/Cancel buttons but either we do have them + // or we already made the labels custom because we called + // SetYesNoLabels() above so doing this does no harm -- and is + // necessary in wxYES_NO | wxCANCEL case + // + // note that we don't use mnemonics here for consistency with the + // native message box (which probably doesn't use them because + // Enter/Esc keys can be already used to dismiss the message box + // using keyboard) + if ( GetCustomOKLabel().empty() && GetCustomCancelLabel().empty() ) + SetOKCancelLabels(_("OK"), _("Cancel")); + } +#endif // wxUSE_INTL + + // translate wx style in MSW + unsigned int msStyle; + const long wxStyle = GetMessageDialogStyle(); + if ( wxStyle & wxYES_NO ) + { +#if !(defined(__SMARTPHONE__) && defined(__WXWINCE__)) + if (wxStyle & wxCANCEL) + msStyle = MB_YESNOCANCEL; + else +#endif // !(__SMARTPHONE__ && __WXWINCE__) + msStyle = MB_YESNO; + + if ( wxStyle & wxNO_DEFAULT ) + msStyle |= MB_DEFBUTTON2; + else if ( wxStyle & wxCANCEL_DEFAULT ) + msStyle |= MB_DEFBUTTON3; + } + else // without Yes/No we're going to have an OK button + { + if ( wxStyle & wxCANCEL ) + { + msStyle = MB_OKCANCEL; + + if ( wxStyle & wxCANCEL_DEFAULT ) + msStyle |= MB_DEFBUTTON2; + } + else // just "OK" + { + msStyle = MB_OK; + } + } + + if ( wxStyle & wxHELP ) + { + msStyle |= MB_HELP; + } + + // set the icon style + switch ( GetEffectiveIcon() ) + { + case wxICON_ERROR: + msStyle |= MB_ICONHAND; + break; + + case wxICON_WARNING: + msStyle |= MB_ICONEXCLAMATION; + break; + + case wxICON_QUESTION: + msStyle |= MB_ICONQUESTION; + break; + + case wxICON_INFORMATION: + msStyle |= MB_ICONINFORMATION; + break; + } + + if ( wxStyle & wxSTAY_ON_TOP ) + msStyle |= MB_TOPMOST; + +#ifndef __WXWINCE__ + if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft ) + msStyle |= MB_RTLREADING | MB_RIGHT; #endif -wxMessageDialog::wxMessageDialog(wxWindow *parent, const wxString& message, const wxString& caption, - long style, const wxPoint& pos) + if (hWnd) + msStyle |= MB_APPLMODAL; + else + msStyle |= MB_TASKMODAL; + + // per MSDN documentation for MessageBox() we can prefix the message with 2 + // right-to-left mark characters to tell the function to use RTL layout + // (unfortunately this only works in Unicode builds) + wxString message = GetFullMessage(); +#if wxUSE_UNICODE + if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft ) + { + // NB: not all compilers support \u escapes + static const wchar_t wchRLM = 0x200f; + message.Prepend(wxString(wchRLM, 2)); + } +#endif // wxUSE_UNICODE + +#if wxUSE_MSGBOX_HOOK + // install the hook in any case as we don't know in advance if the message + // box is not going to be too big (requiring the replacement of the static + // control with an edit one) + const DWORD tid = ::GetCurrentThreadId(); + m_hook = ::SetWindowsHookEx(WH_CBT, + &wxMessageDialog::HookFunction, NULL, tid); + HookMap()[tid] = this; +#endif // wxUSE_MSGBOX_HOOK + + // do show the dialog + int msAns = MessageBox(hWnd, message.t_str(), m_caption.t_str(), msStyle); + + return MSWTranslateReturnCode(msAns); +} + +int wxMessageDialog::ShowModal() +{ + WX_TESTING_SHOW_MODAL_HOOK(); + +#ifdef wxHAS_MSW_TASKDIALOG + if ( HasNativeTaskDialog() ) + { + TaskDialogIndirect_t taskDialogIndirect = GetTaskDialogIndirectFunc(); + wxCHECK_MSG( taskDialogIndirect, wxID_CANCEL, wxS("no task dialog?") ); + + WinStruct tdc; + wxMSWTaskDialogConfig wxTdc( *this ); + wxTdc.MSWCommonTaskDialogInit( tdc ); + + int msAns; + HRESULT hr = taskDialogIndirect( &tdc, &msAns, NULL, NULL ); + if ( FAILED(hr) ) + { + wxLogApiError( "TaskDialogIndirect", hr ); + return wxID_CANCEL; + } + + // In case only an "OK" button was specified we actually created a + // "Cancel" button (see comment in MSWCommonTaskDialogInit). This + // results in msAns being IDCANCEL while we want IDOK (just like + // how the native MessageBox function does with only an "OK" button). + if ( (msAns == IDCANCEL) + && !(GetMessageDialogStyle() & (wxYES_NO|wxCANCEL)) ) + { + msAns = IDOK; + } + + return MSWTranslateReturnCode( msAns ); + } +#endif // wxHAS_MSW_TASKDIALOG + + return ShowMessageBox(); +} + +void wxMessageDialog::DoCentre(int dir) { - m_caption = caption; - m_message = message; - m_dialogStyle = style; - m_parent = parent; +#ifdef wxHAS_MSW_TASKDIALOG + // Task dialog is always centered on its parent window and trying to center + // it manually doesn't work because its HWND is not created yet so don't + // even try as this would only result in (debug) error messages. + if ( HasNativeTaskDialog() ) + return; +#endif // wxHAS_MSW_TASKDIALOG + + wxMessageDialogBase::DoCentre(dir); } -int wxMessageDialog::ShowModal(void) +// ---------------------------------------------------------------------------- +// Helpers of the wxMSWMessageDialog namespace +// ---------------------------------------------------------------------------- + +#ifdef wxHAS_MSW_TASKDIALOG + +wxMSWTaskDialogConfig::wxMSWTaskDialogConfig(const wxMessageDialogBase& dlg) + : buttons(new TASKDIALOG_BUTTON[MAX_BUTTONS]) { - HWND hWnd = 0; - if (m_parent) hWnd = (HWND) m_parent->GetHWND(); - unsigned int msStyle = MB_OK; - if (m_dialogStyle & wxYES_NO) - { - if (m_dialogStyle & wxCANCEL) - msStyle = MB_YESNOCANCEL; + parent = dlg.GetParentForModalDialog(); + caption = dlg.GetCaption(); + message = dlg.GetMessage(); + extendedMessage = dlg.GetExtendedMessage(); + + // Before wxMessageDialog added support for extended message it was common + // practice to have long multiline texts in the message box with the first + // line playing the role of the main message and the rest of the extended + // one. Try to detect such usage automatically here by synthesizing the + // extended message on our own if it wasn't given. + if ( extendedMessage.empty() ) + { + // Check if there is a blank separating line after the first line (this + // is not the same as searching for "\n\n" as we want the automatically + // recognized main message be single line to avoid embarrassing false + // positives). + const size_t posNL = message.find('\n'); + if ( posNL != wxString::npos && + posNL < message.length() - 1 && + message[posNL + 1 ] == '\n' ) + { + extendedMessage.assign(message, posNL + 2, wxString::npos); + message.erase(posNL); + } + } + + iconId = dlg.GetEffectiveIcon(); + style = dlg.GetMessageDialogStyle(); + useCustomLabels = dlg.HasCustomLabels(); + btnYesLabel = dlg.GetYesLabel(); + btnNoLabel = dlg.GetNoLabel(); + btnOKLabel = dlg.GetOKLabel(); + btnCancelLabel = dlg.GetCancelLabel(); + btnHelpLabel = dlg.GetHelpLabel(); +} + +void wxMSWTaskDialogConfig::MSWCommonTaskDialogInit(TASKDIALOGCONFIG &tdc) +{ + // Use TDF_SIZE_TO_CONTENT to try to prevent Windows from truncating or + // ellipsizing the message text. This doesn't always work as Windows will + // still do it if the message contains too long "words" (i.e. runs of the + // text without spaces) but at least it ensures that the message text is + // fully shown for reasonably-sized words whereas without it using almost + // any file system path in a message box would result in truncation. + tdc.dwFlags = TDF_EXPAND_FOOTER_AREA | + TDF_POSITION_RELATIVE_TO_WINDOW | + TDF_SIZE_TO_CONTENT; + tdc.hInstance = wxGetInstance(); + tdc.pszWindowTitle = caption.t_str(); + + // use the top level window as parent if none specified + tdc.hwndParent = parent ? GetHwndOf(parent) : NULL; + + if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft ) + tdc.dwFlags |= TDF_RTL_LAYOUT; + + // If we have both the main and extended messages, just use them as + // intended. However if only one message is given we normally use it as the + // content and not as the main instruction because the latter is supposed + // to stand out compared to the former and doesn't look good if there is + // nothing for it to contrast with. Finally, notice that the extended + // message we use here might be automatically extracted from the main + // message in our ctor, see comment there. + if ( !extendedMessage.empty() ) + { + tdc.pszMainInstruction = message.t_str(); + tdc.pszContent = extendedMessage.t_str(); + } else - msStyle = MB_YESNO; - } - if (m_dialogStyle & wxOK) - { - if (m_dialogStyle & wxCANCEL) - msStyle = MB_OKCANCEL; + { + tdc.pszContent = message.t_str(); + } + + // set an icon to be used, if possible + switch ( iconId ) + { + case wxICON_ERROR: + tdc.pszMainIcon = TD_ERROR_ICON; + break; + + case wxICON_WARNING: + tdc.pszMainIcon = TD_WARNING_ICON; + break; + + case wxICON_INFORMATION: + tdc.pszMainIcon = TD_INFORMATION_ICON; + break; + } + + // custom label button array that can hold all buttons in use + tdc.pButtons = buttons.get(); + + if ( style & wxYES_NO ) + { + AddTaskDialogButton(tdc, IDYES, TDCBF_YES_BUTTON, btnYesLabel); + AddTaskDialogButton(tdc, IDNO, TDCBF_NO_BUTTON, btnNoLabel); + + if (style & wxCANCEL) + AddTaskDialogButton(tdc, IDCANCEL, + TDCBF_CANCEL_BUTTON, btnCancelLabel); + + if ( style & wxNO_DEFAULT ) + tdc.nDefaultButton = IDNO; + else if ( style & wxCANCEL_DEFAULT ) + tdc.nDefaultButton = IDCANCEL; + } + else // without Yes/No we're going to have an OK button + { + if ( style & wxCANCEL ) + { + AddTaskDialogButton(tdc, IDOK, TDCBF_OK_BUTTON, btnOKLabel); + AddTaskDialogButton(tdc, IDCANCEL, + TDCBF_CANCEL_BUTTON, btnCancelLabel); + + if ( style & wxCANCEL_DEFAULT ) + tdc.nDefaultButton = IDCANCEL; + } + else // Only "OK" + { + // We actually create a "Cancel" button instead because we want to + // allow closing the dialog box with Escape (and also Alt-F4 or + // clicking the close button in the title bar) which wouldn't work + // without a Cancel button. + if ( !useCustomLabels ) + { + useCustomLabels = true; + btnOKLabel = _("OK"); + } + + AddTaskDialogButton(tdc, IDCANCEL, TDCBF_CANCEL_BUTTON, btnOKLabel); + } + } + + if ( style & wxHELP ) + { + // There is no support for "Help" button in the task dialog, it can + // only show "Retry" or "Close" ones. + useCustomLabels = true; + + AddTaskDialogButton(tdc, IDHELP, 0 /* not used */, btnHelpLabel); + } +} + +void wxMSWTaskDialogConfig::AddTaskDialogButton(TASKDIALOGCONFIG &tdc, + int btnCustomId, + int btnCommonId, + const wxString& customLabel) +{ + if ( useCustomLabels ) + { + // use custom buttons to implement custom labels + TASKDIALOG_BUTTON &tdBtn = buttons[tdc.cButtons]; + + tdBtn.nButtonID = btnCustomId; + tdBtn.pszButtonText = customLabel.t_str(); + tdc.cButtons++; + + // We should never have more than 4 buttons currently as this is the + // maximal number of buttons supported by the message dialog. + wxASSERT_MSG( tdc.cButtons <= MAX_BUTTONS, wxT("Too many buttons") ); + } else - msStyle = MB_OK; - } - if (m_dialogStyle & wxICON_EXCLAMATION) - msStyle |= MB_ICONEXCLAMATION; - else if (m_dialogStyle & wxICON_HAND) - msStyle |= MB_ICONHAND; - else if (m_dialogStyle & wxICON_INFORMATION) - msStyle |= MB_ICONINFORMATION; - else if (m_dialogStyle & wxICON_QUESTION) - msStyle |= MB_ICONQUESTION; - - if (hWnd) - msStyle |= MB_APPLMODAL; - else - msStyle |= MB_TASKMODAL; - - int msAns = MessageBox(hWnd, (LPCSTR)(const char *)m_message, (LPCSTR)(const char *)m_caption, msStyle); - int ans = wxOK; - switch (msAns) - { - case IDCANCEL: - ans = wxID_CANCEL; - break; - case IDOK: - ans = wxID_OK; - break; - case IDYES: - ans = wxID_YES; - break; - case IDNO: - ans = wxID_NO; - break; - } - return ans; + { + tdc.dwCommonButtons |= btnCommonId; + } } -/* - * Common dialogs - * - */ - -// Pop up a message box -int wxMessageBox(const wxString& message, const wxString& caption, const long style, - wxWindow *parent, const int x, const int y) -{ - wxMessageDialog dialog(parent, message, caption, style); - - int ans = dialog.ShowModal(); - switch ( ans ) - { - case wxID_OK: - return wxOK; - break; - case wxID_YES: - return wxYES; - break; - case wxID_NO: - return wxNO; - break; - default: - case wxID_CANCEL: - return wxCANCEL; - break; - } - - return ans; +// Task dialog can be used from different threads (and wxProgressDialog always +// uses it from another thread in fact) so protect access to the static +// variable below with a critical section. +wxCRIT_SECT_DECLARE(gs_csTaskDialogIndirect); + +TaskDialogIndirect_t wxMSWMessageDialog::GetTaskDialogIndirectFunc() +{ + // Initialize the function pointer to an invalid value different from NULL + // to avoid reloading comctl32.dll and trying to resolve it every time + // we're called if task dialog is not available (notice that this may + // happen even under Vista+ if we don't use comctl32.dll v6). + static const TaskDialogIndirect_t + INVALID_TASKDIALOG_FUNC = reinterpret_cast(-1); + static TaskDialogIndirect_t s_TaskDialogIndirect = INVALID_TASKDIALOG_FUNC; + + wxCRIT_SECT_LOCKER(lock, gs_csTaskDialogIndirect); + + if ( s_TaskDialogIndirect == INVALID_TASKDIALOG_FUNC ) + { + wxLoadedDLL dllComCtl32("comctl32.dll"); + wxDL_INIT_FUNC(s_, TaskDialogIndirect, dllComCtl32); + } + + return s_TaskDialogIndirect; } +#endif // wxHAS_MSW_TASKDIALOG + +bool wxMSWMessageDialog::HasNativeTaskDialog() +{ +#ifdef wxHAS_MSW_TASKDIALOG + if ( wxGetWinVersion() >= wxWinVersion_6 ) + { + if ( wxMSWMessageDialog::GetTaskDialogIndirectFunc() ) + return true; + } +#endif // wxHAS_MSW_TASKDIALOG + + return false; +} + +int wxMSWMessageDialog::MSWTranslateReturnCode(int msAns) +{ + int ans; + switch (msAns) + { + default: + wxFAIL_MSG(wxT("unexpected return code")); + // fall through + + case IDCANCEL: + ans = wxID_CANCEL; + break; + case IDOK: + ans = wxID_OK; + break; + case IDYES: + ans = wxID_YES; + break; + case IDNO: + ans = wxID_NO; + break; + case IDHELP: + ans = wxID_HELP; + break; + } + + return ans; +} +#endif // wxUSE_MSGDLG