]>
Commit | Line | Data |
---|---|---|
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 |