]> git.saurik.com Git - wxWidgets.git/blob - src/x11/app.cpp
More updates for gdi
[wxWidgets.git] / src / x11 / app.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: app.cpp
3 // Purpose: wxApp
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 "app.h"
14 #endif
15
16 #include "wx/frame.h"
17 #include "wx/app.h"
18 #include "wx/utils.h"
19 #include "wx/gdicmn.h"
20 #include "wx/icon.h"
21 #include "wx/dialog.h"
22 #include "wx/log.h"
23 #include "wx/module.h"
24 #include "wx/memory.h"
25 #include "wx/log.h"
26 #include "wx/intl.h"
27 #include "wx/evtloop.h"
28 #include "wx/timer.h"
29
30 #include "wx/univ/theme.h"
31 #include "wx/univ/renderer.h"
32
33 #define ABS(a) (((a) < 0) ? -(a) : (a))
34
35 #if wxUSE_THREADS
36 #include "wx/thread.h"
37 #endif
38
39 #if wxUSE_WX_RESOURCES
40 #include "wx/resource.h"
41 #endif
42
43 #include "wx/x11/private.h"
44
45 #include <string.h>
46
47 //------------------------------------------------------------------------
48 // global data
49 //------------------------------------------------------------------------
50
51 extern wxList wxPendingDelete;
52
53 wxHashTable *wxWidgetHashTable = NULL;
54 wxHashTable *wxClientWidgetHashTable = NULL;
55
56 wxApp *wxTheApp = NULL;
57
58 // This is set within wxEntryStart -- too early on
59 // to put these in wxTheApp
60 static int g_newArgc = 0;
61 static wxChar** g_newArgv = NULL;
62 static bool g_showIconic = FALSE;
63 static wxSize g_initialSize = wxDefaultSize;
64
65 // This is required for wxFocusEvent::SetWindow(). It will only
66 // work for focus events which we provoke ourselves (by calling
67 // SetFocus()). It will not work for those events, which X11
68 // generates itself.
69 static wxWindow *g_nextFocus = NULL;
70 static wxWindow *g_prevFocus = NULL;
71
72 //------------------------------------------------------------------------
73 // X11 error handling
74 //------------------------------------------------------------------------
75
76 #ifdef __WXDEBUG__
77 typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *);
78
79 XErrorHandlerFunc gs_pfnXErrorHandler = 0;
80
81 static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent)
82 {
83 // just forward to the default handler for now
84 if (gs_pfnXErrorHandler)
85 return gs_pfnXErrorHandler(dpy, xevent);
86 else
87 return 0;
88 }
89 #endif // __WXDEBUG__
90
91 //------------------------------------------------------------------------
92 // wxApp
93 //------------------------------------------------------------------------
94
95 long wxApp::sm_lastMessageTime = 0;
96 WXDisplay *wxApp::ms_display = NULL;
97
98 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
99
100 BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
101 EVT_IDLE(wxApp::OnIdle)
102 END_EVENT_TABLE()
103
104 bool wxApp::Initialize()
105 {
106 wxClassInfo::InitializeClasses();
107
108 // GL: I'm annoyed ... I don't know where to put this and I don't want to
109 // create a module for that as it's part of the core.
110 #if wxUSE_THREADS
111 wxPendingEventsLocker = new wxCriticalSection();
112 #endif
113
114 wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
115 wxTheColourDatabase->Initialize();
116
117 wxInitializeStockLists();
118 wxInitializeStockObjects();
119
120 #if wxUSE_WX_RESOURCES
121 wxInitializeResourceSystem();
122 #endif
123
124 wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
125 wxClientWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
126
127 wxModule::RegisterModules();
128 if (!wxModule::InitializeModules()) return FALSE;
129
130 return TRUE;
131 }
132
133 void wxApp::CleanUp()
134 {
135 if (g_newArgv)
136 delete[] g_newArgv;
137 g_newArgv = NULL;
138
139 delete wxWidgetHashTable;
140 wxWidgetHashTable = NULL;
141 delete wxClientWidgetHashTable;
142 wxClientWidgetHashTable = NULL;
143
144 wxModule::CleanUpModules();
145
146 #if wxUSE_WX_RESOURCES
147 wxCleanUpResourceSystem();
148 #endif
149
150 delete wxTheColourDatabase;
151 wxTheColourDatabase = NULL;
152
153 wxDeleteStockObjects();
154
155 wxDeleteStockLists();
156
157 delete wxTheApp;
158 wxTheApp = NULL;
159
160 wxClassInfo::CleanUpClasses();
161
162 #if wxUSE_THREADS
163 delete wxPendingEvents;
164 delete wxPendingEventsLocker;
165 #endif
166
167 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
168 // At this point we want to check if there are any memory
169 // blocks that aren't part of the wxDebugContext itself,
170 // as a special case. Then when dumping we need to ignore
171 // wxDebugContext, too.
172 if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
173 {
174 wxLogDebug("There were memory leaks.");
175 wxDebugContext::Dump();
176 wxDebugContext::PrintStatistics();
177 }
178 #endif
179
180 // do it as the very last thing because everything else can log messages
181 wxLog::DontCreateOnDemand();
182 // do it as the very last thing because everything else can log messages
183 delete wxLog::SetActiveTarget(NULL);
184 }
185
186 // NB: argc and argv may be changed here, pass by reference!
187 int wxEntryStart( int& argc, char *argv[] )
188 {
189 #ifdef __WXDEBUG__
190 #if !wxUSE_NANOX
191 // install the X error handler
192 gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler );
193 #endif
194 #endif // __WXDEBUG__
195
196 wxString displayName;
197 bool syncDisplay = FALSE;
198
199 // Parse the arguments.
200 // We can't use wxCmdLineParser or OnInitCmdLine and friends because
201 // we have to create the Display earlier. If we can find a way to
202 // use the wxAppBase API then I'll be quite happy to change it.
203 g_newArgv = new wxChar*[argc];
204 g_newArgc = 0;
205 int i;
206 for (i = 0; i < argc; i++)
207 {
208 wxString arg(argv[i]);
209 if (arg == wxT("-display"))
210 {
211 if (i < (argc - 1))
212 {
213 i ++;
214 displayName = argv[i];
215 continue;
216 }
217 }
218 else if (arg == wxT("-geometry"))
219 {
220 if (i < (argc - 1))
221 {
222 i ++;
223 wxString windowGeometry = argv[i];
224 int w, h;
225 if (wxSscanf(windowGeometry.c_str(), _T("%dx%d"), &w, &h) != 2)
226 {
227 wxLogError(_("Invalid geometry specification '%s'"), windowGeometry.c_str());
228 }
229 else
230 {
231 g_initialSize = wxSize(w, h);
232 }
233 continue;
234 }
235 }
236 else if (arg == wxT("-sync"))
237 {
238 syncDisplay = TRUE;
239 continue;
240 }
241 else if (arg == wxT("-iconic"))
242 {
243 g_showIconic = TRUE;
244
245 continue;
246 }
247
248 // Not eaten by wxWindows, so pass through
249 g_newArgv[g_newArgc] = argv[i];
250 g_newArgc ++;
251 }
252
253 Display* xdisplay = NULL;
254 if (displayName.IsEmpty())
255 xdisplay = XOpenDisplay(NULL);
256 else
257 xdisplay = XOpenDisplay((char*) displayName.c_str());
258
259 if (!xdisplay)
260 {
261 wxLogError( _("wxWindows could not open display. Exiting.") );
262 return -1;
263 }
264
265 if (syncDisplay)
266 {
267 XSynchronize(xdisplay, True);
268 }
269
270 wxApp::ms_display = (WXDisplay*) xdisplay;
271
272 XSelectInput( xdisplay, XDefaultRootWindow(xdisplay), PropertyChangeMask);
273
274 wxSetDetectableAutoRepeat( TRUE );
275
276 if (!wxApp::Initialize())
277 return -1;
278
279 return 0;
280 }
281
282 int wxEntryInitGui()
283 {
284 int retValue = 0;
285
286 if ( !wxTheApp->OnInitGui() )
287 retValue = -1;
288
289 return retValue;
290 }
291
292
293 int wxEntry( int argc, char *argv[] )
294 {
295 #if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
296 // This seems to be necessary since there are 'rogue'
297 // objects present at this point (perhaps global objects?)
298 // Setting a checkpoint will ignore them as far as the
299 // memory checking facility is concerned.
300 // Of course you may argue that memory allocated in globals should be
301 // checked, but this is a reasonable compromise.
302 wxDebugContext::SetCheckpoint();
303 #endif
304 int err = wxEntryStart(argc, argv);
305 if (err)
306 return err;
307
308 if (!wxTheApp)
309 {
310 if (!wxApp::GetInitializerFunction())
311 {
312 printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" );
313 return 0;
314 };
315
316 wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) ();
317 };
318
319 if (!wxTheApp)
320 {
321 printf( "wxWindows error: wxTheApp == NULL\n" );
322 return 0;
323 };
324
325 wxTheApp->SetClassName(wxFileNameFromPath(argv[0]));
326 wxTheApp->SetAppName(wxFileNameFromPath(argv[0]));
327
328 // The command line may have been changed
329 // by stripping out -display etc.
330 if (g_newArgc > 0)
331 {
332 wxTheApp->argc = g_newArgc;
333 wxTheApp->argv = g_newArgv;
334 }
335 else
336 {
337 wxTheApp->argc = argc;
338 wxTheApp->argv = argv;
339 }
340 wxTheApp->m_showIconic = g_showIconic;
341 wxTheApp->m_initialSize = g_initialSize;
342
343 int retValue;
344 retValue = wxEntryInitGui();
345
346 // Here frames insert themselves automatically into wxTopLevelWindows by
347 // getting created in OnInit().
348 if ( retValue == 0 )
349 {
350 if ( !wxTheApp->OnInit() )
351 retValue = -1;
352 }
353
354 if ( retValue == 0 )
355 {
356 if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
357 }
358
359 // flush the logged messages if any
360 wxLog *pLog = wxLog::GetActiveTarget();
361 if ( pLog != NULL && pLog->HasPendingMessages() )
362 pLog->Flush();
363
364 delete wxLog::SetActiveTarget(new wxLogStderr); // So dialog boxes aren't used
365 // for further messages
366
367 if (wxTheApp->GetTopWindow())
368 {
369 delete wxTheApp->GetTopWindow();
370 wxTheApp->SetTopWindow(NULL);
371 }
372
373 wxTheApp->DeletePendingObjects();
374
375 wxTheApp->OnExit();
376
377 wxApp::CleanUp();
378
379 return retValue;
380 };
381
382 // Static member initialization
383 wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
384
385 wxApp::wxApp()
386 {
387 m_topWindow = NULL;
388 wxTheApp = this;
389 m_className = "";
390 m_wantDebugOutput = TRUE ;
391 m_appName = "";
392 argc = 0;
393 argv = NULL;
394 m_exitOnFrameDelete = TRUE;
395 m_mainColormap = (WXColormap) NULL;
396 m_topLevelWidget = (WXWindow) NULL;
397 m_maxRequestSize = 0;
398 m_mainLoop = NULL;
399 m_showIconic = FALSE;
400 m_initialSize = wxDefaultSize;
401
402 #if !wxUSE_NANOX
403 m_visualColormap = NULL;
404 m_colorCube = NULL;
405 #endif
406 }
407
408 wxApp::~wxApp()
409 {
410 #if !wxUSE_NANOX
411 if (m_colorCube)
412 free( m_colorCube );
413
414 if (m_visualColormap)
415 delete [] (XColor*)m_visualColormap;
416 #endif
417 }
418
419 bool wxApp::Initialized()
420 {
421 if (GetTopWindow())
422 return TRUE;
423 else
424 return FALSE;
425 }
426
427 int wxApp::MainLoop()
428 {
429 int rt;
430 m_mainLoop = new wxEventLoop;
431
432 rt = m_mainLoop->Run();
433
434 delete m_mainLoop;
435 m_mainLoop = NULL;
436 return rt;
437 }
438
439 #if !wxUSE_NANOX
440 //-----------------------------------------------------------------------
441 // X11 predicate function for exposure compression
442 //-----------------------------------------------------------------------
443
444 struct wxExposeInfo
445 {
446 Window window;
447 Bool found_non_matching;
448 };
449
450 static Bool expose_predicate (Display *display, XEvent *xevent, XPointer arg)
451 {
452 wxExposeInfo *info = (wxExposeInfo*) arg;
453
454 if (info->found_non_matching)
455 return FALSE;
456
457 if (xevent->xany.type != Expose)
458 {
459 info->found_non_matching = TRUE;
460 return FALSE;
461 }
462
463 if (xevent->xexpose.window != info->window)
464 {
465 info->found_non_matching = TRUE;
466 return FALSE;
467 }
468
469 return TRUE;
470 }
471 #endif
472 // wxUSE_NANOX
473
474 //-----------------------------------------------------------------------
475 // Processes an X event, returning TRUE if the event was processed.
476 //-----------------------------------------------------------------------
477
478 bool wxApp::ProcessXEvent(WXEvent* _event)
479 {
480 XEvent* event = (XEvent*) _event;
481
482 wxWindow* win = NULL;
483 Window window = XEventGetWindow(event);
484 #if 0
485 Window actualWindow = window;
486 #endif
487
488 // Find the first wxWindow that corresponds to this event window
489 // Because we're receiving events after a window
490 // has been destroyed, assume a 1:1 match between
491 // Window and wxWindow, so if it's not in the table,
492 // it must have been destroyed.
493
494 win = wxGetWindowFromTable(window);
495 if (!win)
496 {
497 #if wxUSE_TWO_WINDOWS
498 win = wxGetClientWindowFromTable(window);
499 if (!win)
500 #endif
501 return FALSE;
502 }
503
504 #ifdef __WXDEBUG__
505 wxString windowClass = win->GetClassInfo()->GetClassName();
506 #endif
507
508 switch (event->type)
509 {
510 case Expose:
511 {
512 #if wxUSE_TWO_WINDOWS && !wxUSE_NANOX
513 if (event->xexpose.window != (Window)win->GetClientWindow())
514 {
515 XEvent tmp_event;
516 wxExposeInfo info;
517 info.window = event->xexpose.window;
518 info.found_non_matching = FALSE;
519 while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, expose_predicate, (XPointer) &info ))
520 {
521 // Don't worry about optimizing redrawing the border etc.
522 }
523 win->NeedUpdateNcAreaInIdle();
524 }
525 else
526 #endif
527 {
528 win->GetUpdateRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
529 XExposeEventGetWidth(event), XExposeEventGetHeight(event));
530 win->GetClearRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
531 XExposeEventGetWidth(event), XExposeEventGetHeight(event));
532
533 #if !wxUSE_NANOX
534 XEvent tmp_event;
535 wxExposeInfo info;
536 info.window = event->xexpose.window;
537 info.found_non_matching = FALSE;
538 while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, expose_predicate, (XPointer) &info ))
539 {
540 win->GetUpdateRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
541 tmp_event.xexpose.width, tmp_event.xexpose.height );
542
543 win->GetClearRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
544 tmp_event.xexpose.width, tmp_event.xexpose.height );
545 }
546 #endif
547
548 // This simplifies the expose and clear areas to simple
549 // rectangles.
550 win->GetUpdateRegion() = win->GetUpdateRegion().GetBox();
551 win->GetClearRegion() = win->GetClearRegion().GetBox();
552
553 // If we only have one X11 window, always indicate
554 // that borders might have to be redrawn.
555 if (win->GetMainWindow() == win->GetClientWindow())
556 win->NeedUpdateNcAreaInIdle();
557
558 // Only erase background, paint in idle time.
559 win->SendEraseEvents();
560 // win->Update();
561 }
562
563 return TRUE;
564 }
565
566 #if !wxUSE_NANOX
567 case GraphicsExpose:
568 {
569 printf( "GraphicExpose event\n" );
570
571 // wxLogDebug( "GraphicsExpose from %s", win->GetName().c_str(),
572 // event->xgraphicsexpose.x, event->xgraphicsexpose.y,
573 // event->xgraphicsexpose.width, event->xgraphicsexpose.height);
574
575 win->GetUpdateRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
576 event->xgraphicsexpose.width, event->xgraphicsexpose.height);
577
578 win->GetClearRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
579 event->xgraphicsexpose.width, event->xgraphicsexpose.height);
580
581 if (event->xgraphicsexpose.count == 0)
582 {
583 // Only erase background, paint in idle time.
584 win->SendEraseEvents();
585 // win->Update();
586 }
587
588 return TRUE;
589 }
590 #endif
591
592 case KeyPress:
593 {
594 if (!win->IsEnabled())
595 return FALSE;
596
597 wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
598 wxTranslateKeyEvent(keyEvent, win, window, event);
599
600 // wxLogDebug( "OnKey from %s", win->GetName().c_str() );
601
602 // We didn't process wxEVT_KEY_DOWN, so send wxEVT_CHAR
603 if (win->GetEventHandler()->ProcessEvent( keyEvent ))
604 return TRUE;
605
606 keyEvent.SetEventType(wxEVT_CHAR);
607 if (win->GetEventHandler()->ProcessEvent( keyEvent ))
608 return TRUE;
609
610 if ( (keyEvent.m_keyCode == WXK_TAB) &&
611 win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
612 {
613 wxNavigationKeyEvent new_event;
614 new_event.SetEventObject( win->GetParent() );
615 /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
616 new_event.SetDirection( (keyEvent.m_keyCode == WXK_TAB) );
617 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
618 new_event.SetWindowChange( keyEvent.ControlDown() );
619 new_event.SetCurrentFocus( win );
620 return win->GetParent()->GetEventHandler()->ProcessEvent( new_event );
621 }
622
623 return FALSE;
624 }
625 case KeyRelease:
626 {
627 if (!win->IsEnabled())
628 return FALSE;
629
630 wxKeyEvent keyEvent(wxEVT_KEY_UP);
631 wxTranslateKeyEvent(keyEvent, win, window, event);
632
633 return win->GetEventHandler()->ProcessEvent( keyEvent );
634 }
635 case ConfigureNotify:
636 {
637 #if wxUSE_NANOX
638 if (event->update.utype == GR_UPDATE_SIZE)
639 #endif
640 {
641 if (win->IsTopLevel())
642 {
643 wxTopLevelWindow *tlw = (wxTopLevelWindow*) win;
644 tlw->SetConfigureGeometry( XConfigureEventGetX(event), XConfigureEventGetY(event),
645 XConfigureEventGetWidth(event), XConfigureEventGetHeight(event) );
646 }
647
648 if (win->IsTopLevel() && win->IsShown())
649 {
650 wxTopLevelWindowX11 *tlw = (wxTopLevelWindowX11 *) win;
651 tlw->SetNeedResizeInIdle();
652 }
653 else
654 {
655 wxSizeEvent sizeEvent( wxSize(XConfigureEventGetWidth(event), XConfigureEventGetHeight(event)), win->GetId() );
656 sizeEvent.SetEventObject( win );
657
658 return win->GetEventHandler()->ProcessEvent( sizeEvent );
659 }
660 }
661 return FALSE;
662 break;
663 }
664 #if !wxUSE_NANOX
665 case PropertyNotify:
666 {
667 //wxLogDebug("PropertyNotify: %s", windowClass.c_str());
668 return HandlePropertyChange(_event);
669 }
670 case ClientMessage:
671 {
672 if (!win->IsEnabled())
673 return FALSE;
674
675 Atom wm_delete_window = XInternAtom(wxGlobalDisplay(), "WM_DELETE_WINDOW", True);
676 Atom wm_protocols = XInternAtom(wxGlobalDisplay(), "WM_PROTOCOLS", True);
677
678 if (event->xclient.message_type == wm_protocols)
679 {
680 if ((Atom) (event->xclient.data.l[0]) == wm_delete_window)
681 {
682 win->Close(FALSE);
683 return TRUE;
684 }
685 }
686 return FALSE;
687 }
688 #if 0
689 case DestroyNotify:
690 {
691 printf( "destroy from %s\n", win->GetName().c_str() );
692 break;
693 }
694 case CreateNotify:
695 {
696 printf( "create from %s\n", win->GetName().c_str() );
697 break;
698 }
699 case MapRequest:
700 {
701 printf( "map request from %s\n", win->GetName().c_str() );
702 break;
703 }
704 case ResizeRequest:
705 {
706 printf( "resize request from %s\n", win->GetName().c_str() );
707
708 Display *disp = (Display*) wxGetDisplay();
709 XEvent report;
710
711 // to avoid flicker
712 report = * event;
713 while( XCheckTypedWindowEvent (disp, actualWindow, ResizeRequest, &report));
714
715 wxSize sz = win->GetSize();
716 wxSizeEvent sizeEvent(sz, win->GetId());
717 sizeEvent.SetEventObject(win);
718
719 return win->GetEventHandler()->ProcessEvent( sizeEvent );
720 }
721 #endif
722 #endif
723 #if wxUSE_NANOX
724 case GR_EVENT_TYPE_CLOSE_REQ:
725 {
726 if (win)
727 {
728 win->Close(FALSE);
729 return TRUE;
730 }
731 return FALSE;
732 break;
733 }
734 #endif
735 case EnterNotify:
736 case LeaveNotify:
737 case ButtonPress:
738 case ButtonRelease:
739 case MotionNotify:
740 {
741 if (!win->IsEnabled())
742 return FALSE;
743
744 // Here we check if the top level window is
745 // disabled, which is one aspect of modality.
746 wxWindow *tlw = win;
747 while (tlw && !tlw->IsTopLevel())
748 tlw = tlw->GetParent();
749 if (tlw && !tlw->IsEnabled())
750 return FALSE;
751
752 if (event->type == ButtonPress)
753 {
754 if ((win != wxWindow::FindFocus()) && win->AcceptsFocus())
755 {
756 // This might actually be done in wxWindow::SetFocus()
757 // and not here. TODO.
758 g_prevFocus = wxWindow::FindFocus();
759 g_nextFocus = win;
760
761 win->SetFocus();
762 }
763 }
764
765 #if !wxUSE_NANOX
766 if (event->type == LeaveNotify || event->type == EnterNotify)
767 {
768 // Throw out NotifyGrab and NotifyUngrab
769 if (event->xcrossing.mode != NotifyNormal)
770 return FALSE;
771 }
772 #endif
773 wxMouseEvent wxevent;
774 wxTranslateMouseEvent(wxevent, win, window, event);
775 return win->GetEventHandler()->ProcessEvent( wxevent );
776 }
777 case FocusIn:
778 {
779 #if !wxUSE_NANOX
780 if ((event->xfocus.detail != NotifyPointer) &&
781 (event->xfocus.mode == NotifyNormal))
782 #endif
783 {
784 // wxLogDebug( "FocusIn from %s of type %s", win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
785
786 wxFocusEvent focusEvent(wxEVT_SET_FOCUS, win->GetId());
787 focusEvent.SetEventObject(win);
788 focusEvent.SetWindow( g_prevFocus );
789 g_prevFocus = NULL;
790
791 return win->GetEventHandler()->ProcessEvent(focusEvent);
792 }
793 return FALSE;
794 break;
795 }
796 case FocusOut:
797 {
798 #if !wxUSE_NANOX
799 if ((event->xfocus.detail != NotifyPointer) &&
800 (event->xfocus.mode == NotifyNormal))
801 #endif
802 {
803 // wxLogDebug( "FocusOut from %s of type %s", win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
804
805 wxFocusEvent focusEvent(wxEVT_KILL_FOCUS, win->GetId());
806 focusEvent.SetEventObject(win);
807 focusEvent.SetWindow( g_nextFocus );
808 g_nextFocus = NULL;
809 return win->GetEventHandler()->ProcessEvent(focusEvent);
810 }
811 return FALSE;
812 break;
813 }
814 default:
815 {
816 #ifdef __WXDEBUG__
817 //wxString eventName = wxGetXEventName(XEvent& event);
818 //wxLogDebug(wxT("Event %s not handled"), eventName.c_str());
819 #endif
820 return FALSE;
821 break;
822 }
823 }
824 return FALSE;
825 }
826
827 // Returns TRUE if more time is needed.
828 // Note that this duplicates wxEventLoopImpl::SendIdleEvent
829 // but ProcessIdle may be needed by apps, so is kept.
830 bool wxApp::ProcessIdle()
831 {
832 wxIdleEvent event;
833 event.SetEventObject(this);
834 ProcessEvent(event);
835
836 return event.MoreRequested();
837 }
838
839 void wxApp::ExitMainLoop()
840 {
841 if (m_mainLoop)
842 m_mainLoop->Exit(0);
843 }
844
845 // Is a message/event pending?
846 bool wxApp::Pending()
847 {
848 return wxEventLoop::GetActive()->Pending();
849 }
850
851 // Dispatch a message.
852 void wxApp::Dispatch()
853 {
854 wxEventLoop::GetActive()->Dispatch();
855 }
856
857 // This should be redefined in a derived class for
858 // handling property change events for XAtom IPC.
859 bool wxApp::HandlePropertyChange(WXEvent *event)
860 {
861 // by default do nothing special
862 // TODO: what to do for X11
863 // XtDispatchEvent((XEvent*) event);
864 return FALSE;
865 }
866
867 void wxApp::OnIdle(wxIdleEvent& event)
868 {
869 static bool s_inOnIdle = FALSE;
870
871 // Avoid recursion (via ProcessEvent default case)
872 if (s_inOnIdle)
873 return;
874
875 s_inOnIdle = TRUE;
876
877 // Resend in the main thread events which have been prepared in other
878 // threads
879 ProcessPendingEvents();
880
881 // 'Garbage' collection of windows deleted with Close()
882 DeletePendingObjects();
883
884 // Send OnIdle events to all windows
885 bool needMore = SendIdleEvents();
886
887 if (needMore)
888 event.RequestMore(TRUE);
889
890 s_inOnIdle = FALSE;
891 }
892
893 void wxWakeUpIdle()
894 {
895 // **** please implement me! ****
896 // Wake up the idle handler processor, even if it is in another thread...
897 }
898
899
900 // Send idle event to all top-level windows
901 bool wxApp::SendIdleEvents()
902 {
903 bool needMore = FALSE;
904
905 wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
906 while (node)
907 {
908 wxWindow* win = node->GetData();
909 if (SendIdleEvents(win))
910 needMore = TRUE;
911 node = node->GetNext();
912 }
913
914 return needMore;
915 }
916
917 // Send idle event to window and all subwindows
918 bool wxApp::SendIdleEvents(wxWindow* win)
919 {
920 bool needMore = FALSE;
921
922 wxIdleEvent event;
923 event.SetEventObject(win);
924
925 win->GetEventHandler()->ProcessEvent(event);
926
927 if (event.MoreRequested())
928 needMore = TRUE;
929
930 wxNode* node = win->GetChildren().First();
931 while (node)
932 {
933 wxWindow* win = (wxWindow*) node->Data();
934 if (SendIdleEvents(win))
935 needMore = TRUE;
936
937 node = node->Next();
938 }
939
940 win->OnInternalIdle();
941
942 return needMore;
943 }
944
945 void wxApp::DeletePendingObjects()
946 {
947 wxNode *node = wxPendingDelete.First();
948 while (node)
949 {
950 wxObject *obj = (wxObject *)node->Data();
951
952 delete obj;
953
954 if (wxPendingDelete.Member(obj))
955 delete node;
956
957 // Deleting one object may have deleted other pending
958 // objects, so start from beginning of list again.
959 node = wxPendingDelete.First();
960 }
961 }
962
963 static void wxCalcPrecAndShift( unsigned long mask, int *shift, int *prec )
964 {
965 *shift = 0;
966 *prec = 0;
967
968 while (!(mask & 0x1))
969 {
970 (*shift)++;
971 mask >>= 1;
972 }
973
974 while (mask & 0x1)
975 {
976 (*prec)++;
977 mask >>= 1;
978 }
979 }
980
981 // Create display, and other initialization
982 bool wxApp::OnInitGui()
983 {
984 // Eventually this line will be removed, but for
985 // now we don't want to try popping up a dialog
986 // for error messages.
987 delete wxLog::SetActiveTarget(new wxLogStderr);
988
989 if (!wxAppBase::OnInitGui())
990 return FALSE;
991
992 GetMainColormap( wxApp::GetDisplay() );
993
994 m_maxRequestSize = XMaxRequestSize( (Display*) wxApp::GetDisplay() );
995
996 #if !wxUSE_NANOX
997 // Get info about the current visual. It is enough
998 // to do this once here unless we support different
999 // visuals, displays and screens. Given that wxX11
1000 // mostly for embedded things, that is no real
1001 // limitation.
1002 Display *xdisplay = (Display*) wxApp::GetDisplay();
1003 int xscreen = DefaultScreen(xdisplay);
1004 Visual* xvisual = DefaultVisual(xdisplay,xscreen);
1005 int xdepth = DefaultDepth(xdisplay, xscreen);
1006
1007 XVisualInfo vinfo_template;
1008 vinfo_template.visual = xvisual;
1009 vinfo_template.visualid = XVisualIDFromVisual( xvisual );
1010 vinfo_template.depth = xdepth;
1011
1012 int nitem = 0;
1013 XVisualInfo *vi = XGetVisualInfo( xdisplay, VisualIDMask|VisualDepthMask, &vinfo_template, &nitem );
1014 wxASSERT_MSG( vi, wxT("No visual info") );
1015
1016 m_visualType = vi->visual->c_class;
1017 m_visualScreen = vi->screen;
1018
1019 m_visualRedMask = vi->red_mask;
1020 m_visualGreenMask = vi->green_mask;
1021 m_visualBlueMask = vi->blue_mask;
1022
1023 if (m_visualType != GrayScale && m_visualType != PseudoColor)
1024 {
1025 wxCalcPrecAndShift( m_visualRedMask, &m_visualRedShift, &m_visualRedPrec );
1026 wxCalcPrecAndShift( m_visualGreenMask, &m_visualGreenShift, &m_visualGreenPrec );
1027 wxCalcPrecAndShift( m_visualBlueMask, &m_visualBlueShift, &m_visualBluePrec );
1028 }
1029
1030 m_visualDepth = xdepth;
1031 if (xdepth == 16)
1032 xdepth = m_visualRedPrec + m_visualGreenPrec + m_visualBluePrec;
1033
1034 m_visualColormapSize = vi->colormap_size;
1035
1036 XFree( vi );
1037
1038 if (m_visualDepth > 8)
1039 return TRUE;
1040
1041 m_visualColormap = new XColor[m_visualColormapSize];
1042 XColor* colors = (XColor*) m_visualColormap;
1043
1044 for (int i = 0; i < m_visualColormapSize; i++)
1045 colors[i].pixel = i;
1046
1047 XQueryColors( xdisplay, DefaultColormap(xdisplay,xscreen), colors, m_visualColormapSize );
1048
1049 m_colorCube = (unsigned char*)malloc(32 * 32 * 32);
1050
1051 for (int r = 0; r < 32; r++)
1052 {
1053 for (int g = 0; g < 32; g++)
1054 {
1055 for (int b = 0; b < 32; b++)
1056 {
1057 int rr = (r << 3) | (r >> 2);
1058 int gg = (g << 3) | (g >> 2);
1059 int bb = (b << 3) | (b >> 2);
1060
1061 int index = -1;
1062
1063 if (colors)
1064 {
1065 int max = 3 * 65536;
1066
1067 for (int i = 0; i < m_visualColormapSize; i++)
1068 {
1069 int rdiff = ((rr << 8) - colors[i].red);
1070 int gdiff = ((gg << 8) - colors[i].green);
1071 int bdiff = ((bb << 8) - colors[i].blue);
1072 int sum = ABS (rdiff) + ABS (gdiff) + ABS (bdiff);
1073 if (sum < max)
1074 {
1075 index = i; max = sum;
1076 }
1077 }
1078 }
1079 else
1080 {
1081 // assume 8-bit true or static colors. this really exists
1082 index = (r >> (5 - m_visualRedPrec)) << m_visualRedShift;
1083 index |= (g >> (5 - m_visualGreenPrec)) << m_visualGreenShift;
1084 index |= (b >> (5 - m_visualBluePrec)) << m_visualBlueShift;
1085 }
1086 m_colorCube[ (r*1024) + (g*32) + b ] = index;
1087 }
1088 }
1089 }
1090 #endif
1091
1092 return TRUE;
1093 }
1094
1095 WXColormap wxApp::GetMainColormap(WXDisplay* display)
1096 {
1097 if (!display) /* Must be called first with non-NULL display */
1098 return m_mainColormap;
1099
1100 int defaultScreen = DefaultScreen((Display*) display);
1101 Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);
1102
1103 Colormap c = DefaultColormapOfScreen(screen);
1104
1105 if (!m_mainColormap)
1106 m_mainColormap = (WXColormap) c;
1107
1108 return (WXColormap) c;
1109 }
1110
1111 Window wxGetWindowParent(Window window)
1112 {
1113 wxASSERT_MSG( window, "invalid window" );
1114
1115 return (Window) 0;
1116
1117 Window parent, root = 0;
1118 #if wxUSE_NANOX
1119 int noChildren = 0;
1120 #else
1121 unsigned int noChildren = 0;
1122 #endif
1123 Window* children = NULL;
1124
1125 // #define XQueryTree(d,w,r,p,c,nc) GrQueryTree(w,p,c,nc)
1126 int res = 1;
1127 #if !wxUSE_NANOX
1128 res =
1129 #endif
1130 XQueryTree((Display*) wxGetDisplay(), window, & root, & parent,
1131 & children, & noChildren);
1132 if (children)
1133 XFree(children);
1134 if (res)
1135 return parent;
1136 else
1137 return (Window) 0;
1138 }
1139
1140 void wxExit()
1141 {
1142 int retValue = 0;
1143 if (wxTheApp)
1144 retValue = wxTheApp->OnExit();
1145
1146 wxApp::CleanUp();
1147 /*
1148 * Exit in some platform-specific way. Not recommended that the app calls this:
1149 * only for emergencies.
1150 */
1151 exit(retValue);
1152 }
1153
1154 // Yield to other processes
1155
1156 bool wxApp::Yield(bool onlyIfNeeded)
1157 {
1158 bool s_inYield = FALSE;
1159
1160 if ( s_inYield )
1161 {
1162 if ( !onlyIfNeeded )
1163 {
1164 wxFAIL_MSG( wxT("wxYield called recursively" ) );
1165 }
1166
1167 return FALSE;
1168 }
1169
1170 s_inYield = TRUE;
1171
1172 // Make sure we have an event loop object,
1173 // or Pending/Dispatch will fail
1174 wxEventLoop* eventLoop = wxEventLoop::GetActive();
1175 wxEventLoop* newEventLoop = NULL;
1176 if (!eventLoop)
1177 {
1178 newEventLoop = new wxEventLoop;
1179 wxEventLoop::SetActive(newEventLoop);
1180 }
1181
1182 while (wxTheApp && wxTheApp->Pending())
1183 wxTheApp->Dispatch();
1184
1185 #if wxUSE_TIMER
1186 wxTimer::NotifyTimers();
1187 #endif
1188 ProcessIdle();
1189
1190 if (newEventLoop)
1191 {
1192 wxEventLoop::SetActive(NULL);
1193 delete newEventLoop;
1194 }
1195
1196 s_inYield = FALSE;
1197
1198 return TRUE;
1199 }
1200
1201 void wxApp::OnAssert(const wxChar *file, int line, const wxChar *msg)
1202 {
1203 // While the GUI isn't working that well, just print out the
1204 // message.
1205 #if 1
1206 wxAppBase::OnAssert(file, line, msg);
1207 #else
1208 wxString msg2;
1209 msg2.Printf("At file %s:%d: %s", file, line, msg);
1210 wxLogDebug(msg2);
1211 #endif
1212 }
1213