src/x11/app.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/x11/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 // for compilers that support precompilation, includes "wx.h".
  13 #include "wx/wxprec.h"
  14
  15 #include "wx/app.h"
  16
  17 #ifndef WX_PRECOMP
  18     #include "wx/hash.h"
  19     #include "wx/intl.h"
  20     #include "wx/log.h"
  21     #include "wx/utils.h"
  22     #include "wx/frame.h"
  23     #include "wx/icon.h"
  24     #include "wx/dialog.h"
  25     #include "wx/memory.h"
  26     #include "wx/gdicmn.h"
  27     #include "wx/module.h"
  28     #include "wx/crt.h"
  29 #endif
  30
  31 #include "wx/evtloop.h"
  32 #include "wx/filename.h"
  33
  34 #include "wx/univ/theme.h"
  35 #include "wx/univ/renderer.h"
  36 #include "wx/generic/private/timer.h"
  37
  38 #if wxUSE_THREADS
  39     #include "wx/thread.h"
  40 #endif
  41
  42 #include "wx/x11/private.h"
  43
  44 #include <string.h>
  45
  46 //------------------------------------------------------------------------
  47 //   global data
  48 //------------------------------------------------------------------------
  49
  50 wxWindowHash *wxWidgetHashTable = NULL;
  51 wxWindowHash *wxClientWidgetHashTable = NULL;
  52
  53 static bool g_showIconic = false;
  54 static wxSize g_initialSize = wxDefaultSize;
  55
  56 // This is required for wxFocusEvent::SetWindow(). It will only
  57 // work for focus events which we provoke ourselves (by calling
  58 // SetFocus()). It will not work for those events, which X11
  59 // generates itself.
  60 static wxWindow *g_nextFocus = NULL;
  61 static wxWindow *g_prevFocus = NULL;
  62
  63 //------------------------------------------------------------------------
  64 //   X11 error handling
  65 //------------------------------------------------------------------------
  66
  67 #ifdef __WXDEBUG__
  68 typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *);
  69
  70 XErrorHandlerFunc gs_pfnXErrorHandler = 0;
  71
  72 static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent)
  73 {
  74     // just forward to the default handler for now
  75     if (gs_pfnXErrorHandler)
  76         return gs_pfnXErrorHandler(dpy, xevent);
  77     else
  78         return 0;
  79 }
  80 #endif // __WXDEBUG__
  81
  82 //------------------------------------------------------------------------
  83 //   wxApp
  84 //------------------------------------------------------------------------
  85
  86 long wxApp::sm_lastMessageTime = 0;
  87
  88 IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
  89
  90 bool wxApp::Initialize(int& argC, wxChar **argV)
  91 {
  92 #if defined(__WXDEBUG__) && !wxUSE_NANOX
  93     // install the X error handler
  94     gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler );
  95 #endif // __WXDEBUG__
  96
  97     wxString displayName;
  98     bool syncDisplay = false;
  99
 100     int argCOrig = argC;
 101     for ( int i = 0; i < argCOrig; i++ )
 102     {
 103         if (wxStrcmp( argV[i], _T("-display") ) == 0)
 104         {
 105             if (i < (argC - 1))
 106             {
 107                 argV[i++] = NULL;
 108
 109                 displayName = argV[i];
 110
 111                 argV[i] = NULL;
 112                 argC -= 2;
 113             }
 114         }
 115         else if (wxStrcmp( argV[i], _T("-geometry") ) == 0)
 116         {
 117             if (i < (argC - 1))
 118             {
 119                 argV[i++] = NULL;
 120
 121                 int w, h;
 122                 if (wxSscanf(argV[i], _T("%dx%d"), &w, &h) != 2)
 123                 {
 124                     wxLogError( _("Invalid geometry specification '%s'"),
 125                                 wxString(argV[i]).c_str() );
 126                 }
 127                 else
 128                 {
 129                     g_initialSize = wxSize(w, h);
 130                 }
 131
 132                 argV[i] = NULL;
 133                 argC -= 2;
 134             }
 135         }
 136         else if (wxStrcmp( argV[i], _T("-sync") ) == 0)
 137         {
 138             syncDisplay = true;
 139
 140             argV[i] = NULL;
 141             argC--;
 142         }
 143         else if (wxStrcmp( argV[i], _T("-iconic") ) == 0)
 144         {
 145             g_showIconic = true;
 146
 147             argV[i] = NULL;
 148             argC--;
 149         }
 150     }
 151
 152     if ( argC != argCOrig )
 153     {
 154         // remove the argumens we consumed
 155         for ( int i = 0; i < argC; i++ )
 156         {
 157             while ( !argV[i] )
 158             {
 159                 memmove(argV + i, argV + i + 1, argCOrig - i);
 160             }
 161         }
 162     }
 163
 164     // open and set up the X11 display
 165     if ( !wxSetDisplay(displayName) )
 166     {
 167         wxLogError(_("wxWidgets could not open display. Exiting."));
 168         return false;
 169     }
 170
 171     Display *dpy = wxGlobalDisplay();
 172     if (syncDisplay)
 173         XSynchronize(dpy, True);
 174
 175     XSelectInput(dpy, XDefaultRootWindow(dpy), PropertyChangeMask);
 176
 177     wxSetDetectableAutoRepeat( true );
 178
 179
 180     if ( !wxAppBase::Initialize(argC, argV) )
 181         return false;
 182
 183 #if wxUSE_UNICODE
 184     // Glib's type system required by Pango
 185     g_type_init();
 186 #endif
 187
 188 #if wxUSE_INTL
 189     wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
 190 #endif
 191
 192     wxWidgetHashTable = new wxWindowHash;
 193     wxClientWidgetHashTable = new wxWindowHash;
 194
 195     return true;
 196 }
 197
 198 void wxApp::CleanUp()
 199 {
 200     delete wxWidgetHashTable;
 201     wxWidgetHashTable = NULL;
 202     delete wxClientWidgetHashTable;
 203     wxClientWidgetHashTable = NULL;
 204
 205     wxAppBase::CleanUp();
 206 }
 207
 208 wxApp::wxApp()
 209 {
 210     m_mainColormap = NULL;
 211     m_topLevelWidget = NULL;
 212     m_maxRequestSize = 0;
 213     m_showIconic = false;
 214     m_initialSize = wxDefaultSize;
 215
 216 #if !wxUSE_NANOX
 217     m_visualInfo = NULL;
 218 #endif
 219 }
 220
 221 wxApp::~wxApp()
 222 {
 223 #if !wxUSE_NANOX
 224     delete m_visualInfo;
 225 #endif
 226 }
 227
 228 #if !wxUSE_NANOX
 229
 230 //-----------------------------------------------------------------------
 231 // X11 predicate function for exposure compression
 232 //-----------------------------------------------------------------------
 233
 234 struct wxExposeInfo
 235 {
 236     Window window;
 237     Bool found_non_matching;
 238 };
 239
 240 extern "C"
 241 Bool wxX11ExposePredicate (Display *WXUNUSED(display), XEvent *xevent, XPointer arg)
 242 {
 243     wxExposeInfo *info = (wxExposeInfo*) arg;
 244
 245     if (info->found_non_matching)
 246        return FALSE;
 247
 248     if (xevent->xany.type != Expose)
 249     {
 250         info->found_non_matching = true;
 251         return FALSE;
 252     }
 253
 254     if (xevent->xexpose.window != info->window)
 255     {
 256         info->found_non_matching = true;
 257         return FALSE;
 258     }
 259
 260     return TRUE;
 261 }
 262
 263 #endif // wxUSE_NANOX
 264
 265 //-----------------------------------------------------------------------
 266 // Processes an X event, returning true if the event was processed.
 267 //-----------------------------------------------------------------------
 268
 269 bool wxApp::ProcessXEvent(WXEvent* _event)
 270 {
 271     XEvent* event = (XEvent*) _event;
 272
 273     wxWindow* win = NULL;
 274     Window window = XEventGetWindow(event);
 275 #if 0
 276     Window actualWindow = window;
 277 #endif
 278
 279     // Find the first wxWindow that corresponds to this event window
 280     // Because we're receiving events after a window
 281     // has been destroyed, assume a 1:1 match between
 282     // Window and wxWindow, so if it's not in the table,
 283     // it must have been destroyed.
 284
 285     win = wxGetWindowFromTable(window);
 286     if (!win)
 287     {
 288 #if wxUSE_TWO_WINDOWS
 289         win = wxGetClientWindowFromTable(window);
 290         if (!win)
 291 #endif
 292             return false;
 293     }
 294
 295 #ifdef __WXDEBUG__
 296     wxString windowClass = win->GetClassInfo()->GetClassName();
 297 #endif
 298
 299     switch (event->type)
 300     {
 301         case Expose:
 302         {
 303 #if wxUSE_TWO_WINDOWS && !wxUSE_NANOX
 304             if (event->xexpose.window != (Window)win->GetClientAreaWindow())
 305             {
 306                 XEvent tmp_event;
 307                 wxExposeInfo info;
 308                 info.window = event->xexpose.window;
 309                 info.found_non_matching = false;
 310                 while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
 311                 {
 312                     // Don't worry about optimizing redrawing the border etc.
 313                 }
 314                 win->NeedUpdateNcAreaInIdle();
 315             }
 316             else
 317 #endif
 318             {
 319                 win->GetUpdateRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
 320                                               XExposeEventGetWidth(event), XExposeEventGetHeight(event));
 321                 win->GetClearRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
 322                                          XExposeEventGetWidth(event), XExposeEventGetHeight(event));
 323
 324 #if !wxUSE_NANOX
 325                 XEvent tmp_event;
 326                 wxExposeInfo info;
 327                 info.window = event->xexpose.window;
 328                 info.found_non_matching = false;
 329                 while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
 330                 {
 331                     win->GetUpdateRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
 332                                                   tmp_event.xexpose.width, tmp_event.xexpose.height );
 333
 334                     win->GetClearRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
 335                                                  tmp_event.xexpose.width, tmp_event.xexpose.height );
 336                 }
 337 #endif
 338
 339                 // This simplifies the expose and clear areas to simple
 340                 // rectangles.
 341                 win->GetUpdateRegion() = win->GetUpdateRegion().GetBox();
 342                 win->GetClearRegion() = win->GetClearRegion().GetBox();
 343
 344                 // If we only have one X11 window, always indicate
 345                 // that borders might have to be redrawn.
 346                 if (win->GetMainWindow() == win->GetClientAreaWindow())
 347                     win->NeedUpdateNcAreaInIdle();
 348
 349                 // Only erase background, paint in idle time.
 350                 win->SendEraseEvents();
 351
 352                 // EXPERIMENT
 353                 //win->Update();
 354             }
 355
 356             return true;
 357         }
 358
 359 #if !wxUSE_NANOX
 360         case GraphicsExpose:
 361         {
 362             wxLogTrace( _T("expose"), _T("GraphicsExpose from %s"), win->GetName().c_str());
 363
 364             win->GetUpdateRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
 365                                           event->xgraphicsexpose.width, event->xgraphicsexpose.height);
 366
 367             win->GetClearRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
 368                                          event->xgraphicsexpose.width, event->xgraphicsexpose.height);
 369
 370             if (event->xgraphicsexpose.count == 0)
 371             {
 372                 // Only erase background, paint in idle time.
 373                 win->SendEraseEvents();
 374                 // win->Update();
 375             }
 376
 377             return true;
 378         }
 379 #endif
 380
 381         case KeyPress:
 382         {
 383             if (!win->IsEnabled())
 384                 return false;
 385
 386             wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
 387             wxTranslateKeyEvent(keyEvent, win, window, event);
 388
 389             // wxLogDebug( "OnKey from %s", win->GetName().c_str() );
 390
 391             // We didn't process wxEVT_KEY_DOWN, so send wxEVT_CHAR
 392             if (win->HandleWindowEvent( keyEvent ))
 393                 return true;
 394
 395             keyEvent.SetEventType(wxEVT_CHAR);
 396             // Do the translation again, retaining the ASCII
 397             // code.
 398             if (wxTranslateKeyEvent(keyEvent, win, window, event, true) &&
 399                 win->HandleWindowEvent( keyEvent ))
 400                 return true;
 401
 402             if ( (keyEvent.m_keyCode == WXK_TAB) &&
 403                  win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
 404             {
 405                 wxNavigationKeyEvent new_event;
 406                 new_event.SetEventObject( win->GetParent() );
 407                 /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
 408                 new_event.SetDirection( (keyEvent.m_keyCode == WXK_TAB) );
 409                 /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
 410                 new_event.SetWindowChange( keyEvent.ControlDown() );
 411                 new_event.SetCurrentFocus( win );
 412                 return win->GetParent()->HandleWindowEvent( new_event );
 413             }
 414
 415             return false;
 416         }
 417         case KeyRelease:
 418         {
 419             if (!win->IsEnabled())
 420                 return false;
 421
 422             wxKeyEvent keyEvent(wxEVT_KEY_UP);
 423             wxTranslateKeyEvent(keyEvent, win, window, event);
 424
 425             return win->HandleWindowEvent( keyEvent );
 426         }
 427         case ConfigureNotify:
 428         {
 429 #if wxUSE_NANOX
 430             if (event->update.utype == GR_UPDATE_SIZE)
 431 #endif
 432             {
 433                 wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
 434                 if ( tlw )
 435                 {
 436                     tlw->SetConfigureGeometry( XConfigureEventGetX(event), XConfigureEventGetY(event),
 437                         XConfigureEventGetWidth(event), XConfigureEventGetHeight(event) );
 438                 }
 439
 440                 if ( tlw && tlw->IsShown() )
 441                 {
 442                     tlw->SetNeedResizeInIdle();
 443                 }
 444                 else
 445                 {
 446                     wxSizeEvent sizeEvent( wxSize(XConfigureEventGetWidth(event), XConfigureEventGetHeight(event)), win->GetId() );
 447                     sizeEvent.SetEventObject( win );
 448
 449                     return win->HandleWindowEvent( sizeEvent );
 450                 }
 451             }
 452             return false;
 453         }
 454 #if !wxUSE_NANOX
 455         case PropertyNotify:
 456         {
 457             //wxLogDebug("PropertyNotify: %s", windowClass.c_str());
 458             return HandlePropertyChange(_event);
 459         }
 460         case ClientMessage:
 461         {
 462             if (!win->IsEnabled())
 463                 return false;
 464
 465             Atom wm_delete_window = XInternAtom(wxGlobalDisplay(), "WM_DELETE_WINDOW", True);
 466             Atom wm_protocols = XInternAtom(wxGlobalDisplay(), "WM_PROTOCOLS", True);
 467
 468             if (event->xclient.message_type == wm_protocols)
 469             {
 470                 if ((Atom) (event->xclient.data.l[0]) == wm_delete_window)
 471                 {
 472                     win->Close(false);
 473                     return true;
 474                 }
 475             }
 476             return false;
 477         }
 478 #if 0
 479         case DestroyNotify:
 480         {
 481             printf( "destroy from %s\n", win->GetName().c_str() );
 482             break;
 483         }
 484         case CreateNotify:
 485         {
 486             printf( "create from %s\n", win->GetName().c_str() );
 487             break;
 488         }
 489         case MapRequest:
 490         {
 491             printf( "map request from %s\n", win->GetName().c_str() );
 492             break;
 493         }
 494         case ResizeRequest:
 495         {
 496             printf( "resize request from %s\n", win->GetName().c_str() );
 497
 498             Display *disp = (Display*) wxGetDisplay();
 499             XEvent report;
 500
 501             //  to avoid flicker
 502             report = * event;
 503             while( XCheckTypedWindowEvent (disp, actualWindow, ResizeRequest, &report));
 504
 505             wxSize sz = win->GetSize();
 506             wxSizeEvent sizeEvent(sz, win->GetId());
 507             sizeEvent.SetEventObject(win);
 508
 509             return win->HandleWindowEvent( sizeEvent );
 510         }
 511 #endif
 512 #endif
 513 #if wxUSE_NANOX
 514         case GR_EVENT_TYPE_CLOSE_REQ:
 515         {
 516             if (win)
 517             {
 518                 win->Close(false);
 519                 return true;
 520             }
 521             return false;
 522             break;
 523         }
 524 #endif
 525         case EnterNotify:
 526         case LeaveNotify:
 527         case ButtonPress:
 528         case ButtonRelease:
 529         case MotionNotify:
 530         {
 531             if (!win->IsEnabled())
 532                 return false;
 533
 534             // Here we check if the top level window is
 535             // disabled, which is one aspect of modality.
 536             wxWindow *tlw = win;
 537             while (tlw && !tlw->IsTopLevel())
 538                 tlw = tlw->GetParent();
 539             if (tlw && !tlw->IsEnabled())
 540                 return false;
 541
 542             if (event->type == ButtonPress)
 543             {
 544                 if ((win != wxWindow::FindFocus()) && win->CanAcceptFocus())
 545                 {
 546                     // This might actually be done in wxWindow::SetFocus()
 547                     // and not here. TODO.
 548                     g_prevFocus = wxWindow::FindFocus();
 549                     g_nextFocus = win;
 550
 551                     wxLogTrace( _T("focus"), _T("About to call SetFocus on %s of type %s due to button press"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
 552
 553                     // Record the fact that this window is
 554                     // getting the focus, because we'll need to
 555                     // check if its parent is getting a bogus
 556                     // focus and duly ignore it.
 557                     // TODO: may need to have this code in SetFocus, too.
 558                     extern wxWindow* g_GettingFocus;
 559                     g_GettingFocus = win;
 560                     win->SetFocus();
 561                 }
 562             }
 563
 564 #if !wxUSE_NANOX
 565             if (event->type == LeaveNotify || event->type == EnterNotify)
 566             {
 567                 // Throw out NotifyGrab and NotifyUngrab
 568                 if (event->xcrossing.mode != NotifyNormal)
 569                     return false;
 570             }
 571 #endif
 572             wxMouseEvent wxevent;
 573             wxTranslateMouseEvent(wxevent, win, window, event);
 574             return win->HandleWindowEvent( wxevent );
 575         }
 576         case FocusIn:
 577 #if !wxUSE_NANOX
 578             if ((event->xfocus.detail != NotifyPointer) &&
 579                 (event->xfocus.mode == NotifyNormal))
 580 #endif
 581             {
 582                 wxLogTrace( _T("focus"), _T("FocusIn from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
 583
 584                 extern wxWindow* g_GettingFocus;
 585                 if (g_GettingFocus && g_GettingFocus->GetParent() == win)
 586                 {
 587                     // Ignore this, this can be a spurious FocusIn
 588                     // caused by a child having its focus set.
 589                     g_GettingFocus = NULL;
 590                     wxLogTrace( _T("focus"), _T("FocusIn from %s of type %s being deliberately ignored"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
 591                     return true;
 592                 }
 593                 else
 594                 {
 595                     wxFocusEvent focusEvent(wxEVT_SET_FOCUS, win->GetId());
 596                     focusEvent.SetEventObject(win);
 597                     focusEvent.SetWindow( g_prevFocus );
 598                     g_prevFocus = NULL;
 599
 600                     return win->HandleWindowEvent(focusEvent);
 601                 }
 602             }
 603             return false;
 604
 605         case FocusOut:
 606 #if !wxUSE_NANOX
 607             if ((event->xfocus.detail != NotifyPointer) &&
 608                 (event->xfocus.mode == NotifyNormal))
 609 #endif
 610             {
 611                 wxLogTrace( _T("focus"), _T("FocusOut from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
 612
 613                 wxFocusEvent focusEvent(wxEVT_KILL_FOCUS, win->GetId());
 614                 focusEvent.SetEventObject(win);
 615                 focusEvent.SetWindow( g_nextFocus );
 616                 g_nextFocus = NULL;
 617                 return win->HandleWindowEvent(focusEvent);
 618             }
 619             return false;
 620
 621 #ifdef __WXDEBUG__
 622         default:
 623             //wxString eventName = wxGetXEventName(XEvent& event);
 624             //wxLogDebug(wxT("Event %s not handled"), eventName.c_str());
 625             break;
 626 #endif // __WXDEBUG__
 627     }
 628
 629     return false;
 630 }
 631
 632 // This should be redefined in a derived class for
 633 // handling property change events for XAtom IPC.
 634 bool wxApp::HandlePropertyChange(WXEvent *WXUNUSED(event))
 635 {
 636     // by default do nothing special
 637     // TODO: what to do for X11
 638     // XtDispatchEvent((XEvent*) event);
 639     return false;
 640 }
 641
 642 void wxApp::WakeUpIdle()
 643 {
 644     // TODO: use wxMotif implementation?
 645
 646     // Wake up the idle handler processor, even if it is in another thread...
 647 }
 648
 649
 650 // Create display, and other initialization
 651 bool wxApp::OnInitGui()
 652 {
 653 #if wxUSE_LOG
 654     // Eventually this line will be removed, but for
 655     // now we don't want to try popping up a dialog
 656     // for error messages.
 657     delete wxLog::SetActiveTarget(new wxLogStderr);
 658 #endif
 659
 660     if (!wxAppBase::OnInitGui())
 661         return false;
 662
 663     Display *dpy = wxGlobalDisplay();
 664     GetMainColormap(dpy);
 665
 666     m_maxRequestSize = XMaxRequestSize(dpy);
 667
 668 #if !wxUSE_NANOX
 669     m_visualInfo = new wxXVisualInfo;
 670     wxFillXVisualInfo(m_visualInfo, dpy);
 671 #endif
 672
 673     return true;
 674 }
 675
 676 #if wxUSE_UNICODE
 677
 678 #include <pango/pango.h>
 679 #include <pango/pangox.h>
 680 #ifdef HAVE_PANGO_XFT
 681     #include <pango/pangoxft.h>
 682 #endif
 683
 684 PangoContext* wxApp::GetPangoContext()
 685 {
 686     static PangoContext *s_pangoContext = NULL;
 687     if ( !s_pangoContext )
 688     {
 689         Display *dpy = wxGlobalDisplay();
 690
 691 #ifdef HAVE_PANGO_XFT
 692         int xscreen = DefaultScreen(dpy);
 693         static int use_xft = -1;
 694         if (use_xft == -1)
 695         {
 696             wxString val = wxGetenv( L"GDK_USE_XFT" );
 697             use_xft = val == L"1";
 698         }
 699
 700         if (use_xft)
 701             s_pangoContext = pango_xft_get_context(dpy, xscreen);
 702         else
 703 #endif // HAVE_PANGO_XFT
 704             s_pangoContext = pango_x_get_context(dpy);
 705
 706         if (!PANGO_IS_CONTEXT(s_pangoContext))
 707             wxLogError( wxT("No pango context.") );
 708     }
 709
 710     return s_pangoContext;
 711 }
 712
 713 #endif // wxUSE_UNICODE
 714
 715 WXColormap wxApp::GetMainColormap(WXDisplay* display)
 716 {
 717     if (!display) /* Must be called first with non-NULL display */
 718         return m_mainColormap;
 719
 720     int defaultScreen = DefaultScreen((Display*) display);
 721     Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);
 722
 723     Colormap c = DefaultColormapOfScreen(screen);
 724
 725     if (!m_mainColormap)
 726         m_mainColormap = (WXColormap) c;
 727
 728     return (WXColormap) c;
 729 }
 730
 731 Window wxGetWindowParent(Window window)
 732 {
 733     wxASSERT_MSG( window, _T("invalid window") );
 734
 735     return (Window) 0;
 736
 737 #ifndef __VMS
 738    // VMS chokes on unreacheable code
 739    Window parent, root = 0;
 740 #if wxUSE_NANOX
 741     int noChildren = 0;
 742 #else
 743     unsigned int noChildren = 0;
 744 #endif
 745     Window* children = NULL;
 746
 747     // #define XQueryTree(d,w,r,p,c,nc)     GrQueryTree(w,p,c,nc)
 748     int res = 1;
 749 #if !wxUSE_NANOX
 750     res =
 751 #endif
 752         XQueryTree((Display*) wxGetDisplay(), window, & root, & parent,
 753              & children, & noChildren);
 754     if (children)
 755         XFree(children);
 756     if (res)
 757         return parent;
 758     else
 759         return (Window) 0;
 760 #endif
 761 }
 762
 763 void wxApp::Exit()
 764 {
 765     wxApp::CleanUp();
 766
 767     wxAppConsole::Exit();
 768 }
 769
 770 // Yield to other processes
 771
 772 bool wxApp::Yield(bool onlyIfNeeded)
 773 {
 774     // Sometimes only 2 yields seem
 775     // to do the trick, e.g. in the
 776     // progress dialog
 777     int i;
 778     for (i = 0; i < 2; i++)
 779     {
 780         static bool s_inYield = false;
 781
 782         if ( s_inYield )
 783         {
 784             if ( !onlyIfNeeded )
 785             {
 786                 wxFAIL_MSG( wxT("wxYield called recursively" ) );
 787             }
 788
 789             return false;
 790         }
 791
 792         s_inYield = true;
 793
 794         // Make sure we have an event loop object,
 795         // or Pending/Dispatch will fail
 796         wxEventLoopBase * const eventLoop = wxEventLoop::GetActive();
 797         wxEventLoop* newEventLoop = NULL;
 798         if (!eventLoop)
 799         {
 800             newEventLoop = new wxEventLoop;
 801             wxEventLoop::SetActive(newEventLoop);
 802         }
 803
 804         // Call dispatch at least once so that sockets
 805         // can be tested
 806         wxTheApp->Dispatch();
 807
 808         while (wxTheApp && wxTheApp->Pending())
 809             wxTheApp->Dispatch();
 810
 811 #if wxUSE_TIMER
 812         wxGenericTimerImpl::NotifyTimers();
 813 #endif
 814         ProcessIdle();
 815
 816         if (newEventLoop)
 817         {
 818             wxEventLoop::SetActive(NULL);
 819             delete newEventLoop;
 820         }
 821
 822         s_inYield = false;
 823     }
 824
 825     return true;
 826 }
 827
 828 #ifdef __WXDEBUG__
 829
 830 void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg)
 831 {
 832     // While the GUI isn't working that well, just print out the
 833     // message.
 834 #if 1
 835     wxAppBase::OnAssert(file, line, cond, msg);
 836 #else
 837     wxString msg2;
 838     msg2.Printf("At file %s:%d: %s", file, line, msg);
 839     wxLogDebug(msg2);
 840 #endif
 841 }
 842
 843 #endif // __WXDEBUG__