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

Cleanly separate GUI socket-related code from net library.

Browse Source 
This fixes linking problems under Unix introduced by recent changes which
fixed previous problems which were due to files not being linked in at all.

In order to provide a clean separation between base, net and core libraries we
now use the same wxSocketManager (wxSocketFDBasedManager), defined in net
library for both console and GUI Unix applications and just use different FD
IO manager for them: the latter can be defined in base and core libraries as
it doesn't involve wxSocketImpl at all, only its base wxFDIOHandler class.

At more detailed level, these changes required:
 1. Adding the new wxFDIOManager class.
 2. Refactoring the old (and now removed) wxSocketFDIOManager to use the same
    code as wxSocketFDIOManager. This involved:
  a) Adding handler and direction parameter to RemoveInput().
  b) Storing the mask of registered events in wxFDIOHandler itself.
  c) Defining wxFDIOManagerUnix which works with wxFDIODispatcher.
 3. Changing the traits classes in Unix ports to define GetFDIOManager()
    instead of GetSocketManager().

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@61688 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
2009-08-17 23:02:46 +00:00
parent b79dfbca98
commit 6bcc1145fe
16 changed files with 519 additions and 336 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/wx/os2/apptbase.h
View File

@@ -27,11 +27,9 @@ public:
// Clean up message queue.
virtual void TerminateGui(unsigned long ulHab);
#if wxUSE_SOCKETS
// returns the select()-based socket manager for console applications which
// is also used by some ports (wxX11, wxDFB) in the GUI build (hence it is
// here and not in wxConsoleAppTraits)
virtual wxSocketManager *GetSocketManager();
virtual wxFDIOManager *GetFDIOManager();
#endif
};

2
include/wx/os2/apptrait.h
View File

@@ -50,7 +50,7 @@ public:
virtual wxString GetDesktopEnvironment() const;
#endif
#if wxUSE_SOCKETS
virtual wxSocketManager *GetSocketManager();
virtual wxFDIOManager *GetFDIOManager();
#endif
};

15
include/wx/private/fdiohandler.h
View File

@@ -18,6 +18,8 @@
class wxFDIOHandler
{
public:
wxFDIOHandler() { m_regmask = 0; }
// called when descriptor is available for non-blocking read
virtual void OnReadWaiting() = 0;
@@ -31,8 +33,21 @@ public:
// wxSocketImplUnix currently
virtual bool IsOk() const { return true; }
// get/set the mask of events for which we're currently registered for:
// it's a combination of wxFDIO_{INPUT,OUTPUT,EXCEPTION}
int GetRegisteredEvents() const { return m_regmask; }
void SetRegisteredEvent(int flag) { m_regmask |= flag; }
void ClearRegisteredEvent(int flag) { m_regmask &= ~flag; }
// virtual dtor for the base class
virtual ~wxFDIOHandler() { }
private:
int m_regmask;
wxDECLARE_NO_COPY_CLASS(wxFDIOHandler);
};
#endif // _WX_PRIVATE_FDIOHANDLER_H_

43
include/wx/private/fdiomanager.h Normal file
View File

@@ -0,0 +1,43 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/private/fdiomanager.h
// Purpose: declaration of wxFDIOManager
// Author: Vadim Zeitlin
// Created: 2009-08-17
// 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_PRIVATE_FDIOMANAGER_H_
#define _WX_PRIVATE_FDIOMANAGER_H_
#include "wx/private/fdiohandler.h"
// ----------------------------------------------------------------------------
// wxFDIOManager: register or unregister wxFDIOHandlers
// ----------------------------------------------------------------------------
// currently only used in wxGTK and wxMotif, see wx/unix/apptrait.h
class wxFDIOManager
{
public:
// identifies either input or output direction
//
// NB: the values of this enum shouldn't change
enum Direction
{
INPUT,
OUTPUT
};
// start or stop monitoring the events on the given file descriptor
virtual int AddInput(wxFDIOHandler *handler, int fd, Direction d) = 0;
virtual void RemoveInput(wxFDIOHandler *handler, int fd, Direction d) = 0;
// empty but virtual dtor for the base class
virtual ~wxFDIOManager() { }
};
#endif // _WX_PRIVATE_FDIOMANAGER_H_

13
include/wx/unix/apptbase.h
View File

@@ -14,6 +14,7 @@
struct wxEndProcessData;
struct wxExecuteData;
class wxFDIOManager;
// ----------------------------------------------------------------------------
// wxAppTraits: the Unix version adds extra hooks needed by Unix code
@@ -42,6 +43,18 @@ public:
// loop
virtual int AddProcessCallback(wxEndProcessData *data, int fd);
#if wxUSE_SOCKETS
// return a pointer to the object which should be used to integrate
// monitoring of the file descriptors to the event loop (currently this is
// used for the sockets only but should be used for arbitrary event loop
// sources in the future)
//
// this object may be different for the console and GUI applications
//
// the pointer is not deleted by the caller as normally it points to a
// static variable
virtual wxFDIOManager *GetFDIOManager();
#endif // wxUSE_SOCKETS
protected:
// a helper for the implementation of WaitForChild() in wxGUIAppTraits:

17
include/wx/unix/apptrait.h
View File

@@ -36,7 +36,12 @@ public:
// TODO: Should we use XtAddInput() for wxX11 too? Or, vice versa, if there is
// no advantage in doing this compared to the generic way currently used
// by wxX11, should we continue to use GTK/Motif-specific stuff?
#if defined(__WXGTK__) || defined(__WXMOTIF__) || defined(__WXMAC__)
#if defined(__WXGTK__) || defined(__WXMOTIF__)
#define wxHAS_GUI_FDIOMANAGER
#define wxHAS_GUI_PROCESS_CALLBACKS
#endif // ports using wxFDIOManager
#if defined(__WXMAC__)
#define wxHAS_GUI_PROCESS_CALLBACKS
#define wxHAS_GUI_SOCKET_MANAGER
#endif
@@ -76,9 +81,17 @@ public:
virtual bool ShowAssertDialog(const wxString& msg);
#endif
#if wxUSE_SOCKETS && defined(wxHAS_GUI_SOCKET_MANAGER)
#if wxUSE_SOCKETS
#ifdef wxHAS_GUI_SOCKET_MANAGER
virtual wxSocketManager *GetSocketManager();
#endif
#ifdef wxHAS_GUI_FDIOMANAGER
virtual wxFDIOManager *GetFDIOManager();
#endif
#endif // wxUSE_SOCKETS
};
#endif // wxUSE_GUI

28
include/wx/unix/private/fdiounix.h Normal file
View File

@@ -0,0 +1,28 @@
///////////////////////////////////////////////////////////////////////////////
// Name: wx/unix/private/fdiounix.h
// Purpose: wxFDIOManagerUnix class used by console Unix applications
// Author: Vadim Zeitlin
// Created: 2009-08-17
// 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 _UNIX_PRIVATE_FDIOUNIX_H_
#define _UNIX_PRIVATE_FDIOUNIX_H_
#include "wx/private/fdiomanager.h"
// ----------------------------------------------------------------------------
// wxFDIOManagerUnix: implement wxFDIOManager interface using wxFDIODispatcher
// ----------------------------------------------------------------------------
class wxFDIOManagerUnix : public wxFDIOManager
{
public:
virtual int AddInput(wxFDIOHandler *handler, int fd, Direction d);
virtual void RemoveInput(wxFDIOHandler *handler, int fd, Direction d);
};
#endif // _UNIX_PRIVATE_FDIOUNIX_H_

116
include/wx/unix/private/sockunix.h
View File

@@ -14,7 +14,7 @@
#include <unistd.h>
#include <sys/ioctl.h>
#include "wx/private/fdiodispatcher.h"
#include "wx/private/fdiomanager.h"
class wxSocketImplUnix : public wxSocketImpl,
public wxFDIOHandler
@@ -25,8 +25,6 @@ public:
{
m_fds[0] =
m_fds[1] = -1;
m_enabledCallbacks = 0;
}
virtual wxSocketError GetLastError() const;
@@ -54,14 +52,6 @@ public:
virtual void OnExceptionWaiting();
virtual bool IsOk() const { return m_fd != INVALID_SOCKET; }
// Unix-specific functions used by wxSocketFDIOManager only
bool HasAnyEnabledCallbacks() const { return m_enabledCallbacks != 0; }
void EnableCallback(wxFDIODispatcherEntryFlags flag)
{ m_enabledCallbacks |= flag; }
void DisableCallback(wxFDIODispatcherEntryFlags flag)
{ m_enabledCallbacks &= ~flag; }
int GetEnabledCallbacks() const { return m_enabledCallbacks; }
private:
virtual void DoClose()
{
@@ -92,10 +82,6 @@ protected:
// with the socket
int m_fds[2];
// the events which are currently enabled for this socket, combination of
// wxFDIO_INPUT and wxFDIO_OUTPUT values
int m_enabledCallbacks;
private:
// notify the associated wxSocket about a change in socket state and shut
// down the socket if the event is wxSOCKET_LOST
@@ -110,12 +96,18 @@ private:
friend class wxSocketFDBasedManager;
};
// A version of wxSocketManager which uses FDs for socket IO
// A version of wxSocketManager which uses FDs for socket IO: it is used by
// Unix console applications and some X11-like ports (wxGTK and wxMotif but not
// wxX11 currently) which implement their own port-specific wxFDIOManagers
class wxSocketFDBasedManager : public wxSocketManager
{
public:
// no special initialization/cleanup needed when using FDs
virtual bool OnInit() { return true; }
wxSocketFDBasedManager()
{
m_fdioManager = NULL;
}
virtual bool OnInit();
virtual void OnExit() { }
virtual wxSocketImpl *CreateSocket(wxSocketBase& wxsocket)
@@ -123,95 +115,23 @@ public:
return new wxSocketImplUnix(wxsocket);
}
virtual void Install_Callback(wxSocketImpl *socket_, wxSocketNotify event);
virtual void Uninstall_Callback(wxSocketImpl *socket_, wxSocketNotify event);
protected:
// identifies either input or output direction
//
// NB: the values of this enum shouldn't change
enum SocketDir
{
FD_INPUT,
FD_OUTPUT
};
// get the FD index corresponding to the given wxSocketNotify
SocketDir GetDirForEvent(wxSocketImpl *socket, wxSocketNotify event)
{
switch ( event )
{
default:
wxFAIL_MSG( "unknown socket event" );
return FD_INPUT; // we must return something
case wxSOCKET_LOST:
wxFAIL_MSG( "unexpected socket event" );
return FD_INPUT; // as above
case wxSOCKET_INPUT:
return FD_INPUT;
case wxSOCKET_OUTPUT:
return FD_OUTPUT;
case wxSOCKET_CONNECTION:
// for server sockets we're interested in events indicating
// that a new connection is pending, i.e. that accept() will
// succeed and this is indicated by socket becoming ready for
// reading, while for the other ones we're interested in the
// completion of non-blocking connect() which is indicated by
// the socket becoming ready for writing
return socket->IsServer() ? FD_INPUT : FD_OUTPUT;
}
}
wxFDIOManager::Direction
GetDirForEvent(wxSocketImpl *socket, wxSocketNotify event);
// access the FDs we store
int& FD(wxSocketImplUnix *socket, SocketDir d)
int& FD(wxSocketImplUnix *socket, wxFDIOManager::Direction d)
{
return socket->m_fds[d];
}
};
// Common base class for all ports using X11-like (and hence implemented in
// X11, Motif and GTK) AddInput() and RemoveInput() functions
class wxSocketInputBasedManager : public wxSocketFDBasedManager
{
public:
virtual void Install_Callback(wxSocketImpl *socket_, wxSocketNotify event)
{
wxSocketImplUnix * const
socket = static_cast<wxSocketImplUnix *>(socket_);
wxFDIOManager *m_fdioManager;
wxCHECK_RET( socket->m_fd != -1,
"shouldn't be called on invalid socket" );
const SocketDir d = GetDirForEvent(socket, event);
int& fd = FD(socket, d);
if ( fd != -1 )
RemoveInput(fd);
fd = AddInput(socket, socket->m_fd, d);
}
virtual void Uninstall_Callback(wxSocketImpl *socket_, wxSocketNotify event)
{
wxSocketImplUnix * const
socket = static_cast<wxSocketImplUnix *>(socket_);
const SocketDir d = GetDirForEvent(socket, event);
int& fd = FD(socket, d);
if ( fd != -1 )
{
RemoveInput(fd);
fd = -1;
}
}
private:
// these functions map directly to XtAdd/RemoveInput() or
// gdk_input_add/remove()
virtual int AddInput(wxSocketImplUnix *handler, int fd, SocketDir d) = 0;
virtual void RemoveInput(int fd) = 0;
wxDECLARE_NO_COPY_CLASS(wxSocketFDBasedManager);
};
#endif /* _WX_UNIX_GSOCKUNX_H_ */