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

moved wxX11's wxSocketTable to private wxSocketEventDispatcher class reusable in other ports (backport from SOC2006_SOCKETS branch); use it in wxDFB

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@43976 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Václav Slavík
2006-12-14 14:13:57 +00:00
parent ede5511517
commit 6b44a33553
7 changed files with 462 additions and 414 deletions
Download Patch File Download Diff File Expand all files Collapse all files

243
src/x11/evtloop.cpp
View File

@@ -30,7 +30,7 @@
#include "wx/module.h"
#endif
#include "wx/tooltip.h"
#include "wx/private/socketevtdispatch.h"
#include "wx/unix/private.h"
#include "wx/x11/private.h"
#include "X11/Xlib.h"
@@ -46,218 +46,6 @@
# include <sys/select.h>
#endif
#if wxUSE_SOCKETS
// ----------------------------------------------------------------------------
// wxSocketTable
// ----------------------------------------------------------------------------
typedef void (*wxSocketCallback) (int fd, void* data);
class wxSocketTableEntry: public wxObject
{
public:
wxSocketTableEntry()
{
m_fdInput = -1; m_fdOutput = -1;
m_callbackInput = NULL; m_callbackOutput = NULL;
m_dataInput = NULL; m_dataOutput = NULL;
}
int m_fdInput;
int m_fdOutput;
wxSocketCallback m_callbackInput;
wxSocketCallback m_callbackOutput;
void* m_dataInput;
void* m_dataOutput;
};
typedef enum
{ wxSocketTableInput, wxSocketTableOutput } wxSocketTableType ;
class wxSocketTable: public wxHashTable
{
public:
wxSocketTable(): wxHashTable(wxKEY_INTEGER)
{
}
virtual ~wxSocketTable()
{
WX_CLEAR_HASH_TABLE(*this)
}
wxSocketTableEntry* FindEntry(int fd);
void RegisterCallback(int fd, wxSocketTableType socketType, wxSocketCallback callback, void* data);
void UnregisterCallback(int fd, wxSocketTableType socketType);
bool CallCallback(int fd, wxSocketTableType socketType);
void FillSets(fd_set* readset, fd_set* writeset, int* highest);
void ProcessEvents(fd_set* readset, fd_set* writeset);
};
wxSocketTableEntry* wxSocketTable::FindEntry(int fd)
{
wxSocketTableEntry* entry = (wxSocketTableEntry*) Get(fd);
return entry;
}
void wxSocketTable::RegisterCallback(int fd, wxSocketTableType socketType, wxSocketCallback callback, void* data)
{
wxSocketTableEntry* entry = FindEntry(fd);
if (!entry)
{
entry = new wxSocketTableEntry();
Put(fd, entry);
}
if (socketType == wxSocketTableInput)
{
entry->m_fdInput = fd;
entry->m_dataInput = data;
entry->m_callbackInput = callback;
}
else
{
entry->m_fdOutput = fd;
entry->m_dataOutput = data;
entry->m_callbackOutput = callback;
}
}
void wxSocketTable::UnregisterCallback(int fd, wxSocketTableType socketType)
{
wxSocketTableEntry* entry = FindEntry(fd);
if (entry)
{
if (socketType == wxSocketTableInput)
{
entry->m_fdInput = -1;
entry->m_dataInput = NULL;
entry->m_callbackInput = NULL;
}
else
{
entry->m_fdOutput = -1;
entry->m_dataOutput = NULL;
entry->m_callbackOutput = NULL;
}
if (entry->m_fdInput == -1 && entry->m_fdOutput == -1)
{
Delete(fd);
delete entry;
}
}
}
bool wxSocketTable::CallCallback(int fd, wxSocketTableType socketType)
{
wxSocketTableEntry* entry = FindEntry(fd);
if (entry)
{
if (socketType == wxSocketTableInput)
{
if (entry->m_fdInput != -1 && entry->m_callbackInput)
{
(entry->m_callbackInput) (entry->m_fdInput, entry->m_dataInput);
}
}
else
{
if (entry->m_fdOutput != -1 && entry->m_callbackOutput)
{
(entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
}
}
return true;
}
else
return false;
}
void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
{
BeginFind();
wxHashTable::compatibility_iterator node = Next();
while (node)
{
wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
if (entry->m_fdInput != -1)
{
wxFD_SET(entry->m_fdInput, readset);
if (entry->m_fdInput > *highest)
* highest = entry->m_fdInput;
}
if (entry->m_fdOutput != -1)
{
wxFD_SET(entry->m_fdOutput, writeset);
if (entry->m_fdOutput > *highest)
* highest = entry->m_fdOutput;
}
node = Next();
}
}
void wxSocketTable::ProcessEvents(fd_set* readset, fd_set* writeset)
{
BeginFind();
wxHashTable::compatibility_iterator node = Next();
while (node)
{
wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
if (entry->m_fdInput != -1 && wxFD_ISSET(entry->m_fdInput, readset))
{
(entry->m_callbackInput) (entry->m_fdInput, entry->m_dataInput);
}
if (entry->m_fdOutput != -1 && wxFD_ISSET(entry->m_fdOutput, writeset))
{
(entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
}
node = Next();
}
}
wxSocketTable* wxTheSocketTable = NULL;
class wxSocketTableModule: public wxModule
{
DECLARE_DYNAMIC_CLASS(wxSocketTableModule)
public:
wxSocketTableModule() {}
bool OnInit() { wxTheSocketTable = new wxSocketTable; return true; };
void OnExit() { delete wxTheSocketTable; wxTheSocketTable = NULL; };
};
IMPLEMENT_DYNAMIC_CLASS(wxSocketTableModule, wxModule)
// Implement registration functions as C functions so they
// can be called from gsock11.c
extern "C" void wxRegisterSocketCallback(int fd, wxSocketTableType socketType, wxSocketCallback callback, void* data)
{
if (wxTheSocketTable)
{
wxTheSocketTable->RegisterCallback(fd, socketType, callback, data);
}
}
extern "C" void wxUnregisterSocketCallback(int fd, wxSocketTableType socketType)
{
if (wxTheSocketTable)
{
wxTheSocketTable->UnregisterCallback(fd, socketType);
}
}
#endif
// ----------------------------------------------------------------------------
// wxEventLoopImpl
// ----------------------------------------------------------------------------
@@ -456,35 +244,16 @@ bool wxEventLoop::Dispatch()
fd_set readset;
fd_set writeset;
int highest = fd;
wxFD_ZERO(&readset);
wxFD_ZERO(&writeset);
wxFD_SET(fd, &readset);
#if wxUSE_SOCKETS
if (wxTheSocketTable)
wxTheSocketTable->FillSets( &readset, &writeset, &highest );
#endif
if (select( highest+1, &readset, &writeset, NULL, &tv ) == 0)
if (select( fd+1, &readset, &writeset, NULL, &tv ) != 0)
{
// Timed out, so no event to process
return true;
}
else
{
// An X11 event was pending, so get it
// An X11 event was pending, get it
if (wxFD_ISSET( fd, &readset ))
XNextEvent( wxGlobalDisplay(), &event );
#if wxUSE_SOCKETS
// Check if any socket events were pending,
// and if so, call their callbacks
if (wxTheSocketTable)
wxTheSocketTable->ProcessEvents( &readset, &writeset );
#endif
}
}
#endif
}
else
@@ -492,6 +261,10 @@ bool wxEventLoop::Dispatch()
XNextEvent( wxGlobalDisplay(), &event );
}
#if wxUSE_SOCKETS
// handle any pending socket events:
wxSocketEventDispatcher::Get().RunLoop();
#endif
(void) m_impl->ProcessEvent( &event );
return true;