src/x11/app.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/x11/app.cpp
// Purpose:     wxApp
// Author:      Julian Smart
// Modified by:
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// for compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#include "wx/app.h"

#ifndef WX_PRECOMP
    #include "wx/hash.h"
    #include "wx/intl.h"
    #include "wx/log.h"
    #include "wx/utils.h"
    #include "wx/frame.h"
    #include "wx/icon.h"
    #include "wx/dialog.h"
    #include "wx/memory.h"
    #include "wx/gdicmn.h"
    #include "wx/module.h"
    #include "wx/crt.h"
#endif

#include "wx/evtloop.h"
#include "wx/filename.h"

#include "wx/univ/theme.h"
#include "wx/univ/renderer.h"
#include "wx/generic/private/timer.h"

#if wxUSE_THREADS
    #include "wx/thread.h"
#endif

#include "wx/x11/private.h"

#include <string.h>

//------------------------------------------------------------------------
//   global data
//------------------------------------------------------------------------

wxWindowHash *wxWidgetHashTable = NULL;
wxWindowHash *wxClientWidgetHashTable = NULL;

static bool g_showIconic = false;
static wxSize g_initialSize = wxDefaultSize;

// This is required for wxFocusEvent::SetWindow(). It will only
// work for focus events which we provoke ourselves (by calling
// SetFocus()). It will not work for those events, which X11
// generates itself.
static wxWindow *g_nextFocus = NULL;
static wxWindow *g_prevFocus = NULL;

//------------------------------------------------------------------------
//   X11 error handling
//------------------------------------------------------------------------

#ifdef __WXDEBUG__
typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *);

XErrorHandlerFunc gs_pfnXErrorHandler = 0;

static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent)
{
    // just forward to the default handler for now
    if (gs_pfnXErrorHandler)
        return gs_pfnXErrorHandler(dpy, xevent);
    else
        return 0;
}
#endif // __WXDEBUG__

//------------------------------------------------------------------------
//   wxApp
//------------------------------------------------------------------------

long wxApp::sm_lastMessageTime = 0;

IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)

bool wxApp::Initialize(int& argC, wxChar **argV)
{
#if defined(__WXDEBUG__) && !wxUSE_NANOX
    // install the X error handler
    gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler );
#endif // __WXDEBUG__

    wxString displayName;
    bool syncDisplay = false;

    int argCOrig = argC;
    for ( int i = 0; i < argCOrig; i++ )
    {
        if (wxStrcmp( argV[i], _T("-display") ) == 0)
        {
            if (i < (argC - 1))
            {
                argV[i++] = NULL;

                displayName = argV[i];

                argV[i] = NULL;
                argC -= 2;
            }
        }
        else if (wxStrcmp( argV[i], _T("-geometry") ) == 0)
        {
            if (i < (argC - 1))
            {
                argV[i++] = NULL;

                int w, h;
                if (wxSscanf(argV[i], _T("%dx%d"), &w, &h) != 2)
                {
                    wxLogError( _("Invalid geometry specification '%s'"),
                                wxString(argV[i]).c_str() );
                }
                else
                {
                    g_initialSize = wxSize(w, h);
                }

                argV[i] = NULL;
                argC -= 2;
            }
        }
        else if (wxStrcmp( argV[i], _T("-sync") ) == 0)
        {
            syncDisplay = true;

            argV[i] = NULL;
            argC--;
        }
        else if (wxStrcmp( argV[i], _T("-iconic") ) == 0)
        {
            g_showIconic = true;

            argV[i] = NULL;
            argC--;
        }
    }

    if ( argC != argCOrig )
    {
        // remove the argumens we consumed
        for ( int i = 0; i < argC; i++ )
        {
            while ( !argV[i] )
            {
                memmove(argV + i, argV + i + 1, argCOrig - i);
            }
        }
    }

    // open and set up the X11 display
    if ( !wxSetDisplay(displayName) )
    {
        wxLogError(_("wxWidgets could not open display. Exiting."));
        return false;
    }

    Display *dpy = wxGlobalDisplay();
    if (syncDisplay)
        XSynchronize(dpy, True);

    XSelectInput(dpy, XDefaultRootWindow(dpy), PropertyChangeMask);

    wxSetDetectableAutoRepeat( true );


    if ( !wxAppBase::Initialize(argC, argV) )
        return false;

#if wxUSE_UNICODE
    // Glib's type system required by Pango
    g_type_init();
#endif

#if wxUSE_INTL
    wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
#endif

    wxWidgetHashTable = new wxWindowHash;
    wxClientWidgetHashTable = new wxWindowHash;

    return true;
}

void wxApp::CleanUp()
{
    delete wxWidgetHashTable;
    wxWidgetHashTable = NULL;
    delete wxClientWidgetHashTable;
    wxClientWidgetHashTable = NULL;

    wxAppBase::CleanUp();
}

wxApp::wxApp()
{
    m_mainColormap = NULL;
    m_topLevelWidget = NULL;
    m_maxRequestSize = 0;
    m_showIconic = false;
    m_initialSize = wxDefaultSize;

#if !wxUSE_NANOX
    m_visualInfo = NULL;
#endif
}

wxApp::~wxApp()
{
#if !wxUSE_NANOX
    delete m_visualInfo;
#endif
}

#if !wxUSE_NANOX

//-----------------------------------------------------------------------
// X11 predicate function for exposure compression
//-----------------------------------------------------------------------

struct wxExposeInfo
{
    Window window;
    Bool found_non_matching;
};

extern "C"
Bool wxX11ExposePredicate (Display *WXUNUSED(display), XEvent *xevent, XPointer arg)
{
    wxExposeInfo *info = (wxExposeInfo*) arg;

    if (info->found_non_matching)
       return FALSE;

    if (xevent->xany.type != Expose)
    {
        info->found_non_matching = true;
        return FALSE;
    }

    if (xevent->xexpose.window != info->window)
    {
        info->found_non_matching = true;
        return FALSE;
    }

    return TRUE;
}

#endif // wxUSE_NANOX

//-----------------------------------------------------------------------
// Processes an X event, returning true if the event was processed.
//-----------------------------------------------------------------------

bool wxApp::ProcessXEvent(WXEvent* _event)
{
    XEvent* event = (XEvent*) _event;

    wxWindow* win = NULL;
    Window window = XEventGetWindow(event);
#if 0
    Window actualWindow = window;
#endif

    // Find the first wxWindow that corresponds to this event window
    // Because we're receiving events after a window
    // has been destroyed, assume a 1:1 match between
    // Window and wxWindow, so if it's not in the table,
    // it must have been destroyed.

    win = wxGetWindowFromTable(window);
    if (!win)
    {
#if wxUSE_TWO_WINDOWS
        win = wxGetClientWindowFromTable(window);
        if (!win)
#endif
            return false;
    }

#ifdef __WXDEBUG__
    wxString windowClass = win->GetClassInfo()->GetClassName();
#endif

    switch (event->type)
    {
        case Expose:
        {
#if wxUSE_TWO_WINDOWS && !wxUSE_NANOX
            if (event->xexpose.window != (Window)win->GetClientAreaWindow())
            {
                XEvent tmp_event;
                wxExposeInfo info;
                info.window = event->xexpose.window;
                info.found_non_matching = false;
                while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
                {
                    // Don't worry about optimizing redrawing the border etc.
                }
                win->NeedUpdateNcAreaInIdle();
            }
            else
#endif
            {
                win->GetUpdateRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
                                              XExposeEventGetWidth(event), XExposeEventGetHeight(event));
                win->GetClearRegion().Union( XExposeEventGetX(event), XExposeEventGetY(event),
                                         XExposeEventGetWidth(event), XExposeEventGetHeight(event));

#if !wxUSE_NANOX
                XEvent tmp_event;
                wxExposeInfo info;
                info.window = event->xexpose.window;
                info.found_non_matching = false;
                while (XCheckIfEvent( wxGlobalDisplay(), &tmp_event, wxX11ExposePredicate, (XPointer) &info ))
                {
                    win->GetUpdateRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
                                                  tmp_event.xexpose.width, tmp_event.xexpose.height );

                    win->GetClearRegion().Union( tmp_event.xexpose.x, tmp_event.xexpose.y,
                                                 tmp_event.xexpose.width, tmp_event.xexpose.height );
                }
#endif

                // This simplifies the expose and clear areas to simple
                // rectangles.
                win->GetUpdateRegion() = win->GetUpdateRegion().GetBox();
                win->GetClearRegion() = win->GetClearRegion().GetBox();

                // If we only have one X11 window, always indicate
                // that borders might have to be redrawn.
                if (win->GetMainWindow() == win->GetClientAreaWindow())
                    win->NeedUpdateNcAreaInIdle();

                // Only erase background, paint in idle time.
                win->SendEraseEvents();

                // EXPERIMENT
                //win->Update();
            }

            return true;
        }

#if !wxUSE_NANOX
        case GraphicsExpose:
        {
            wxLogTrace( _T("expose"), _T("GraphicsExpose from %s"), win->GetName().c_str());

            win->GetUpdateRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
                                          event->xgraphicsexpose.width, event->xgraphicsexpose.height);

            win->GetClearRegion().Union( event->xgraphicsexpose.x, event->xgraphicsexpose.y,
                                         event->xgraphicsexpose.width, event->xgraphicsexpose.height);

            if (event->xgraphicsexpose.count == 0)
            {
                // Only erase background, paint in idle time.
                win->SendEraseEvents();
                // win->Update();
            }

            return true;
        }
#endif

        case KeyPress:
        {
            if (!win->IsEnabled())
                return false;

            wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
            wxTranslateKeyEvent(keyEvent, win, window, event);

            // wxLogDebug( "OnKey from %s", win->GetName().c_str() );

            // We didn't process wxEVT_KEY_DOWN, so send wxEVT_CHAR
            if (win->HandleWindowEvent( keyEvent ))
                return true;

            keyEvent.SetEventType(wxEVT_CHAR);
            // Do the translation again, retaining the ASCII
            // code.
            if (wxTranslateKeyEvent(keyEvent, win, window, event, true) &&
                win->HandleWindowEvent( keyEvent ))
                return true;

            if ( (keyEvent.m_keyCode == WXK_TAB) &&
                 win->GetParent() && (win->GetParent()->HasFlag( wxTAB_TRAVERSAL)) )
            {
                wxNavigationKeyEvent new_event;
                new_event.SetEventObject( win->GetParent() );
                /* GDK reports GDK_ISO_Left_Tab for SHIFT-TAB */
                new_event.SetDirection( (keyEvent.m_keyCode == WXK_TAB) );
                /* CTRL-TAB changes the (parent) window, i.e. switch notebook page */
                new_event.SetWindowChange( keyEvent.ControlDown() );
                new_event.SetCurrentFocus( win );
                return win->GetParent()->HandleWindowEvent( new_event );
            }

            return false;
        }
        case KeyRelease:
        {
            if (!win->IsEnabled())
                return false;

            wxKeyEvent keyEvent(wxEVT_KEY_UP);
            wxTranslateKeyEvent(keyEvent, win, window, event);

            return win->HandleWindowEvent( keyEvent );
        }
        case ConfigureNotify:
        {
#if wxUSE_NANOX
            if (event->update.utype == GR_UPDATE_SIZE)
#endif
            {
                wxTopLevelWindow *tlw = wxDynamicCast(win, wxTopLevelWindow);
                if ( tlw )
                {
                    tlw->SetConfigureGeometry( XConfigureEventGetX(event), XConfigureEventGetY(event),
                        XConfigureEventGetWidth(event), XConfigureEventGetHeight(event) );
                }

                if ( tlw && tlw->IsShown() )
                {
                    tlw->SetNeedResizeInIdle();
                }
                else
                {
                    wxSizeEvent sizeEvent( wxSize(XConfigureEventGetWidth(event), XConfigureEventGetHeight(event)), win->GetId() );
                    sizeEvent.SetEventObject( win );

                    return win->HandleWindowEvent( sizeEvent );
                }
            }
            return false;
        }
#if !wxUSE_NANOX
        case PropertyNotify:
        {
            //wxLogDebug("PropertyNotify: %s", windowClass.c_str());
            return HandlePropertyChange(_event);
        }
        case ClientMessage:
        {
            if (!win->IsEnabled())
                return false;

            Atom wm_delete_window = XInternAtom(wxGlobalDisplay(), "WM_DELETE_WINDOW", True);
            Atom wm_protocols = XInternAtom(wxGlobalDisplay(), "WM_PROTOCOLS", True);

            if (event->xclient.message_type == wm_protocols)
            {
                if ((Atom) (event->xclient.data.l[0]) == wm_delete_window)
                {
                    win->Close(false);
                    return true;
                }
            }
            return false;
        }
#if 0
        case DestroyNotify:
        {
            printf( "destroy from %s\n", win->GetName().c_str() );
            break;
        }
        case CreateNotify:
        {
            printf( "create from %s\n", win->GetName().c_str() );
            break;
        }
        case MapRequest:
        {
            printf( "map request from %s\n", win->GetName().c_str() );
            break;
        }
        case ResizeRequest:
        {
            printf( "resize request from %s\n", win->GetName().c_str() );

            Display *disp = (Display*) wxGetDisplay();
            XEvent report;

            //  to avoid flicker
            report = * event;
            while( XCheckTypedWindowEvent (disp, actualWindow, ResizeRequest, &report));

            wxSize sz = win->GetSize();
            wxSizeEvent sizeEvent(sz, win->GetId());
            sizeEvent.SetEventObject(win);

            return win->HandleWindowEvent( sizeEvent );
        }
#endif
#endif
#if wxUSE_NANOX
        case GR_EVENT_TYPE_CLOSE_REQ:
        {
            if (win)
            {
                win->Close(false);
                return true;
            }
            return false;
            break;
        }
#endif
        case EnterNotify:
        case LeaveNotify:
        case ButtonPress:
        case ButtonRelease:
        case MotionNotify:
        {
            if (!win->IsEnabled())
                return false;

            // Here we check if the top level window is
            // disabled, which is one aspect of modality.
            wxWindow *tlw = win;
            while (tlw && !tlw->IsTopLevel())
                tlw = tlw->GetParent();
            if (tlw && !tlw->IsEnabled())
                return false;

            if (event->type == ButtonPress)
            {
                if ((win != wxWindow::FindFocus()) && win->CanAcceptFocus())
                {
                    // This might actually be done in wxWindow::SetFocus()
                    // and not here. TODO.
                    g_prevFocus = wxWindow::FindFocus();
                    g_nextFocus = win;

                    wxLogTrace( _T("focus"), _T("About to call SetFocus on %s of type %s due to button press"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );

                    // Record the fact that this window is
                    // getting the focus, because we'll need to
                    // check if its parent is getting a bogus
                    // focus and duly ignore it.
                    // TODO: may need to have this code in SetFocus, too.
                    extern wxWindow* g_GettingFocus;
                    g_GettingFocus = win;
                    win->SetFocus();
                }
            }

#if !wxUSE_NANOX
            if (event->type == LeaveNotify || event->type == EnterNotify)
            {
                // Throw out NotifyGrab and NotifyUngrab
                if (event->xcrossing.mode != NotifyNormal)
                    return false;
            }
#endif
            wxMouseEvent wxevent;
            wxTranslateMouseEvent(wxevent, win, window, event);
            return win->HandleWindowEvent( wxevent );
        }
        case FocusIn:
#if !wxUSE_NANOX
            if ((event->xfocus.detail != NotifyPointer) &&
                (event->xfocus.mode == NotifyNormal))
#endif
            {
                wxLogTrace( _T("focus"), _T("FocusIn from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );

                extern wxWindow* g_GettingFocus;
                if (g_GettingFocus && g_GettingFocus->GetParent() == win)
                {
                    // Ignore this, this can be a spurious FocusIn
                    // caused by a child having its focus set.
                    g_GettingFocus = NULL;
                    wxLogTrace( _T("focus"), _T("FocusIn from %s of type %s being deliberately ignored"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );
                    return true;
                }
                else
                {
                    wxFocusEvent focusEvent(wxEVT_SET_FOCUS, win->GetId());
                    focusEvent.SetEventObject(win);
                    focusEvent.SetWindow( g_prevFocus );
                    g_prevFocus = NULL;

                    return win->HandleWindowEvent(focusEvent);
                }
            }
            return false;

        case FocusOut:
#if !wxUSE_NANOX
            if ((event->xfocus.detail != NotifyPointer) &&
                (event->xfocus.mode == NotifyNormal))
#endif
            {
                wxLogTrace( _T("focus"), _T("FocusOut from %s of type %s"), win->GetName().c_str(), win->GetClassInfo()->GetClassName() );

                wxFocusEvent focusEvent(wxEVT_KILL_FOCUS, win->GetId());
                focusEvent.SetEventObject(win);
                focusEvent.SetWindow( g_nextFocus );
                g_nextFocus = NULL;
                return win->HandleWindowEvent(focusEvent);
            }
            return false;

#ifdef __WXDEBUG__
        default:
            //wxString eventName = wxGetXEventName(XEvent& event);
            //wxLogDebug(wxT("Event %s not handled"), eventName.c_str());
            break;
#endif // __WXDEBUG__
    }

    return false;
}

// This should be redefined in a derived class for
// handling property change events for XAtom IPC.
bool wxApp::HandlePropertyChange(WXEvent *WXUNUSED(event))
{
    // by default do nothing special
    // TODO: what to do for X11
    // XtDispatchEvent((XEvent*) event);
    return false;
}

void wxApp::WakeUpIdle()
{
    // TODO: use wxMotif implementation?

    // Wake up the idle handler processor, even if it is in another thread...
}


// Create display, and other initialization
bool wxApp::OnInitGui()
{
#if wxUSE_LOG
    // Eventually this line will be removed, but for
    // now we don't want to try popping up a dialog
    // for error messages.
    delete wxLog::SetActiveTarget(new wxLogStderr);
#endif

    if (!wxAppBase::OnInitGui())
        return false;

    Display *dpy = wxGlobalDisplay();
    GetMainColormap(dpy);

    m_maxRequestSize = XMaxRequestSize(dpy);

#if !wxUSE_NANOX
    m_visualInfo = new wxXVisualInfo;
    wxFillXVisualInfo(m_visualInfo, dpy);
#endif

    return true;
}

#if wxUSE_UNICODE

#include <pango/pango.h>
#include <pango/pangox.h>
#ifdef HAVE_PANGO_XFT
    #include <pango/pangoxft.h>
#endif

PangoContext* wxApp::GetPangoContext()
{
    static PangoContext *s_pangoContext = NULL;
    if ( !s_pangoContext )
    {
        Display *dpy = wxGlobalDisplay();

#ifdef HAVE_PANGO_XFT
        int xscreen = DefaultScreen(dpy);
        static int use_xft = -1;
        if (use_xft == -1)
        {
            wxString val = wxGetenv( L"GDK_USE_XFT" );
            use_xft = val == L"1";
        }

        if (use_xft)
            s_pangoContext = pango_xft_get_context(dpy, xscreen);
        else
#endif // HAVE_PANGO_XFT
            s_pangoContext = pango_x_get_context(dpy);

        if (!PANGO_IS_CONTEXT(s_pangoContext))
            wxLogError( wxT("No pango context.") );
    }

    return s_pangoContext;
}

#endif // wxUSE_UNICODE

WXColormap wxApp::GetMainColormap(WXDisplay* display)
{
    if (!display) /* Must be called first with non-NULL display */
        return m_mainColormap;

    int defaultScreen = DefaultScreen((Display*) display);
    Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);

    Colormap c = DefaultColormapOfScreen(screen);

    if (!m_mainColormap)
        m_mainColormap = (WXColormap) c;

    return (WXColormap) c;
}

Window wxGetWindowParent(Window window)
{
    wxASSERT_MSG( window, _T("invalid window") );

    return (Window) 0;

#ifndef __VMS
   // VMS chokes on unreacheable code
   Window parent, root = 0;
#if wxUSE_NANOX
    int noChildren = 0;
#else
    unsigned int noChildren = 0;
#endif
    Window* children = NULL;

    // #define XQueryTree(d,w,r,p,c,nc)     GrQueryTree(w,p,c,nc)
    int res = 1;
#if !wxUSE_NANOX
    res =
#endif
        XQueryTree((Display*) wxGetDisplay(), window, & root, & parent,
             & children, & noChildren);
    if (children)
        XFree(children);
    if (res)
        return parent;
    else
        return (Window) 0;
#endif
}

void wxApp::Exit()
{
    wxApp::CleanUp();

    wxAppConsole::Exit();
}

// Yield to other processes

bool wxApp::Yield(bool onlyIfNeeded)
{
    // Sometimes only 2 yields seem
    // to do the trick, e.g. in the
    // progress dialog
    int i;
    for (i = 0; i < 2; i++)
    {
        static bool s_inYield = false;

        if ( s_inYield )
        {
            if ( !onlyIfNeeded )
            {
                wxFAIL_MSG( wxT("wxYield called recursively" ) );
            }

            return false;
        }

        s_inYield = true;

        // Make sure we have an event loop object,
        // or Pending/Dispatch will fail
        wxEventLoopBase * const eventLoop = wxEventLoop::GetActive();
        wxEventLoop* newEventLoop = NULL;
        if (!eventLoop)
        {
            newEventLoop = new wxEventLoop;
            wxEventLoop::SetActive(newEventLoop);
        }

        // Call dispatch at least once so that sockets
        // can be tested
        wxTheApp->Dispatch();

        while (wxTheApp && wxTheApp->Pending())
            wxTheApp->Dispatch();

#if wxUSE_TIMER
        wxGenericTimerImpl::NotifyTimers();
#endif
        ProcessIdle();

        if (newEventLoop)
        {
            wxEventLoop::SetActive(NULL);
            delete newEventLoop;
        }

        s_inYield = false;
    }

    return true;
}

#ifdef __WXDEBUG__

void wxApp::OnAssert(const wxChar *file, int line, const wxChar* cond, const wxChar *msg)
{
    // While the GUI isn't working that well, just print out the
    // message.
#if 1
    wxAppBase::OnAssert(file, line, cond, msg);
#else
    wxString msg2;
    msg2.Printf("At file %s:%d: %s", file, line, msg);
    wxLogDebug(msg2);
#endif
}

#endif // __WXDEBUG__
Commit	Line	Data
	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__