src/motif/app.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/motif/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"

#ifdef __VMS
#define XtParent XTPARENT
#define XtDisplay XTDISPLAY
#endif

#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/memory.h"
    #include "wx/font.h"
#endif

#include "wx/evtloop.h"

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

#ifdef __VMS__
    #pragma message disable nosimpint
#endif
#include <Xm/Xm.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xresource.h>
#include <X11/Xatom.h>
#ifdef __VMS__
    #pragma message enable nosimpint
#endif

#include "wx/motif/private.h"

#include <string.h>

struct wxPerDisplayData
{
    wxPerDisplayData()
    {
        m_visualInfo = NULL;
        m_topLevelWidget = NULL;
        m_topLevelRealizedWidget = NULL;
    }

    wxXVisualInfo* m_visualInfo;
    Widget         m_topLevelWidget, m_topLevelRealizedWidget;
};

static void wxTLWidgetDestroyCallback(Widget w, XtPointer clientData,
                                      XtPointer ptr);
static WXWidget wxCreateTopLevelWidget( WXDisplay* display );

extern bool wxAddIdleCallback();

wxHashTable *wxWidgetHashTable = NULL;

IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)

#ifdef __WXDEBUG__
extern "C"
{
    typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *);
}

XErrorHandlerFunc gs_pfnXErrorHandler = 0;

extern "C"
{

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

}
#endif // __WXDEBUG__

bool wxApp::Initialize(int& argcOrig, wxChar **argvOrig)
{
#if wxUSE_INTL
    wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
#endif

    if ( !wxAppBase::Initialize(argcOrig, argvOrig) )
        return false;

    wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);

    return true;
}

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

    delete wxWidgetHashTable;
    wxWidgetHashTable = NULL;

    delete m_mainLoop;

    for( wxPerDisplayDataMap::iterator it  = m_perDisplayData->begin(),
                                       end = m_perDisplayData->end();
         it != end; ++it )
    {
        delete it->second->m_visualInfo;
        // On Solaris 10 calling XtDestroyWidget on the top level widget
        // dumps core if the locale is set to something other than "C"
#ifndef __SUN__
        XtDestroyWidget( it->second->m_topLevelWidget );
#endif
        delete it->second;
    }
}

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

    wxAppConsole::Exit();
}

// ============================================================================
// wxApp
// ============================================================================

wxApp::wxApp()
{
    argc = 0;
    argv = NULL;

    m_mainLoop = new wxEventLoop;
    m_mainColormap = (WXColormap) NULL;
    m_appContext = (WXAppContext) NULL;
    m_initialDisplay = (WXDisplay*) 0;
    m_perDisplayData = new wxPerDisplayDataMap;
}

wxApp::~wxApp()
{
    delete m_perDisplayData;
}

int wxApp::MainLoop()
{
    /*
    * Sit around forever waiting to process X-events. Property Change
    * event are handled special, because they have to refer to
    * the root window rather than to a widget. therefore we can't
    * use an Xt-eventhandler.
    */

    XSelectInput(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()),
        XDefaultRootWindow(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())),
        PropertyChangeMask);

    m_mainLoop->Run();

    return 0;
}

// This should be redefined in a derived class for
// handling property change events for XAtom IPC.
void wxApp::HandlePropertyChange(WXEvent *event)
{
    // by default do nothing special
    XtDispatchEvent((XEvent*) event); /* let Motif do the work */
}

static char *fallbackResources[] = {
    // better defaults for CDE under Irix
    //
    // TODO: do something similar for the other systems, the hardcoded defaults
    //       below are ugly
#ifdef __SGI__
    wxMOTIF_STR("*sgiMode: True"),
    wxMOTIF_STR("*useSchemes: all"),
#else // !__SGI__
#if !wxMOTIF_USE_RENDER_TABLE
    wxMOTIF_STR("*.fontList: -*-helvetica-medium-r-normal-*-*-120-*-*-*-*-*-*"),
#else
    wxMOTIF_STR("*wxDefaultRendition.fontName: -*-helvetica-medium-r-normal-*-*-120-*-*-*-*-*-*"),
    wxMOTIF_STR("*wxDefaultRendition.fontType: FONT_IS_FONTSET"),
    wxMOTIF_STR("*.renderTable: wxDefaultRendition"),
#endif
    wxMOTIF_STR("*listBox.background: white"),
    wxMOTIF_STR("*text.background: white"),
    wxMOTIF_STR("*comboBox.Text.background: white"),
    wxMOTIF_STR("*comboBox.List.background: white"),
#endif // __SGI__/!__SGI__
    NULL
};

// Create an application context
bool wxApp::OnInitGui()
{
    if( !wxAppBase::OnInitGui() )
        return false;

#ifdef __HPUX__
    // under HP-UX creating XmFontSet fails when the system locale is C and
    // we're using a remote DISPLAY, presumably because HP-UX uses its own
    // names for C and ISO locales (roman8 and iso8859n respectively) and so
    // its Motif libraries have troubles with non-HP X server
    //
    // whatever the reason, the fact is that without this hack any wxMotif
    // program crashes on startup because it can't create any font (HP programs
    // still work but they do spit out messages about failing to create font
    // sets and failing back on "fixed" font too)
    //
    // notice that calling setlocale() here is not enough because X(m) init
    // functions call setlocale() later so we really have to change environment
    bool fixAll = false; // tweak LC_ALL (or just LC_CTYPE)?
    const char *loc = getenv("LC_CTYPE");
    if ( !loc )
    {
        loc = getenv("LC_ALL");
        if ( loc )
            fixAll = true;
    }

    if ( !loc ||
            (loc[0] == 'C' && loc[1] == '\0') ||
                strcmp(loc, "POSIX") == 0 )
    {
        // we're using C locale, "fix" it
        wxLogDebug(_T("HP-UX fontset hack: forcing locale to en_US.iso88591"));
        putenv(fixAll ? "LC_ALL=en_US.iso88591" : "LC_CTYPE=en_US.iso88591");
    }
#endif // __HPUX__

    XtSetLanguageProc(NULL, NULL, NULL);
    XtToolkitInitialize() ;
    wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext();
    XtAppSetFallbackResources((XtAppContext) wxTheApp->m_appContext, fallbackResources);

    // we shouldn't pass empty application/class name as it results in
    // immediate crash inside XOpenIM() (if XIM is used) under IRIX
    wxString appname = wxTheApp->GetAppName();
    if ( appname.empty() )
        appname = _T("wxapp");
    wxString clsname = wxTheApp->GetClassName();
    if ( clsname.empty() )
        clsname = _T("wx");

    // FIXME-UTF8: This code is taken from wxGTK and duplicated here. This
    //             is just a temporary fix to make wxX11 compile in Unicode
    //             build, the real fix is to change Initialize()'s signature
    //             to use char* on Unix.
#if wxUSE_UNICODE
    // XtOpenDisplay() wants char*, not wchar_t*, so convert
    int i;
    char **argvX11 = new char *[argc + 1];
    for ( i = 0; i < argc; i++ )
    {
        argvX11[i] = strdup(wxConvLibc.cWX2MB(argv[i]));
    }

    argvX11[argc] = NULL;

    int argcX11 = argc;

    Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,
        (String)NULL,
        appname.c_str(),
        clsname.c_str(),
        NULL, 0,    // no options
# if XtSpecificationRelease < 5
        (Cardinal*) &argcX11,
# else
        &argcX11,
# endif
        argvX11);

    if ( argcX11 != argc )
    {
        // we have to drop the parameters which were consumed by X11+
        for ( i = 0; i < argcX11; i++ )
        {
            while ( strcmp(wxConvLibc.cWX2MB(argv[i]), argvX11[i]) != 0 )
            {
                memmove(argv + i, argv + i + 1, (argc - i)*sizeof(*argv));
            }
        }

        argc = argcX11;
    }
    //else: XtOpenDisplay() didn't modify our parameters

    // free our copy
    for ( i = 0; i < argcX11; i++ )
    {
        free(argvX11[i]);
    }

    delete [] argvX11;

#else // ANSI

    Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,
        (String)NULL,
        appname.c_str(),
        clsname.c_str(),
        NULL, 0,    // no options
# if XtSpecificationRelease < 5
        (Cardinal*) &argc,
# else
        &argc,
# endif
        argv);

#endif // Unicode/ANSI

    if (!dpy) {
         // if you don't log to stderr, nothing will be shown...
        delete wxLog::SetActiveTarget(new wxLogStderr);
        wxString className(wxTheApp->GetClassName());
        wxLogError(_("wxWidgets could not open display for '%s': exiting."),
                   className.c_str());
        exit(-1);
    }
    m_initialDisplay = (WXDisplay*) dpy;

#ifdef __WXDEBUG__
    // install the X error handler
    gs_pfnXErrorHandler = XSetErrorHandler(wxXErrorHandler);
#endif // __WXDEBUG__

    // Add general resize proc
    XtActionsRec rec;
    rec.string = wxMOTIF_STR("resize");
    rec.proc = (XtActionProc)wxWidgetResizeProc;
    XtAppAddActions((XtAppContext) wxTheApp->m_appContext, &rec, 1);

    GetMainColormap(dpy);

    wxAddIdleCallback();

    return true;
}

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;
}

static inline wxPerDisplayData& GetOrCreatePerDisplayData
    ( wxPerDisplayDataMap& m, WXDisplay* display )
{
    wxPerDisplayDataMap::iterator it = m.find( display );
    if( it != m.end() && it->second != NULL )
        return *(it->second);

    wxPerDisplayData* nData = new wxPerDisplayData();
    m[display] = nData;

    return *nData;
}

wxXVisualInfo* wxApp::GetVisualInfo( WXDisplay* display )
{
    wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
                                                        display );
    if( data.m_visualInfo )
        return data.m_visualInfo;

    wxXVisualInfo* vi = new wxXVisualInfo;
    wxFillXVisualInfo( vi, (Display*)display );

    data.m_visualInfo = vi;

    return vi;
}

static void wxTLWidgetDestroyCallback(Widget w, XtPointer WXUNUSED(clientData),
                                      XtPointer WXUNUSED(ptr))
{
    if( wxTheApp )
    {
        wxTheApp->SetTopLevelWidget( (WXDisplay*)XtDisplay(w),
                                     (WXWidget)NULL );
        wxTheApp->SetTopLevelRealizedWidget( (WXDisplay*)XtDisplay(w),
                                             (WXWidget)NULL );
    }
}

WXWidget wxCreateTopLevelWidget( WXDisplay* display )
{
    Widget tlw = XtAppCreateShell( (String)NULL,
                                   wxTheApp->GetClassName().c_str(),
                                   applicationShellWidgetClass,
                                   (Display*)display,
                                   NULL, 0 );
    XtVaSetValues( tlw,
                   XmNoverrideRedirect, True,
                   NULL );

    XtAddCallback( tlw, XmNdestroyCallback,
                   (XtCallbackProc)wxTLWidgetDestroyCallback,
                   (XtPointer)NULL );

    return (WXWidget)tlw;
}

WXWidget wxCreateTopLevelRealizedWidget( WXDisplay* WXUNUSED(display) )
{
    Widget rTlw = XtVaCreateWidget( "dummy_widget", topLevelShellWidgetClass,
                                    (Widget)wxTheApp->GetTopLevelWidget(),
                                     NULL );
    XtSetMappedWhenManaged( rTlw, False );
    XtRealizeWidget( rTlw );

    return (WXWidget)rTlw;
}

WXWidget wxApp::GetTopLevelWidget()
{
    WXDisplay* display = wxGetDisplay();
    wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
                                                        display );
    if( data.m_topLevelWidget )
        return (WXWidget)data.m_topLevelWidget;

    WXWidget tlw = wxCreateTopLevelWidget( display );
    SetTopLevelWidget( display, tlw );

    return tlw;
}

WXWidget wxApp::GetTopLevelRealizedWidget()
{
    WXDisplay* display = wxGetDisplay();
    wxPerDisplayDataMap::iterator it = m_perDisplayData->find( display );

    if( it != m_perDisplayData->end() && it->second->m_topLevelRealizedWidget )
        return (WXWidget)it->second->m_topLevelRealizedWidget;

    WXWidget rTlw = wxCreateTopLevelRealizedWidget( display );
    SetTopLevelRealizedWidget( display, rTlw );

    return rTlw;
}

void wxApp::SetTopLevelWidget(WXDisplay* display, WXWidget widget)
{
    GetOrCreatePerDisplayData( *m_perDisplayData, display )
        .m_topLevelWidget = (Widget)widget;
}

void wxApp::SetTopLevelRealizedWidget(WXDisplay* display, WXWidget widget)
{
    GetOrCreatePerDisplayData( *m_perDisplayData, display )
        .m_topLevelRealizedWidget = (Widget)widget;
}

// Yield to other processes

bool wxApp::Yield(bool onlyIfNeeded)
{
    static bool s_inYield = false;

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

        return false;
    }

    s_inYield = true;

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

    s_inYield = false;

    return true;
}

// ----------------------------------------------------------------------------
// accessors for C modules
// ----------------------------------------------------------------------------

extern "C" XtAppContext wxGetAppContext()
{
    return (XtAppContext)wxTheApp->GetAppContext();
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/motif/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	#ifdef __VMS
	16	#define XtParent XTPARENT
	17	#define XtDisplay XTDISPLAY
	18	#endif
	19
	20	#include "wx/app.h"
	21
	22	#ifndef WX_PRECOMP
	23	#include "wx/hash.h"
	24	#include "wx/intl.h"
	25	#include "wx/log.h"
	26	#include "wx/utils.h"
	27	#include "wx/memory.h"
	28	#include "wx/font.h"
	29	#endif
	30
	31	#include "wx/evtloop.h"
	32
	33	#if wxUSE_THREADS
	34	#include "wx/thread.h"
	35	#endif
	36
	37	#ifdef __VMS__
	38	#pragma message disable nosimpint
	39	#endif
	40	#include <Xm/Xm.h>
	41	#include <X11/Xlib.h>
	42	#include <X11/Xutil.h>
	43	#include <X11/Xresource.h>
	44	#include <X11/Xatom.h>
	45	#ifdef __VMS__
	46	#pragma message enable nosimpint
	47	#endif
	48
	49	#include "wx/motif/private.h"
	50
	51	#include <string.h>
	52
	53	struct wxPerDisplayData
	54	{
	55	wxPerDisplayData()
	56	{
	57	m_visualInfo = NULL;
	58	m_topLevelWidget = NULL;
	59	m_topLevelRealizedWidget = NULL;
	60	}
	61
	62	wxXVisualInfo* m_visualInfo;
	63	Widget m_topLevelWidget, m_topLevelRealizedWidget;
	64	};
	65
	66	static void wxTLWidgetDestroyCallback(Widget w, XtPointer clientData,
	67	XtPointer ptr);
	68	static WXWidget wxCreateTopLevelWidget( WXDisplay* display );
	69
	70	extern bool wxAddIdleCallback();
	71
	72	wxHashTable *wxWidgetHashTable = NULL;
	73
	74	IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
	75
	76	#ifdef __WXDEBUG__
	77	extern "C"
	78	{
	79	typedef int (XErrorHandlerFunc)(Display , XErrorEvent *);
	80	}
	81
	82	XErrorHandlerFunc gs_pfnXErrorHandler = 0;
	83
	84	extern "C"
	85	{
	86
	87	static int wxXErrorHandler(Display dpy, XErrorEvent xevent)
	88	{
	89	// just forward to the default handler for now
	90	return gs_pfnXErrorHandler(dpy, xevent);
	91	}
	92
	93	}
	94	#endif // __WXDEBUG__
	95
	96	bool wxApp::Initialize(int& argcOrig, wxChar **argvOrig)
	97	{
	98	#if wxUSE_INTL
	99	wxFont::SetDefaultEncoding(wxLocale::GetSystemEncoding());
	100	#endif
	101
	102	if ( !wxAppBase::Initialize(argcOrig, argvOrig) )
	103	return false;
	104
	105	wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
	106
	107	return true;
	108	}
	109
	110	void wxApp::CleanUp()
	111	{
	112	wxAppBase::CleanUp();
	113
	114	delete wxWidgetHashTable;
	115	wxWidgetHashTable = NULL;
	116
	117	delete m_mainLoop;
	118
	119	for( wxPerDisplayDataMap::iterator it = m_perDisplayData->begin(),
	120	end = m_perDisplayData->end();
	121	it != end; ++it )
	122	{
	123	delete it->second->m_visualInfo;
	124	// On Solaris 10 calling XtDestroyWidget on the top level widget
	125	// dumps core if the locale is set to something other than "C"
	126	#ifndef __SUN__
	127	XtDestroyWidget( it->second->m_topLevelWidget );
	128	#endif
	129	delete it->second;
	130	}
	131	}
	132
	133	void wxApp::Exit()
	134	{
	135	wxApp::CleanUp();
	136
	137	wxAppConsole::Exit();
	138	}
	139
	140	// ============================================================================
	141	// wxApp
	142	// ============================================================================
	143
	144	wxApp::wxApp()
	145	{
	146	argc = 0;
	147	argv = NULL;
	148
	149	m_mainLoop = new wxEventLoop;
	150	m_mainColormap = (WXColormap) NULL;
	151	m_appContext = (WXAppContext) NULL;
	152	m_initialDisplay = (WXDisplay*) 0;
	153	m_perDisplayData = new wxPerDisplayDataMap;
	154	}
	155
	156	wxApp::~wxApp()
	157	{
	158	delete m_perDisplayData;
	159	}
	160
	161	int wxApp::MainLoop()
	162	{
	163	/*
	164	* Sit around forever waiting to process X-events. Property Change
	165	* event are handled special, because they have to refer to
	166	* the root window rather than to a widget. therefore we can't
	167	* use an Xt-eventhandler.
	168	*/
	169
	170	XSelectInput(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()),
	171	XDefaultRootWindow(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())),
	172	PropertyChangeMask);
	173
	174	m_mainLoop->Run();
	175
	176	return 0;
	177	}
	178
	179	// This should be redefined in a derived class for
	180	// handling property change events for XAtom IPC.
	181	void wxApp::HandlePropertyChange(WXEvent *event)
	182	{
	183	// by default do nothing special
	184	XtDispatchEvent((XEvent) event); / let Motif do the work */
	185	}
	186
	187	static char *fallbackResources[] = {
	188	// better defaults for CDE under Irix
	189	//
	190	// TODO: do something similar for the other systems, the hardcoded defaults
	191	// below are ugly
	192	#ifdef __SGI__
	193	wxMOTIF_STR("*sgiMode: True"),
	194	wxMOTIF_STR("*useSchemes: all"),
	195	#else // !__SGI__
	196	#if !wxMOTIF_USE_RENDER_TABLE
	197	wxMOTIF_STR(".fontList: --helvetica-medium-r-normal---120------"),
	198	#else
	199	wxMOTIF_STR("wxDefaultRendition.fontName: --helvetica-medium-r-normal---120------"),
	200	wxMOTIF_STR("*wxDefaultRendition.fontType: FONT_IS_FONTSET"),
	201	wxMOTIF_STR("*.renderTable: wxDefaultRendition"),
	202	#endif
	203	wxMOTIF_STR("*listBox.background: white"),
	204	wxMOTIF_STR("*text.background: white"),
	205	wxMOTIF_STR("*comboBox.Text.background: white"),
	206	wxMOTIF_STR("*comboBox.List.background: white"),
	207	#endif // __SGI__/!__SGI__
	208	NULL
	209	};
	210
	211	// Create an application context
	212	bool wxApp::OnInitGui()
	213	{
	214	if( !wxAppBase::OnInitGui() )
	215	return false;
	216
	217	#ifdef __HPUX__
	218	// under HP-UX creating XmFontSet fails when the system locale is C and
	219	// we're using a remote DISPLAY, presumably because HP-UX uses its own
	220	// names for C and ISO locales (roman8 and iso8859n respectively) and so
	221	// its Motif libraries have troubles with non-HP X server
	222	//
	223	// whatever the reason, the fact is that without this hack any wxMotif
	224	// program crashes on startup because it can't create any font (HP programs
	225	// still work but they do spit out messages about failing to create font
	226	// sets and failing back on "fixed" font too)
	227	//
	228	// notice that calling setlocale() here is not enough because X(m) init
	229	// functions call setlocale() later so we really have to change environment
	230	bool fixAll = false; // tweak LC_ALL (or just LC_CTYPE)?
	231	const char *loc = getenv("LC_CTYPE");
	232	if ( !loc )
	233	{
	234	loc = getenv("LC_ALL");
	235	if ( loc )
	236	fixAll = true;
	237	}
	238
	239	if ( !loc \|\|
	240	(loc[0] == 'C' && loc[1] == '\0') \|\|
	241	strcmp(loc, "POSIX") == 0 )
	242	{
	243	// we're using C locale, "fix" it
	244	wxLogDebug(_T("HP-UX fontset hack: forcing locale to en_US.iso88591"));
	245	putenv(fixAll ? "LC_ALL=en_US.iso88591" : "LC_CTYPE=en_US.iso88591");
	246	}
	247	#endif // __HPUX__
	248
	249	XtSetLanguageProc(NULL, NULL, NULL);
	250	XtToolkitInitialize() ;
	251	wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext();
	252	XtAppSetFallbackResources((XtAppContext) wxTheApp->m_appContext, fallbackResources);
	253
	254	// we shouldn't pass empty application/class name as it results in
	255	// immediate crash inside XOpenIM() (if XIM is used) under IRIX
	256	wxString appname = wxTheApp->GetAppName();
	257	if ( appname.empty() )
	258	appname = _T("wxapp");
	259	wxString clsname = wxTheApp->GetClassName();
	260	if ( clsname.empty() )
	261	clsname = _T("wx");
	262
	263	// FIXME-UTF8: This code is taken from wxGTK and duplicated here. This
	264	// is just a temporary fix to make wxX11 compile in Unicode
	265	// build, the real fix is to change Initialize()'s signature
	266	// to use char* on Unix.
	267	#if wxUSE_UNICODE
	268	// XtOpenDisplay() wants char, not wchar_t, so convert
	269	int i;
	270	char *argvX11 = new char [argc + 1];
	271	for ( i = 0; i < argc; i++ )
	272	{
	273	argvX11[i] = strdup(wxConvLibc.cWX2MB(argv[i]));
	274	}
	275
	276	argvX11[argc] = NULL;
	277
	278	int argcX11 = argc;
	279
	280	Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,
	281	(String)NULL,
	282	appname.c_str(),
	283	clsname.c_str(),
	284	NULL, 0, // no options
	285	# if XtSpecificationRelease < 5
	286	(Cardinal*) &argcX11,
	287	# else
	288	&argcX11,
	289	# endif
	290	argvX11);
	291
	292	if ( argcX11 != argc )
	293	{
	294	// we have to drop the parameters which were consumed by X11+
	295	for ( i = 0; i < argcX11; i++ )
	296	{
	297	while ( strcmp(wxConvLibc.cWX2MB(argv[i]), argvX11[i]) != 0 )
	298	{
	299	memmove(argv + i, argv + i + 1, (argc - i)sizeof(argv));
	300	}
	301	}
	302
	303	argc = argcX11;
	304	}
	305	//else: XtOpenDisplay() didn't modify our parameters
	306
	307	// free our copy
	308	for ( i = 0; i < argcX11; i++ )
	309	{
	310	free(argvX11[i]);
	311	}
	312
	313	delete [] argvX11;
	314
	315	#else // ANSI
	316
	317	Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,
	318	(String)NULL,
	319	appname.c_str(),
	320	clsname.c_str(),
	321	NULL, 0, // no options
	322	# if XtSpecificationRelease < 5
	323	(Cardinal*) &argc,
	324	# else
	325	&argc,
	326	# endif
	327	argv);
	328
	329	#endif // Unicode/ANSI
	330
	331	if (!dpy) {
	332	// if you don't log to stderr, nothing will be shown...
	333	delete wxLog::SetActiveTarget(new wxLogStderr);
	334	wxString className(wxTheApp->GetClassName());
	335	wxLogError(_("wxWidgets could not open display for '%s': exiting."),
	336	className.c_str());
	337	exit(-1);
	338	}
	339	m_initialDisplay = (WXDisplay*) dpy;
	340
	341	#ifdef __WXDEBUG__
	342	// install the X error handler
	343	gs_pfnXErrorHandler = XSetErrorHandler(wxXErrorHandler);
	344	#endif // __WXDEBUG__
	345
	346	// Add general resize proc
	347	XtActionsRec rec;
	348	rec.string = wxMOTIF_STR("resize");
	349	rec.proc = (XtActionProc)wxWidgetResizeProc;
	350	XtAppAddActions((XtAppContext) wxTheApp->m_appContext, &rec, 1);
	351
	352	GetMainColormap(dpy);
	353
	354	wxAddIdleCallback();
	355
	356	return true;
	357	}
	358
	359	WXColormap wxApp::GetMainColormap(WXDisplay* display)
	360	{
	361	if (!display) /* Must be called first with non-NULL display */
	362	return m_mainColormap;
	363
	364	int defaultScreen = DefaultScreen((Display*) display);
	365	Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);
	366
	367	Colormap c = DefaultColormapOfScreen(screen);
	368
	369	if (!m_mainColormap)
	370	m_mainColormap = (WXColormap) c;
	371
	372	return (WXColormap) c;
	373	}
	374
	375	static inline wxPerDisplayData& GetOrCreatePerDisplayData
	376	( wxPerDisplayDataMap& m, WXDisplay* display )
	377	{
	378	wxPerDisplayDataMap::iterator it = m.find( display );
	379	if( it != m.end() && it->second != NULL )
	380	return *(it->second);
	381
	382	wxPerDisplayData* nData = new wxPerDisplayData();
	383	m[display] = nData;
	384
	385	return *nData;
	386	}
	387
	388	wxXVisualInfo* wxApp::GetVisualInfo( WXDisplay* display )
	389	{
	390	wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
	391	display );
	392	if( data.m_visualInfo )
	393	return data.m_visualInfo;
	394
	395	wxXVisualInfo* vi = new wxXVisualInfo;
	396	wxFillXVisualInfo( vi, (Display*)display );
	397
	398	data.m_visualInfo = vi;
	399
	400	return vi;
	401	}
	402
	403	static void wxTLWidgetDestroyCallback(Widget w, XtPointer WXUNUSED(clientData),
	404	XtPointer WXUNUSED(ptr))
	405	{
	406	if( wxTheApp )
	407	{
	408	wxTheApp->SetTopLevelWidget( (WXDisplay*)XtDisplay(w),
	409	(WXWidget)NULL );
	410	wxTheApp->SetTopLevelRealizedWidget( (WXDisplay*)XtDisplay(w),
	411	(WXWidget)NULL );
	412	}
	413	}
	414
	415	WXWidget wxCreateTopLevelWidget( WXDisplay* display )
	416	{
	417	Widget tlw = XtAppCreateShell( (String)NULL,
	418	wxTheApp->GetClassName().c_str(),
	419	applicationShellWidgetClass,
	420	(Display*)display,
	421	NULL, 0 );
	422	XtVaSetValues( tlw,
	423	XmNoverrideRedirect, True,
	424	NULL );
	425
	426	XtAddCallback( tlw, XmNdestroyCallback,
	427	(XtCallbackProc)wxTLWidgetDestroyCallback,
	428	(XtPointer)NULL );
	429
	430	return (WXWidget)tlw;
	431	}
	432
	433	WXWidget wxCreateTopLevelRealizedWidget( WXDisplay* WXUNUSED(display) )
	434	{
	435	Widget rTlw = XtVaCreateWidget( "dummy_widget", topLevelShellWidgetClass,
	436	(Widget)wxTheApp->GetTopLevelWidget(),
	437	NULL );
	438	XtSetMappedWhenManaged( rTlw, False );
	439	XtRealizeWidget( rTlw );
	440
	441	return (WXWidget)rTlw;
	442	}
	443
	444	WXWidget wxApp::GetTopLevelWidget()
	445	{
	446	WXDisplay* display = wxGetDisplay();
	447	wxPerDisplayData& data = GetOrCreatePerDisplayData( *m_perDisplayData,
	448	display );
	449	if( data.m_topLevelWidget )
	450	return (WXWidget)data.m_topLevelWidget;
	451
	452	WXWidget tlw = wxCreateTopLevelWidget( display );
	453	SetTopLevelWidget( display, tlw );
	454
	455	return tlw;
	456	}
	457
	458	WXWidget wxApp::GetTopLevelRealizedWidget()
	459	{
	460	WXDisplay* display = wxGetDisplay();
	461	wxPerDisplayDataMap::iterator it = m_perDisplayData->find( display );
	462
	463	if( it != m_perDisplayData->end() && it->second->m_topLevelRealizedWidget )
	464	return (WXWidget)it->second->m_topLevelRealizedWidget;
	465
	466	WXWidget rTlw = wxCreateTopLevelRealizedWidget( display );
	467	SetTopLevelRealizedWidget( display, rTlw );
	468
	469	return rTlw;
	470	}
	471
	472	void wxApp::SetTopLevelWidget(WXDisplay* display, WXWidget widget)
	473	{
	474	GetOrCreatePerDisplayData( *m_perDisplayData, display )
	475	.m_topLevelWidget = (Widget)widget;
	476	}
	477
	478	void wxApp::SetTopLevelRealizedWidget(WXDisplay* display, WXWidget widget)
	479	{
	480	GetOrCreatePerDisplayData( *m_perDisplayData, display )
	481	.m_topLevelRealizedWidget = (Widget)widget;
	482	}
	483
	484	// Yield to other processes
	485
	486	bool wxApp::Yield(bool onlyIfNeeded)
	487	{
	488	static bool s_inYield = false;
	489
	490	if ( s_inYield )
	491	{
	492	if ( !onlyIfNeeded )
	493	{
	494	wxFAIL_MSG( wxT("wxYield called recursively" ) );
	495	}
	496
	497	return false;
	498	}
	499
	500	s_inYield = true;
	501
	502	while (wxTheApp && wxTheApp->Pending())
	503	wxTheApp->Dispatch();
	504
	505	s_inYield = false;
	506
	507	return true;
	508	}
	509
	510	// ----------------------------------------------------------------------------
	511	// accessors for C modules
	512	// ----------------------------------------------------------------------------
	513
	514	extern "C" XtAppContext wxGetAppContext()
	515	{
	516	return (XtAppContext)wxTheApp->GetAppContext();
	517	}