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

Refactor wxEventLoopSource-related code.

Browse Source 
Currently wxEventLoopSource can't be created directly and can only be used to
monitor file descriptors so reduce the API to just wxEventLoop::AddSourceForFD()
and remove AddSource(), RemoveSource() and RemoveAllSources() which couldn't
be implemented for all ports. This makes the code much simpler without any
loss of functionality.

Make wxEventLoopSource responsible for removing itself from the event loop
when it is deleted. This allows to remove IsOk() and Invalidate() methods
making the code simpler and gets rid of various sets/maps which were used
before.

This also allows to support event loop sources in Carbon as well: wxOSX/Carbon
now compiles and works with wxUSE_FSWATCHER==1.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@62475 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2009-10-22 11:36:35 +00:00
parent 6b8ef0b35d
commit 5cd9986613
25 changed files with 634 additions and 655 deletions
Download Patch File Download Diff File Expand all files Collapse all files

305
include/wx/evtloop.h
View File

@@ -14,208 +14,20 @@
#include "wx/event.h"
#include "wx/utils.h"
#include "wx/hashset.h"
// ----------------------------------------------------------------------------
// wxEventLoopSource: source of i/o for wxEventLoop
// ----------------------------------------------------------------------------
#define wxTRACE_EVT_SOURCE "EventSource"
#if defined(__UNIX__) && (wxUSE_CONSOLE_EVENTLOOP || defined(__WXGTK__) || \
defined(__WXOSX_COCOA__))
// TODO: implement wxEventLoopSource for MSW (it should wrap a HANDLE and be
// monitored using MsgWaitForMultipleObjects())
#if defined(__WXOSX__) || defined(__WXGTK20__) || defined(__WXDFB__) || \
(!wxUSE_GUI && defined(__UNIX__))
#define wxUSE_EVENTLOOP_SOURCE 1
#else
#define wxUSE_EVENTLOOP_SOURCE 0
#endif
#if wxUSE_EVENTLOOP_SOURCE
// handler used to process events on event loop sources
class WXDLLIMPEXP_BASE wxEventLoopSourceHandler
{
public:
// called when descriptor is available for non-blocking read
virtual void OnReadWaiting() = 0;
// called when descriptor is available for non-blocking write
virtual void OnWriteWaiting() = 0;
// called when there is exception on descriptor
virtual void OnExceptionWaiting() = 0;
// virtual dtor for the base class
virtual ~wxEventLoopSourceHandler() { }
};
// those flags describes what events should be reported
enum
{
wxEVENT_SOURCE_INPUT = 0x01,
wxEVENT_SOURCE_OUTPUT = 0x02,
wxEVENT_SOURCE_EXCEPTION = 0x04,
wxEVENT_SOURCE_ALL = wxEVENT_SOURCE_INPUT | wxEVENT_SOURCE_OUTPUT |
wxEVENT_SOURCE_EXCEPTION,
};
class wxAbstractEventLoopSource
{
public:
wxAbstractEventLoopSource() :
m_handler(NULL), m_flags(-1)
{}
wxAbstractEventLoopSource(wxEventLoopSourceHandler* handler, int flags) :
m_handler(handler), m_flags(flags)
{}
virtual ~wxAbstractEventLoopSource() { }
virtual bool IsOk() const = 0;
virtual void Invalidate() = 0;
void SetHandler(wxEventLoopSourceHandler* handler)
{
m_handler = handler;
}
wxEventLoopSourceHandler* GetHandler() const
{
return m_handler;
}
void SetFlags(int flags)
{
m_flags = flags;
}
int GetFlags() const
{
return m_flags;
}
protected:
wxEventLoopSourceHandler* m_handler;
int m_flags;
};
// This class is a simple wrapper for OS specific resources than can be a
// source of I/O. On Unix,for instance these are file descriptors.
//
// Instances of this class doesn't take resposibility of any resource you pass
// to them, I.E. you have to release them yourself.
template<class T>
class WXDLLIMPEXP_BASE wxEventLoopSourceBase : public wxAbstractEventLoopSource
{
public:
typedef T Resource;
// copy ctor
wxEventLoopSourceBase(const wxEventLoopSourceBase& source) :
wxAbstractEventLoopSource(source.GetHandler(), source.GetFlags()),
m_res(source.GetResource())
{
}
virtual const T InvalidResource() const
{
return (T)-1;
}
virtual void Invalidate()
{
SetResource(InvalidResource());
SetHandler(NULL);
}
// sets internal value to res
void SetResource(T res)
{
m_res = res;
}
// returns associated resource
T GetResource() const
{
return m_res;
}
virtual bool IsOk() const
{
// flags < 0 are invalid and flags == 0 mean monitoring for nothing
return m_res != InvalidResource() && m_handler && m_flags >=1;
}
protected:
// empty ctor, beacuse we often store event sources as values
wxEventLoopSourceBase() :
wxAbstractEventLoopSource(),
m_res(InvalidResource())
{
}
// ctor setting internal value to the os resource res
wxEventLoopSourceBase(T res, wxEventLoopSourceHandler* handler,
int flags) :
wxAbstractEventLoopSource(handler, flags),
m_res(res)
{ }
T m_res;
};
#if defined(__WXMAC__)
class wxMacEventLoopSource : public wxEventLoopSourceBase<CFRunLoopSourceRef>
{
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
int GetFileDescriptor() const
{
return m_fd;
}
class wxEventLoopSource;
class wxEventLoopSourceHandler;
#endif
protected:
wxMacEventLoopSource() : wxEventLoopSourceBase<CFRunLoopSourceRef>() { }
// ctor setting internal value to the os resource res
wxMacEventLoopSource(CFRunLoopSourceRef res,
wxEventLoopSourceHandler* handler, int flags) :
wxEventLoopSourceBase<CFRunLoopSourceRef>(res, handler, flags)
{
}
#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
int m_fd;
#endif
friend class wxGUIEventLoop;
};
#endif
#if defined(__UNIX__)
class wxUnixEventLoopSource : public wxEventLoopSourceBase<int>
{
protected:
wxUnixEventLoopSource() : wxEventLoopSourceBase<int>() { }
// ctor setting internal value to the os resource res
wxUnixEventLoopSource(int res, wxEventLoopSourceHandler* handler,
int flags) :
wxEventLoopSourceBase<int>(res, handler, flags)
{
}
friend class wxConsoleEventLoop;
friend class wxGUIEventLoop;
};
#endif
// the list of watched sources
WX_DECLARE_HASH_SET(wxAbstractEventLoopSource*, wxPointerHash, wxPointerEqual,
wxEventLoopSourceHashSet);
#endif
/*
NOTE ABOUT wxEventLoopBase::YieldFor LOGIC
@@ -267,67 +79,11 @@ public:
bool IsMain() const;
#if wxUSE_EVENTLOOP_SOURCE
virtual wxAbstractEventLoopSource* CreateSource() const = 0;
virtual wxAbstractEventLoopSource* CreateSource(int WXUNUSED(res),
wxEventLoopSourceHandler* WXUNUSED(handler),
int WXUNUSED(flags)) const
{
return NULL;
}
// adds source to be monitored for I/O events specified in flags. Upon an
// event the appropriate method of handler will be called. The handler is
// owned be the calling client and will not be freed in any case.
// Returns true if the source was successfully added, false if it failed
// (this may happen for example when this source is already monitored)
virtual bool AddSource(wxAbstractEventLoopSource* source)
{
wxCHECK_MSG( source && source->IsOk(), false, "Invalid source" );
wxEventLoopSourceHashSet::value_type val(source);
if (!m_sourceMap.insert(val).second)
{
return false;
}
bool ret = DoAddSource(source);
if (!ret)
{
(void) m_sourceMap.erase(source);
}
return ret;
}
// removes the source from the list of monitored sources.
// Returns true if the source was successfully removed, false otherwise
virtual bool RemoveSource(wxAbstractEventLoopSource* source)
{
wxCHECK_MSG( source && source->IsOk(), false, "Invalid source" );
if (m_sourceMap.find(source) == m_sourceMap.end())
{
return false;
}
bool ret = DoRemoveSource(source);
m_sourceMap.erase(source);
return ret;
}
bool RemoveAllSources()
{
wxEventLoopSourceHashSet::iterator it = m_sourceMap.begin();
while ( !m_sourceMap.empty() )
{
(void) RemoveSource(*it);
m_sourceMap.erase(it);
it = m_sourceMap.begin();
}
return true;
}
#endif
// create a new event loop source wrapping the given file descriptor and
// start monitoring it
virtual wxEventLoopSource *
AddSourceForFD(int fd, wxEventLoopSourceHandler *handler, int flags) = 0;
#endif // wxUSE_EVENTLOOP_SOURCE
// dispatch&processing
// -------------------
@@ -414,13 +170,6 @@ public:
protected:
#if wxUSE_EVENTLOOP_SOURCE
virtual bool DoAddSource(wxAbstractEventLoopSource* source) = 0;
virtual bool DoRemoveSource(wxAbstractEventLoopSource* source) = 0;
wxEventLoopSourceHashSet m_sourceMap;
#endif
// this function should be called before the event loop terminates, whether
// this happens normally (because of Exit() call) or abnormally (because of
// an exception thrown from inside the loop)
@@ -479,18 +228,31 @@ private:
#endif // platforms using "manual" loop
// include the header defining wxConsoleEventLoop for Unix systems
#if defined(__UNIX__)
#include "wx/unix/evtloop.h"
#endif
// 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.
// integration with MFC) but currently this is not done for all ports yet (e.g.
// wxX11) so fall back to the old wxGUIEventLoop definition below for them
#if defined(__WXPALMOS__)
#include "wx/palmos/evtloop.h"
#elif defined(__WXMSW__)
// this header defines both console and GUI loops for MSW
#include "wx/msw/evtloop.h"
#elif defined(__WXMAC__)
#elif defined(__WXOSX__)
// CoreFoundation-based event loop is currently in wxBase so include it in
// any case too (although maybe it actually shouldn't be there at all)
#include "wx/osx/evtloop.h"
#elif defined(__WXCOCOA__)
#elif wxUSE_GUI
// include the appropriate header defining wxGUIEventLoop
#if defined(__WXCOCOA__)
#include "wx/cocoa/evtloop.h"
#elif defined(__WXDFB__)
#include "wx/dfb/evtloop.h"
@@ -538,16 +300,13 @@ protected:
#endif // platforms
// also include the header defining wxConsoleEventLoop for Unix systems
#if defined(__UNIX__)
#include "wx/unix/evtloop.h"
#endif
#endif // wxUSE_GUI
// we use a class rather than a typedef because wxEventLoop is forward-declared
// in many places
#if wxUSE_GUI
// we use a class rather than a typedef because wxEventLoop is
// forward-declared in many places
class wxEventLoop : public wxGUIEventLoop { };
#else // !GUI
#else // !wxUSE_GUI
// we can't define wxEventLoop differently in GUI and base libraries so use
// a #define to still allow writing wxEventLoop in the user code
#if wxUSE_CONSOLE_EVENTLOOP && (defined(__WXMSW__) || defined(__UNIX__))

99
include/wx/evtloopsrc.h Normal file
View File

@@ -0,0 +1,99 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/evtloopsrc.h
// Purpose: declaration of wxEventLoopSource class
// Author: Vadim Zeitlin
// Created: 2009-10-21
// RCS-ID: $Id: wxhead.h,v 1.11 2009-06-29 10:23:04 zeitlin Exp $
// Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_EVTLOOPSRC_H_
#define _WX_EVTLOOPSRC_H_
// ----------------------------------------------------------------------------
// wxEventLoopSource: a source of events which may be added to wxEventLoop
// ----------------------------------------------------------------------------
// TODO: refactor wxSocket under Unix to reuse wxEventLoopSource instead of
// duplicating much of its logic
//
// TODO: freeze the API and document it
#if wxUSE_EVENTLOOP_SOURCE
#define wxTRACE_EVT_SOURCE "EventSource"
// handler used to process events on event loop sources
class wxEventLoopSourceHandler
{
public:
// called when descriptor is available for non-blocking read
virtual void OnReadWaiting() = 0;
// called when descriptor is available for non-blocking write
virtual void OnWriteWaiting() = 0;
// called when there is exception on descriptor
virtual void OnExceptionWaiting() = 0;
// virtual dtor for the base class
virtual ~wxEventLoopSourceHandler() { }
};
// flags describing which kind of IO events we're interested in
enum
{
wxEVENT_SOURCE_INPUT = 0x01,
wxEVENT_SOURCE_OUTPUT = 0x02,
wxEVENT_SOURCE_EXCEPTION = 0x04,
wxEVENT_SOURCE_ALL = wxEVENT_SOURCE_INPUT |
wxEVENT_SOURCE_OUTPUT |
wxEVENT_SOURCE_EXCEPTION,
};
// wxEventLoopSource itself is an ABC and can't be created directly, currently
// the only way to create it is by using wxEventLoop::AddSourceForFD().
class wxEventLoopSource
{
public:
// dtor is pure virtual because it must be overridden to remove the source
// from the event loop monitoring it
virtual ~wxEventLoopSource() = 0;
void SetHandler(wxEventLoopSourceHandler* handler) { m_handler = handler; }
wxEventLoopSourceHandler* GetHandler() const { return m_handler; }
void SetFlags(int flags) { m_flags = flags; }
int GetFlags() const { return m_flags; }
protected:
// ctor is only used by the derived classes
wxEventLoopSource(wxEventLoopSourceHandler *handler, int flags)
: m_handler(handler),
m_flags(flags)
{
}
wxEventLoopSourceHandler* m_handler;
int m_flags;
wxDECLARE_NO_COPY_CLASS(wxEventLoopSource);
};
inline wxEventLoopSource::~wxEventLoopSource() { }
#if defined(__UNIX__)
#include "wx/unix/evtloopsrc.h"
#endif // __UNIX__
#if defined(__WXGTK20__)
#include "wx/gtk/evtloopsrc.h"
#elif defined(__WXOSX__)
#include "wx/osx/evtloopsrc.h"
#endif // platform
#endif // wxUSE_EVENTLOOP_SOURCE
#endif // _WX_EVTLOOPSRC_H_

40
include/wx/gtk/evtloop.h
View File

@@ -17,17 +17,9 @@
typedef union _GdkEvent GdkEvent;
#if wxUSE_EVENTLOOP_SOURCE
// maps event loop sources to gtk source ids
WX_DECLARE_HASH_MAP(wxUnixEventLoopSource*, int, wxPointerHash, wxPointerEqual,
wxEventLoopSourceIdMap);
#endif
class WXDLLIMPEXP_BASE wxGUIEventLoop : public wxEventLoopBase
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxEventLoopBase
{
public:
typedef wxUnixEventLoopSource Source;
wxGUIEventLoop();
virtual int Run();
@@ -38,33 +30,15 @@ public:
virtual void WakeUp();
virtual bool YieldFor(long eventsToProcess);
#if wxUSE_EVENTLOOP_SOURCE
virtual wxEventLoopSource *
AddSourceForFD(int fd, wxEventLoopSourceHandler *handler, int flags);
#endif // wxUSE_EVENTLOOP_SOURCE
void StoreGdkEventForLaterProcessing(GdkEvent* ev)
{ m_arrGdkEvents.Add(ev); }
#if wxUSE_EVENTLOOP_SOURCE
virtual wxUnixEventLoopSource* CreateSource() const
{
return new wxUnixEventLoopSource();
}
virtual wxUnixEventLoopSource* CreateSource(int res,
wxEventLoopSourceHandler* handler,
int flags) const
{
return new wxUnixEventLoopSource(res, handler, flags);
}
#endif
protected:
#if wxUSE_EVENTLOOP_SOURCE
// adding/removing sources
virtual bool DoAddSource(wxAbstractEventLoopSource* source);
virtual bool DoRemoveSource(wxAbstractEventLoopSource* source);
// map of event loop sources gtk ids
wxEventLoopSourceIdMap m_sourceIdMap;
#endif
private:
// the exit code of this event loop
int m_exitcode;

40
include/wx/gtk/evtloopsrc.h Normal file
View File

@@ -0,0 +1,40 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/gtk/evtloopsrc.h
// Purpose: wxGTKEventLoopSource class
// Author: Vadim Zeitlin
// Created: 2009-10-21
// RCS-ID: $Id: wxhead.h,v 1.11 2009-06-29 10:23:04 zeitlin Exp $
// Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_EVTLOOPSRC_H_
#define _WX_GTK_EVTLOOPSRC_H_
// ----------------------------------------------------------------------------
// wxGTKEventLoopSource: wxEventLoopSource for GTK port
// ----------------------------------------------------------------------------
class wxGTKEventLoopSource : public wxEventLoopSource
{
public:
// sourceId is the id of the watch in GTK context, not the FD of the file
// this source corresponds to
wxGTKEventLoopSource(unsigned sourceId,
wxEventLoopSourceHandler *handler,
int flags)
: wxEventLoopSource(handler, flags),
m_sourceId(sourceId)
{
}
virtual ~wxGTKEventLoopSource();
private:
const unsigned m_sourceId;
wxDECLARE_NO_COPY_CLASS(wxGTKEventLoopSource);
};
#endif // _WX_GTK_EVTLOOPSRC_H_

5
include/wx/osx/carbon/evtloop.h
View File

@@ -15,7 +15,7 @@
class OpaqueEventRef;
typedef OpaqueEventRef *EventRef;
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxEventLoopManual
class WXDLLIMPEXP_CORE wxGUIEventLoop : public wxCFEventLoop
{
public:
wxGUIEventLoop();
@@ -28,6 +28,9 @@ public:
virtual void WakeUp();
virtual bool YieldFor(long eventsToProcess);
protected:
virtual CFRunLoopRef CFGetCurrentRunLoop() const;
private:
// dispatch an event and release it
void DispatchAndReleaseEvent(EventRef event);

28
include/wx/osx/cocoa/evtloop.h
View File

@@ -11,11 +11,9 @@
#ifndef _WX_OSX_COCOA_EVTLOOP_H_
#define _WX_OSX_COCOA_EVTLOOP_H_
class WXDLLIMPEXP_BASE wxGUIEventLoop : public wxEventLoopManual
class WXDLLIMPEXP_BASE wxGUIEventLoop : public wxCFEventLoop
{
public:
typedef wxMacEventLoopSource Source;
wxGUIEventLoop();
// implement/override base class pure virtual
@@ -26,30 +24,8 @@ public:
virtual void WakeUp();
virtual bool YieldFor(long eventsToProcess);
#if wxUSE_EVENTLOOP_SOURCE
virtual wxMacEventLoopSource* CreateSource() const
{
return new wxMacEventLoopSource();
}
virtual wxMacEventLoopSource* CreateSource(int res,
wxEventLoopSourceHandler* handler,
int flags) const;
virtual wxMacEventLoopSource* CreateSource(CFRunLoopSourceRef res,
wxEventLoopSourceHandler* handler,
int flags) const
{
return new wxMacEventLoopSource(res, handler, flags);
}
#endif
protected:
#if wxUSE_EVENTLOOP_SOURCE
// adding/removing sources
virtual bool DoAddSource(wxAbstractEventLoopSource* source);
virtual bool DoRemoveSource(wxAbstractEventLoopSource* source);
#endif
virtual CFRunLoopRef CFGetCurrentRunLoop() const;
private:
double m_sleepTime;

9
include/wx/osx/core/cfref.h
View File

@@ -308,6 +308,15 @@ public:
wxCFRelease(m_ptr);
m_ptr = p; // Automatic conversion should occur
}
// Release the pointer, i.e. give up its ownership.
refType release()
{
refType p = m_ptr;
m_ptr = NULL;
return p;
}
protected:
/*! @var m_ptr The raw pointer.
*/

33
include/wx/osx/evtloop.h
View File

@@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////////
// Name: include/wx/mac/evtloop.h
// Name: include/wx/osx/evtloop.h
// Purpose: simply forwards to wx/mac/carbon/evtloop.h for consistency with
// the other Mac headers
// Author: Vadim Zeitlin
@@ -10,9 +10,30 @@
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __WXOSX_COCOA__
#include "wx/osx/cocoa/evtloop.h"
#else
#include "wx/osx/carbon/evtloop.h"
#endif
#ifndef _WX_OSX_EVTLOOP_H_
#define _WX_OSX_EVTLOOP_H_
typedef struct __CFRunLoop * CFRunLoopRef;
class WXDLLIMPEXP_BASE wxCFEventLoop : public wxEventLoopManual
{
public:
#if wxUSE_EVENTLOOP_SOURCE
virtual wxEventLoopSource *
AddSourceForFD(int fd, wxEventLoopSourceHandler *handler, int flags);
#endif // wxUSE_EVENTLOOP_SOURCE
protected:
// get the currently executing CFRunLoop
virtual CFRunLoopRef CFGetCurrentRunLoop() const = 0;
};
#if wxUSE_GUI
#ifdef __WXOSX_COCOA__
#include "wx/osx/cocoa/evtloop.h"
#else
#include "wx/osx/carbon/evtloop.h"
#endif
#endif // wxUSE_GUI
#endif // _WX_OSX_EVTLOOP_H_

41
include/wx/osx/evtloopsrc.h Normal file
View File

@@ -0,0 +1,41 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/evtloopsrc.h
// Purpose: wxCFEventLoopSource class
// Author: Vadim Zeitlin
// Created: 2009-10-21
// RCS-ID: $Id: wxhead.h,v 1.11 2009-06-29 10:23:04 zeitlin Exp $
// Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OSX_EVTLOOPSRC_H_
#define _WX_OSX_EVTLOOPSRC_H_
typedef struct __CFFileDescriptor *CFFileDescriptorRef;
// ----------------------------------------------------------------------------
// wxCFEventLoopSource: CoreFoundation-based wxEventLoopSource for OS X
// ----------------------------------------------------------------------------
class wxCFEventLoopSource : public wxEventLoopSource
{
public:
wxCFEventLoopSource(wxEventLoopSourceHandler *handler, int flags)
: wxEventLoopSource(handler, flags)
{
m_cffd = NULL;
}
// we take ownership of this CFFileDescriptorRef
void SetFileDescriptor(CFFileDescriptorRef cffd);
virtual ~wxCFEventLoopSource();
private:
CFFileDescriptorRef m_cffd;
wxDECLARE_NO_COPY_CLASS(wxCFEventLoopSource);
};
#endif // _WX_OSX_EVTLOOPSRC_H_

2
include/wx/private/fswatcher.h
View File

@@ -52,7 +52,7 @@ public:
wxCHECK_MSG( m_watches.find(winfo.GetPath()) == m_watches.end(), false,
"Path '%s' is already watched");
// conctruct watch entry
// construct watch entry
wxSharedPtr<wxFSWatchEntry> watch(new wxFSWatchEntry(winfo));
if (!DoAdd(watch))

26
include/wx/unix/evtloop.h
View File

@@ -1,4 +1,4 @@
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/evtloop.h
// Purpose: declares wxEventLoop class
// Author: Lukasz Michalski (lm@zork.pl)
@@ -18,6 +18,7 @@
// ----------------------------------------------------------------------------
class wxFDIODispatcher;
class wxUnixEventLoopSource;
namespace wxPrivate
{
@@ -27,8 +28,6 @@ namespace wxPrivate
class WXDLLIMPEXP_BASE wxConsoleEventLoop : public wxEventLoopManual
{
public:
typedef wxUnixEventLoopSource Source;
// initialize the event loop, use IsOk() to check if we were successful
wxConsoleEventLoop();
virtual ~wxConsoleEventLoop();
@@ -42,26 +41,11 @@ public:
virtual bool YieldFor(long WXUNUSED(eventsToProcess)) { return true; }
#if wxUSE_EVENTLOOP_SOURCE
virtual wxUnixEventLoopSource* CreateSource() const
{
return new wxUnixEventLoopSource();
}
virtual wxUnixEventLoopSource* CreateSource(int res,
wxEventLoopSourceHandler* handler,
int flags) const
{
return new wxUnixEventLoopSource(res, handler, flags);
}
#endif
virtual wxEventLoopSource *
AddSourceForFD(int fd, wxEventLoopSourceHandler *handler, int flags);
#endif // wxUSE_EVENTLOOP_SOURCE
protected:
#if wxUSE_EVENTLOOP_SOURCE
// adding/removing sources
virtual bool DoAddSource(wxAbstractEventLoopSource* source);
virtual bool DoRemoveSource(wxAbstractEventLoopSource* source);
#endif
virtual void OnNextIteration();
private:

49
include/wx/unix/evtloopsrc.h Normal file
View File

@@ -0,0 +1,49 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/evtloopsrc.h
// Purpose: wxUnixEventLoopSource class
// Author: Vadim Zeitlin
// Created: 2009-10-21
// RCS-ID: $Id: wxhead.h,v 1.11 2009-06-29 10:23:04 zeitlin Exp $
// Copyright: (c) 2009 Vadim Zeitlin <vadim@wxwidgets.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UNIX_EVTLOOPSRC_H_
#define _WX_UNIX_EVTLOOPSRC_H_
class wxFDIODispatcher;
class wxFDIOHandler;
// ----------------------------------------------------------------------------
// wxUnixEventLoopSource: wxEventLoopSource for Unix-like toolkits using fds
// ----------------------------------------------------------------------------
class wxUnixEventLoopSource : public wxEventLoopSource
{
public:
// dispatcher and fdioHandler are only used here to allow us to unregister
// from the event loop when we're destroyed
wxUnixEventLoopSource(wxFDIODispatcher *dispatcher,
wxFDIOHandler *fdioHandler,
int fd,
wxEventLoopSourceHandler *handler,
int flags)
: wxEventLoopSource(handler, flags),
m_dispatcher(dispatcher),
m_fdioHandler(fdioHandler),
m_fd(fd)
{
}
virtual ~wxUnixEventLoopSource();
private:
wxFDIODispatcher * const m_dispatcher;
wxFDIOHandler * const m_fdioHandler;
const int m_fd;
wxDECLARE_NO_COPY_CLASS(wxUnixEventLoopSource);
};
#endif // _WX_UNIX_EVTLOOPSRC_H_

1
include/wx/unix/private/fswatcher_inotify.h
View File

@@ -12,6 +12,7 @@
#define WX_UNIX_PRIVATE_FSWATCHER_INOTIFY_H_
#include "wx/filename.h"
#include "wx/evtloopsrc.h"
// ============================================================================
// wxFSWatcherEntry implementation & helper declarations

25
include/wx/unix/private/fswatcher_kqueue.h
View File

@@ -106,29 +106,4 @@ private:
wxDECLARE_NO_COPY_CLASS(wxFSWatchEntryKq);
};
// ============================================================================
// wxFSWSourceHandler helper class
// ============================================================================
class wxFSWatcherImplKqueue;
/**
* Handler for handling i/o from inotify descriptor
*/
class wxFSWSourceHandler : public wxEventLoopSourceHandler
{
public:
wxFSWSourceHandler(wxFSWatcherImplKqueue* service) :
m_service(service)
{ }
virtual void OnReadWaiting();
virtual void OnWriteWaiting();
virtual void OnExceptionWaiting();
protected:
wxFSWatcherImplKqueue* m_service;
};
#endif /* WX_UNIX_PRIVATE_FSWATCHER_KQUEUE_H_ */