X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/86fd8bda3817a22588e5ff92b932dfaecc1eb37a..cd72551c2b6cbf67a4a5caf0ba00ba64e41183b2:/src/x11/app.cpp diff --git a/src/x11/app.cpp b/src/x11/app.cpp index 232b4ec21c..91b39edbb7 100644 --- a/src/x11/app.cpp +++ b/src/x11/app.cpp @@ -17,19 +17,17 @@ #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/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" #include "wx/evtloop.h" -#include "wx/cmdline.h" + +#include "wx/univ/theme.h" +#include "wx/univ/renderer.h" #if wxUSE_THREADS #include "wx/thread.h" @@ -39,40 +37,37 @@ #include "wx/resource.h" #endif -#ifdef __VMS__ -#pragma message disable nosimpint -#endif -#include -#include -#include -#include -#ifdef __VMS__ -#pragma message enable nosimpint -#endif - #include "wx/x11/private.h" #include -extern wxList wxPendingDelete; +//------------------------------------------------------------------------ +// global data +//------------------------------------------------------------------------ -wxApp *wxTheApp = NULL; +extern wxList wxPendingDelete; wxHashTable *wxWidgetHashTable = NULL; -IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler) +wxApp *wxTheApp = NULL; -BEGIN_EVENT_TABLE(wxApp, wxEvtHandler) - EVT_IDLE(wxApp::OnIdle) -END_EVENT_TABLE() +// This is set within wxEntryStart -- too early on +// to put these in wxTheApp +static int g_newArgc = 0; +static wxChar** g_newArgv = NULL; +static bool g_showIconic = FALSE; +static wxSize g_initialSize = wxDefaultSize; -static const wxCmdLineEntryDesc g_cmdLineDesc[] = -{ - { wxCMD_LINE_SWITCH, "sync", "sync", "synchronize the display" }, - { wxCMD_LINE_OPTION, "display", "display", "use the given display", wxCMD_LINE_VAL_STRING }, +// 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; - { wxCMD_LINE_NONE } -}; +//------------------------------------------------------------------------ +// X11 error handling +//------------------------------------------------------------------------ #ifdef __WXDEBUG__ typedef int (*XErrorHandlerFunc)(Display *, XErrorEvent *); @@ -82,13 +77,26 @@ XErrorHandlerFunc gs_pfnXErrorHandler = 0; static int wxXErrorHandler(Display *dpy, XErrorEvent *xevent) { // just forward to the default handler for now - return gs_pfnXErrorHandler(dpy, xevent); + if (gs_pfnXErrorHandler) + return gs_pfnXErrorHandler(dpy, xevent); + else + return 0; } #endif // __WXDEBUG__ +//------------------------------------------------------------------------ +// wxApp +//------------------------------------------------------------------------ + long wxApp::sm_lastMessageTime = 0; WXDisplay *wxApp::ms_display = NULL; +IMPLEMENT_DYNAMIC_CLASS(wxApp, wxEvtHandler) + +BEGIN_EVENT_TABLE(wxApp, wxEvtHandler) + EVT_IDLE(wxApp::OnIdle) +END_EVENT_TABLE() + bool wxApp::Initialize() { wxClassInfo::InitializeClasses(); @@ -119,6 +127,10 @@ bool wxApp::Initialize() void wxApp::CleanUp() { + if (g_newArgv) + delete[] g_newArgv; + g_newArgv = NULL; + delete wxWidgetHashTable; wxWidgetHashTable = NULL; @@ -152,7 +164,7 @@ void wxApp::CleanUp() // wxDebugContext, too. if (wxDebugContext::CountObjectsLeft(TRUE) > 0) { - wxLogDebug("There were memory leaks.\n"); + wxLogDebug("There were memory leaks."); wxDebugContext::Dump(); wxDebugContext::PrintStatistics(); } @@ -164,39 +176,95 @@ void wxApp::CleanUp() delete wxLog::SetActiveTarget(NULL); } -// This is set within wxEntryStart -- too early on -// to put these in wxTheApp -static int g_newArgc = 0; -static wxChar** g_newArgv = NULL; - // NB: argc and argv may be changed here, pass by reference! int wxEntryStart( int& argc, char *argv[] ) { #ifdef __WXDEBUG__ +#if !wxUSE_NANOX // install the X error handler gs_pfnXErrorHandler = XSetErrorHandler( wxXErrorHandler ); +#endif #endif // __WXDEBUG__ - /// TODO -#if 0 - // Parse the arguments. Is it OK to use the command line - // parser before calling Initialize? - wxCmdLineParser cmdLine(argv, argv); -#endif + wxString displayName; + bool syncDisplay = FALSE; + + // Parse the arguments. + // We can't use wxCmdLineParser or OnInitCmdLine and friends because + // we have to create the Display earlier. If we can find a way to + // use the wxAppBase API then I'll be quite happy to change it. + g_newArgv = new wxChar*[argc]; + g_newArgc = 0; + int i; + for (i = 0; i < argc; i++) + { + wxString arg(argv[i]); + if (arg == wxT("-display")) + { + if (i < (argc - 1)) + { + i ++; + displayName = argv[i]; + continue; + } + } + else if (arg == wxT("-geometry")) + { + if (i < (argc - 1)) + { + i ++; + wxString windowGeometry = argv[i]; + int w, h; + if (wxSscanf(windowGeometry.c_str(), _T("%dx%d"), &w, &h) != 2) + { + wxLogError(_("Invalid geometry specification '%s'"), windowGeometry.c_str()); + } + else + { + g_initialSize = wxSize(w, h); + } + continue; + } + } + else if (arg == wxT("-sync")) + { + syncDisplay = TRUE; + continue; + } + else if (arg == wxT("-iconic")) + { + g_showIconic = TRUE; - Display* xdisplay = XOpenDisplay(NULL); + continue; + } + + // Not eaten by wxWindows, so pass through + g_newArgv[g_newArgc] = argv[i]; + g_newArgc ++; + } + + Display* xdisplay = NULL; + if (displayName.IsEmpty()) + xdisplay = XOpenDisplay(NULL); + else + xdisplay = XOpenDisplay((char*) displayName.c_str()); if (!xdisplay) { wxLogError( _("wxWindows could not open display. Exiting.") ); return -1; } + + if (syncDisplay) + { + XSynchronize(xdisplay, True); + } wxApp::ms_display = (WXDisplay*) xdisplay; XSelectInput( xdisplay, XDefaultRootWindow(xdisplay), PropertyChangeMask); -// wxSetDetectableAutoRepeat( TRUE ); + wxSetDetectableAutoRepeat( TRUE ); if (!wxApp::Initialize()) return -1; @@ -204,7 +272,6 @@ int wxEntryStart( int& argc, char *argv[] ) return 0; } - int wxEntryInitGui() { int retValue = 0; @@ -263,6 +330,8 @@ int wxEntry( int argc, char *argv[] ) wxTheApp->argc = argc; wxTheApp->argv = argv; } + wxTheApp->m_showIconic = g_showIconic; + wxTheApp->m_initialSize = g_initialSize; int retValue; retValue = wxEntryInitGui(); @@ -320,6 +389,8 @@ wxApp::wxApp() m_topLevelWidget = (WXWindow) NULL; m_maxRequestSize = 0; m_mainLoop = NULL; + m_showIconic = FALSE; + m_initialSize = wxDefaultSize; } bool wxApp::Initialized() @@ -342,21 +413,54 @@ int wxApp::MainLoop() return rt; } +#if !wxUSE_NANOX +//----------------------------------------------------------------------- +// X11 predicate function for exposure compression +//----------------------------------------------------------------------- + +struct wxExposeInfo +{ + Window window; + Bool found_non_matching; +}; + +static Bool expose_predicate (Display *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. +//----------------------------------------------------------------------- + void wxApp::ProcessXEvent(WXEvent* _event) { XEvent* event = (XEvent*) _event; wxWindow* win = NULL; - Window window = event->xany.window; + Window window = XEventGetWindow(event); Window actualWindow = window; // Find the first wxWindow that corresponds to this event window - // TODO: may need to translate coordinates from actualWindow - // to window, if the receiving window != wxWindow window - // while (window && !(win = wxGetWindowFromTable(window))) - // window = wxGetWindowParent(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, @@ -366,82 +470,83 @@ void wxApp::ProcessXEvent(WXEvent* _event) if (!win) return; +#ifdef __WXDEBUG__ + wxString windowClass = win->GetClassInfo()->GetClassName(); +#endif + switch (event->type) { case KeyPress: { - if (win && !win->IsEnabled()) + if (!win->IsEnabled()) return; - { - if (win) - { - wxKeyEvent keyEvent(wxEVT_KEY_DOWN); - wxTranslateKeyEvent(keyEvent, win, window, event); + 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->GetEventHandler()->ProcessEvent( keyEvent )) - { - keyEvent.SetEventType(wxEVT_CHAR); - win->GetEventHandler()->ProcessEvent( keyEvent ); - } - - // We intercepted and processed the key down event - return; - } + // We didn't process wxEVT_KEY_DOWN, so send + // wxEVT_CHAR + if (!win->GetEventHandler()->ProcessEvent( keyEvent )) + { + keyEvent.SetEventType(wxEVT_CHAR); + win->GetEventHandler()->ProcessEvent( keyEvent ); } return; } case KeyRelease: { - if (win && !win->IsEnabled()) + if (!win->IsEnabled()) return; - if (win) - { - wxKeyEvent keyEvent(wxEVT_KEY_UP); - wxTranslateKeyEvent(keyEvent, win, window, event); + wxKeyEvent keyEvent(wxEVT_KEY_UP); + wxTranslateKeyEvent(keyEvent, win, window, event); - win->GetEventHandler()->ProcessEvent( keyEvent ); - } + win->GetEventHandler()->ProcessEvent( keyEvent ); return; } + case ConfigureNotify: + { +#if wxUSE_NANOX + if (event->update.utype == GR_UPDATE_SIZE) +#endif + { + //wxLogDebug("ConfigureNotify: %s", windowClass.c_str()); + wxSizeEvent sizeEvent( wxSize(XConfigureEventGetWidth(event), XConfigureEventGetHeight(event)), win->GetId() ); + sizeEvent.SetEventObject( win ); + + win->GetEventHandler()->ProcessEvent( sizeEvent ); + } + break; + } +#if !wxUSE_NANOX case PropertyNotify: { + //wxLogDebug("PropertyNotify: %s", windowClass.c_str()); HandlePropertyChange(_event); return; } case ClientMessage: - { - Atom wm_delete_window = XInternAtom(wxGlobalDisplay(), "WM_DELETE_WINDOW", True);; - Atom wm_protocols = XInternAtom(wxGlobalDisplay(), "WM_PROTOCOLS", True);; + { + if (!win->IsEnabled()) + return; + + 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) { - if (win) - { - win->Close(FALSE); - } + win->Close(FALSE); } } return; } - case ConfigureNotify: - { - if (win) - { - wxSizeEvent sizeEvent( wxSize(event->xconfigure.width,event->xconfigure.height), win->GetId() ); - sizeEvent.SetEventObject( win ); - - win->GetEventHandler()->ProcessEvent( sizeEvent ); - } - } case ResizeRequest: { - /* Terry Gitnick - 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. */ @@ -453,9 +558,6 @@ void wxApp::ProcessXEvent(WXEvent* _event) report = * event; while( XCheckTypedWindowEvent (disp, actualWindow, ResizeRequest, &report)); - // TODO: when implementing refresh optimization, we can use - // XtAddExposureToRegion to expand the window's paint region. - if (win) { wxSize sz = win->GetSize(); @@ -467,60 +569,155 @@ void wxApp::ProcessXEvent(WXEvent* _event) return; } - case Expose: +#endif +#if wxUSE_NANOX + case GR_EVENT_TYPE_CLOSE_REQ: { if (win) { - // Schedule update for later - win->GetUpdateRegion().Union( event->xexpose.x, event->xexpose.y, - event->xexpose.width, event->xexpose.height); + win->Close(FALSE); + } + break; + } +#endif + case Expose: + { + //wxLogDebug("Expose: %s", windowClass.c_str()); + 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, expose_predicate, (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 + + win->SendEraseEvents(); return; } +#if !wxUSE_NANOX + case GraphicsExpose: + { + // wxLogDebug( "GraphicsExpose from %s", win->GetName().c_str(), + // event->xgraphicsexpose.x, event->xgraphicsexpose.y, + // event->xgraphicsexpose.width, event->xgraphicsexpose.height); + + 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(); + } + + return; + } +#endif case EnterNotify: case LeaveNotify: case ButtonPress: case ButtonRelease: case MotionNotify: { - if (win && !win->IsEnabled()) + if (!win->IsEnabled()) return; - - if (win) + + // 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; + + if (event->type == ButtonPress) + { + if ((win != wxWindow::FindFocus()) && win->AcceptsFocus()) + { + // This might actually be done in wxWindow::SetFocus() + // and not here. TODO. + g_prevFocus = wxWindow::FindFocus(); + g_nextFocus = win; + + win->SetFocus(); + } + } + +#if !wxUSE_NANOX + if (event->type == LeaveNotify || event->type == EnterNotify) { - wxMouseEvent wxevent; - wxTranslateMouseEvent(wxevent, win, window, event); - win->GetEventHandler()->ProcessEvent( wxevent ); + // Throw out NotifyGrab and NotifyUngrab + if (event->xcrossing.mode != NotifyNormal) + return; } +#endif + wxMouseEvent wxevent; + wxTranslateMouseEvent(wxevent, win, window, event); + win->GetEventHandler()->ProcessEvent( wxevent ); + return; } case FocusIn: { - if (win && event->xfocus.detail != NotifyPointer) +#if !wxUSE_NANOX + if ((event->xfocus.detail != NotifyPointer) && + (event->xfocus.mode == NotifyNormal)) +#endif { + // wxLogDebug( "FocusIn from %s of type %s", win->GetName().c_str(), win->GetClassInfo()->GetClassName() ); + wxFocusEvent focusEvent(wxEVT_SET_FOCUS, win->GetId()); focusEvent.SetEventObject(win); + focusEvent.SetWindow( g_prevFocus ); + g_prevFocus = NULL; + win->GetEventHandler()->ProcessEvent(focusEvent); } break; } case FocusOut: { - if (win && event->xfocus.detail != NotifyPointer) +#if !wxUSE_NANOX + if ((event->xfocus.detail != NotifyPointer) && + (event->xfocus.mode == NotifyNormal)) +#endif { + // wxLogDebug( "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; win->GetEventHandler()->ProcessEvent(focusEvent); } break; } - case DestroyNotify: +#ifndef wxUSE_NANOX + case DestroyNotify: { // Do we want to process this (for top-level windows)? // But we want to be able to veto closes, anyway break; } +#endif default: { #ifdef __WXDEBUG__ @@ -568,7 +765,7 @@ void wxApp::HandlePropertyChange(WXEvent *event) { // by default do nothing special // TODO: what to do for X11 - // XtDispatchEvent((XEvent*) event); /* let Motif do the work */ + // XtDispatchEvent((XEvent*) event); } void wxApp::OnIdle(wxIdleEvent& event) @@ -667,7 +864,7 @@ void wxApp::DeletePendingObjects() } } -// Create an application context +// Create display, and other initialization bool wxApp::OnInitGui() { // Eventually this line will be removed, but for @@ -678,8 +875,8 @@ bool wxApp::OnInitGui() if (!wxAppBase::OnInitGui()) return FALSE; - GetMainColormap( wxApp::GetDisplay() ); + m_maxRequestSize = XMaxRequestSize( (Display*) wxApp::GetDisplay() ); return TRUE; @@ -708,9 +905,19 @@ Window wxGetWindowParent(Window window) return (Window) 0; Window parent, root = 0; +#if wxUSE_NANOX + int noChildren = 0; +#else unsigned int noChildren = 0; +#endif Window* children = NULL; - int res = XQueryTree((Display*) wxGetDisplay(), window, & root, & parent, + + // #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); @@ -760,39 +967,9 @@ bool wxApp::Yield(bool onlyIfNeeded) return TRUE; } -// TODO use XmGetPixmap (?) to get the really standard icons! - -// XPM hack: make the arrays const -#define static static const - -#include "wx/generic/info.xpm" -#include "wx/generic/error.xpm" -#include "wx/generic/question.xpm" -#include "wx/generic/warning.xpm" - -#undef static - -wxIcon -wxApp::GetStdIcon(int which) const +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); - } + return wxTheme::Get()->GetRenderer()->GetStdIcon(which); } void wxApp::OnAssert(const wxChar *file, int line, const wxChar *msg)