#include "wx/utils.h"
-class WXDLLEXPORT wxEventLoopImpl;
+class WXDLLEXPORT wxEventLoop;
// ----------------------------------------------------------------------------
// wxEventLoop: a GUI event loop
// ----------------------------------------------------------------------------
-class WXDLLEXPORT wxEventLoop
+class WXDLLEXPORT wxEventLoopBase
{
public:
- // ctor
- wxEventLoop() { m_impl = NULL; }
+ // trivial, but needed (because of wxEventLoopBase) ctor
+ wxEventLoopBase() { }
// dtor
- virtual ~wxEventLoop();
+ virtual ~wxEventLoopBase() { }
// start the event loop, return the exit code when it is finished
- virtual int Run();
+ virtual int Run() = 0;
// exit from the loop with the given exit code
- virtual void Exit(int rc = 0);
+ virtual void Exit(int rc = 0) = 0;
// return TRUE if any events are available
- virtual bool Pending() const;
+ virtual bool Pending() const = 0;
// dispatch a single event, return FALSE if we should exit from the loop
- virtual bool Dispatch();
+ virtual bool Dispatch() = 0;
// is the event loop running now?
- virtual bool IsRunning() const;
+ virtual bool IsRunning() const = 0;
// return currently active (running) event loop, may be NULL
static wxEventLoop *GetActive() { return ms_activeLoop; }
// the pointer to currently active loop
static wxEventLoop *ms_activeLoop;
+ DECLARE_NO_COPY_CLASS(wxEventLoopBase)
+};
+
+// we're moving away from old m_impl wxEventLoop model as otherwise the user
+// code doesn't have access to platform-specific wxEventLoop methods and this
+// can sometimes be very useful (e.g. under MSW this is necessary for
+// integration with MFC) but currently this is done for MSW only, other ports
+// should follow a.s.a.p.
+#ifdef __WXMSW__
+ #include "wx/msw/evtloop.h"
+#else
+
+class WXDLLEXPORT wxEventLoopImpl;
+
+class WXDLLEXPORT wxEventLoop : public wxEventLoopBase
+{
+public:
+ wxEventLoop() { m_impl = NULL; }
+
+ virtual int Run();
+ virtual void Exit(int rc = 0);
+ virtual bool Pending() const;
+ virtual bool Dispatch();
+ virtual bool IsRunning() const { return m_impl != NULL; }
+
+protected:
// the pointer to the port specific implementation class
wxEventLoopImpl *m_impl;
DECLARE_NO_COPY_CLASS(wxEventLoop)
-};
+}
+
+#endif // __WXMSW__/!__WXMSW__
// ----------------------------------------------------------------------------
// wxModalEventLoop
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: wx/msw/evtloop.h
+// Purpose: wxEventLoop class for MSW
+// Author: Vadim Zeitlin
+// Modified by:
+// Created: 2004-07-31
+// RCS-ID: $Id$
+// Copyright: (c) 2003-2004 Vadim Zeitlin <vadim@wxwindows.org>
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_MSW_EVTLOOP_H_
+#define _WX_MSW_EVTLOOP_H_
+
+// ----------------------------------------------------------------------------
+// wxEventLoop
+// ----------------------------------------------------------------------------
+
+class WXDLLEXPORT wxEventLoop : public wxEventLoopBase
+{
+public:
+ wxEventLoop();
+
+ // implement base class pure virtuals
+ virtual int Run();
+ virtual void Exit(int rc = 0);
+ virtual bool Pending() const;
+ virtual bool Dispatch();
+ virtual bool IsRunning() const;
+
+ // MSW-specific methods
+ // --------------------
+
+ // preprocess a message, return true if processed (i.e. no further
+ // dispatching required)
+ virtual bool PreProcessMessage(WXMSG *msg);
+
+ // process a single message
+ virtual void ProcessMessage(WXMSG *msg);
+
+protected:
+ // should we exit the loop?
+ bool m_shouldExit;
+
+ // the loop exit code
+ int m_exitcode;
+};
+
+#endif // _WX_MSW_EVTLOOP_H_
+
// wxEventLoop running and exiting
// ----------------------------------------------------------------------------
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
wxEventLoop::~wxEventLoop()
{
wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
}
-bool wxEventLoop::IsRunning() const
-{
- return m_impl;
-}
-
int wxEventLoop::Run()
{
// event loops are not recursive, you need to create another loop!
// wxEventLoop running and exiting
// ----------------------------------------------------------------------------
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
wxEventLoop::~wxEventLoop()
{
wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
}
-bool wxEventLoop::IsRunning() const
-{
- return m_impl != NULL;
-}
-
int wxEventLoop::Run()
{
// event loops are not recursive, you need to create another loop!
// wxEventLoop running and exiting
// ----------------------------------------------------------------------------
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
wxEventLoop::~wxEventLoop()
{
wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
}
-bool wxEventLoop::IsRunning() const
-{
- return m_impl != NULL;
-}
-
int wxEventLoop::Run()
{
// event loops are not recursive, you need to create another loop!
// wxEventLoop running and exiting
// ----------------------------------------------------------------------------
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
wxEventLoop::~wxEventLoop()
{
wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
}
-bool wxEventLoop::IsRunning() const
-{
- return m_impl != NULL;
-}
-
int wxEventLoop::Run()
{
// event loops are not recursive, you need to create another loop!
// wxEventLoop running and exiting
// ----------------------------------------------------------------------------
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
wxEventLoop::~wxEventLoop()
{
wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
}
-bool wxEventLoop::IsRunning() const
-{
- return m_impl != NULL;
-}
-
int wxEventLoop::Run()
{
// event loops are not recursive, you need to create another loop!
WX_DEFINE_OBJARRAY(wxMsgArray);
#endif // wxUSE_THREADS
-// ----------------------------------------------------------------------------
-// wxEventLoopImpl
-// ----------------------------------------------------------------------------
-
-class WXDLLEXPORT wxEventLoopImpl
-{
-public:
- // ctor
- wxEventLoopImpl() { m_exitcode = 0; m_shouldExit = false; }
-
- // process a message
- void ProcessMessage(MSG *msg);
-
- // generate an idle message, return TRUE if more idle time requested
- bool SendIdleMessage();
-
- // set/get the exit code
- void Exit(int exitcode) { m_exitcode = exitcode; m_shouldExit = true; }
- int GetExitCode() const { return m_exitcode; }
- bool ShouldExit() const { return m_shouldExit; }
-
-private:
- // preprocess a message, return TRUE if processed (i.e. no further
- // dispatching required)
- bool PreProcessMessage(MSG *msg);
-
- // the exit code of the event loop
- int m_exitcode;
-
- // true if we were asked to terminate
- bool m_shouldExit;
-};
-
// ----------------------------------------------------------------------------
// helper class
// ----------------------------------------------------------------------------
-wxDEFINE_TIED_SCOPED_PTR_TYPE(wxEventLoopImpl);
-
// this object sets the wxEventLoop given to the ctor as the currently active
// one and unsets it in its dtor
class wxEventLoopActivator
};
// ============================================================================
-// wxEventLoopImpl implementation
+// wxEventLoop implementation
// ============================================================================
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
+
// ----------------------------------------------------------------------------
-// wxEventLoopImpl message processing
+// ctor/dtor
// ----------------------------------------------------------------------------
-void wxEventLoopImpl::ProcessMessage(MSG *msg)
+wxEventLoop::wxEventLoop()
+{
+ m_shouldExit = false;
+ m_exitcode = 0;
+}
+
+// ----------------------------------------------------------------------------
+// wxEventLoop message processing
+// ----------------------------------------------------------------------------
+
+void wxEventLoop::ProcessMessage(WXMSG *msg)
{
// give us the chance to preprocess the message first
if ( !PreProcessMessage(msg) )
}
}
-bool wxEventLoopImpl::PreProcessMessage(MSG *msg)
+bool wxEventLoop::PreProcessMessage(WXMSG *msg)
{
HWND hwnd = msg->hwnd;
wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
if ( !wndThis )
{
// we need to find the dialog containing this control as
- // IsDialogMessage() just eats all the messages (i.e. returns TRUE for
+ // IsDialogMessage() just eats all the messages (i.e. returns true for
// them) if we call it for the control itself
while ( hwnd && ::GetWindowLong(hwnd, GWL_STYLE) & WS_CHILD )
{
// grab Ctrl-C/V/X, even if they are also accelerators in some parent)
if ( !wndThis->MSWShouldPreProcessMessage((WXMSG *)msg) )
{
- return FALSE;
+ return false;
}
// try translations first: the accelerators override everything
for ( wnd = wndThis; wnd; wnd = wnd->GetParent() )
{
if ( wnd->MSWTranslateMessage((WXMSG *)msg))
- return TRUE;
+ return true;
// stop at first top level window, i.e. don't try to process the key
// strokes originating in a dialog using the accelerators of the parent
for ( wnd = wndThis->GetParent(); wnd; wnd = wnd->GetParent() )
{
if ( wnd->MSWProcessMessage((WXMSG *)msg) )
- return TRUE;
+ return true;
}
// no special preprocessing for this message, dispatch it normally
- return FALSE;
-}
-
-// ----------------------------------------------------------------------------
-// wxEventLoopImpl idle event processing
-// ----------------------------------------------------------------------------
-
-bool wxEventLoopImpl::SendIdleMessage()
-{
- return wxTheApp && wxTheApp->ProcessIdle();
+ return false;
}
-// ============================================================================
-// wxEventLoop implementation
-// ============================================================================
-
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
-
// ----------------------------------------------------------------------------
// wxEventLoop running and exiting
// ----------------------------------------------------------------------------
-wxEventLoop::~wxEventLoop()
-{
- wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
-}
-
bool wxEventLoop::IsRunning() const
{
- return m_impl != NULL;
+ return ms_activeLoop == this;
}
int wxEventLoop::Run()
// event loops are not recursive, you need to create another loop!
wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
- // SendIdleMessage() and Dispatch() below may throw so the code here should
+ // ProcessIdle() and Dispatch() below may throw so the code here should
// be exception-safe, hence we must use local objects for all actions we
// should undo
wxEventLoopActivator activate(&ms_activeLoop, this);
- wxEventLoopImplTiedPtr impl(&m_impl, new wxEventLoopImpl);
// 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
// generate and process idle events for as long as we don't
// have anything else to do
- while ( !Pending() && m_impl->SendIdleMessage() )
+ 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_impl->ShouldExit() )
+ if ( m_shouldExit )
{
while ( Pending() )
Dispatch();
}
#endif // wxUSE_EXCEPTIONS
- return m_impl->GetExitCode();
+ return m_exitcode;
}
void wxEventLoop::Exit(int rc)
{
wxCHECK_RET( IsRunning(), _T("can't call Exit() if not running") );
- m_impl->Exit(rc);
+ m_exitcode = rc;
+ m_shouldExit = true;
OnExit();
bool wxEventLoop::Dispatch()
{
- wxCHECK_MSG( IsRunning(), FALSE, _T("can't call Dispatch() if not running") );
+ wxCHECK_MSG( IsRunning(), false, _T("can't call Dispatch() if not running") );
MSG msg;
BOOL rc = ::GetMessage(&msg, (HWND) NULL, 0, 0);
if ( rc == 0 )
{
// got WM_QUIT
- return FALSE;
+ return false;
}
if ( rc == -1 )
wxLogLastError(wxT("GetMessage"));
// still break from the loop
- return FALSE;
+ return false;
}
#if wxUSE_THREADS
wxASSERT_MSG( wxThread::IsMain(),
wxT("only the main thread can process Windows messages") );
- static bool s_hadGuiLock = TRUE;
+ static bool s_hadGuiLock = true;
static wxMsgArray s_aSavedMessages;
// if a secondary thread owning the mutex is doing GUI calls, save all
// it will lead to recursive library calls (and we're not reentrant)
if ( !wxGuiOwnedByMainThread() )
{
- s_hadGuiLock = FALSE;
+ s_hadGuiLock = false;
// leave out WM_COMMAND messages: too dangerous, sometimes
// the message will be processed twice
s_aSavedMessages.Add(msg);
}
- return TRUE;
+ return true;
}
else
{
// messages normally - expect some things to break...
if ( !s_hadGuiLock )
{
- s_hadGuiLock = TRUE;
+ s_hadGuiLock = true;
size_t count = s_aSavedMessages.Count();
for ( size_t n = 0; n < count; n++ )
{
MSG& msg = s_aSavedMessages[n];
- m_impl->ProcessMessage(&msg);
+ ProcessMessage(&msg);
}
s_aSavedMessages.Empty();
}
#endif // wxUSE_THREADS
- m_impl->ProcessMessage(&msg);
+ ProcessMessage(&msg);
- return TRUE;
+ return true;
}
// wxEventLoop implementation
// ============================================================================
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
// ----------------------------------------------------------------------------
// wxEventLoop running and exiting
wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
}
-bool wxEventLoop::IsRunning() const
-{
- return m_impl != NULL;
-}
-
//////////////////////////////////////////////////////////////////////////////
//
// Keep trying to process messages until WM_QUIT
m_callbackInput = NULL; m_callbackOutput = NULL;
m_dataInput = NULL; m_dataOutput = NULL;
}
-
+
int m_fdInput;
int m_fdOutput;
wxSocketCallback m_callbackInput;
while (node)
{
wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
-
+
if (entry->m_fdInput != -1)
{
FD_SET(entry->m_fdInput, readset);
while (node)
{
wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
-
+
if (entry->m_fdInput != -1 && FD_ISSET(entry->m_fdInput, readset))
{
(entry->m_callbackInput) (entry->m_fdInput, entry->m_dataInput);
// give us the chance to preprocess the message first
if ( PreProcessEvent(event) )
return TRUE;
-
+
// if it wasn't done, dispatch it to the corresponding window
if (wxTheApp)
return wxTheApp->ProcessXEvent((WXEvent*) event);
// wxEventLoop implementation
// ============================================================================
-wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
+wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
// ----------------------------------------------------------------------------
// wxEventLoop running and exiting
wxASSERT_MSG( !m_impl, _T("should have been deleted in Run()") );
}
-bool wxEventLoop::IsRunning() const
-{
- return m_impl != NULL;
-}
-
int wxEventLoop::Run()
{
// event loops are not recursive, you need to create another loop!
wxCHECK_MSG( !IsRunning(), -1, _T("can't reenter a message loop") );
m_impl = new wxEventLoopImpl;
-
+
wxEventLoop *oldLoop = ms_activeLoop;
ms_activeLoop = this;
// does also mean that idle processing will happen more
// often, so we should probably limit idle processing to
// not be repeated more than every N milliseconds.
-
+
if (XPending( wxGlobalDisplay() ) == 0)
{
#if wxUSE_NANOX
// Fall through to ProcessEvent.
// we'll assume that ProcessEvent will just ignore
// the event if there was a timeout and no event.
-
+
#else
struct timeval tv;
tv.tv_sec=0;
tv.tv_usec=10000; // TODO make this configurable
int fd = ConnectionNumber( wxGlobalDisplay() );
-
+
fd_set readset;
fd_set writeset;
int highest = fd;
FD_ZERO(&readset);
FD_ZERO(&writeset);
-
+
FD_SET(fd, &readset);
#if wxUSE_SOCKETS
if (wxTheSocketTable)
wxTheSocketTable->FillSets( &readset, &writeset, &highest );
#endif
-
+
if (select( highest+1, &readset, &writeset, NULL, &tv ) == 0)
{
// Timed out, so no event to process
#endif
}
#endif
- }
+ }
else
{
XNextEvent( wxGlobalDisplay(), &event );
}
-
-
+
+
(void) m_impl->ProcessEvent( &event );
return TRUE;
}
projects / wxWidgets.git / commitdiff
