src/msw/dialog.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/dialog.cpp
   3 // Purpose:     wxDialog class
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21     #pragma implementation "dialog.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/dialog.h"
  33     #include "wx/utils.h"
  34     #include "wx/frame.h"
  35     #include "wx/app.h"
  36     #include "wx/settings.h"
  37     #include "wx/intl.h"
  38     #include "wx/log.h"
  39 #endif
  40
  41 #include "wx/msw/private.h"
  42 #include "wx/log.h"
  43 #include "wx/evtloop.h"
  44 #include "wx/ptr_scpd.h"
  45
  46 #if wxUSE_COMMON_DIALOGS && !defined(__WXMICROWIN__)
  47     #include <commdlg.h>
  48 #endif
  49
  50 // ----------------------------------------------------------------------------
  51 // wxWin macros
  52 // ----------------------------------------------------------------------------
  53
  54 #if wxUSE_EXTENDED_RTTI
  55 WX_DEFINE_FLAGS( wxDialogStyle )
  56
  57 wxBEGIN_FLAGS( wxDialogStyle )
  58     // new style border flags, we put them first to
  59     // use them for streaming out
  60     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  61     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  62     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  63     wxFLAGS_MEMBER(wxBORDER_RAISED)
  64     wxFLAGS_MEMBER(wxBORDER_STATIC)
  65     wxFLAGS_MEMBER(wxBORDER_NONE)
  66
  67     // old style border flags
  68     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  69     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  70     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  71     wxFLAGS_MEMBER(wxRAISED_BORDER)
  72     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  73     wxFLAGS_MEMBER(wxNO_BORDER)
  74
  75     // standard window styles
  76     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  77     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  78
  79     // dialog styles
  80     wxFLAGS_MEMBER(wxDIALOG_MODAL)
  81     wxFLAGS_MEMBER(wxDIALOG_MODELESS)
  82     wxFLAGS_MEMBER(wxNO_3D)
  83     wxFLAGS_MEMBER(wxWS_EX_VALIDATE_RECURSIVELY)
  84     wxFLAGS_MEMBER(wxSTAY_ON_TOP)
  85     wxFLAGS_MEMBER(wxCAPTION)
  86     wxFLAGS_MEMBER(wxTHICK_FRAME)
  87     wxFLAGS_MEMBER(wxSYSTEM_MENU)
  88     wxFLAGS_MEMBER(wxRESIZE_BORDER)
  89     wxFLAGS_MEMBER(wxRESIZE_BOX)
  90     wxFLAGS_MEMBER(wxCLOSE_BOX)
  91     wxFLAGS_MEMBER(wxMAXIMIZE_BOX)
  92     wxFLAGS_MEMBER(wxMINIMIZE_BOX)
  93 wxEND_FLAGS( wxDialogStyle )
  94
  95 IMPLEMENT_DYNAMIC_CLASS_XTI(wxDialog, wxTopLevelWindow,"wx/dialog.h")
  96
  97 wxBEGIN_PROPERTIES_TABLE(wxDialog)
  98     wxPROPERTY( Title,wxString, SetTitle, GetTitle, wxString() , 0 /*flags*/ , wxT("Helpstring") , wxT("group"))
  99     wxPROPERTY_FLAGS( WindowStyle , wxDialogStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
 100 wxEND_PROPERTIES_TABLE()
 101
 102 wxBEGIN_HANDLERS_TABLE(wxDialog)
 103 wxEND_HANDLERS_TABLE()
 104
 105 wxCONSTRUCTOR_6( wxDialog , wxWindow* , Parent , wxWindowID , Id , wxString , Title , wxPoint , Position , wxSize , Size , long , WindowStyle)
 106
 107 #else
 108 IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxTopLevelWindow)
 109 #endif
 110
 111 BEGIN_EVENT_TABLE(wxDialog, wxDialogBase)
 112     EVT_BUTTON(wxID_OK, wxDialog::OnOK)
 113     EVT_BUTTON(wxID_APPLY, wxDialog::OnApply)
 114     EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel)
 115
 116     EVT_CHAR_HOOK(wxDialog::OnCharHook)
 117
 118     EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
 119
 120     EVT_CLOSE(wxDialog::OnCloseWindow)
 121 END_EVENT_TABLE()
 122
 123 // ----------------------------------------------------------------------------
 124 // wxDialogModalData
 125 // ----------------------------------------------------------------------------
 126
 127 // this is simply a container for any data we need to implement modality which
 128 // allows us to avoid changing wxDialog each time the implementation changes
 129 class wxDialogModalData
 130 {
 131 public:
 132     wxDialogModalData(wxDialog *dialog) : m_evtLoop(dialog) { }
 133
 134     void RunLoop()
 135     {
 136         m_evtLoop.Run();
 137     }
 138
 139     void ExitLoop()
 140     {
 141         m_evtLoop.Exit();
 142     }
 143
 144 private:
 145     wxModalEventLoop m_evtLoop;
 146 };
 147
 148 wxDEFINE_TIED_SCOPED_PTR_TYPE(wxDialogModalData);
 149
 150 // ============================================================================
 151 // implementation
 152 // ============================================================================
 153
 154 // ----------------------------------------------------------------------------
 155 // wxDialog construction
 156 // ----------------------------------------------------------------------------
 157
 158 void wxDialog::Init()
 159 {
 160     m_oldFocus = (wxWindow *)NULL;
 161     m_isShown = FALSE;
 162     m_modalData = NULL;
 163     m_endModalCalled = FALSE;
 164 }
 165
 166 bool wxDialog::Create(wxWindow *parent,
 167                       wxWindowID id,
 168                       const wxString& title,
 169                       const wxPoint& pos,
 170                       const wxSize& size,
 171                       long style,
 172                       const wxString& name)
 173 {
 174     SetExtraStyle(GetExtraStyle() | wxTOPLEVEL_EX_DIALOG);
 175
 176     // save focus before doing anything which can potentially change it
 177     m_oldFocus = FindFocus();
 178
 179     // All dialogs should really have this style
 180     style |= wxTAB_TRAVERSAL;
 181
 182     if ( !wxTopLevelWindow::Create(parent, id, title, pos, size, style, name) )
 183         return FALSE;
 184
 185     if ( !m_hasFont )
 186         SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 187
 188     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
 189
 190     return TRUE;
 191 }
 192
 193 void wxDialog::SetModal(bool flag)
 194 {
 195     if ( flag )
 196     {
 197         m_windowStyle |= wxDIALOG_MODAL;
 198
 199         wxModelessWindows.DeleteObject(this);
 200     }
 201     else
 202     {
 203         m_windowStyle &= ~wxDIALOG_MODAL;
 204
 205         wxModelessWindows.Append(this);
 206     }
 207 }
 208
 209 wxDialog::~wxDialog()
 210 {
 211     m_isBeingDeleted = TRUE;
 212
 213     // this will also reenable all the other windows for a modal dialog
 214     Show(FALSE);
 215 }
 216
 217 // ----------------------------------------------------------------------------
 218 // kbd handling
 219 // ----------------------------------------------------------------------------
 220
 221 // By default, pressing escape cancels the dialog
 222 void wxDialog::OnCharHook(wxKeyEvent& event)
 223 {
 224     if (GetHWND())
 225     {
 226         // "Esc" works as an accelerator for the "Cancel" button, but it
 227         // shouldn't close the dialog which doesn't have any cancel button
 228         if ( (event.m_keyCode == WXK_ESCAPE) && FindWindow(wxID_CANCEL) )
 229         {
 230             wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
 231             cancelEvent.SetEventObject( this );
 232             GetEventHandler()->ProcessEvent(cancelEvent);
 233
 234             // ensure that there is another message for this window so the
 235             // ShowModal loop will exit and won't get stuck in GetMessage().
 236             ::PostMessage(GetHwnd(), WM_NULL, 0, 0);
 237
 238             return;
 239         }
 240     }
 241
 242     // We didn't process this event.
 243     event.Skip();
 244 }
 245
 246 // ----------------------------------------------------------------------------
 247 // showing the dialogs
 248 // ----------------------------------------------------------------------------
 249
 250 bool wxDialog::IsModal() const
 251 {
 252     return (GetWindowStyleFlag() & wxDIALOG_MODAL) != 0;
 253 }
 254
 255 bool wxDialog::IsModalShowing() const
 256 {
 257     return m_modalData != NULL;
 258 }
 259
 260 wxWindow *wxDialog::FindSuitableParent() const
 261 {
 262     // first try to use the currently active window
 263     HWND hwndFg = ::GetForegroundWindow();
 264     wxWindow *parent = hwndFg ? wxFindWinFromHandle((WXHWND)hwndFg)
 265                               : NULL;
 266     if ( !parent )
 267     {
 268         // next try the main app window
 269         parent = wxTheApp->GetTopWindow();
 270     }
 271
 272     // finally, check if the parent we found is really suitable
 273     if ( !parent || parent == (wxWindow *)this || !parent->IsShown() )
 274     {
 275         // don't use this one
 276         parent = NULL;
 277     }
 278
 279     return parent;
 280 }
 281
 282 void wxDialog::DoShowModal()
 283 {
 284     wxCHECK_RET( !IsModalShowing(), _T("DoShowModal() called twice") );
 285     wxCHECK_RET( IsModal(), _T("can't DoShowModal() modeless dialog") );
 286
 287     wxWindow *parent = GetParent();
 288
 289     wxWindow* oldFocus = m_oldFocus;
 290
 291     // We have to remember the HWND because we need to check
 292     // the HWND still exists (oldFocus can be garbage when the dialog
 293     // exits, if it has been destroyed)
 294     HWND hwndOldFocus = 0;
 295     if (oldFocus)
 296         hwndOldFocus = (HWND) oldFocus->GetHWND();
 297
 298     // remember where the focus was
 299     if ( !oldFocus )
 300     {
 301         oldFocus = parent;
 302         if ( parent )
 303             hwndOldFocus = GetHwndOf(parent);
 304     }
 305
 306     // enter the modal loop
 307     {
 308         wxDialogModalDataTiedPtr modalData(&m_modalData,
 309                                            new wxDialogModalData(this));
 310         modalData->RunLoop();
 311     }
 312
 313     // and restore focus
 314     // Note that this code MUST NOT access the dialog object's data
 315     // in case the object has been deleted (which will be the case
 316     // for a modal dialog that has been destroyed before calling EndModal).
 317     if ( oldFocus && (oldFocus != this) && ::IsWindow(hwndOldFocus))
 318     {
 319         // This is likely to prove that the object still exists
 320         if (wxFindWinFromHandle((WXHWND) hwndOldFocus) == oldFocus)
 321             oldFocus->SetFocus();
 322     }
 323 }
 324
 325 bool wxDialog::Show(bool show)
 326 {
 327     if ( !show && m_modalData )
 328     {
 329         // we need to do this before calling wxDialogBase version because if we
 330         // had disabled other app windows, they must be reenabled right now as
 331         // if they stay disabled Windows will activate another window (one
 332         // which is enabled, anyhow) when we're hidden in the base class Show()
 333         // and we will lose activation
 334         m_modalData->ExitLoop();
 335     }
 336
 337     // ShowModal() may be called for already shown dialog
 338     if ( !wxDialogBase::Show(show) && !(show && IsModal()) )
 339     {
 340         // nothing to do
 341         return FALSE;
 342     }
 343
 344     if ( show )
 345     {
 346         // dialogs don't get WM_SIZE message after creation unlike most (all?)
 347         // other windows and so could start their life non laid out correctly
 348         // if we didn't call Layout() from here
 349         //
 350         // NB: normally we should call it just the first time but doing it
 351         //     every time is simpler than keeping a flag
 352         Layout();
 353
 354         // this usually will result in TransferDataToWindow() being called
 355         InitDialog();
 356     }
 357
 358     // EndModal may have been called from InitDialog handler,
 359     // which would cause an infinite loop if we didn't take it
 360     // into account
 361     if ( show && IsModal() && !m_endModalCalled )
 362     {
 363         // modal dialog needs a parent window, so try to find one
 364         if ( !GetParent() )
 365         {
 366             m_parent = FindSuitableParent();
 367         }
 368
 369         DoShowModal();
 370     }
 371
 372     return TRUE;
 373 }
 374
 375 void wxDialog::Raise()
 376 {
 377     ::SetForegroundWindow(GetHwnd());
 378 }
 379
 380 // a special version for Show(TRUE) for modal dialogs which returns return code
 381 int wxDialog::ShowModal()
 382 {
 383     m_endModalCalled = FALSE;
 384     if ( !IsModal() )
 385     {
 386         SetModal(TRUE);
 387     }
 388
 389     Show(TRUE);
 390
 391     return GetReturnCode();
 392 }
 393
 394 // NB: this function (surprizingly) may be called for both modal and modeless
 395 //     dialogs and should work for both of them
 396 void wxDialog::EndModal(int retCode)
 397 {
 398     m_endModalCalled = TRUE;
 399     SetReturnCode(retCode);
 400
 401     Show(FALSE);
 402 }
 403
 404 // ----------------------------------------------------------------------------
 405 // wxWin event handlers
 406 // ----------------------------------------------------------------------------
 407
 408 // Standard buttons
 409 void wxDialog::OnOK(wxCommandEvent& WXUNUSED(event))
 410 {
 411   if ( Validate() && TransferDataFromWindow() )
 412   {
 413       EndModal(wxID_OK);
 414   }
 415 }
 416
 417 void wxDialog::OnApply(wxCommandEvent& WXUNUSED(event))
 418 {
 419     if ( Validate() )
 420         TransferDataFromWindow();
 421
 422     // TODO probably need to disable the Apply button until things change again
 423 }
 424
 425 void wxDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 426 {
 427     EndModal(wxID_CANCEL);
 428 }
 429
 430 void wxDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 431 {
 432     // We'll send a Cancel message by default, which may close the dialog.
 433     // Check for looping if the Cancel event handler calls Close().
 434
 435     // Note that if a cancel button and handler aren't present in the dialog,
 436     // nothing will happen when you close the dialog via the window manager, or
 437     // via Close(). We wouldn't want to destroy the dialog by default, since
 438     // the dialog may have been created on the stack. However, this does mean
 439     // that calling dialog->Close() won't delete the dialog unless the handler
 440     // for wxID_CANCEL does so. So use Destroy() if you want to be sure to
 441     // destroy the dialog. The default OnCancel (above) simply ends a modal
 442     // dialog, and hides a modeless dialog.
 443
 444     // VZ: this is horrible and MT-unsafe. Can't we reuse some of these global
 445     //     lists here? don't dare to change it now, but should be done later!
 446     static wxList closing;
 447
 448     if ( closing.Member(this) )
 449         return;
 450
 451     closing.Append(this);
 452
 453     wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
 454     cancelEvent.SetEventObject( this );
 455     GetEventHandler()->ProcessEvent(cancelEvent); // This may close the dialog
 456
 457     closing.DeleteObject(this);
 458 }
 459
 460 void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
 461 {
 462 #if wxUSE_CTL3D
 463     Ctl3dColorChange();
 464 #else
 465     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
 466     Refresh();
 467 #endif
 468 }
 469
 470 // ---------------------------------------------------------------------------
 471 // dialog window proc
 472 // ---------------------------------------------------------------------------
 473
 474 long wxDialog::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 475 {
 476     long rc = 0;
 477     bool processed = FALSE;
 478
 479     switch ( message )
 480     {
 481         case WM_CLOSE:
 482             // if we can't close, tell the system that we processed the
 483             // message - otherwise it would close us
 484             processed = !Close();
 485             break;
 486
 487         case WM_SIZE:
 488             // the Windows dialogs unfortunately are not meant to be resizeable
 489             // at all and their standard class doesn't include CS_[VH]REDRAW
 490             // styles which means that the window is not refreshed properly
 491             // after the resize and no amount of WS_CLIPCHILDREN/SIBLINGS can
 492             // help with it - so we have to refresh it manually which certainly
 493             // creates flicker but at least doesn't show garbage on the screen
 494             rc = wxWindow::MSWWindowProc(message, wParam, lParam);
 495             processed = TRUE;
 496             if ( HasFlag(wxFULL_REPAINT_ON_RESIZE) )
 497             {
 498                 ::InvalidateRect(GetHwnd(), NULL, FALSE /* erase bg */);
 499             }
 500             break;
 501
 502 #ifndef __WXMICROWIN__
 503         case WM_SETCURSOR:
 504             // we want to override the busy cursor for modal dialogs:
 505             // typically, wxBeginBusyCursor() is called and then a modal dialog
 506             // is shown, but the modal dialog shouldn't have hourglass cursor
 507             if ( IsModalShowing() && wxIsBusy() )
 508             {
 509                 // set our cursor for all windows (but see below)
 510                 wxCursor cursor = m_cursor;
 511                 if ( !cursor.Ok() )
 512                     cursor = wxCURSOR_ARROW;
 513
 514                 ::SetCursor(GetHcursorOf(cursor));
 515
 516                 // in any case, stop here and don't let wxWindow process this
 517                 // message (it would set the busy cursor)
 518                 processed = TRUE;
 519
 520                 // but return FALSE to tell the child window (if the event
 521                 // comes from one of them and not from ourselves) that it can
 522                 // set its own cursor if it has one: thus, standard controls
 523                 // (e.g. text ctrl) still have correct cursors in a dialog
 524                 // invoked while wxIsBusy()
 525                 rc = FALSE;
 526             }
 527             break;
 528 #endif // __WXMICROWIN__
 529     }
 530
 531     if ( !processed )
 532         rc = wxWindow::MSWWindowProc(message, wParam, lParam);
 533
 534     return rc;
 535 }
 536
 537 #if wxUSE_CTL3D
 538
 539 // Define for each class of dialog and control
 540 WXHBRUSH wxDialog::OnCtlColor(WXHDC WXUNUSED(pDC),
 541                               WXHWND WXUNUSED(pWnd),
 542                               WXUINT WXUNUSED(nCtlColor),
 543                               WXUINT message,
 544                               WXWPARAM wParam,
 545                               WXLPARAM lParam)
 546 {
 547     return (WXHBRUSH)Ctl3dCtlColorEx(message, wParam, lParam);
 548 }
 549
 550 #endif // wxUSE_CTL3D
 551