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