]>
Commit | Line | Data |
---|---|---|
1 | ///////////////////////////////////////////////////////////////////////////// | |
2 | // Name: dialog.cpp | |
3 | // Purpose: wxDialog class | |
4 | // Author: Julian Smart | |
5 | // Modified by: | |
6 | // Created: 17/09/98 | |
7 | // RCS-ID: $Id$ | |
8 | // Copyright: (c) Julian Smart | |
9 | // Licence: wxWindows licence | |
10 | ///////////////////////////////////////////////////////////////////////////// | |
11 | ||
12 | #ifdef __GNUG__ | |
13 | #pragma implementation "dialog.h" | |
14 | #endif | |
15 | ||
16 | #include "wx/dialog.h" | |
17 | #include "wx/utils.h" | |
18 | #include "wx/frame.h" | |
19 | #include "wx/app.h" | |
20 | #include "wx/settings.h" | |
21 | ||
22 | #include <Xm/Xm.h> | |
23 | ||
24 | #include <X11/Shell.h> | |
25 | #if XmVersion >= 1002 | |
26 | #include <Xm/XmAll.h> | |
27 | #endif | |
28 | #include <Xm/MwmUtil.h> | |
29 | #include <Xm/Label.h> | |
30 | #include <Xm/BulletinB.h> | |
31 | #include <Xm/Frame.h> | |
32 | #include <Xm/Text.h> | |
33 | #include <Xm/DialogS.h> | |
34 | #include <Xm/FileSB.h> | |
35 | #include <Xm/RowColumn.h> | |
36 | #include <Xm/LabelG.h> | |
37 | #include <Xm/AtomMgr.h> | |
38 | #if XmVersion > 1000 | |
39 | #include <Xm/Protocols.h> | |
40 | #endif | |
41 | ||
42 | #include "wx/motif/private.h" | |
43 | ||
44 | static void wxCloseDialogCallback(Widget widget, XtPointer client_data, XmAnyCallbackStruct *cbs); | |
45 | static void wxDialogBoxRepaintProc(Widget w, XtPointer c_data, XEvent *event, char *); | |
46 | static void wxDialogBoxEventHandler (Widget wid, | |
47 | XtPointer client_data, | |
48 | XEvent* event, | |
49 | Boolean *continueToDispatch); | |
50 | ||
51 | static void wxUnmapBulletinBoard(Widget dialog, wxDialog *client,XtPointer call); | |
52 | ||
53 | // A stack of modal_showing flags, since we can't rely | |
54 | // on accessing wxDialog::m_modalShowing within | |
55 | // wxDialog::Show in case a callback has deleted the wxDialog. | |
56 | static wxList wxModalShowingStack; | |
57 | ||
58 | // Lists to keep track of windows, so we can disable/enable them | |
59 | // for modal dialogs | |
60 | wxList wxModalDialogs; | |
61 | wxList wxModelessWindows; // Frames and modeless dialogs | |
62 | extern wxList wxPendingDelete; | |
63 | ||
64 | #define wxUSE_INVISIBLE_RESIZE 1 | |
65 | ||
66 | #if !USE_SHARED_LIBRARY | |
67 | IMPLEMENT_DYNAMIC_CLASS(wxDialog, wxPanel) | |
68 | ||
69 | BEGIN_EVENT_TABLE(wxDialog, wxPanel) | |
70 | EVT_BUTTON(wxID_OK, wxDialog::OnOK) | |
71 | EVT_BUTTON(wxID_APPLY, wxDialog::OnApply) | |
72 | EVT_BUTTON(wxID_CANCEL, wxDialog::OnCancel) | |
73 | EVT_CHAR_HOOK(wxDialog::OnCharHook) | |
74 | EVT_SYS_COLOUR_CHANGED(wxDialog::OnSysColourChanged) | |
75 | EVT_CLOSE(wxDialog::OnCloseWindow) | |
76 | END_EVENT_TABLE() | |
77 | ||
78 | #endif | |
79 | ||
80 | wxDialog::wxDialog() | |
81 | { | |
82 | m_modalShowing = FALSE; | |
83 | SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); | |
84 | } | |
85 | ||
86 | bool wxDialog::Create(wxWindow *parent, wxWindowID id, | |
87 | const wxString& title, | |
88 | const wxPoint& pos, | |
89 | const wxSize& size, | |
90 | long style, | |
91 | const wxString& name) | |
92 | { | |
93 | m_windowStyle = style; | |
94 | m_modalShowing = FALSE; | |
95 | m_dialogTitle = title; | |
96 | ||
97 | SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); | |
98 | SetName(name); | |
99 | ||
100 | if (!parent) | |
101 | wxTopLevelWindows.Append(this); | |
102 | ||
103 | if (parent) parent->AddChild(this); | |
104 | ||
105 | if ( id == -1 ) | |
106 | m_windowId = (int)NewControlId(); | |
107 | else | |
108 | m_windowId = id; | |
109 | ||
110 | Widget parentWidget = (Widget) 0; | |
111 | if (parent) | |
112 | parentWidget = (Widget) parent->GetTopWidget(); | |
113 | if (!parent) | |
114 | parentWidget = (Widget) wxTheApp->GetTopLevelWidget(); | |
115 | ||
116 | wxASSERT_MSG( (parentWidget != (Widget) 0), "Could not find a suitable parent shell for dialog." ); | |
117 | ||
118 | Arg args[1]; | |
119 | XtSetArg (args[0], XmNdefaultPosition, False); | |
120 | Widget dialogShell = XmCreateBulletinBoardDialog(parentWidget, (char*) (const char*) name, args, 1); | |
121 | m_mainWidget = (WXWidget) dialogShell; | |
122 | ||
123 | // We don't want margins, since there is enough elsewhere. | |
124 | XtVaSetValues(dialogShell, | |
125 | XmNmarginHeight, 0, | |
126 | XmNmarginWidth, 0, | |
127 | XmNresizePolicy, XmRESIZE_NONE, | |
128 | NULL) ; | |
129 | ||
130 | Widget shell = XtParent(dialogShell) ; | |
131 | if (!title.IsNull()) | |
132 | { | |
133 | XmString str = XmStringCreateSimple((char*) (const char*)title); | |
134 | XtVaSetValues(dialogShell, | |
135 | XmNdialogTitle, str, | |
136 | NULL); | |
137 | XmStringFree(str); | |
138 | } | |
139 | ||
140 | wxAddWindowToTable(dialogShell, this); | |
141 | ||
142 | // Intercept CLOSE messages from the window manager | |
143 | Atom WM_DELETE_WINDOW = XmInternAtom(XtDisplay(shell), "WM_DELETE_WINDOW", False); | |
144 | ||
145 | /* MATTHEW: [8] Remove and add WM_DELETE_WINDOW so ours is only handler */ | |
146 | /* Why do we have to do this for wxDialog, but not wxFrame? */ | |
147 | XmRemoveWMProtocols(shell, &WM_DELETE_WINDOW, 1); | |
148 | XmAddWMProtocols(shell, &WM_DELETE_WINDOW, 1); | |
149 | XmActivateWMProtocol(shell, WM_DELETE_WINDOW); | |
150 | ||
151 | // Modified Steve Hammes for Motif 2.0 | |
152 | #if (XmREVISION > 1 || XmVERSION > 1) | |
153 | XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW, (XtCallbackProc) wxCloseDialogCallback, (XtPointer)this); | |
154 | #elif XmREVISION == 1 | |
155 | XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW, (XtCallbackProc) wxCloseDialogCallback, (caddr_t)this); | |
156 | #else | |
157 | XmAddWMProtocolCallback(shell, WM_DELETE_WINDOW, (void (*)())wxCloseDialogCallback, (caddr_t)this); | |
158 | #endif | |
159 | ||
160 | XtTranslations ptr ; | |
161 | XtOverrideTranslations(dialogShell, | |
162 | ptr = XtParseTranslationTable("<Configure>: resize()")); | |
163 | XtFree((char *)ptr); | |
164 | ||
165 | // Can't remember what this was about... but I think it's necessary. | |
166 | ||
167 | if (wxUSE_INVISIBLE_RESIZE) | |
168 | { | |
169 | if (pos.x > -1) | |
170 | XtVaSetValues(dialogShell, XmNx, pos.x, | |
171 | NULL); | |
172 | if (pos.y > -1) | |
173 | XtVaSetValues(dialogShell, XmNy, pos.y, | |
174 | NULL); | |
175 | ||
176 | if (size.x > -1) | |
177 | XtVaSetValues(dialogShell, XmNwidth, size.x, NULL); | |
178 | if (size.y > -1) | |
179 | XtVaSetValues(dialogShell, XmNheight, size.y, NULL); | |
180 | } | |
181 | ||
182 | // This patch come from Torsten Liermann lier@lier1.muc.de | |
183 | if (XmIsMotifWMRunning(shell)) | |
184 | { | |
185 | int decor = 0 ; | |
186 | if (m_windowStyle & wxRESIZE_BORDER) | |
187 | decor |= MWM_DECOR_RESIZEH ; | |
188 | if (m_windowStyle & wxSYSTEM_MENU) | |
189 | decor |= MWM_DECOR_MENU; | |
190 | if ((m_windowStyle & wxCAPTION) || | |
191 | (m_windowStyle & wxTINY_CAPTION_HORIZ) || | |
192 | (m_windowStyle & wxTINY_CAPTION_VERT)) | |
193 | decor |= MWM_DECOR_TITLE; | |
194 | if (m_windowStyle & wxTHICK_FRAME) | |
195 | decor |= MWM_DECOR_BORDER; | |
196 | if (m_windowStyle & wxMINIMIZE_BOX) | |
197 | decor |= MWM_DECOR_MINIMIZE; | |
198 | if (m_windowStyle & wxMAXIMIZE_BOX) | |
199 | decor |= MWM_DECOR_MAXIMIZE; | |
200 | ||
201 | XtVaSetValues(shell,XmNmwmDecorations,decor,NULL) ; | |
202 | } | |
203 | // This allows non-Motif window managers to support at least the | |
204 | // no-decorations case. | |
205 | else | |
206 | { | |
207 | if ((m_windowStyle & wxCAPTION) != wxCAPTION) | |
208 | XtVaSetValues((Widget) shell,XmNoverrideRedirect,TRUE,NULL); | |
209 | } | |
210 | ||
211 | XtRealizeWidget(dialogShell); | |
212 | ||
213 | XtAddCallback(dialogShell,XmNunmapCallback, | |
214 | (XtCallbackProc)wxUnmapBulletinBoard,this) ; | |
215 | ||
216 | // Positioning of the dialog doesn't work properly unless the dialog | |
217 | // is managed, so we manage without mapping to the screen. | |
218 | // To show, we map the shell (actually it's parent). | |
219 | if (!wxUSE_INVISIBLE_RESIZE) | |
220 | XtVaSetValues(shell, XmNmappedWhenManaged, FALSE, NULL); | |
221 | ||
222 | if (!wxUSE_INVISIBLE_RESIZE) | |
223 | { | |
224 | XtManageChild(dialogShell); | |
225 | SetSize(pos.x, pos.y, size.x, size.y); | |
226 | } | |
227 | XtAddEventHandler(dialogShell,ExposureMask,FALSE, | |
228 | wxDialogBoxRepaintProc, (XtPointer) this); | |
229 | ||
230 | XtAddEventHandler(dialogShell, | |
231 | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | KeyPressMask, | |
232 | FALSE, | |
233 | wxDialogBoxEventHandler, | |
234 | (XtPointer)this); | |
235 | ||
236 | return TRUE; | |
237 | } | |
238 | ||
239 | void wxDialog::SetModal(bool flag) | |
240 | { | |
241 | if ( flag ) | |
242 | m_windowStyle |= wxDIALOG_MODAL ; | |
243 | else | |
244 | if ( m_windowStyle & wxDIALOG_MODAL ) | |
245 | m_windowStyle -= wxDIALOG_MODAL ; | |
246 | ||
247 | wxModelessWindows.DeleteObject(this); | |
248 | if (!flag) | |
249 | wxModelessWindows.Append(this); | |
250 | } | |
251 | ||
252 | wxDialog::~wxDialog() | |
253 | { | |
254 | m_modalShowing = FALSE; | |
255 | if (!wxUSE_INVISIBLE_RESIZE && m_mainWidget) | |
256 | { | |
257 | XtUnmapWidget((Widget) m_mainWidget); | |
258 | } | |
259 | ||
260 | wxTopLevelWindows.DeleteObject(this); | |
261 | ||
262 | if ( (GetWindowStyleFlag() & wxDIALOG_MODAL) != wxDIALOG_MODAL ) | |
263 | wxModelessWindows.DeleteObject(this); | |
264 | ||
265 | // If this is the last top-level window, exit. | |
266 | if (wxTheApp && (wxTopLevelWindows.Number() == 0)) | |
267 | { | |
268 | wxTheApp->SetTopWindow(NULL); | |
269 | ||
270 | if (wxTheApp->GetExitOnFrameDelete()) | |
271 | { | |
272 | wxTheApp->ExitMainLoop(); | |
273 | } | |
274 | } | |
275 | ||
276 | // This event-flushing code used to be in wxWindow::PostDestroyChildren (wx_dialog.cpp) | |
277 | // but I think this should work, if we destroy the children first. | |
278 | // Note that this might need to be done for wxFrame also. | |
279 | DestroyChildren(); | |
280 | ||
281 | // Now process all events, because otherwise | |
282 | // this might remain on the screen. | |
283 | Display* display; | |
284 | if (m_mainWidget) | |
285 | display = XtDisplay((Widget) m_mainWidget); | |
286 | else | |
287 | display = (Display*) wxGetDisplay(); | |
288 | ||
289 | XSync(display, FALSE); | |
290 | XEvent event; | |
291 | while (XtAppPending((XtAppContext) wxTheApp->GetAppContext())) { | |
292 | XFlush(display); | |
293 | XtAppNextEvent((XtAppContext) wxTheApp->GetAppContext(), &event); | |
294 | XtDispatchEvent(&event); | |
295 | } | |
296 | } | |
297 | ||
298 | // By default, pressing escape cancels the dialog | |
299 | void wxDialog::OnCharHook(wxKeyEvent& event) | |
300 | { | |
301 | if (event.m_keyCode == WXK_ESCAPE) | |
302 | { | |
303 | // Behaviour changed in 2.0: we'll send a Cancel message | |
304 | // to the dialog instead of Close. | |
305 | wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); | |
306 | cancelEvent.SetEventObject( this ); | |
307 | GetEventHandler()->ProcessEvent(cancelEvent); | |
308 | ||
309 | return; | |
310 | } | |
311 | // We didn't process this event. | |
312 | event.Skip(); | |
313 | } | |
314 | ||
315 | void wxDialog::Iconize(bool WXUNUSED(iconize)) | |
316 | { | |
317 | // Can't iconize a dialog in Motif, apparently | |
318 | // TODO: try using the parent of m_mainShell. | |
319 | // XtVaSetValues((Widget) m_mainWidget, XmNiconic, iconize, NULL); | |
320 | } | |
321 | ||
322 | bool wxDialog::IsIconized() const | |
323 | { | |
324 | /* | |
325 | Boolean iconic; | |
326 | XtVaGetValues((Widget) m_mainWidget, XmNiconic, &iconic, NULL); | |
327 | ||
328 | return iconic; | |
329 | */ | |
330 | return FALSE; | |
331 | } | |
332 | ||
333 | void wxDialog::SetSize(int x, int y, int width, int height, int sizeFlags) | |
334 | { | |
335 | XtVaSetValues((Widget) m_mainWidget, XmNresizePolicy, XmRESIZE_ANY, NULL); | |
336 | wxWindow::SetSize(x, y, width, height, sizeFlags); | |
337 | XtVaSetValues((Widget) m_mainWidget, XmNresizePolicy, XmRESIZE_NONE, NULL); | |
338 | } | |
339 | ||
340 | void wxDialog::SetClientSize(int width, int height) | |
341 | { | |
342 | SetSize(-1, -1, width, height); | |
343 | } | |
344 | ||
345 | ||
346 | void wxDialog::SetTitle(const wxString& title) | |
347 | { | |
348 | m_dialogTitle = title; | |
349 | if (!title.IsNull()) | |
350 | { | |
351 | XmString str = XmStringCreateSimple((char*) (const char*) title); | |
352 | XtVaSetValues((Widget) m_mainWidget, | |
353 | XmNtitle, (char*) (const char*) title, | |
354 | XmNdialogTitle, str, // Roberto Cocchi | |
355 | XmNiconName, (char*) (const char*) title, | |
356 | NULL); | |
357 | XmStringFree(str); | |
358 | } | |
359 | } | |
360 | ||
361 | wxString wxDialog::GetTitle() const | |
362 | { | |
363 | return m_dialogTitle; | |
364 | } | |
365 | ||
366 | void wxDialog::Centre(int direction) | |
367 | { | |
368 | int x_offset,y_offset ; | |
369 | int display_width, display_height; | |
370 | int width, height, x, y; | |
371 | wxWindow *parent = GetParent(); | |
372 | if ((direction & wxCENTER_FRAME) && parent) | |
373 | { | |
374 | parent->GetPosition(&x_offset,&y_offset) ; | |
375 | parent->GetSize(&display_width,&display_height) ; | |
376 | } | |
377 | else | |
378 | { | |
379 | wxDisplaySize(&display_width, &display_height); | |
380 | x_offset = 0 ; | |
381 | y_offset = 0 ; | |
382 | } | |
383 | ||
384 | GetSize(&width, &height); | |
385 | GetPosition(&x, &y); | |
386 | ||
387 | if (direction & wxHORIZONTAL) | |
388 | x = (int)((display_width - width)/2); | |
389 | if (direction & wxVERTICAL) | |
390 | y = (int)((display_height - height)/2); | |
391 | ||
392 | SetSize(x+x_offset, y+y_offset, width, height); | |
393 | } | |
394 | ||
395 | void wxDialog::Raise() | |
396 | { | |
397 | Window parent_window = XtWindow((Widget) m_mainWidget), | |
398 | next_parent = XtWindow((Widget) m_mainWidget), | |
399 | root = RootWindowOfScreen(XtScreen((Widget) m_mainWidget)); | |
400 | // search for the parent that is child of ROOT, because the WM may | |
401 | // reparent twice and notify only the next parent (like FVWM) | |
402 | while (next_parent != root) { | |
403 | Window *theChildren; unsigned int n; | |
404 | parent_window = next_parent; | |
405 | XQueryTree(XtDisplay((Widget) m_mainWidget), parent_window, &root, | |
406 | &next_parent, &theChildren, &n); | |
407 | XFree(theChildren); // not needed | |
408 | } | |
409 | XRaiseWindow(XtDisplay((Widget) m_mainWidget), parent_window); | |
410 | } | |
411 | ||
412 | void wxDialog::Lower() | |
413 | { | |
414 | Window parent_window = XtWindow((Widget) m_mainWidget), | |
415 | next_parent = XtWindow((Widget) m_mainWidget), | |
416 | root = RootWindowOfScreen(XtScreen((Widget) m_mainWidget)); | |
417 | // search for the parent that is child of ROOT, because the WM may | |
418 | // reparent twice and notify only the next parent (like FVWM) | |
419 | while (next_parent != root) { | |
420 | Window *theChildren; unsigned int n; | |
421 | parent_window = next_parent; | |
422 | XQueryTree(XtDisplay((Widget) m_mainWidget), parent_window, &root, | |
423 | &next_parent, &theChildren, &n); | |
424 | XFree(theChildren); // not needed | |
425 | } | |
426 | XLowerWindow(XtDisplay((Widget) m_mainWidget), parent_window); | |
427 | } | |
428 | ||
429 | bool wxDialog::Show(bool show) | |
430 | { | |
431 | m_isShown = show; | |
432 | ||
433 | if (show) | |
434 | { | |
435 | if (!wxUSE_INVISIBLE_RESIZE) | |
436 | XtMapWidget(XtParent((Widget) m_mainWidget)); | |
437 | else | |
438 | XtManageChild((Widget) m_mainWidget) ; | |
439 | ||
440 | XRaiseWindow(XtDisplay((Widget) m_mainWidget), XtWindow((Widget) m_mainWidget)); | |
441 | ||
442 | } | |
443 | else | |
444 | { | |
445 | if (!wxUSE_INVISIBLE_RESIZE) | |
446 | XtUnmapWidget(XtParent((Widget) m_mainWidget)); | |
447 | else | |
448 | XtUnmanageChild((Widget) m_mainWidget) ; | |
449 | ||
450 | XFlush(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())); | |
451 | XSync(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()), FALSE); | |
452 | } | |
453 | ||
454 | return TRUE; | |
455 | } | |
456 | ||
457 | // Shows a dialog modally, returning a return code | |
458 | int wxDialog::ShowModal() | |
459 | { | |
460 | m_windowStyle |= wxDIALOG_MODAL; | |
461 | ||
462 | Show(TRUE); | |
463 | ||
464 | if (m_modalShowing) | |
465 | return 0; | |
466 | ||
467 | wxModalShowingStack.Insert((wxObject *)TRUE); | |
468 | ||
469 | m_modalShowing = TRUE; | |
470 | XtAddGrab((Widget) m_mainWidget, TRUE, FALSE); | |
471 | XEvent event; | |
472 | ||
473 | // Loop until we signal that the dialog should be closed | |
474 | while ((wxModalShowingStack.Number() > 0) && (bool)wxModalShowingStack.First()->Data()) | |
475 | { | |
476 | XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMAll); | |
477 | } | |
478 | ||
479 | // Remove modal dialog flag from stack | |
480 | wxNode *node = wxModalShowingStack.First(); | |
481 | if (node) | |
482 | delete node; | |
483 | ||
484 | // Now process all events in case they get sent to a destroyed dialog | |
485 | XSync(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()), FALSE); | |
486 | while (XtAppPending((XtAppContext) wxTheApp->GetAppContext())) | |
487 | { | |
488 | XFlush(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())); | |
489 | XtAppNextEvent((XtAppContext) wxTheApp->GetAppContext(), &event); | |
490 | XtDispatchEvent(&event); | |
491 | } | |
492 | ||
493 | // TODO: is it safe to call this, if the dialog may have been deleted | |
494 | // by now? Probably only if we're using delayed deletion of dialogs. | |
495 | return GetReturnCode(); | |
496 | } | |
497 | ||
498 | void wxDialog::EndModal(int retCode) | |
499 | { | |
500 | if (!m_modalShowing) | |
501 | return; | |
502 | ||
503 | SetReturnCode(retCode); | |
504 | ||
505 | XtRemoveGrab((Widget) m_mainWidget); | |
506 | ||
507 | Show(FALSE); | |
508 | ||
509 | m_modalShowing = FALSE; | |
510 | ||
511 | wxNode *node = wxModalShowingStack.First(); | |
512 | if (node) | |
513 | node->SetData((wxObject *)FALSE); | |
514 | } | |
515 | ||
516 | // Standard buttons | |
517 | void wxDialog::OnOK(wxCommandEvent& event) | |
518 | { | |
519 | if ( Validate() && TransferDataFromWindow() ) | |
520 | { | |
521 | if ( IsModal() ) | |
522 | EndModal(wxID_OK); | |
523 | else | |
524 | { | |
525 | SetReturnCode(wxID_OK); | |
526 | this->Show(FALSE); | |
527 | } | |
528 | } | |
529 | } | |
530 | ||
531 | void wxDialog::OnApply(wxCommandEvent& event) | |
532 | { | |
533 | if (Validate()) | |
534 | TransferDataFromWindow(); | |
535 | // TODO probably need to disable the Apply button until things change again | |
536 | } | |
537 | ||
538 | void wxDialog::OnCancel(wxCommandEvent& event) | |
539 | { | |
540 | if ( IsModal() ) | |
541 | EndModal(wxID_CANCEL); | |
542 | else | |
543 | { | |
544 | SetReturnCode(wxID_CANCEL); | |
545 | this->Show(FALSE); | |
546 | } | |
547 | } | |
548 | ||
549 | bool wxDialog::OnClose() | |
550 | { | |
551 | // Behaviour changed in 2.0: we'll send a Cancel message by default, | |
552 | // which may close the dialog. | |
553 | // Check for looping if the Cancel event handler calls Close() | |
554 | ||
555 | static wxList closing; | |
556 | ||
557 | if ( closing.Member(this) ) | |
558 | return FALSE; | |
559 | ||
560 | closing.Append(this); | |
561 | ||
562 | wxCommandEvent cancelEvent(wxEVT_COMMAND_BUTTON_CLICKED, wxID_CANCEL); | |
563 | cancelEvent.SetEventObject( this ); | |
564 | GetEventHandler()->ProcessEvent(cancelEvent); | |
565 | ||
566 | closing.DeleteObject(this); | |
567 | ||
568 | return FALSE; | |
569 | } | |
570 | ||
571 | void wxDialog::OnCloseWindow(wxCloseEvent& event) | |
572 | { | |
573 | // Compatibility | |
574 | if ( GetEventHandler()->OnClose() || event.GetForce()) | |
575 | { | |
576 | this->Destroy(); | |
577 | } | |
578 | } | |
579 | ||
580 | // Destroy the window (delayed, if a managed window) | |
581 | bool wxDialog::Destroy() | |
582 | { | |
583 | if (!wxPendingDelete.Member(this)) | |
584 | wxPendingDelete.Append(this); | |
585 | return TRUE; | |
586 | } | |
587 | ||
588 | void wxDialog::OnSysColourChanged(wxSysColourChangedEvent& event) | |
589 | { | |
590 | SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DFACE)); | |
591 | Refresh(); | |
592 | } | |
593 | ||
594 | void wxDialog::Fit() | |
595 | { | |
596 | } | |
597 | ||
598 | // Handle a close event from the window manager | |
599 | static void wxCloseDialogCallback(Widget widget, XtPointer client_data, XmAnyCallbackStruct *cbs) | |
600 | { | |
601 | wxDialog *dialog = (wxDialog *)client_data; | |
602 | wxCloseEvent closeEvent(wxEVT_CLOSE_WINDOW, dialog->GetId()); | |
603 | closeEvent.SetEventObject(dialog); | |
604 | ||
605 | // May delete the dialog (with delayed deletion) | |
606 | dialog->GetEventHandler()->ProcessEvent(closeEvent); | |
607 | } | |
608 | ||
609 | // TODO: Preferably, we should have a universal repaint proc. | |
610 | // Meanwhile, use a special one for dialogs. | |
611 | static void wxDialogBoxRepaintProc(Widget w, XtPointer c_data, XEvent *event, char *) | |
612 | { | |
613 | Window window; | |
614 | static XRectangle *xrect; | |
615 | Display *display; | |
616 | GC gc; | |
617 | int llp = 0; | |
618 | static int last_count = 0; | |
619 | static int draw_count = 0; | |
620 | ||
621 | wxWindow* win = (wxWindow *)wxWidgetHashTable->Get((long)w); | |
622 | if (!win) | |
623 | return; | |
624 | ||
625 | switch(event -> type) | |
626 | { | |
627 | case Expose : | |
628 | window = (Window) win -> GetXWindow(); | |
629 | display = (Display *) win -> GetXDisplay(); | |
630 | /* TODO | |
631 | gc = (GC) panel -> GetDC() -> gc; | |
632 | ||
633 | llp = event -> xexpose.count; | |
634 | ||
635 | if ((last_count == 0) && (llp == 0)) | |
636 | { | |
637 | xrect = new XRectangle[1]; | |
638 | xrect[0].x = event -> xexpose.x; | |
639 | xrect[0].y = event -> xexpose.y; | |
640 | xrect[0].width = event -> xexpose.width; | |
641 | xrect[0].height = event -> xexpose.height; | |
642 | ||
643 | XSetClipRectangles(display,gc,0,0,xrect,1,Unsorted); | |
644 | // panel->DoPaint(xrect, 1); | |
645 | panel->GetEventHandler()->OnPaint(); | |
646 | ||
647 | delete xrect; | |
648 | } | |
649 | ||
650 | if ((last_count == 0) && (llp != 0)) | |
651 | { | |
652 | xrect = new XRectangle[llp + 1]; | |
653 | draw_count = llp + 1; | |
654 | ||
655 | xrect[draw_count - llp - 1].x = event -> xexpose.x; | |
656 | xrect[draw_count - llp - 1].y = event -> xexpose.y; | |
657 | xrect[draw_count - llp - 1].width = event -> xexpose.width; | |
658 | xrect[draw_count - llp - 1].height = event -> xexpose.height; | |
659 | } | |
660 | ||
661 | if ((last_count != 0) && (llp != 0)) | |
662 | { | |
663 | xrect[draw_count - llp - 1].x = event -> xexpose.x; | |
664 | xrect[draw_count - llp - 1].y = event -> xexpose.y; | |
665 | xrect[draw_count - llp - 1].width = event -> xexpose.width; | |
666 | xrect[draw_count - llp - 1].height = event -> xexpose.height; | |
667 | } | |
668 | ||
669 | if ((last_count != 0) && (llp == 0)) | |
670 | { | |
671 | xrect[draw_count - llp - 1].x = event -> xexpose.x; | |
672 | xrect[draw_count - llp - 1].y = event -> xexpose.y; | |
673 | xrect[draw_count - llp - 1].width = event -> xexpose.width; | |
674 | xrect[draw_count - llp - 1].height = event -> xexpose.height; | |
675 | ||
676 | XSetClipRectangles(display,gc,0,0,xrect,draw_count,Unsorted); | |
677 | // panel->DoPaint(xrect,draw_count); | |
678 | panel->GetEventHandler()->OnPaint(); | |
679 | ||
680 | delete xrect; | |
681 | } | |
682 | last_count = event -> xexpose.count; | |
683 | */ | |
684 | break; | |
685 | default : | |
686 | cout << "\n\nNew Event ! is = " << event -> type << "\n"; | |
687 | break; | |
688 | } | |
689 | } | |
690 | ||
691 | static void wxDialogBoxEventHandler (Widget wid, | |
692 | XtPointer client_data, | |
693 | XEvent* event, | |
694 | Boolean *continueToDispatch) | |
695 | { | |
696 | wxDialog *dialog = (wxDialog *)wxWidgetHashTable->Get((long)wid); | |
697 | if (dialog) | |
698 | { | |
699 | wxMouseEvent wxevent(wxEVT_NULL); | |
700 | if (wxTranslateMouseEvent(wxevent, dialog, wid, event)) | |
701 | { | |
702 | wxevent.SetEventObject(dialog); | |
703 | wxevent.SetId(dialog->GetId()); | |
704 | dialog->GetEventHandler()->ProcessEvent(wxevent); | |
705 | } | |
706 | else | |
707 | { | |
708 | // An attempt to implement OnCharHook by calling OnCharHook first; | |
709 | // if this returns TRUE, set continueToDispatch to False | |
710 | // (don't continue processing). | |
711 | // Otherwise set it to True and call OnChar. | |
712 | wxKeyEvent keyEvent(wxEVENT_TYPE_CHAR); | |
713 | if (wxTranslateKeyEvent(keyEvent, dialog, wid, event)) | |
714 | { | |
715 | keyEvent.SetEventObject(dialog); | |
716 | keyEvent.SetId(dialog->GetId()); | |
717 | keyEvent.SetEventType(wxEVT_CHAR_HOOK); | |
718 | if (dialog->GetEventHandler()->ProcessEvent(keyEvent)) | |
719 | { | |
720 | *continueToDispatch = False; | |
721 | return; | |
722 | } | |
723 | else | |
724 | { | |
725 | keyEvent.SetEventType(wxEVT_CHAR); | |
726 | dialog->GetEventHandler()->ProcessEvent(keyEvent); | |
727 | } | |
728 | } | |
729 | } | |
730 | } | |
731 | *continueToDispatch = True; | |
732 | } | |
733 | ||
734 | static void wxUnmapBulletinBoard(Widget dialog, wxDialog *client,XtPointer call) | |
735 | { | |
736 | /* This gets called when the dialog is being shown, which | |
737 | * defeats modal showing. | |
738 | client->m_modalShowing = FALSE ; | |
739 | client->m_isShown = FALSE; | |
740 | */ | |
741 | } |