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 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #ifndef WX_PRECOMP
  28     #include "wx/dialog.h"
  29     #include "wx/utils.h"
  30     #include "wx/frame.h"
  31     #include "wx/app.h"
  32     #include "wx/button.h"
  33     #include "wx/settings.h"
  34     #include "wx/intl.h"
  35     #include "wx/log.h"
  36 #endif
  37
  38 #include "wx/msw/private.h"
  39 #include "wx/log.h"
  40 #include "wx/evtloop.h"
  41 #include "wx/ptr_scpd.h"
  42
  43 #include "wx/msw/wrapcdlg.h"
  44
  45 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
  46     #include "wx/msw/wince/resources.h"
  47 #endif // __SMARTPHONE__ && __WXWINCE__
  48
  49 #if wxUSE_TOOLBAR && defined(__POCKETPC__)
  50 #include "wx/toolbar.h"
  51 #endif
  52
  53 // ----------------------------------------------------------------------------
  54 // wxWin macros
  55 // ----------------------------------------------------------------------------
  56
  57 #if wxUSE_EXTENDED_RTTI
  58 WX_DEFINE_FLAGS( wxDialogStyle )
  59
  60 wxBEGIN_FLAGS( wxDialogStyle )
  61     // new style border flags, we put them first to
  62     // use them for streaming out
  63     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  64     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  65     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  66     wxFLAGS_MEMBER(wxBORDER_RAISED)
  67     wxFLAGS_MEMBER(wxBORDER_STATIC)
  68     wxFLAGS_MEMBER(wxBORDER_NONE)
  69
  70     // old style border flags
  71     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  72     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  73     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  74     wxFLAGS_MEMBER(wxRAISED_BORDER)
  75     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  76     wxFLAGS_MEMBER(wxNO_BORDER)
  77
  78     // standard window styles
  79     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  80     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  81
  82     // dialog styles
  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 , EMPTY_MACROVALUE , 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_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged)
 117
 118     EVT_CLOSE(wxDialog::OnCloseWindow)
 119 END_EVENT_TABLE()
 120
 121 // ----------------------------------------------------------------------------
 122 // wxDialogModalData
 123 // ----------------------------------------------------------------------------
 124
 125 // this is simply a container for any data we need to implement modality which
 126 // allows us to avoid changing wxDialog each time the implementation changes
 127 class wxDialogModalData
 128 {
 129 public:
 130     wxDialogModalData(wxDialog *dialog) : m_evtLoop(dialog) { }
 131
 132     void RunLoop()
 133     {
 134         m_evtLoop.Run();
 135     }
 136
 137     void ExitLoop()
 138     {
 139         m_evtLoop.Exit();
 140     }
 141
 142 private:
 143     wxModalEventLoop m_evtLoop;
 144 };
 145
 146 wxDEFINE_TIED_SCOPED_PTR_TYPE(wxDialogModalData)
 147
 148 // ============================================================================
 149 // implementation
 150 // ============================================================================
 151
 152 // ----------------------------------------------------------------------------
 153 // wxDialog construction
 154 // ----------------------------------------------------------------------------
 155
 156 void wxDialog::Init()
 157 {
 158     m_oldFocus = (wxWindow *)NULL;
 159     m_isShown = false;
 160     m_modalData = NULL;
 161     m_endModalCalled = false;
 162 #if wxUSE_TOOLBAR && defined(__POCKETPC__)
 163     m_dialogToolBar = NULL;
 164 #endif
 165 }
 166
 167 bool wxDialog::Create(wxWindow *parent,
 168                       wxWindowID id,
 169                       const wxString& title,
 170                       const wxPoint& pos,
 171                       const wxSize& size,
 172                       long style,
 173                       const wxString& name)
 174 {
 175     SetExtraStyle(GetExtraStyle() | wxTOPLEVEL_EX_DIALOG);
 176
 177     // save focus before doing anything which can potentially change it
 178     m_oldFocus = FindFocus();
 179
 180     // All dialogs should really have this style
 181     style |= wxTAB_TRAVERSAL;
 182
 183     if ( !wxTopLevelWindow::Create(parent, id, title, pos, size, style, name) )
 184         return false;
 185
 186     if ( !m_hasFont )
 187         SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
 188
 189 #if defined(__SMARTPHONE__) && defined(__WXWINCE__)
 190     SetLeftMenu(wxID_OK, _("OK"));
 191 #endif
 192 #if wxUSE_TOOLBAR && defined(__POCKETPC__)
 193     CreateToolBar();
 194 #endif
 195
 196     return true;
 197 }
 198
 199 // deprecated ctor
 200 wxDialog::wxDialog(wxWindow *parent,
 201                    const wxString& title,
 202                    bool WXUNUSED(modal),
 203                    int x,
 204                    int y,
 205                    int w,
 206                    int h,
 207                    long style,
 208                    const wxString& name)
 209 {
 210     Init();
 211
 212     Create(parent, wxID_ANY, title, wxPoint(x, y), wxSize(w, h), style, name);
 213 }
 214
 215 void wxDialog::SetModal(bool WXUNUSED(flag))
 216 {
 217     // nothing to do, obsolete method
 218 }
 219
 220 wxDialog::~wxDialog()
 221 {
 222     m_isBeingDeleted = true;
 223
 224     // this will also reenable all the other windows for a modal dialog
 225     Show(false);
 226 }
 227
 228 // ----------------------------------------------------------------------------
 229 // showing the dialogs
 230 // ----------------------------------------------------------------------------
 231
 232 bool wxDialog::IsModalShowing() const
 233 {
 234     return IsModal();
 235 }
 236
 237 wxWindow *wxDialog::FindSuitableParent() const
 238 {
 239     // first try to use the currently active window
 240     HWND hwndFg = ::GetForegroundWindow();
 241     wxWindow *parent = hwndFg ? wxFindWinFromHandle((WXHWND)hwndFg)
 242                               : NULL;
 243     if ( !parent )
 244     {
 245         // next try the main app window
 246         parent = wxTheApp->GetTopWindow();
 247     }
 248
 249     // finally, check if the parent we found is really suitable
 250     if ( !parent || parent == (wxWindow *)this || !parent->IsShown() )
 251     {
 252         // don't use this one
 253         parent = NULL;
 254     }
 255
 256     return parent;
 257 }
 258
 259 bool wxDialog::Show(bool show)
 260 {
 261     if ( show == IsShown() )
 262         return false;
 263
 264     if ( !show && m_modalData )
 265     {
 266         // we need to do this before calling wxDialogBase version because if we
 267         // had disabled other app windows, they must be reenabled right now as
 268         // if they stay disabled Windows will activate another window (one
 269         // which is enabled, anyhow) when we're hidden in the base class Show()
 270         // and we will lose activation
 271         m_modalData->ExitLoop();
 272     }
 273
 274     if ( show )
 275     {
 276         // this usually will result in TransferDataToWindow() being called
 277         // which will change the controls values so do it before showing as
 278         // otherwise we could have some flicker
 279         InitDialog();
 280     }
 281
 282     wxDialogBase::Show(show);
 283
 284     if ( show )
 285     {
 286         // dialogs don't get WM_SIZE message after creation unlike most (all?)
 287         // other windows and so could start their life non laid out correctly
 288         // if we didn't call Layout() from here
 289         //
 290         // NB: normally we should call it just the first time but doing it
 291         //     every time is simpler than keeping a flag
 292         Layout();
 293     }
 294
 295     return true;
 296 }
 297
 298 void wxDialog::Raise()
 299 {
 300     ::SetForegroundWindow(GetHwnd());
 301 }
 302
 303 // show dialog modally
 304 int wxDialog::ShowModal()
 305 {
 306     wxASSERT_MSG( !IsModal(), _T("wxDialog::ShowModal() reentered?") );
 307
 308     m_endModalCalled = false;
 309
 310     Show();
 311
 312     // EndModal may have been called from InitDialog handler (called from
 313     // inside Show()), which would cause an infinite loop if we didn't take it
 314     // into account
 315     if ( !m_endModalCalled )
 316     {
 317         // modal dialog needs a parent window, so try to find one
 318         wxWindow *parent = GetParent();
 319         if ( !parent )
 320         {
 321             parent = FindSuitableParent();
 322         }
 323
 324         // remember where the focus was
 325         wxWindow *oldFocus = m_oldFocus;
 326         if ( !oldFocus )
 327         {
 328             // VZ: do we really want to do this?
 329             oldFocus = parent;
 330         }
 331
 332         // We have to remember the HWND because we need to check
 333         // the HWND still exists (oldFocus can be garbage when the dialog
 334         // exits, if it has been destroyed)
 335         HWND hwndOldFocus = oldFocus ? GetHwndOf(oldFocus) : NULL;
 336
 337
 338         // enter and run the modal loop
 339         {
 340             wxDialogModalDataTiedPtr modalData(&m_modalData,
 341                                                new wxDialogModalData(this));
 342             modalData->RunLoop();
 343         }
 344
 345
 346         // and restore focus
 347         // Note that this code MUST NOT access the dialog object's data
 348         // in case the object has been deleted (which will be the case
 349         // for a modal dialog that has been destroyed before calling EndModal).
 350         if ( oldFocus && (oldFocus != this) && ::IsWindow(hwndOldFocus))
 351         {
 352             // This is likely to prove that the object still exists
 353             if (wxFindWinFromHandle((WXHWND) hwndOldFocus) == oldFocus)
 354                 oldFocus->SetFocus();
 355         }
 356     }
 357
 358     return GetReturnCode();
 359 }
 360
 361 void wxDialog::EndModal(int retCode)
 362 {
 363     wxASSERT_MSG( IsModal(), _T("EndModal() called for non modal dialog") );
 364
 365     m_endModalCalled = true;
 366     SetReturnCode(retCode);
 367
 368     Hide();
 369 }
 370
 371 void wxDialog::EndDialog(int rc)
 372 {
 373     if ( IsModal() )
 374         EndModal(rc);
 375     else
 376         Hide();
 377 }
 378
 379 // ----------------------------------------------------------------------------
 380 // wxWin event handlers
 381 // ----------------------------------------------------------------------------
 382
 383 bool wxDialog::EmulateButtonClickIfPresent(int id)
 384 {
 385     wxButton *btn = wxDynamicCast(FindWindow(id), wxButton);
 386
 387     if ( !btn || !btn->IsEnabled() || !btn->IsShown() )
 388         return false;
 389
 390     btn->MSWCommand(BN_CLICKED, 0 /* unused */);
 391     return true;
 392 }
 393
 394 // Standard buttons
 395 void wxDialog::OnOK(wxCommandEvent& WXUNUSED(event))
 396 {
 397   if ( Validate() && TransferDataFromWindow() )
 398   {
 399       EndDialog(wxID_OK);
 400   }
 401 }
 402
 403 void wxDialog::OnApply(wxCommandEvent& WXUNUSED(event))
 404 {
 405     if ( Validate() )
 406         TransferDataFromWindow();
 407
 408     // TODO probably need to disable the Apply button until things change again
 409 }
 410
 411 void wxDialog::OnCancel(wxCommandEvent& WXUNUSED(event))
 412 {
 413     EndDialog(wxID_CANCEL);
 414 }
 415
 416 void wxDialog::OnCloseWindow(wxCloseEvent& WXUNUSED(event))
 417 {
 418     // We'll send a Cancel message by default, which may close the dialog.
 419     // Check for looping if the Cancel event handler calls Close().
 420
 421     // Note that if a cancel button and handler aren't present in the dialog,
 422     // nothing will happen when you close the dialog via the window manager, or
 423     // via Close(). We wouldn't want to destroy the dialog by default, since
 424     // the dialog may have been created on the stack. However, this does mean
 425     // that calling dialog->Close() won't delete the dialog unless the handler
 426     // for wxID_CANCEL does so. So use Destroy() if you want to be sure to
 427     // destroy the dialog. The default OnCancel (above) simply ends a modal
 428     // dialog, and hides a modeless dialog.
 429
 430     // VZ: this is horrible and MT-unsafe. Can't we reuse some of these global
 431     //     lists here? don't dare to change it now, but should be done later!
 432     static wxList closing;
 433
 434     if ( closing.Member(this) )
 435         return;
 436
 437     closing.Append(this);
 438
 439     wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL);
 440     cancelEvent.SetEventObject( this );
 441     GetEventHandler()->ProcessEvent(cancelEvent); // This may close the dialog
 442
 443     closing.DeleteObject(this);
 444 }
 445
 446 void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& WXUNUSED(event))
 447 {
 448     SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_3DFACE));
 449     Refresh();
 450 }
 451
 452 #ifdef __POCKETPC__
 453 // Responds to the OK button in a PocketPC titlebar. This
 454 // can be overridden, or you can change the id used for
 455 // sending the event, by calling SetAffirmativeId.
 456 bool wxDialog::DoOK()
 457 {
 458     const int idOk = GetAffirmativeId();
 459     if ( EmulateButtonClickIfPresent(idOk) )
 460         return true;
 461
 462     wxCommandEvent event(wxEVT_COMMAND_BUTTON_CLICKED, GetAffirmativeId());
 463     event.SetEventObject(this);
 464
 465     return GetEventHandler()->ProcessEvent(event);
 466 }
 467 #endif // __POCKETPC__
 468
 469 #if wxUSE_TOOLBAR && defined(__POCKETPC__)
 470 // create main toolbar by calling OnCreateToolBar()
 471 wxToolBar* wxDialog::CreateToolBar(long style, wxWindowID winid, const wxString& name)
 472 {
 473     m_dialogToolBar = OnCreateToolBar(style, winid, name);
 474
 475     return m_dialogToolBar;
 476 }
 477
 478 // return a new toolbar
 479 wxToolBar *wxDialog::OnCreateToolBar(long style,
 480                                        wxWindowID winid,
 481                                        const wxString& name)
 482 {
 483     return new wxToolMenuBar(this, winid,
 484                          wxDefaultPosition, wxDefaultSize,
 485                          style, name);
 486 }
 487 #endif
 488
 489 // ---------------------------------------------------------------------------
 490 // dialog Windows messages processing
 491 // ---------------------------------------------------------------------------
 492
 493 bool wxDialog::MSWProcessMessage(WXMSG* pMsg)
 494 {
 495     const MSG * const msg = wx_reinterpret_cast(MSG *, pMsg);
 496     if ( msg->message == WM_KEYDOWN && msg->wParam == VK_ESCAPE )
 497     {
 498         int idCancel = GetEscapeId();
 499         switch ( idCancel )
 500         {
 501             case wxID_NONE:
 502                 // don't handle Esc specially at all
 503                 break;
 504
 505             case wxID_ANY:
 506                 // this value is special: it means translate Esc to wxID_CANCEL
 507                 // but if there is no such button, then fall back to wxID_OK
 508                 if ( EmulateButtonClickIfPresent(wxID_CANCEL) )
 509                     return true;
 510                 idCancel = wxID_OK;
 511                 // fall through
 512
 513             default:
 514                 // translate Esc to button press for the button with given id
 515                 if ( EmulateButtonClickIfPresent(idCancel) )
 516                     return true;
 517         }
 518     }
 519
 520     return wxDialogBase::MSWProcessMessage(pMsg);
 521 }
 522
 523 WXLRESULT wxDialog::MSWWindowProc(WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
 524 {
 525     WXLRESULT rc = 0;
 526     bool processed = false;
 527
 528     switch ( message )
 529     {
 530 #ifdef __WXWINCE__
 531         // react to pressing the OK button in the title
 532         case WM_COMMAND:
 533         {
 534             switch ( LOWORD(wParam) )
 535             {
 536 #ifdef __POCKETPC__
 537                 case IDOK:
 538                     processed = DoOK();
 539                     if (!processed)
 540                         processed = !Close();
 541 #endif
 542 #ifdef __SMARTPHONE__
 543                 case IDM_LEFT:
 544                 case IDM_RIGHT:
 545                     processed = HandleCommand( LOWORD(wParam) , 0 , NULL );
 546                     break;
 547 #endif // __SMARTPHONE__
 548             }
 549             break;
 550         }
 551 #endif
 552         case WM_CLOSE:
 553             // if we can't close, tell the system that we processed the
 554             // message - otherwise it would close us
 555             processed = !Close();
 556             break;
 557
 558         case WM_SIZE:
 559             // the Windows dialogs unfortunately are not meant to be resizeable
 560             // at all and their standard class doesn't include CS_[VH]REDRAW
 561             // styles which means that the window is not refreshed properly
 562             // after the resize and no amount of WS_CLIPCHILDREN/SIBLINGS can
 563             // help with it - so we have to refresh it manually which certainly
 564             // creates flicker but at least doesn't show garbage on the screen
 565             rc = wxWindow::MSWWindowProc(message, wParam, lParam);
 566             processed = true;
 567             if ( HasFlag(wxFULL_REPAINT_ON_RESIZE) )
 568             {
 569                 ::InvalidateRect(GetHwnd(), NULL, false /* erase bg */);
 570             }
 571             break;
 572
 573 #ifndef __WXMICROWIN__
 574         case WM_SETCURSOR:
 575             // we want to override the busy cursor for modal dialogs:
 576             // typically, wxBeginBusyCursor() is called and then a modal dialog
 577             // is shown, but the modal dialog shouldn't have hourglass cursor
 578             if ( IsModal() && wxIsBusy() )
 579             {
 580                 // set our cursor for all windows (but see below)
 581                 wxCursor cursor = m_cursor;
 582                 if ( !cursor.Ok() )
 583                     cursor = wxCURSOR_ARROW;
 584
 585                 ::SetCursor(GetHcursorOf(cursor));
 586
 587                 // in any case, stop here and don't let wxWindow process this
 588                 // message (it would set the busy cursor)
 589                 processed = true;
 590
 591                 // but return false to tell the child window (if the event
 592                 // comes from one of them and not from ourselves) that it can
 593                 // set its own cursor if it has one: thus, standard controls
 594                 // (e.g. text ctrl) still have correct cursors in a dialog
 595                 // invoked while wxIsBusy()
 596                 rc = false;
 597             }
 598             break;
 599 #endif // __WXMICROWIN__
 600     }
 601
 602     if ( !processed )
 603         rc = wxWindow::MSWWindowProc(message, wParam, lParam);
 604
 605     return rc;
 606 }
 607