- Fixed wxScopeGuard to work with VC++, documented it.
- Fixed proxy handling in wxURL.
+- Changed exceptions handling to work under wxGTK, added
+ virtual wxEvtHandler::DoHandleEvent()
wxMSW:
Returns the application's vendor name.
+\membersection{wxApp::HandleEvent}\label{wxapphandleevent}
+
+\constfunc{virtual void}{HandleEvent}{\param{wxEvtHandler}{ *handler}, \param{wxEventFunction}{ func}, \param{wxEvent\& }{event}}
+
+This function simply invokes the
+\helpref{DoHandleEvent}{wxevthandlerdohandleevent} method of event handler
+\arg{handler}, passing \arg{func} and \arg{event} as parameters. If an
+exception occurs, \helpref{OnExceptionInMainLoop}{wxapponexceptioninmainloop}
+is called by this function. You can override it to customize exceptions
+handling.
+
+If you want to modify this behaviour, override this function.
+
+
\membersection{wxApp::IsActive}\label{wxappisactive}
\constfunc{bool}{IsActive}{\void}
\docparam{flag}{If true, the app will use the best visual.}
-
-\membersection{wxApp::HandleEvent}\label{wxapphandleevent}
-
-\constfunc{virtual void}{HandleEvent}{\param{wxEvtHandler}{ *handler}, \param{wxEventFunction}{ func}, \param{wxEvent\& }{event}}
-
-This function simply invokes the given method \arg{func} of the specified
-event handler \arg{handler} with the \arg{event} as parameter. It exists solely
-to allow to catch the C++ exceptions which could be thrown by all event
-handlers in the application in one place: if you want to do this, override this
-function in your wxApp-derived class and add try/catch clause(s) to it.
-
-
\membersection{wxApp::Yield}\label{wxappyield}
\func{bool}{Yield}{\param{bool}{ onlyIfNeeded = false}}
\perlnote{In wxPerl this function takes 3 arguments: \texttt{id,
lastid, type}.}
+\membersection{wxEvtHandler::DoHandleEvent}\label{wxevthandlerdohandleevent}
+
+\func{virtual void}{DoHandleEvent}{\param{wxEventFunction}{ func}, \param{wxEvent\& }{event}}
+
+This function simply invokes the given method \arg{func} of this
+event handler with the \arg{event} as parameter. It exists solely
+to allow to catch the C++ exceptions which could be thrown by this event
+handlers in one place: if you want to do this, override this
+function in your wxEvtHandler-derived class and add try/catch clause(s) to it.
+
+Exceptions not caught at this level propagate to
+\helpref{wxApp::HandleEvent}{wxapphandleevent} which in turn calls
+\helpref{wxApp::OnExceptionInMainLoop}{wxapponexceptioninmainloop}.
+
\membersection{wxEvtHandler::GetClientData}\label{wxevthandlergetclientdata}
\func{void* }{GetClientData}{\void}
// Perform standard OnIdle behaviour: call from port's OnIdle
void OnIdle(wxIdleEvent& event);
+#if wxUSE_EXCEPTIONS
+ virtual void HandleEvent(wxEvtHandler *handler,
+ wxEventFunction func,
+ wxEvent& event) const;
+#endif // wxUSE_EXCEPTIONS
+
// top level window functions
// --------------------------
// wxEvtHandler: the base class for all objects handling wxWidgets events
// ----------------------------------------------------------------------------
+typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
+
class WXDLLIMPEXP_BASE wxEvtHandler : public wxObject
{
public:
bool ProcessThreadEvent(wxEvent& event);
#endif
+#if wxUSE_EXCEPTIONS
+ // call the specified handler with the given event
+ //
+ // this method only exists to allow catching the exceptions thrown by any
+ // event handler, it would lead to an extra (useless) virtual function call
+ // if the exceptions were not used, so it doesn't even exist in that case
+ virtual void DoHandleEvent(wxEventFunction func, wxEvent& event);
+#endif // wxUSE_EXCEPTIONS
+
// Dynamic association of a member function handler with the event handler,
// winid and event type
void Connect(int winid,
dest->AddPendingEvent(event);
}
-typedef void (wxEvtHandler::*wxEventFunction)(wxEvent&);
-
#define wxEventHandler(func) \
(wxObjectEventFunction)wxStaticCastEvent(wxEventFunction, &func)
class WXDLLIMPEXP_BASE wxObject;
+// FIXME: remove in wx-2.7:
+class WXDLLIMPEXP_BASE wxEvent;
+class WXDLLIMPEXP_BASE wxEvtHandler;
+
#ifndef wxUSE_EXTENDED_RTTI
#define wxUSE_EXTENDED_RTTI 0
#endif
virtual void ReservedObjectFunc6() {}
virtual void ReservedObjectFunc7() {}
virtual void ReservedObjectFunc8() {}
- virtual void ReservedObjectFunc9() {}
+ // FIXME: turn back into ReservedObjectFunc9() in wx-2.7 (see also FIXME
+ // near the top of this file)
+ virtual void DoHandleEvent(void (wxEvtHandler::*)(wxEvent&), wxEvent&) {}
protected:
// ensure that our data is not shared with anybody else: if we have no
wxEventFunction func,
wxEvent& event) const
{
- // by default, simply call the handler
- (handler->*func)(event);
+ // by default, call wxApp::OnExceptionInMainLoop if an exception occurs
+ try
+ {
+ handler->DoHandleEvent(func, event);
+ }
+ catch ( ... )
+ {
+ wxConstCast(this, wxAppConsole)->OnExceptionInMainLoop();
+ }
}
bool
#include "wx/thread.h"
#include "wx/utils.h"
#include "wx/ptr_scpd.h"
+#include "wx/evtloop.h"
#if defined(__WXMSW__)
#include "wx/msw/private.h" // includes windows.h for LOGFONT
}
+// ----------------------------------------------------------------------------
+// exception handling
+// ----------------------------------------------------------------------------
+
+#if wxUSE_EXCEPTIONS
+
+void wxAppBase::HandleEvent(wxEvtHandler *handler,
+ wxEventFunction func,
+ wxEvent& event) const
+{
+ // by default, call wxApp::OnExceptionInMainLoop if an exception occurs
+ try
+ {
+ handler->DoHandleEvent(func, event);
+ }
+ catch ( ... )
+ {
+ if ( !wxConstCast(this, wxAppBase)->OnExceptionInMainLoop() )
+ {
+ wxEventLoop *loop = wxEventLoop::GetActive();
+ if ( loop )
+ loop->Exit(-1);
+ }
+ //else: continue running the event loop
+ }
+}
+
+#endif // wxUSE_EXCEPTIONS
+
// ----------------------------------------------------------------------------
// wxGUIAppTraitsBase
// ----------------------------------------------------------------------------
#endif // wxUSE_THREADS
+#if wxUSE_EXCEPTIONS
+void wxEvtHandler::DoHandleEvent(wxEventFunction func, wxEvent& event)
+{
+ // by default, just call then handler
+ (this->*func)(event);
+}
+#endif // wxUSE_EXCEPTIONS
+
void wxEvtHandler::AddPendingEvent(wxEvent& event)
{
// 1) Add event to list of pending events of this event handler
#include "wx/frame.h"
#include "wx/app.h"
#include "wx/cursor.h"
+#include "wx/evtloop.h"
#include <gdk/gdk.h>
#include <gtk/gtk.h>
g_openDialogs++;
gtk_grab_add( m_widget );
- gtk_main();
+
+ wxEventLoop().Run();
+
gtk_grab_remove( m_widget );
g_openDialogs--;
#include "wx/gtk/private.h"
#include "wx/timer.h"
#include "wx/settings.h"
+#include "wx/evtloop.h"
#include <glib.h>
#include <gdk/gdk.h>
{
m_grabbed = TRUE;
gtk_grab_add( m_widget );
- gtk_main();
+ wxEventLoop().Run();
gtk_grab_remove( m_widget );
}
}
#include "wx/frame.h"
#include "wx/app.h"
#include "wx/cursor.h"
+#include "wx/evtloop.h"
#include <gdk/gdk.h>
#include <gtk/gtk.h>
g_openDialogs++;
gtk_grab_add( m_widget );
- gtk_main();
+
+ wxEventLoop().Run();
+
gtk_grab_remove( m_widget );
g_openDialogs--;
#include "wx/gtk/private.h"
#include "wx/timer.h"
#include "wx/settings.h"
+#include "wx/evtloop.h"
#include <glib.h>
#include <gdk/gdk.h>
{
m_grabbed = TRUE;
gtk_grab_add( m_widget );
- gtk_main();
+ wxEventLoop().Run();
gtk_grab_remove( m_widget );
}
}
// should undo
wxEventLoopActivator activate(&ms_activeLoop, this);
- // we must ensure that OnExit() is called even if an exception is thrown
- // from inside Dispatch() but we must call it from Exit() in normal
- // situations because it is supposed to be called synchronously,
- // wxModalEventLoop depends on this (so we can't just use ON_BLOCK_EXIT or
- // something similar here)
#if wxUSE_EXCEPTIONS
- for ( ;; )
+ try
{
- try
+#endif
+ // this is the event loop itself
+ for ( ;; )
{
-#endif // wxUSE_EXCEPTIONS
-
- // this is the event loop itself
- for ( ;; )
+ #if wxUSE_THREADS
+ wxMutexGuiLeaveOrEnter();
+ #endif // wxUSE_THREADS
+
+ // generate and process idle events for as long as we don't
+ // have anything else to do
+ while ( !Pending() && (wxTheApp && wxTheApp->ProcessIdle()) )
+ ;
+
+ // if the "should exit" flag is set, the loop should terminate
+ // but not before processing any remaining messages so while
+ // Pending() returns true, do process them
+ if ( m_shouldExit )
{
- #if wxUSE_THREADS
- wxMutexGuiLeaveOrEnter();
- #endif // wxUSE_THREADS
-
- // generate and process idle events for as long as we don't
- // have anything else to do
- while ( !Pending() && (wxTheApp && wxTheApp->ProcessIdle()) )
- ;
-
- // if the "should exit" flag is set, the loop should terminate
- // but not before processing any remaining messages so while
- // Pending() returns true, do process them
- if ( m_shouldExit )
- {
- while ( Pending() )
- Dispatch();
-
- break;
- }
-
- // a message came or no more idle processing to do, sit in
- // Dispatch() waiting for the next message
- if ( !Dispatch() )
- {
- // we got WM_QUIT
- break;
- }
- }
+ while ( Pending() )
+ Dispatch();
-#if wxUSE_EXCEPTIONS
- // exit the outer loop as well
- break;
- }
- catch ( ... )
- {
- try
- {
- if ( !wxTheApp || !wxTheApp->OnExceptionInMainLoop() )
- {
- OnExit();
- break;
- }
- //else: continue running the event loop
+ break;
}
- catch ( ... )
+
+ // a message came or no more idle processing to do, sit in
+ // Dispatch() waiting for the next message
+ if ( !Dispatch() )
{
- // OnException() throwed, possibly rethrowing the same
- // exception again: very good, but we still need OnExit() to
- // be called
- OnExit();
- throw;
+ // we got WM_QUIT
+ break;
}
}
+#if wxUSE_EXCEPTIONS
+ }
+ catch ( ... )
+ {
+ // we need OnExit() to be called before the event loop stops
+ OnExit();
+ throw;
}
#endif // wxUSE_EXCEPTIONS
projects / wxWidgets.git / commitdiff
