Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

switched to wxEventLoopBase/wxEventLoop implementation (instead of m_impl based one) for wxMSW; minimal changes for the other ports

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@28549 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2004-07-30 22:54:31 +00:00
parent 2cc1424ded
commit 3754265e32
10 changed files with 147 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
include/wx/evtloop.h
View File

@@ -18,35 +18,35 @@
#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; }
@@ -64,11 +64,39 @@ protected:
// 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

50
include/wx/msw/evtloop.h Normal file
View File

@@ -0,0 +1,50 @@
///////////////////////////////////////////////////////////////////////////////
// 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_

7
src/cocoa/evtloop.mm
View File

@@ -48,18 +48,13 @@ private:
// 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!

7
src/gtk/evtloop.cpp
View File

@@ -62,18 +62,13 @@ private:
// 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!

7
src/gtk1/evtloop.cpp
View File

@@ -62,18 +62,13 @@ private:
// 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!

7
src/mgl/evtloop.cpp
View File

@@ -108,18 +108,13 @@ bool wxEventLoopImpl::SendIdleEvent()
// 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!

7
src/motif/evtloop.cpp
View File

@@ -99,18 +99,13 @@ bool wxEventLoopImpl::SendIdleMessage()
// 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!

119
src/msw/evtloop.cpp
View File

@@ -52,45 +52,10 @@
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
@@ -116,14 +81,26 @@ private:
};
// ============================================================================
// 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) )
@@ -134,7 +111,7 @@ void wxEventLoopImpl::ProcessMessage(MSG *msg)
}
}
bool wxEventLoopImpl::PreProcessMessage(MSG *msg)
bool wxEventLoop::PreProcessMessage(WXMSG *msg)
{
HWND hwnd = msg->hwnd;
wxWindow *wndThis = wxGetWindowFromHWND((WXHWND)hwnd);
@@ -145,7 +122,7 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg)
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 )
{
@@ -173,7 +150,7 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg)
// 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
@@ -182,7 +159,7 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg)
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
@@ -197,40 +174,20 @@ bool wxEventLoopImpl::PreProcessMessage(MSG *msg)
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;
return false;
}
// ----------------------------------------------------------------------------
// wxEventLoopImpl idle event processing
// ----------------------------------------------------------------------------
bool wxEventLoopImpl::SendIdleMessage()
{
return wxTheApp && wxTheApp->ProcessIdle();
}
// ============================================================================
// 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()
@@ -238,11 +195,10 @@ 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
@@ -265,13 +221,13 @@ int wxEventLoop::Run()
// 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();
@@ -315,14 +271,15 @@ int wxEventLoop::Run()
}
#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();
@@ -348,7 +305,7 @@ bool wxEventLoop::Pending() const
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);
@@ -356,7 +313,7 @@ bool wxEventLoop::Dispatch()
if ( rc == 0 )
{
// got WM_QUIT
return FALSE;
return false;
}
if ( rc == -1 )
@@ -365,14 +322,14 @@ bool wxEventLoop::Dispatch()
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
@@ -380,7 +337,7 @@ bool wxEventLoop::Dispatch()
// 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
@@ -389,7 +346,7 @@ bool wxEventLoop::Dispatch()
s_aSavedMessages.Add(msg);
}
return TRUE;
return true;
}
else
{
@@ -400,13 +357,13 @@ bool wxEventLoop::Dispatch()
// 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();
@@ -414,8 +371,8 @@ bool wxEventLoop::Dispatch()
}
#endif // wxUSE_THREADS
m_impl->ProcessMessage(&msg);
ProcessMessage(&msg);
return TRUE;
return true;
}

7
src/os2/evtloop.cpp
View File

@@ -227,7 +227,7 @@ bool wxEventLoopImpl::SendIdleMessage()
// wxEventLoop implementation
// ============================================================================
wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
// ----------------------------------------------------------------------------
// wxEventLoop running and exiting
@@ -238,11 +238,6 @@ wxEventLoop::~wxEventLoop()
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

7
src/x11/evtloop.cpp
View File

@@ -342,7 +342,7 @@ bool wxEventLoopImpl::SendIdleEvent()
// wxEventLoop implementation
// ============================================================================
wxEventLoop *wxEventLoop::ms_activeLoop = NULL;
wxEventLoop *wxEventLoopBase::ms_activeLoop = NULL;
// ----------------------------------------------------------------------------
// wxEventLoop running and exiting
@@ -353,11 +353,6 @@ 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!