src/msw/msgdlg.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/msgdlg.cpp
   3 // Purpose:     wxMessageDialog
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // For compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #ifdef __BORLANDC__
  16     #pragma hdrstop
  17 #endif
  18
  19 #if wxUSE_MSGDLG
  20
  21 // there is no hook support under CE so we can't use the code for message box
  22 // positioning there
  23 #ifndef __WXWINCE__
  24     #define wxUSE_MSGBOX_HOOK 1
  25 #else
  26     #define wxUSE_MSGBOX_HOOK 0
  27 #endif
  28
  29 #ifndef WX_PRECOMP
  30     #include "wx/msgdlg.h"
  31     #include "wx/app.h"
  32     #include "wx/intl.h"
  33     #include "wx/utils.h"
  34     #include "wx/msw/private.h"
  35     #if wxUSE_MSGBOX_HOOK
  36         #include "wx/hashmap.h"
  37     #endif
  38 #endif
  39
  40 #include "wx/ptr_scpd.h"
  41 #include "wx/dynlib.h"
  42 #include "wx/msw/private/button.h"
  43 #include "wx/msw/private/metrics.h"
  44 #include "wx/msw/private/msgdlg.h"
  45
  46 #if wxUSE_MSGBOX_HOOK
  47     #include "wx/fontutil.h"
  48     #include "wx/textbuf.h"
  49     #include "wx/display.h"
  50 #endif
  51
  52 // For MB_TASKMODAL
  53 #ifdef __WXWINCE__
  54     #include "wx/msw/wince/missing.h"
  55 #endif
  56
  57 using namespace wxMSWMessageDialog;
  58
  59 IMPLEMENT_CLASS(wxMessageDialog, wxDialog)
  60
  61 #if wxUSE_MSGBOX_HOOK
  62
  63 // there can potentially be one message box per thread so we use a hash map
  64 // with thread ids as keys and (currently shown) message boxes as values
  65 //
  66 // TODO: replace this with wxTLS once it's available
  67 WX_DECLARE_HASH_MAP(unsigned long, wxMessageDialog *,
  68                     wxIntegerHash, wxIntegerEqual,
  69                     wxMessageDialogMap);
  70
  71 // the order in this array is the one in which buttons appear in the
  72 // message box
  73 const wxMessageDialog::ButtonAccessors wxMessageDialog::ms_buttons[] =
  74 {
  75     { IDYES,    &wxMessageDialog::GetYesLabel    },
  76     { IDNO,     &wxMessageDialog::GetNoLabel     },
  77     { IDOK,     &wxMessageDialog::GetOKLabel     },
  78     { IDCANCEL, &wxMessageDialog::GetCancelLabel },
  79 };
  80
  81 namespace
  82 {
  83
  84 wxMessageDialogMap& HookMap()
  85 {
  86     static wxMessageDialogMap s_Map;
  87
  88     return s_Map;
  89 }
  90
  91 /*
  92     All this code is used for adjusting the message box layout when we mess
  93     with its contents. It's rather complicated because we try hard to avoid
  94     assuming much about the standard layout details and so, instead of just
  95     laying out everything ourselves (which would have been so much simpler!)
  96     we try to only modify the existing controls positions by offsetting them
  97     from their default ones in the hope that this will continue to work with
  98     the future Windows versions.
  99  */
 100
 101 // convert the given RECT from screen to client coordinates in place
 102 void ScreenRectToClient(HWND hwnd, RECT& rc)
 103 {
 104     // map from desktop (i.e. screen) coordinates to ones of this window
 105     //
 106     // notice that a RECT is laid out as 2 consecutive POINTs so the cast is
 107     // valid
 108     ::MapWindowPoints(HWND_DESKTOP, hwnd, reinterpret_cast<POINT *>(&rc), 2);
 109 }
 110
 111 // set window position to the given rect
 112 inline void SetWindowRect(HWND hwnd, const RECT& rc)
 113 {
 114     ::MoveWindow(hwnd,
 115                  rc.left, rc.top,
 116                  rc.right - rc.left, rc.bottom - rc.top,
 117                  FALSE);
 118 }
 119
 120 // set window position expressed in screen coordinates, whether the window is
 121 // child or top level
 122 void MoveWindowToScreenRect(HWND hwnd, RECT rc)
 123 {
 124     ScreenRectToClient(::GetParent(hwnd), rc);
 125
 126     SetWindowRect(hwnd, rc);
 127 }
 128
 129 // helper of AdjustButtonLabels(): move the given window by dx
 130 //
 131 // works for both child and top level windows
 132 void OffsetWindow(HWND hwnd, int dx)
 133 {
 134     RECT rc = wxGetWindowRect(hwnd);
 135
 136     rc.left += dx;
 137     rc.right += dx;
 138
 139     MoveWindowToScreenRect(hwnd, rc);
 140 }
 141
 142 } // anonymous namespace
 143
 144 /* static */
 145 WXLRESULT wxCALLBACK
 146 wxMessageDialog::HookFunction(int code, WXWPARAM wParam, WXLPARAM lParam)
 147 {
 148     // Find the thread-local instance of wxMessageDialog
 149     const DWORD tid = ::GetCurrentThreadId();
 150     wxMessageDialogMap::iterator node = HookMap().find(tid);
 151     wxCHECK_MSG( node != HookMap().end(), false,
 152                     wxT("bogus thread id in wxMessageDialog::Hook") );
 153
 154     wxMessageDialog *  const wnd = node->second;
 155
 156     const HHOOK hhook = (HHOOK)wnd->m_hook;
 157     const LRESULT rc = ::CallNextHookEx(hhook, code, wParam, lParam);
 158
 159     if ( code == HCBT_ACTIVATE )
 160     {
 161         // we won't need this hook any longer
 162         ::UnhookWindowsHookEx(hhook);
 163         wnd->m_hook = NULL;
 164         HookMap().erase(tid);
 165
 166         wnd->SetHWND((HWND)wParam);
 167
 168         // replace the static text with an edit control if the message box is
 169         // too big to fit the display
 170         wnd->ReplaceStaticWithEdit();
 171
 172         // update the labels if necessary: we need to do it before centering
 173         // the dialog as this can change its size
 174         if ( wnd->HasCustomLabels() )
 175             wnd->AdjustButtonLabels();
 176
 177         // centre the message box on its parent if requested
 178         if ( wnd->GetMessageDialogStyle() & wxCENTER )
 179             wnd->Center(); // center on parent
 180         //else: default behaviour, center on screen
 181
 182         // there seems to be no reason to leave it set
 183         wnd->SetHWND(NULL);
 184     }
 185
 186     return rc;
 187 }
 188
 189 void wxMessageDialog::ReplaceStaticWithEdit()
 190 {
 191     // check if the message box fits the display
 192     int nDisplay = wxDisplay::GetFromWindow(this);
 193     if ( nDisplay == wxNOT_FOUND )
 194         nDisplay = 0;
 195     const wxRect rectDisplay = wxDisplay(nDisplay).GetClientArea();
 196
 197     if ( rectDisplay.Contains(GetRect()) )
 198     {
 199         // nothing to do
 200         return;
 201     }
 202
 203
 204     // find the static control to replace: normally there are two of them, the
 205     // icon and the text itself so search for all of them and ignore the icon
 206     // ones
 207     HWND hwndStatic = ::FindWindowEx(GetHwnd(), NULL, wxT("STATIC"), NULL);
 208     if ( ::GetWindowLong(hwndStatic, GWL_STYLE) & SS_ICON )
 209         hwndStatic = ::FindWindowEx(GetHwnd(), hwndStatic, wxT("STATIC"), NULL);
 210
 211     if ( !hwndStatic )
 212     {
 213         wxLogDebug("Failed to find the static text control in message box.");
 214         return;
 215     }
 216
 217     // set the right font for GetCharHeight() call below
 218     wxWindowBase::SetFont(GetMessageFont());
 219
 220     // put the new edit control at the same place
 221     RECT rc = wxGetWindowRect(hwndStatic);
 222     ScreenRectToClient(GetHwnd(), rc);
 223
 224     // but make it less tall so that the message box fits on the screen: we try
 225     // to make the message box take no more than 7/8 of the screen to leave
 226     // some space above and below it
 227     const int hText = (7*rectDisplay.height)/8 -
 228                       (
 229                          2*::GetSystemMetrics(SM_CYFIXEDFRAME) +
 230                          ::GetSystemMetrics(SM_CYCAPTION) +
 231                          5*GetCharHeight() // buttons + margins
 232                       );
 233     const int dh = (rc.bottom - rc.top) - hText; // vertical space we save
 234     rc.bottom -= dh;
 235
 236     // and it also must be wider as it needs a vertical scrollbar (in order
 237     // to preserve the word wrap, otherwise the number of lines would change
 238     // and we want the control to look as similar as possible to the original)
 239     //
 240     // NB: you would have thought that 2*SM_CXEDGE would be enough but it
 241     //     isn't, somehow, and the text control breaks lines differently from
 242     //     the static one so fudge by adding some extra space
 243     const int dw = ::GetSystemMetrics(SM_CXVSCROLL) +
 244                         4*::GetSystemMetrics(SM_CXEDGE);
 245     rc.right += dw;
 246
 247
 248     // chop of the trailing new line(s) from the message box text, they are
 249     // ignored by the static control but result in extra lines and hence extra
 250     // scrollbar position in the edit one
 251     wxString text(wxGetWindowText(hwndStatic));
 252     for ( wxString::reverse_iterator i = text.rbegin(); i != text.rend(); ++i )
 253     {
 254         if ( *i != '\n' )
 255         {
 256             // found last non-newline char, remove anything after it if
 257             // necessary and stop in any case
 258             if ( i != text.rbegin() )
 259                 text.erase(i.base() + 1, text.end());
 260             break;
 261         }
 262     }
 263
 264     // do create the new control
 265     HWND hwndEdit = ::CreateWindow
 266                       (
 267                         wxT("EDIT"),
 268                         wxTextBuffer::Translate(text).wx_str(),
 269                         WS_CHILD | WS_VSCROLL | WS_VISIBLE |
 270                         ES_MULTILINE | ES_READONLY | ES_AUTOVSCROLL,
 271                         rc.left, rc.top,
 272                         rc.right - rc.left, rc.bottom - rc.top,
 273                         GetHwnd(),
 274                         NULL,
 275                         wxGetInstance(),
 276                         NULL
 277                       );
 278
 279     if ( !hwndEdit )
 280     {
 281         wxLogDebug("Creation of replacement edit control failed in message box");
 282         return;
 283     }
 284
 285     // copy the font from the original control
 286     LRESULT hfont = ::SendMessage(hwndStatic, WM_GETFONT, 0, 0);
 287     ::SendMessage(hwndEdit, WM_SETFONT, hfont, 0);
 288
 289     // and get rid of it
 290     ::DestroyWindow(hwndStatic);
 291
 292
 293     // shrink and centre the message box vertically and widen it box to account
 294     // for the extra scrollbar
 295     RECT rcBox = wxGetWindowRect(GetHwnd());
 296     const int hMsgBox = rcBox.bottom - rcBox.top - dh;
 297     rcBox.top = (rectDisplay.height - hMsgBox)/2;
 298     rcBox.bottom = rcBox.top + hMsgBox + (rectDisplay.height - hMsgBox)%2;
 299     rcBox.left -= dw/2;
 300     rcBox.right += dw - dw/2;
 301     SetWindowRect(GetHwnd(), rcBox);
 302
 303     // and adjust all the buttons positions
 304     for ( unsigned n = 0; n < WXSIZEOF(ms_buttons); n++ )
 305     {
 306         const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id);
 307         if ( !hwndBtn )
 308             continue;   // it's ok, not all buttons are always present
 309
 310         RECT rc = wxGetWindowRect(hwndBtn);
 311         rc.top -= dh;
 312         rc.bottom -= dh;
 313         rc.left += dw/2;
 314         rc.right += dw/2;
 315         MoveWindowToScreenRect(hwndBtn, rc);
 316     }
 317 }
 318
 319 void wxMessageDialog::AdjustButtonLabels()
 320 {
 321     // changing the button labels is the easy part but we also need to ensure
 322     // that the buttons are big enough for the label strings and increase their
 323     // size (and maybe the size of the message box itself) if they are not
 324
 325     // TODO-RTL: check whether this works correctly in RTL
 326
 327     // we want to use this font in GetTextExtent() calls below but we don't
 328     // want to send WM_SETFONT to the message box, who knows how is it going to
 329     // react to it (right now it doesn't seem to do anything but what if this
 330     // changes)
 331     wxWindowBase::SetFont(GetMessageFont());
 332
 333     // first iteration: find the widest button and update the buttons labels
 334     int wBtnOld = 0,            // current buttons width
 335         wBtnNew = 0;            // required new buttons width
 336     RECT rcBtn;                 // stores the button height and y positions
 337     unsigned numButtons = 0;    // total number of buttons in the message box
 338     unsigned n;
 339     for ( n = 0; n < WXSIZEOF(ms_buttons); n++ )
 340     {
 341         const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id);
 342         if ( !hwndBtn )
 343             continue;   // it's ok, not all buttons are always present
 344
 345         numButtons++;
 346
 347         const wxString label = (this->*ms_buttons[n].getter)();
 348         const wxSize sizeLabel = wxWindowBase::GetTextExtent(label);
 349
 350         // check if the button is big enough for this label
 351         const RECT rc = wxGetWindowRect(hwndBtn);
 352         if ( !wBtnOld )
 353         {
 354             // initialize wBtnOld using the first button width, all the other
 355             // ones should have the same one
 356             wBtnOld = rc.right - rc.left;
 357
 358             rcBtn = rc; // remember for use below when we reposition the buttons
 359         }
 360         else
 361         {
 362             wxASSERT_MSG( wBtnOld == rc.right - rc.left,
 363                           "all buttons are supposed to be of same width" );
 364         }
 365
 366         const int widthNeeded = wxMSWButton::GetFittingSize(this, sizeLabel).x;
 367         if ( widthNeeded > wBtnNew )
 368             wBtnNew = widthNeeded;
 369
 370         ::SetWindowText(hwndBtn, label.wx_str());
 371     }
 372
 373     if ( wBtnNew <= wBtnOld )
 374     {
 375         // all buttons fit, nothing else to do
 376         return;
 377     }
 378
 379     // resize the message box to be wider if needed
 380     const int wBoxOld = wxGetClientRect(GetHwnd()).right;
 381
 382     const int CHAR_WIDTH = GetCharWidth();
 383     const int MARGIN_OUTER = 2*CHAR_WIDTH;  // margin between box and buttons
 384     const int MARGIN_INNER = CHAR_WIDTH;    // margin between buttons
 385
 386     RECT rcBox = wxGetWindowRect(GetHwnd());
 387
 388     const int wAllButtons = numButtons*(wBtnNew + MARGIN_INNER) - MARGIN_INNER;
 389     int wBoxNew = 2*MARGIN_OUTER + wAllButtons;
 390     if ( wBoxNew > wBoxOld )
 391     {
 392         const int dw = wBoxNew - wBoxOld;
 393         rcBox.left -= dw/2;
 394         rcBox.right += dw - dw/2;
 395
 396         SetWindowRect(GetHwnd(), rcBox);
 397
 398         // surprisingly, we don't need to resize the static text control, it
 399         // seems to adjust itself to the new size, at least under Windows 2003
 400         // (TODO: test if this happens on older Windows versions)
 401     }
 402     else // the current width is big enough
 403     {
 404         wBoxNew = wBoxOld;
 405     }
 406
 407
 408     // finally position all buttons
 409
 410     // notice that we have to take into account the difference between window
 411     // and client width
 412     rcBtn.left = (rcBox.left + rcBox.right - wxGetClientRect(GetHwnd()).right +
 413                   wBoxNew - wAllButtons) / 2;
 414     rcBtn.right = rcBtn.left + wBtnNew;
 415
 416     for ( n = 0; n < WXSIZEOF(ms_buttons); n++ )
 417     {
 418         const HWND hwndBtn = ::GetDlgItem(GetHwnd(), ms_buttons[n].id);
 419         if ( !hwndBtn )
 420             continue;
 421
 422         MoveWindowToScreenRect(hwndBtn, rcBtn);
 423
 424         rcBtn.left += wBtnNew + MARGIN_INNER;
 425         rcBtn.right += wBtnNew + MARGIN_INNER;
 426     }
 427 }
 428
 429 #endif // wxUSE_MSGBOX_HOOK
 430
 431 /* static */
 432 wxFont wxMessageDialog::GetMessageFont()
 433 {
 434     const NONCLIENTMETRICS& ncm = wxMSWImpl::GetNonClientMetrics();
 435     return wxNativeFontInfo(ncm.lfMessageFont);
 436 }
 437
 438 int wxMessageDialog::ShowMessageBox()
 439 {
 440     if ( !wxTheApp->GetTopWindow() )
 441     {
 442         // when the message box is shown from wxApp::OnInit() (i.e. before the
 443         // message loop is entered), this must be done or the next message box
 444         // will never be shown - just try putting 2 calls to wxMessageBox() in
 445         // OnInit() to see it
 446         while ( wxTheApp->Pending() )
 447             wxTheApp->Dispatch();
 448     }
 449
 450     // use the top level window as parent if none specified
 451     m_parent = GetParentForModalDialog();
 452     HWND hWnd = m_parent ? GetHwndOf(m_parent) : NULL;
 453
 454 #if wxUSE_INTL
 455     // native message box always uses the current user locale but the program
 456     // may be using a different one and in this case we need to manually
 457     // translate the button labels to avoid mismatch between the language of
 458     // the message box text and its buttons
 459     wxLocale * const loc = wxGetLocale();
 460     if ( loc && loc->GetLanguage() != wxLocale::GetSystemLanguage() )
 461     {
 462         if ( m_dialogStyle & wxYES_NO )
 463         {
 464             // use the strings with mnemonics here as the native message box
 465             // does
 466             SetYesNoLabels(_("&Yes"), _("&No"));
 467         }
 468
 469         // we may or not have the Ok/Cancel buttons but either we do have them
 470         // or we already made the labels custom because we called
 471         // SetYesNoLabels() above so doing this does no harm -- and is
 472         // necessary in wxYES_NO | wxCANCEL case
 473         //
 474         // note that we don't use mnemonics here for consistency with the
 475         // native message box (which probably doesn't use them because
 476         // Enter/Esc keys can be already used to dismiss the message box
 477         // using keyboard)
 478         SetOKCancelLabels(_("OK"), _("Cancel"));
 479     }
 480 #endif // wxUSE_INTL
 481
 482     // translate wx style in MSW
 483     unsigned int msStyle;
 484     const long wxStyle = GetMessageDialogStyle();
 485     if ( wxStyle & wxYES_NO )
 486     {
 487 #if !(defined(__SMARTPHONE__) && defined(__WXWINCE__))
 488         if (wxStyle & wxCANCEL)
 489             msStyle = MB_YESNOCANCEL;
 490         else
 491 #endif // !(__SMARTPHONE__ && __WXWINCE__)
 492             msStyle = MB_YESNO;
 493
 494         if ( wxStyle & wxNO_DEFAULT )
 495             msStyle |= MB_DEFBUTTON2;
 496         else if ( wxStyle & wxCANCEL_DEFAULT )
 497             msStyle |= MB_DEFBUTTON3;
 498     }
 499     else // without Yes/No we're going to have an OK button
 500     {
 501         if ( wxStyle & wxCANCEL )
 502         {
 503             msStyle = MB_OKCANCEL;
 504
 505             if ( wxStyle & wxCANCEL_DEFAULT )
 506                 msStyle |= MB_DEFBUTTON2;
 507         }
 508         else // just "OK"
 509         {
 510             msStyle = MB_OK;
 511         }
 512     }
 513
 514     // set the icon style
 515     switch ( GetEffectiveIcon() )
 516     {
 517         case wxICON_ERROR:
 518             msStyle |= MB_ICONHAND;
 519             break;
 520
 521         case wxICON_WARNING:
 522             msStyle |= MB_ICONEXCLAMATION;
 523             break;
 524
 525         case wxICON_QUESTION:
 526             msStyle |= MB_ICONQUESTION;
 527             break;
 528
 529         case wxICON_INFORMATION:
 530             msStyle |= MB_ICONINFORMATION;
 531             break;
 532     }
 533
 534     if ( wxStyle & wxSTAY_ON_TOP )
 535         msStyle |= MB_TOPMOST;
 536
 537 #ifndef __WXWINCE__
 538     if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
 539         msStyle |= MB_RTLREADING | MB_RIGHT;
 540 #endif
 541
 542     if (hWnd)
 543         msStyle |= MB_APPLMODAL;
 544     else
 545         msStyle |= MB_TASKMODAL;
 546
 547     // per MSDN documentation for MessageBox() we can prefix the message with 2
 548     // right-to-left mark characters to tell the function to use RTL layout
 549     // (unfortunately this only works in Unicode builds)
 550     wxString message = GetFullMessage();
 551 #if wxUSE_UNICODE
 552     if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
 553     {
 554         // NB: not all compilers support \u escapes
 555         static const wchar_t wchRLM = 0x200f;
 556         message.Prepend(wxString(wchRLM, 2));
 557     }
 558 #endif // wxUSE_UNICODE
 559
 560 #if wxUSE_MSGBOX_HOOK
 561     // install the hook in any case as we don't know in advance if the message
 562     // box is not going to be too big (requiring the replacement of the static
 563     // control with an edit one)
 564     const DWORD tid = ::GetCurrentThreadId();
 565     m_hook = ::SetWindowsHookEx(WH_CBT,
 566                                 &wxMessageDialog::HookFunction, NULL, tid);
 567     HookMap()[tid] = this;
 568 #endif // wxUSE_MSGBOX_HOOK
 569
 570     // do show the dialog
 571     int msAns = MessageBox(hWnd, message.wx_str(), m_caption.wx_str(), msStyle);
 572
 573     return MSWTranslateReturnCode(msAns);
 574 }
 575
 576 int wxMessageDialog::ShowModal()
 577 {
 578 #ifdef wxHAS_MSW_TASKDIALOG
 579     if ( HasNativeTaskDialog() )
 580     {
 581         TaskDialogIndirect_t taskDialogIndirect = GetTaskDialogIndirectFunc();
 582         wxCHECK_MSG( taskDialogIndirect, wxID_CANCEL, wxS("no task dialog?") );
 583
 584         WinStruct<TASKDIALOGCONFIG> tdc;
 585         wxMSWTaskDialogConfig wxTdc( *this );
 586         wxTdc.MSWCommonTaskDialogInit( tdc );
 587
 588         int msAns;
 589         HRESULT hr = taskDialogIndirect( &tdc, &msAns, NULL, NULL );
 590         if ( FAILED(hr) )
 591         {
 592             wxLogApiError( "TaskDialogIndirect", hr );
 593             return wxID_CANCEL;
 594         }
 595
 596         // In case only an "OK" button was specified we actually created a
 597         // "Cancel" button (see comment in MSWCommonTaskDialogInit). This
 598         // results in msAns being IDCANCEL while we want IDOK (just like
 599         // how the native MessageBox function does with only an "OK" button).
 600         if ( (msAns == IDCANCEL)
 601             && !(GetMessageDialogStyle() & (wxYES_NO|wxCANCEL)) )
 602         {
 603             msAns = IDOK;
 604         }
 605
 606         return MSWTranslateReturnCode( msAns );
 607     }
 608 #endif // wxHAS_MSW_TASKDIALOG
 609
 610     return ShowMessageBox();
 611 }
 612
 613 void wxMessageDialog::DoCentre(int dir)
 614 {
 615 #ifdef wxHAS_MSW_TASKDIALOG
 616     // Task dialog is always centered on its parent window and trying to center
 617     // it manually doesn't work because its HWND is not created yet so don't
 618     // even try as this would only result in (debug) error messages.
 619     if ( HasNativeTaskDialog() )
 620         return;
 621 #endif // wxHAS_MSW_TASKDIALOG
 622
 623     wxMessageDialogBase::DoCentre(dir);
 624 }
 625
 626 // ----------------------------------------------------------------------------
 627 // Helpers of the wxMSWMessageDialog namespace
 628 // ----------------------------------------------------------------------------
 629
 630 #ifdef wxHAS_MSW_TASKDIALOG
 631
 632 wxMSWTaskDialogConfig::wxMSWTaskDialogConfig(const wxMessageDialogBase& dlg)
 633                      : buttons(new TASKDIALOG_BUTTON[3])
 634 {
 635     parent = dlg.GetParentForModalDialog();
 636     caption = dlg.GetCaption();
 637     message = dlg.GetMessage();
 638     extendedMessage = dlg.GetExtendedMessage();
 639
 640     // Before wxMessageDialog added support for extended message it was common
 641     // practice to have long multiline texts in the message box with the first
 642     // line playing the role of the main message and the rest of the extended
 643     // one. Try to detect such usage automatically here by synthesizing the
 644     // extended message on our own if it wasn't given.
 645     if ( extendedMessage.empty() )
 646     {
 647         // Check if there is a blank separating line after the first line (this
 648         // is not the same as searching for "\n\n" as we want the automatically
 649         // recognized main message be single line to avoid embarrassing false
 650         // positives).
 651         const size_t posNL = message.find('\n');
 652         if ( posNL != wxString::npos &&
 653                 posNL < message.length() - 1 &&
 654                     message[posNL + 1 ] == '\n' )
 655         {
 656             extendedMessage.assign(message, posNL + 2, wxString::npos);
 657             message.erase(posNL);
 658         }
 659     }
 660
 661     iconId = dlg.GetEffectiveIcon();
 662     style = dlg.GetMessageDialogStyle();
 663     useCustomLabels = dlg.HasCustomLabels();
 664     btnYesLabel = dlg.GetYesLabel();
 665     btnNoLabel = dlg.GetNoLabel();
 666     btnOKLabel = dlg.GetOKLabel();
 667     btnCancelLabel = dlg.GetCancelLabel();
 668 }
 669
 670 void wxMSWTaskDialogConfig::MSWCommonTaskDialogInit(TASKDIALOGCONFIG &tdc)
 671 {
 672     tdc.dwFlags = TDF_EXPAND_FOOTER_AREA | TDF_POSITION_RELATIVE_TO_WINDOW;
 673     tdc.hInstance = wxGetInstance();
 674     tdc.pszWindowTitle = caption.wx_str();
 675
 676     // use the top level window as parent if none specified
 677     tdc.hwndParent = parent ? GetHwndOf(parent) : NULL;
 678
 679     if ( wxTheApp->GetLayoutDirection() == wxLayout_RightToLeft )
 680         tdc.dwFlags |= TDF_RTL_LAYOUT;
 681
 682     // If we have both the main and extended messages, just use them as
 683     // intended. However if only one message is given we normally use it as the
 684     // content and not as the main instruction because the latter is supposed
 685     // to stand out compared to the former and doesn't look good if there is
 686     // nothing for it to contrast with. Finally, notice that the extended
 687     // message we use here might be automatically extracted from the main
 688     // message in our ctor, see comment there.
 689     if ( !extendedMessage.empty() )
 690     {
 691         tdc.pszMainInstruction = message.wx_str();
 692         tdc.pszContent = extendedMessage.wx_str();
 693     }
 694     else
 695     {
 696         tdc.pszContent = message.wx_str();
 697     }
 698
 699     // set an icon to be used, if possible
 700     switch ( iconId )
 701     {
 702         case wxICON_ERROR:
 703             tdc.pszMainIcon = TD_ERROR_ICON;
 704             break;
 705
 706         case wxICON_WARNING:
 707             tdc.pszMainIcon = TD_WARNING_ICON;
 708             break;
 709
 710         case wxICON_INFORMATION:
 711             tdc.pszMainIcon = TD_INFORMATION_ICON;
 712             break;
 713     }
 714
 715     // custom label button array that can hold all buttons in use
 716     tdc.pButtons = buttons.get();
 717
 718     if ( style & wxYES_NO )
 719     {
 720         AddTaskDialogButton(tdc, IDYES, TDCBF_YES_BUTTON, btnYesLabel);
 721         AddTaskDialogButton(tdc, IDNO,  TDCBF_NO_BUTTON,  btnNoLabel);
 722
 723         if (style & wxCANCEL)
 724             AddTaskDialogButton(tdc, IDCANCEL,
 725                                 TDCBF_CANCEL_BUTTON, btnCancelLabel);
 726
 727         if ( style & wxNO_DEFAULT )
 728             tdc.nDefaultButton = IDNO;
 729         else if ( style & wxCANCEL_DEFAULT )
 730             tdc.nDefaultButton = IDCANCEL;
 731     }
 732     else // without Yes/No we're going to have an OK button
 733     {
 734         if ( style & wxCANCEL )
 735         {
 736             AddTaskDialogButton(tdc, IDOK, TDCBF_OK_BUTTON, btnOKLabel);
 737             AddTaskDialogButton(tdc, IDCANCEL,
 738                                 TDCBF_CANCEL_BUTTON, btnCancelLabel);
 739
 740             if ( style & wxCANCEL_DEFAULT )
 741                 tdc.nDefaultButton = IDCANCEL;
 742         }
 743         else // Only "OK"
 744         {
 745             // We actually create a "Cancel" button instead because we want to
 746             // allow closing the dialog box with Escape (and also Alt-F4 or
 747             // clicking the close button in the title bar) which wouldn't work
 748             // without a Cancel button.
 749             if ( !useCustomLabels )
 750             {
 751                 useCustomLabels = true;
 752                 btnOKLabel = _("OK");
 753             }
 754
 755             AddTaskDialogButton(tdc, IDCANCEL, TDCBF_CANCEL_BUTTON, btnOKLabel);
 756         }
 757     }
 758 }
 759
 760 void wxMSWTaskDialogConfig::AddTaskDialogButton(TASKDIALOGCONFIG &tdc,
 761                                                 int btnCustomId,
 762                                                 int btnCommonId,
 763                                                 const wxString& customLabel)
 764 {
 765     if ( useCustomLabels )
 766     {
 767         // use custom buttons to implement custom labels
 768         TASKDIALOG_BUTTON &tdBtn = buttons[tdc.cButtons];
 769
 770         tdBtn.nButtonID = btnCustomId;
 771         tdBtn.pszButtonText = customLabel.wx_str();
 772         tdc.cButtons++;
 773     }
 774     else
 775     {
 776         tdc.dwCommonButtons |= btnCommonId;
 777     }
 778 }
 779
 780 // Task dialog can be used from different threads (and wxProgressDialog always
 781 // uses it from another thread in fact) so protect access to the static
 782 // variable below with a critical section.
 783 wxCRIT_SECT_DECLARE(gs_csTaskDialogIndirect);
 784
 785 TaskDialogIndirect_t wxMSWMessageDialog::GetTaskDialogIndirectFunc()
 786 {
 787     // Initialize the function pointer to an invalid value different from NULL
 788     // to avoid reloading comctl32.dll and trying to resolve it every time
 789     // we're called if task dialog is not available (notice that this may
 790     // happen even under Vista+ if we don't use comctl32.dll v6).
 791     static const TaskDialogIndirect_t
 792         INVALID_TASKDIALOG_FUNC = reinterpret_cast<TaskDialogIndirect_t>(-1);
 793     static TaskDialogIndirect_t s_TaskDialogIndirect = INVALID_TASKDIALOG_FUNC;
 794
 795     wxCRIT_SECT_LOCKER(lock, gs_csTaskDialogIndirect);
 796
 797     if ( s_TaskDialogIndirect == INVALID_TASKDIALOG_FUNC )
 798     {
 799         wxLoadedDLL dllComCtl32("comctl32.dll");
 800         wxDL_INIT_FUNC(s_, TaskDialogIndirect, dllComCtl32);
 801     }
 802
 803     return s_TaskDialogIndirect;
 804 }
 805
 806 #endif // wxHAS_MSW_TASKDIALOG
 807
 808 bool wxMSWMessageDialog::HasNativeTaskDialog()
 809 {
 810 #ifdef wxHAS_MSW_TASKDIALOG
 811     if ( wxGetWinVersion() >= wxWinVersion_6 )
 812     {
 813         if ( wxMSWMessageDialog::GetTaskDialogIndirectFunc() )
 814             return true;
 815     }
 816 #endif // wxHAS_MSW_TASKDIALOG
 817
 818     return false;
 819 }
 820
 821 int wxMSWMessageDialog::MSWTranslateReturnCode(int msAns)
 822 {
 823     int ans;
 824     switch (msAns)
 825     {
 826         default:
 827             wxFAIL_MSG(wxT("unexpected return code"));
 828             // fall through
 829
 830         case IDCANCEL:
 831             ans = wxID_CANCEL;
 832             break;
 833         case IDOK:
 834             ans = wxID_OK;
 835             break;
 836         case IDYES:
 837             ans = wxID_YES;
 838             break;
 839         case IDNO:
 840             ans = wxID_NO;
 841             break;
 842     }
 843
 844     return ans;
 845 }
 846
 847 #endif // wxUSE_MSGDLG