src/motif/app.cpp

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

#ifdef __GNUG__
    #pragma implementation "app.h"
#endif

#include "wx/frame.h"
#include "wx/app.h"
#include "wx/utils.h"
#include "wx/gdicmn.h"
#include "wx/pen.h"
#include "wx/brush.h"
#include "wx/cursor.h"
#include "wx/icon.h"
#include "wx/palette.h"
#include "wx/dc.h"
#include "wx/dialog.h"
#include "wx/msgdlg.h"
#include "wx/log.h"
#include "wx/module.h"
#include "wx/memory.h"
#include "wx/log.h"
#include "wx/intl.h"

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

#if wxUSE_WX_RESOURCES
    #include "wx/resource.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>

extern char *wxBuffer;
extern wxList wxPendingDelete;

wxApp *wxTheApp = NULL;

wxHashTable *wxWidgetHashTable = NULL;

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)

BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
    EVT_IDLE(wxApp::OnIdle)
END_EVENT_TABLE()
#endif

long wxApp::sm_lastMessageTime = 0;

bool wxApp::Initialize()
{
    wxBuffer = new char[BUFSIZ + 512];

    wxClassInfo::InitializeClasses();

    // GL: I'm annoyed ... I don't know where to put this and I don't want to
    // create a module for that as it's part of the core.
#if wxUSE_THREADS
    wxPendingEventsLocker = new wxCriticalSection();
#endif

    wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
    wxTheColourDatabase->Initialize();

    wxInitializeStockLists();
    wxInitializeStockObjects();

#if wxUSE_WX_RESOURCES
    wxInitializeResourceSystem();
#endif

    // For PostScript printing
#if wxUSE_POSTSCRIPT
    /* Done using wxModule now
    wxInitializePrintSetupData();
    wxThePrintPaperDatabase = new wxPrintPaperDatabase;
    wxThePrintPaperDatabase->CreateDatabase();
    */
#endif

    wxBitmap::InitStandardHandlers();

    wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);

    wxModule::RegisterModules();
    if (!wxModule::InitializeModules()) return FALSE;

    return TRUE;
}

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

    wxModule::CleanUpModules();

#if wxUSE_WX_RESOURCES
    wxCleanUpResourceSystem();
#endif

    wxDeleteStockObjects() ;

    // Destroy all GDI lists, etc.

    delete wxTheBrushList;
    wxTheBrushList = NULL;

    delete wxThePenList;
    wxThePenList = NULL;

    delete wxTheFontList;
    wxTheFontList = NULL;

    delete wxTheBitmapList;
    wxTheBitmapList = NULL;

    delete wxTheColourDatabase;
    wxTheColourDatabase = NULL;

#if wxUSE_POSTSCRIPT
    /* Done using wxModule now
    wxInitializePrintSetupData(FALSE);
    delete wxThePrintPaperDatabase;
    wxThePrintPaperDatabase = NULL;
    */
#endif

    wxBitmap::CleanUpHandlers();

    delete[] wxBuffer;
    wxBuffer = NULL;

    wxClassInfo::CleanUpClasses();

    delete wxTheApp;
    wxTheApp = NULL;

    // GL: I'm annoyed ... I don't know where to put this and I don't want to
    // create a module for that as it's part of the core.
#if wxUSE_THREADS
    delete wxPendingEvents;
    delete wxPendingEventsLocker;
#endif

#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
    // At this point we want to check if there are any memory
    // blocks that aren't part of the wxDebugContext itself,
    // as a special case. Then when dumping we need to ignore
    // wxDebugContext, too.
    if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
    {
        wxLogDebug("There were memory leaks.\n");
        wxDebugContext::Dump();
        wxDebugContext::PrintStatistics();
    }
#endif

    // do it as the very last thing because everything else can log messages
    wxLog::DontCreateOnDemand();
    // do it as the very last thing because everything else can log messages
    delete wxLog::SetActiveTarget(NULL);
}

int wxEntry( int argc, char *argv[] )
{
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
    // This seems to be necessary since there are 'rogue'
    // objects present at this point (perhaps global objects?)
    // Setting a checkpoint will ignore them as far as the
    // memory checking facility is concerned.
    // Of course you may argue that memory allocated in globals should be
    // checked, but this is a reasonable compromise.
    wxDebugContext::SetCheckpoint();
#endif

    if (!wxApp::Initialize())
        return FALSE;

    if (!wxTheApp)
    {
        if (!wxApp::GetInitializerFunction())
        {
            printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" );
            return 0;
        };

        wxTheApp = (wxApp*) (* wxApp::GetInitializerFunction()) ();
    };

    if (!wxTheApp)
    {
        printf( "wxWindows error: wxTheApp == NULL\n" );
        return 0;
    };

    wxTheApp->SetClassName(wxFileNameFromPath(argv[0]));
    wxTheApp->SetAppName(wxFileNameFromPath(argv[0]));

    wxTheApp->argc = argc;
    wxTheApp->argv = argv;

    // GUI-specific initialization, such as creating an app context.
    wxTheApp->OnInitGui();

    // Here frames insert themselves automatically into wxTopLevelWindows by
    // getting created in OnInit().

    int retValue = 0;
    if (wxTheApp->OnInit())
    {
        if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
    }

    // flush the logged messages if any
    wxLog *pLog = wxLog::GetActiveTarget();
    if ( pLog != NULL && pLog->HasPendingMessages() )
        pLog->Flush();

    delete wxLog::SetActiveTarget(new wxLogStderr); // So dialog boxes aren't used
    // for further messages

    if (wxTheApp->GetTopWindow())
    {
        delete wxTheApp->GetTopWindow();
        wxTheApp->SetTopWindow(NULL);
    }

    wxTheApp->DeletePendingObjects();

    wxTheApp->OnExit();

    wxApp::CleanUp();

    return retValue;
};

// Static member initialization
wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;

wxApp::wxApp()
{
    m_topWindow = NULL;
    wxTheApp = this;
    m_className = "";
    m_wantDebugOutput = TRUE ;
    m_appName = "";
    argc = 0;
    argv = NULL;
    m_exitOnFrameDelete = TRUE;

    m_mainColormap = (WXColormap) NULL;
    m_appContext = (WXAppContext) NULL;
    m_topLevelWidget = (WXWidget) NULL;
    m_maxRequestSize = 0;
    m_initialDisplay = (WXDisplay*) 0;
}

bool wxApp::Initialized()
{
    if (GetTopWindow())
        return TRUE;
    else
        return FALSE;
}

int wxApp::MainLoop()
{
    m_keepGoing = TRUE;

    /*
    * 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);

    XEvent event;

    // Use this flag to allow breaking the loop via wxApp::ExitMainLoop()
    while (m_keepGoing)
    {
        XtAppNextEvent( (XtAppContext) wxTheApp->GetAppContext(), &event);

        ProcessXEvent((WXEvent*) & event);

        if (XtAppPending( (XtAppContext) wxTheApp->GetAppContext() ) == 0)
        {
            if (!ProcessIdle())
            {
#if wxUSE_THREADS
                // leave the main loop to give other threads a chance to
                // perform their GUI work
                wxMutexGuiLeave();
                wxUsleep(20);
                wxMutexGuiEnter();
#endif
            }
        }

    }

    return 0;
}

// Processes an X event.
void wxApp::ProcessXEvent(WXEvent* _event)
{
    XEvent* event = (XEvent*) _event;

    if (event->type == KeyPress)
    {
#ifdef __WXDEBUG__
        Widget widget = XtWindowToWidget(event->xany.display, event->xany.window);
        wxLogDebug("Got key press event for 0x%08x (parent = 0x%08x)",
                   widget, XtParent(widget));
#endif // DEBUG

	if (CheckForAccelerator(_event))
	{
            // Do nothing! We intercepted and processed the event as an
            // accelerator.
            return;
	}
#if 1
        // It seemed before that this hack was redundant and
        // key down events were being generated by wxCanvasInputEvent.
        // But no longer - why ???
        //
	else if (CheckForKeyDown(_event))
	{
            // We intercepted and processed the key down event
            return;
	}
#endif
	else
	{
            XtDispatchEvent(event);
	    return;
	}
    }
    else if (event->type == KeyRelease)
    {
        // TODO: work out why we still need this !  -michael
        //
        if (CheckForKeyUp(_event))
	{
	    // We intercepted and processed the key up event
	    return;
	}
	else
	{
	    XtDispatchEvent(event);
	    return;
	}
    }
    else if (event->type == PropertyNotify)
    {
        HandlePropertyChange(_event);
        return;
    }
    else if (event->type == ResizeRequest)
    {
        /* Terry Gitnick <terryg@scientech.com> - 1/21/98
         * If resize event, don't resize until the last resize event for this
         * window is recieved. Prevents flicker as windows are resized.
         */

        Display *disp = XtDisplay((Widget) wxTheApp->GetTopLevelWidget());
        Window win = event->xany.window;
        XEvent report;

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

        // TODO: when implementing refresh optimization, we can use
        // XtAddExposureToRegion to expand the window's paint region.

        XtDispatchEvent(event);
    }
    else
    {
        XtDispatchEvent(event);
    }
}

// Returns TRUE if more time is needed.
bool wxApp::ProcessIdle()
{
    wxIdleEvent event;
    event.SetEventObject(this);
    ProcessEvent(event);

    return event.MoreRequested();
}

void wxApp::ExitMainLoop()
{
    m_keepGoing = FALSE;
}

// Is a message/event pending?
bool wxApp::Pending()
{
    XFlush(XtDisplay( (Widget) wxTheApp->GetTopLevelWidget() ));

    // Fix by Doug from STI, to prevent a stall if non-X event
    // is found.
    return ((XtAppPending( (XtAppContext) GetAppContext() ) & XtIMXEvent) != 0) ;
}

// Dispatch a message.
void wxApp::Dispatch()
{
    //    XtAppProcessEvent( (XtAppContext) wxTheApp->GetAppContext(), XtIMAll);

    XEvent event;
    XtAppNextEvent((XtAppContext) GetAppContext(), &event);
    ProcessXEvent((WXEvent*) & event);
}

// 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 */
}

void wxApp::OnIdle(wxIdleEvent& event)
{
    static bool inOnIdle = FALSE;

    // Avoid recursion (via ProcessEvent default case)
    if (inOnIdle)
        return;

    inOnIdle = TRUE;

    // 'Garbage' collection of windows deleted with Close().
    DeletePendingObjects();

#if wxUSE_THREADS
    // Flush pending events.
    ProcessPendingEvents();
#endif

    // flush the logged messages if any
    wxLog *pLog = wxLog::GetActiveTarget();
    if ( pLog != NULL && pLog->HasPendingMessages() )
        pLog->Flush();

    // Send OnIdle events to all windows
    bool needMore = SendIdleEvents();

    if (needMore)
        event.RequestMore(TRUE);

    inOnIdle = FALSE;
}

void wxWakeUpIdle()
{
    // **** please implement me! ****
    // Wake up the idle handler processor, even if it is in another thread...
}


// Send idle event to all top-level windows
bool wxApp::SendIdleEvents()
{
    bool needMore = FALSE;

    wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
    while (node)
    {
        wxWindow* win = node->GetData();
        if (SendIdleEvents(win))
            needMore = TRUE;
        node = node->GetNext();
    }

    return needMore;
}

// Send idle event to window and all subwindows
bool wxApp::SendIdleEvents(wxWindow* win)
{
    bool needMore = FALSE;

    wxIdleEvent event;
    event.SetEventObject(win);
    win->ProcessEvent(event);

    if (event.MoreRequested())
        needMore = TRUE;

    wxNode* node = win->GetChildren().First();
    while (node)
    {
        wxWindow* win = (wxWindow*) node->Data();
        if (SendIdleEvents(win))
            needMore = TRUE;

        node = node->Next();
    }
    return needMore ;
}

void wxApp::DeletePendingObjects()
{
    wxNode *node = wxPendingDelete.First();
    while (node)
    {
        wxObject *obj = (wxObject *)node->Data();

        delete obj;

        if (wxPendingDelete.Member(obj))
            delete node;

        // Deleting one object may have deleted other pending
        // objects, so start from beginning of list again.
        node = wxPendingDelete.First();
    }
}

// Create an application context
bool wxApp::OnInitGui()
{
    XtToolkitInitialize() ;
    wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext() ;
    Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,(String)NULL,NULL,
        (const char*) wxTheApp->GetClassName(), NULL, 0,
# if XtSpecificationRelease < 5
        (Cardinal*) &argc,
# else
        &argc,
# endif
        argv);

    if (!dpy) {
        wxString className(wxTheApp->GetClassName());
        wxLogError(_("wxWindows could not open display for '%s': exiting."),
                   (const char*) className);
        exit(-1);
    }
    m_initialDisplay = (WXDisplay*) dpy;

    wxTheApp->m_topLevelWidget = (WXWidget) XtAppCreateShell((String)NULL, (const char*) wxTheApp->GetClassName(),
        applicationShellWidgetClass,dpy,
        NULL,0) ;

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

    GetMainColormap(dpy);
    m_maxRequestSize = XMaxRequestSize((Display*) dpy);

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

// Returns TRUE if an accelerator has been processed
bool wxApp::CheckForAccelerator(WXEvent* event)
{
    XEvent* xEvent = (XEvent*) event;
    if (xEvent->xany.type == KeyPress)
    {
        // Find a wxWindow for this window
        // TODO: should get display for the window, not the current display
        Widget widget = XtWindowToWidget((Display*) wxGetDisplay(), xEvent->xany.window);
        wxWindow* win = NULL;

        // Find the first wxWindow that corresponds to this event window
        while (widget && !(win = wxGetWindowFromTable(widget)))
            widget = XtParent(widget);

        if (!widget || !win)
            return FALSE;

        wxKeyEvent keyEvent(wxEVT_CHAR);
        wxTranslateKeyEvent(keyEvent, win, (Widget) 0, xEvent);

        // Now we have a wxKeyEvent and we have a wxWindow.
        // Go up the hierarchy until we find a matching accelerator,
        // or we get to the top.
        while (win)
        {
            if (win->ProcessAccelerator(keyEvent))
                return TRUE;
            win = win->GetParent();
        }
        return FALSE;
    }
    return FALSE;
}

bool wxApp::CheckForKeyDown(WXEvent* event)
{
    XEvent* xEvent = (XEvent*) event;
    if (xEvent->xany.type == KeyPress)
    {
        Widget widget = XtWindowToWidget((Display*) wxGetDisplay(),
					 xEvent->xany.window);
	wxWindow* win = NULL;

	// Find the first wxWindow that corresponds to this event window
	while (widget && !(win = wxGetWindowFromTable(widget)))
            widget = XtParent(widget);

	if (!widget || !win)
            return FALSE;

	wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
	wxTranslateKeyEvent(keyEvent, win, (Widget) 0, xEvent);

	return win->ProcessEvent( keyEvent );
    }

    return FALSE;
}

bool wxApp::CheckForKeyUp(WXEvent* event)
{
    XEvent* xEvent = (XEvent*) event;
    if (xEvent->xany.type == KeyRelease)
    {
        Widget widget = XtWindowToWidget((Display*) wxGetDisplay(),
					 xEvent->xany.window);
	wxWindow* win = NULL;

	// Find the first wxWindow that corresponds to this event window
	while (widget && !(win = wxGetWindowFromTable(widget)))
            widget = XtParent(widget);

	if (!widget || !win)
            return FALSE;

	wxKeyEvent keyEvent(wxEVT_KEY_UP);
	wxTranslateKeyEvent(keyEvent, win, (Widget) 0, xEvent);

	return win->ProcessEvent( keyEvent );
    }

    return FALSE;
}

void wxExit()
{
    int retValue = 0;
    if (wxTheApp)
        retValue = wxTheApp->OnExit();

    wxApp::CleanUp();
    /*
    * Exit in some platform-specific way. Not recommended that the app calls this:
    * only for emergencies.
    */
    exit(retValue);
}

// Yield to other processes
bool wxYield()
{
    while (wxTheApp && wxTheApp->Pending())
        wxTheApp->Dispatch();

    // VZ: is it the same as this (taken from old wxExecute)?
#if 0
    XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMAll);
#endif

    return TRUE;
}

// TODO use XmGetPixmap (?) to get the really standard icons!

#include "wx/generic/info.xpm"
#include "wx/generic/error.xpm"
#include "wx/generic/question.xpm"
#include "wx/generic/warning.xpm"

wxIcon
wxApp::GetStdIcon(int which) const
{
    switch(which)
    {
        case wxICON_INFORMATION:
            return wxIcon(info_xpm);

        case wxICON_QUESTION:
            return wxIcon(question_xpm);

        case wxICON_EXCLAMATION:
            return wxIcon(warning_xpm);

        default:
            wxFAIL_MSG("requested non existent standard icon");
            // still fall through

        case wxICON_HAND:
            return wxIcon(error_xpm);
    }
}

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

extern "C" XtAppContext wxGetAppContext()
{
    return (XtAppContext)wxTheApp->GetAppContext();
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: app.cpp
	3	// Purpose: wxApp
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 17/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "app.h"
	14	#endif
	15
	16	#include "wx/frame.h"
	17	#include "wx/app.h"
	18	#include "wx/utils.h"
	19	#include "wx/gdicmn.h"
	20	#include "wx/pen.h"
	21	#include "wx/brush.h"
	22	#include "wx/cursor.h"
	23	#include "wx/icon.h"
	24	#include "wx/palette.h"
	25	#include "wx/dc.h"
	26	#include "wx/dialog.h"
	27	#include "wx/msgdlg.h"
	28	#include "wx/log.h"
	29	#include "wx/module.h"
	30	#include "wx/memory.h"
	31	#include "wx/log.h"
	32	#include "wx/intl.h"
	33
	34	#if wxUSE_THREADS
	35	#include "wx/thread.h"
	36	#endif
	37
	38	#if wxUSE_WX_RESOURCES
	39	#include "wx/resource.h"
	40	#endif
	41
	42	#ifdef __VMS__
	43	#pragma message disable nosimpint
	44	#endif
	45	#include <Xm/Xm.h>
	46	#include <X11/Xlib.h>
	47	#include <X11/Xutil.h>
	48	#include <X11/Xresource.h>
	49	#include <X11/Xatom.h>
	50	#ifdef __VMS__
	51	#pragma message enable nosimpint
	52	#endif
	53
	54	#include "wx/motif/private.h"
	55
	56	#include <string.h>
	57
	58	extern char *wxBuffer;
	59	extern wxList wxPendingDelete;
	60
	61	wxApp *wxTheApp = NULL;
	62
	63	wxHashTable *wxWidgetHashTable = NULL;
	64
	65	#if !USE_SHARED_LIBRARY
	66	IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler)
	67
	68	BEGIN_EVENT_TABLE(wxApp, wxEvtHandler)
	69	EVT_IDLE(wxApp::OnIdle)
	70	END_EVENT_TABLE()
	71	#endif
	72
	73	long wxApp::sm_lastMessageTime = 0;
	74
	75	bool wxApp::Initialize()
	76	{
	77	wxBuffer = new char[BUFSIZ + 512];
	78
	79	wxClassInfo::InitializeClasses();
	80
	81	// GL: I'm annoyed ... I don't know where to put this and I don't want to
	82	// create a module for that as it's part of the core.
	83	#if wxUSE_THREADS
	84	wxPendingEventsLocker = new wxCriticalSection();
	85	#endif
	86
	87	wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
	88	wxTheColourDatabase->Initialize();
	89
	90	wxInitializeStockLists();
	91	wxInitializeStockObjects();
	92
	93	#if wxUSE_WX_RESOURCES
	94	wxInitializeResourceSystem();
	95	#endif
	96
	97	// For PostScript printing
	98	#if wxUSE_POSTSCRIPT
	99	/* Done using wxModule now
	100	wxInitializePrintSetupData();
	101	wxThePrintPaperDatabase = new wxPrintPaperDatabase;
	102	wxThePrintPaperDatabase->CreateDatabase();
	103	*/
	104	#endif
	105
	106	wxBitmap::InitStandardHandlers();
	107
	108	wxWidgetHashTable = new wxHashTable(wxKEY_INTEGER);
	109
	110	wxModule::RegisterModules();
	111	if (!wxModule::InitializeModules()) return FALSE;
	112
	113	return TRUE;
	114	}
	115
	116	void wxApp::CleanUp()
	117	{
	118	delete wxWidgetHashTable;
	119	wxWidgetHashTable = NULL;
	120
	121	wxModule::CleanUpModules();
	122
	123	#if wxUSE_WX_RESOURCES
	124	wxCleanUpResourceSystem();
	125	#endif
	126
	127	wxDeleteStockObjects() ;
	128
	129	// Destroy all GDI lists, etc.
	130
	131	delete wxTheBrushList;
	132	wxTheBrushList = NULL;
	133
	134	delete wxThePenList;
	135	wxThePenList = NULL;
	136
	137	delete wxTheFontList;
	138	wxTheFontList = NULL;
	139
	140	delete wxTheBitmapList;
	141	wxTheBitmapList = NULL;
	142
	143	delete wxTheColourDatabase;
	144	wxTheColourDatabase = NULL;
	145
	146	#if wxUSE_POSTSCRIPT
	147	/* Done using wxModule now
	148	wxInitializePrintSetupData(FALSE);
	149	delete wxThePrintPaperDatabase;
	150	wxThePrintPaperDatabase = NULL;
	151	*/
	152	#endif
	153
	154	wxBitmap::CleanUpHandlers();
	155
	156	delete[] wxBuffer;
	157	wxBuffer = NULL;
	158
	159	wxClassInfo::CleanUpClasses();
	160
	161	delete wxTheApp;
	162	wxTheApp = NULL;
	163
	164	// GL: I'm annoyed ... I don't know where to put this and I don't want to
	165	// create a module for that as it's part of the core.
	166	#if wxUSE_THREADS
	167	delete wxPendingEvents;
	168	delete wxPendingEventsLocker;
	169	#endif
	170
	171	#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) \|\| wxUSE_DEBUG_CONTEXT
	172	// At this point we want to check if there are any memory
	173	// blocks that aren't part of the wxDebugContext itself,
	174	// as a special case. Then when dumping we need to ignore
	175	// wxDebugContext, too.
	176	if (wxDebugContext::CountObjectsLeft(TRUE) > 0)
	177	{
	178	wxLogDebug("There were memory leaks.\n");
	179	wxDebugContext::Dump();
	180	wxDebugContext::PrintStatistics();
	181	}
	182	#endif
	183
	184	// do it as the very last thing because everything else can log messages
	185	wxLog::DontCreateOnDemand();
	186	// do it as the very last thing because everything else can log messages
	187	delete wxLog::SetActiveTarget(NULL);
	188	}
	189
	190	int wxEntry( int argc, char *argv[] )
	191	{
	192	#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) \|\| wxUSE_DEBUG_CONTEXT
	193	// This seems to be necessary since there are 'rogue'
	194	// objects present at this point (perhaps global objects?)
	195	// Setting a checkpoint will ignore them as far as the
	196	// memory checking facility is concerned.
	197	// Of course you may argue that memory allocated in globals should be
	198	// checked, but this is a reasonable compromise.
	199	wxDebugContext::SetCheckpoint();
	200	#endif
	201
	202	if (!wxApp::Initialize())
	203	return FALSE;
	204
	205	if (!wxTheApp)
	206	{
	207	if (!wxApp::GetInitializerFunction())
	208	{
	209	printf( "wxWindows error: No initializer - use IMPLEMENT_APP macro.\n" );
	210	return 0;
	211	};
	212
	213	wxTheApp = (wxApp) ( wxApp::GetInitializerFunction()) ();
	214	};
	215
	216	if (!wxTheApp)
	217	{
	218	printf( "wxWindows error: wxTheApp == NULL\n" );
	219	return 0;
	220	};
	221
	222	wxTheApp->SetClassName(wxFileNameFromPath(argv[0]));
	223	wxTheApp->SetAppName(wxFileNameFromPath(argv[0]));
	224
	225	wxTheApp->argc = argc;
	226	wxTheApp->argv = argv;
	227
	228	// GUI-specific initialization, such as creating an app context.
	229	wxTheApp->OnInitGui();
	230
	231	// Here frames insert themselves automatically into wxTopLevelWindows by
	232	// getting created in OnInit().
	233
	234	int retValue = 0;
	235	if (wxTheApp->OnInit())
	236	{
	237	if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
	238	}
	239
	240	// flush the logged messages if any
	241	wxLog *pLog = wxLog::GetActiveTarget();
	242	if ( pLog != NULL && pLog->HasPendingMessages() )
	243	pLog->Flush();
	244
	245	delete wxLog::SetActiveTarget(new wxLogStderr); // So dialog boxes aren't used
	246	// for further messages
	247
	248	if (wxTheApp->GetTopWindow())
	249	{
	250	delete wxTheApp->GetTopWindow();
	251	wxTheApp->SetTopWindow(NULL);
	252	}
	253
	254	wxTheApp->DeletePendingObjects();
	255
	256	wxTheApp->OnExit();
	257
	258	wxApp::CleanUp();
	259
	260	return retValue;
	261	};
	262
	263	// Static member initialization
	264	wxAppInitializerFunction wxAppBase::m_appInitFn = (wxAppInitializerFunction) NULL;
	265
	266	wxApp::wxApp()
	267	{
	268	m_topWindow = NULL;
	269	wxTheApp = this;
	270	m_className = "";
	271	m_wantDebugOutput = TRUE ;
	272	m_appName = "";
	273	argc = 0;
	274	argv = NULL;
	275	m_exitOnFrameDelete = TRUE;
	276
	277	m_mainColormap = (WXColormap) NULL;
	278	m_appContext = (WXAppContext) NULL;
	279	m_topLevelWidget = (WXWidget) NULL;
	280	m_maxRequestSize = 0;
	281	m_initialDisplay = (WXDisplay*) 0;
	282	}
	283
	284	bool wxApp::Initialized()
	285	{
	286	if (GetTopWindow())
	287	return TRUE;
	288	else
	289	return FALSE;
	290	}
	291
	292	int wxApp::MainLoop()
	293	{
	294	m_keepGoing = TRUE;
	295
	296	/*
	297	* Sit around forever waiting to process X-events. Property Change
	298	* event are handled special, because they have to refer to
	299	* the root window rather than to a widget. therefore we can't
	300	* use an Xt-eventhandler.
	301	*/
	302
	303	XSelectInput(XtDisplay((Widget) wxTheApp->GetTopLevelWidget()),
	304	XDefaultRootWindow(XtDisplay((Widget) wxTheApp->GetTopLevelWidget())),
	305	PropertyChangeMask);
	306
	307	XEvent event;
	308
	309	// Use this flag to allow breaking the loop via wxApp::ExitMainLoop()
	310	while (m_keepGoing)
	311	{
	312	XtAppNextEvent( (XtAppContext) wxTheApp->GetAppContext(), &event);
	313
	314	ProcessXEvent((WXEvent*) & event);
	315
	316	if (XtAppPending( (XtAppContext) wxTheApp->GetAppContext() ) == 0)
	317	{
	318	if (!ProcessIdle())
	319	{
	320	#if wxUSE_THREADS
	321	// leave the main loop to give other threads a chance to
	322	// perform their GUI work
	323	wxMutexGuiLeave();
	324	wxUsleep(20);
	325	wxMutexGuiEnter();
	326	#endif
	327	}
	328	}
	329
	330	}
	331
	332	return 0;
	333	}
	334
	335	// Processes an X event.
	336	void wxApp::ProcessXEvent(WXEvent* _event)
	337	{
	338	XEvent* event = (XEvent*) _event;
	339
	340	if (event->type == KeyPress)
	341	{
	342	#ifdef __WXDEBUG__
	343	Widget widget = XtWindowToWidget(event->xany.display, event->xany.window);
	344	wxLogDebug("Got key press event for 0x%08x (parent = 0x%08x)",
	345	widget, XtParent(widget));
	346	#endif // DEBUG
	347
	348	if (CheckForAccelerator(_event))
	349	{
	350	// Do nothing! We intercepted and processed the event as an
	351	// accelerator.
	352	return;
	353	}
	354	#if 1
	355	// It seemed before that this hack was redundant and
	356	// key down events were being generated by wxCanvasInputEvent.
	357	// But no longer - why ???
	358	//
	359	else if (CheckForKeyDown(_event))
	360	{
	361	// We intercepted and processed the key down event
	362	return;
	363	}
	364	#endif
	365	else
	366	{
	367	XtDispatchEvent(event);
	368	return;
	369	}
	370	}
	371	else if (event->type == KeyRelease)
	372	{
	373	// TODO: work out why we still need this ! -michael
	374	//
	375	if (CheckForKeyUp(_event))
	376	{
	377	// We intercepted and processed the key up event
	378	return;
	379	}
	380	else
	381	{
	382	XtDispatchEvent(event);
	383	return;
	384	}
	385	}
	386	else if (event->type == PropertyNotify)
	387	{
	388	HandlePropertyChange(_event);
	389	return;
	390	}
	391	else if (event->type == ResizeRequest)
	392	{
	393	/* Terry Gitnick <terryg@scientech.com> - 1/21/98
	394	* If resize event, don't resize until the last resize event for this
	395	* window is recieved. Prevents flicker as windows are resized.
	396	*/
	397
	398	Display *disp = XtDisplay((Widget) wxTheApp->GetTopLevelWidget());
	399	Window win = event->xany.window;
	400	XEvent report;
	401
	402	// to avoid flicker
	403	report = * event;
	404	while( XCheckTypedWindowEvent (disp, win, ResizeRequest, &report));
	405
	406	// TODO: when implementing refresh optimization, we can use
	407	// XtAddExposureToRegion to expand the window's paint region.
	408
	409	XtDispatchEvent(event);
	410	}
	411	else
	412	{
	413	XtDispatchEvent(event);
	414	}
	415	}
	416
	417	// Returns TRUE if more time is needed.
	418	bool wxApp::ProcessIdle()
	419	{
	420	wxIdleEvent event;
	421	event.SetEventObject(this);
	422	ProcessEvent(event);
	423
	424	return event.MoreRequested();
	425	}
	426
	427	void wxApp::ExitMainLoop()
	428	{
	429	m_keepGoing = FALSE;
	430	}
	431
	432	// Is a message/event pending?
	433	bool wxApp::Pending()
	434	{
	435	XFlush(XtDisplay( (Widget) wxTheApp->GetTopLevelWidget() ));
	436
	437	// Fix by Doug from STI, to prevent a stall if non-X event
	438	// is found.
	439	return ((XtAppPending( (XtAppContext) GetAppContext() ) & XtIMXEvent) != 0) ;
	440	}
	441
	442	// Dispatch a message.
	443	void wxApp::Dispatch()
	444	{
	445	// XtAppProcessEvent( (XtAppContext) wxTheApp->GetAppContext(), XtIMAll);
	446
	447	XEvent event;
	448	XtAppNextEvent((XtAppContext) GetAppContext(), &event);
	449	ProcessXEvent((WXEvent*) & event);
	450	}
	451
	452	// This should be redefined in a derived class for
	453	// handling property change events for XAtom IPC.
	454	void wxApp::HandlePropertyChange(WXEvent *event)
	455	{
	456	// by default do nothing special
	457	XtDispatchEvent((XEvent) event); / let Motif do the work */
	458	}
	459
	460	void wxApp::OnIdle(wxIdleEvent& event)
	461	{
	462	static bool inOnIdle = FALSE;
	463
	464	// Avoid recursion (via ProcessEvent default case)
	465	if (inOnIdle)
	466	return;
	467
	468	inOnIdle = TRUE;
	469
	470	// 'Garbage' collection of windows deleted with Close().
	471	DeletePendingObjects();
	472
	473	#if wxUSE_THREADS
	474	// Flush pending events.
	475	ProcessPendingEvents();
	476	#endif
	477
	478	// flush the logged messages if any
	479	wxLog *pLog = wxLog::GetActiveTarget();
	480	if ( pLog != NULL && pLog->HasPendingMessages() )
	481	pLog->Flush();
	482
	483	// Send OnIdle events to all windows
	484	bool needMore = SendIdleEvents();
	485
	486	if (needMore)
	487	event.RequestMore(TRUE);
	488
	489	inOnIdle = FALSE;
	490	}
	491
	492	void wxWakeUpIdle()
	493	{
	494	// ** please implement me! **
	495	// Wake up the idle handler processor, even if it is in another thread...
	496	}
	497
	498
	499	// Send idle event to all top-level windows
	500	bool wxApp::SendIdleEvents()
	501	{
	502	bool needMore = FALSE;
	503
	504	wxWindowList::Node* node = wxTopLevelWindows.GetFirst();
	505	while (node)
	506	{
	507	wxWindow* win = node->GetData();
	508	if (SendIdleEvents(win))
	509	needMore = TRUE;
	510	node = node->GetNext();
	511	}
	512
	513	return needMore;
	514	}
	515
	516	// Send idle event to window and all subwindows
	517	bool wxApp::SendIdleEvents(wxWindow* win)
	518	{
	519	bool needMore = FALSE;
	520
	521	wxIdleEvent event;
	522	event.SetEventObject(win);
	523	win->ProcessEvent(event);
	524
	525	if (event.MoreRequested())
	526	needMore = TRUE;
	527
	528	wxNode* node = win->GetChildren().First();
	529	while (node)
	530	{
	531	wxWindow* win = (wxWindow*) node->Data();
	532	if (SendIdleEvents(win))
	533	needMore = TRUE;
	534
	535	node = node->Next();
	536	}
	537	return needMore ;
	538	}
	539
	540	void wxApp::DeletePendingObjects()
	541	{
	542	wxNode *node = wxPendingDelete.First();
	543	while (node)
	544	{
	545	wxObject obj = (wxObject )node->Data();
	546
	547	delete obj;
	548
	549	if (wxPendingDelete.Member(obj))
	550	delete node;
	551
	552	// Deleting one object may have deleted other pending
	553	// objects, so start from beginning of list again.
	554	node = wxPendingDelete.First();
	555	}
	556	}
	557
	558	// Create an application context
	559	bool wxApp::OnInitGui()
	560	{
	561	XtToolkitInitialize() ;
	562	wxTheApp->m_appContext = (WXAppContext) XtCreateApplicationContext() ;
	563	Display *dpy = XtOpenDisplay((XtAppContext) wxTheApp->m_appContext,(String)NULL,NULL,
	564	(const char*) wxTheApp->GetClassName(), NULL, 0,
	565	# if XtSpecificationRelease < 5
	566	(Cardinal*) &argc,
	567	# else
	568	&argc,
	569	# endif
	570	argv);
	571
	572	if (!dpy) {
	573	wxString className(wxTheApp->GetClassName());
	574	wxLogError(_("wxWindows could not open display for '%s': exiting."),
	575	(const char*) className);
	576	exit(-1);
	577	}
	578	m_initialDisplay = (WXDisplay*) dpy;
	579
	580	wxTheApp->m_topLevelWidget = (WXWidget) XtAppCreateShell((String)NULL, (const char*) wxTheApp->GetClassName(),
	581	applicationShellWidgetClass,dpy,
	582	NULL,0) ;
	583
	584	// Add general resize proc
	585	XtActionsRec rec;
	586	rec.string = "resize";
	587	rec.proc = (XtActionProc)wxWidgetResizeProc;
	588	XtAppAddActions((XtAppContext) wxTheApp->m_appContext, &rec, 1);
	589
	590	GetMainColormap(dpy);
	591	m_maxRequestSize = XMaxRequestSize((Display*) dpy);
	592
	593	return TRUE;
	594	}
	595
	596	WXColormap wxApp::GetMainColormap(WXDisplay* display)
	597	{
	598	if (!display) /* Must be called first with non-NULL display */
	599	return m_mainColormap;
	600
	601	int defaultScreen = DefaultScreen((Display*) display);
	602	Screen* screen = XScreenOfDisplay((Display*) display, defaultScreen);
	603
	604	Colormap c = DefaultColormapOfScreen(screen);
	605
	606	if (!m_mainColormap)
	607	m_mainColormap = (WXColormap) c;
	608
	609	return (WXColormap) c;
	610	}
	611
	612	// Returns TRUE if an accelerator has been processed
	613	bool wxApp::CheckForAccelerator(WXEvent* event)
	614	{
	615	XEvent* xEvent = (XEvent*) event;
	616	if (xEvent->xany.type == KeyPress)
	617	{
	618	// Find a wxWindow for this window
	619	// TODO: should get display for the window, not the current display
	620	Widget widget = XtWindowToWidget((Display*) wxGetDisplay(), xEvent->xany.window);
	621	wxWindow* win = NULL;
	622
	623	// Find the first wxWindow that corresponds to this event window
	624	while (widget && !(win = wxGetWindowFromTable(widget)))
	625	widget = XtParent(widget);
	626
	627	if (!widget \|\| !win)
	628	return FALSE;
	629
	630	wxKeyEvent keyEvent(wxEVT_CHAR);
	631	wxTranslateKeyEvent(keyEvent, win, (Widget) 0, xEvent);
	632
	633	// Now we have a wxKeyEvent and we have a wxWindow.
	634	// Go up the hierarchy until we find a matching accelerator,
	635	// or we get to the top.
	636	while (win)
	637	{
	638	if (win->ProcessAccelerator(keyEvent))
	639	return TRUE;
	640	win = win->GetParent();
	641	}
	642	return FALSE;
	643	}
	644	return FALSE;
	645	}
	646
	647	bool wxApp::CheckForKeyDown(WXEvent* event)
	648	{
	649	XEvent* xEvent = (XEvent*) event;
	650	if (xEvent->xany.type == KeyPress)
	651	{
	652	Widget widget = XtWindowToWidget((Display*) wxGetDisplay(),
	653	xEvent->xany.window);
	654	wxWindow* win = NULL;
	655
	656	// Find the first wxWindow that corresponds to this event window
	657	while (widget && !(win = wxGetWindowFromTable(widget)))
	658	widget = XtParent(widget);
	659
	660	if (!widget \|\| !win)
	661	return FALSE;
	662
	663	wxKeyEvent keyEvent(wxEVT_KEY_DOWN);
	664	wxTranslateKeyEvent(keyEvent, win, (Widget) 0, xEvent);
	665
	666	return win->ProcessEvent( keyEvent );
	667	}
	668
	669	return FALSE;
	670	}
	671
	672	bool wxApp::CheckForKeyUp(WXEvent* event)
	673	{
	674	XEvent* xEvent = (XEvent*) event;
	675	if (xEvent->xany.type == KeyRelease)
	676	{
	677	Widget widget = XtWindowToWidget((Display*) wxGetDisplay(),
	678	xEvent->xany.window);
	679	wxWindow* win = NULL;
	680
	681	// Find the first wxWindow that corresponds to this event window
	682	while (widget && !(win = wxGetWindowFromTable(widget)))
	683	widget = XtParent(widget);
	684
	685	if (!widget \|\| !win)
	686	return FALSE;
	687
	688	wxKeyEvent keyEvent(wxEVT_KEY_UP);
	689	wxTranslateKeyEvent(keyEvent, win, (Widget) 0, xEvent);
	690
	691	return win->ProcessEvent( keyEvent );
	692	}
	693
	694	return FALSE;
	695	}
	696
	697	void wxExit()
	698	{
	699	int retValue = 0;
	700	if (wxTheApp)
	701	retValue = wxTheApp->OnExit();
	702
	703	wxApp::CleanUp();
	704	/*
	705	* Exit in some platform-specific way. Not recommended that the app calls this:
	706	* only for emergencies.
	707	*/
	708	exit(retValue);
	709	}
	710
	711	// Yield to other processes
	712	bool wxYield()
	713	{
	714	while (wxTheApp && wxTheApp->Pending())
	715	wxTheApp->Dispatch();
	716
	717	// VZ: is it the same as this (taken from old wxExecute)?
	718	#if 0
	719	XtAppProcessEvent((XtAppContext) wxTheApp->GetAppContext(), XtIMAll);
	720	#endif
	721
	722	return TRUE;
	723	}
	724
	725	// TODO use XmGetPixmap (?) to get the really standard icons!
	726
	727	#include "wx/generic/info.xpm"
	728	#include "wx/generic/error.xpm"
	729	#include "wx/generic/question.xpm"
	730	#include "wx/generic/warning.xpm"
	731
	732	wxIcon
	733	wxApp::GetStdIcon(int which) const
	734	{
	735	switch(which)
	736	{
	737	case wxICON_INFORMATION:
	738	return wxIcon(info_xpm);
	739
	740	case wxICON_QUESTION:
	741	return wxIcon(question_xpm);
	742
	743	case wxICON_EXCLAMATION:
	744	return wxIcon(warning_xpm);
	745
	746	default:
	747	wxFAIL_MSG("requested non existent standard icon");
	748	// still fall through
	749
	750	case wxICON_HAND:
	751	return wxIcon(error_xpm);
	752	}
	753	}
	754
	755	// ----------------------------------------------------------------------------
	756	// accessors for C modules
	757	// ----------------------------------------------------------------------------
	758
	759	extern "C" XtAppContext wxGetAppContext()
	760	{
	761	return (XtAppContext)wxTheApp->GetAppContext();
	762	}