// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
- #pragma implementation "evtloop.h"
-#endif
-
#include "wx/window.h"
#include "wx/app.h"
#include "wx/evtloop.h"
#include "wx/timer.h"
#include "wx/hash.h"
#include "wx/module.h"
+#include "wx/unix/private.h"
#include "wx/x11/private.h"
#include "X11/Xlib.h"
m_callbackInput = NULL; m_callbackOutput = NULL;
m_dataInput = NULL; m_dataOutput = NULL;
}
-
+
int m_fdInput;
int m_fdOutput;
wxSocketCallback m_callbackInput;
}
~wxSocketTable()
{
- DeleteContents(TRUE);
+ WX_CLEAR_HASH_TABLE(*this)
}
wxSocketTableEntry* FindEntry(int fd);
void wxSocketTable::FillSets(fd_set* readset, fd_set* writeset, int* highest)
{
BeginFind();
- wxNode* node = Next();
+ wxHashTable::compatibility_iterator node = Next();
while (node)
{
- wxSocketTableEntry* entry = (wxSocketTableEntry*) node->Data();
+ wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
if (entry->m_fdInput != -1)
{
- FD_SET(entry->m_fdInput, readset);
+ wxFD_SET(entry->m_fdInput, readset);
if (entry->m_fdInput > *highest)
* highest = entry->m_fdInput;
}
if (entry->m_fdOutput != -1)
{
- FD_SET(entry->m_fdOutput, writeset);
+ wxFD_SET(entry->m_fdOutput, writeset);
if (entry->m_fdOutput > *highest)
* highest = entry->m_fdOutput;
}
void wxSocketTable::ProcessEvents(fd_set* readset, fd_set* writeset)
{
BeginFind();
- wxNode* node = Next();
+ wxHashTable::compatibility_iterator node = Next();
while (node)
{
- wxSocketTableEntry* entry = (wxSocketTableEntry*) node->Data();
+ wxSocketTableEntry* entry = (wxSocketTableEntry*) node->GetData();
- if (entry->m_fdInput != -1 && FD_ISSET(entry->m_fdInput, readset))
+ 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 && FD_ISSET(entry->m_fdOutput, writeset))
+ if (entry->m_fdOutput != -1 && wxFD_ISSET(entry->m_fdOutput, writeset))
{
(entry->m_callbackOutput) (entry->m_fdOutput, entry->m_dataOutput);
}
// 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);
bool wxEventLoopImpl::SendIdleEvent()
{
- wxIdleEvent event;
- event.SetEventObject(wxTheApp);
-
- return wxTheApp->ProcessEvent(event) && event.MoreRequested();
+ return wxTheApp->ProcessIdle();
}
// ============================================================================
// wxEventLoop implementation
// ============================================================================
-wxEventLoop *wxEventLoop::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;
+
+ wxEventLoopActivator activate(this);
m_impl->m_keepGoing = TRUE;
while ( m_impl->m_keepGoing )
{
#if 0 // wxUSE_THREADS
- wxMutexGuiLeaveOrEnter();
+ wxMutexGuiLeaveOrEnter();
#endif // wxUSE_THREADS
// generate and process idle events for as long as we don't have
#endif
if (!m_impl->SendIdleEvent())
{
-#if wxUSE_THREADS
+#if 0 // wxUSE_THREADS
// leave the main loop to give other threads a chance to
// perform their GUI work
wxMutexGuiLeave();
delete m_impl;
m_impl = NULL;
- ms_activeLoop = oldLoop;
-
return exitcode;
}
bool wxEventLoop::Pending() const
{
- XFlush((Display*) wxGetDisplay());
- return (XPending((Display*) wxGetDisplay()) > 0);
+ XFlush( wxGlobalDisplay() );
+ return (XPending( wxGlobalDisplay() ) > 0);
}
bool wxEventLoop::Dispatch()
// 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((Display*) wxGetDisplay()) == 0)
+
+ if (XPending( wxGlobalDisplay() ) == 0)
{
#if wxUSE_NANOX
GR_TIMEOUT timeout = 10; // Milliseconds
// 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((Display*) wxGetDisplay());
+ int fd = ConnectionNumber( wxGlobalDisplay() );
+
fd_set readset;
fd_set writeset;
int highest = fd;
- FD_ZERO(&readset);
- FD_ZERO(&writeset);
-
- FD_SET(fd, &readset);
+ wxFD_ZERO(&readset);
+ wxFD_ZERO(&writeset);
+
+ wxFD_SET(fd, &readset);
#if wxUSE_SOCKETS
if (wxTheSocketTable)
- wxTheSocketTable->FillSets(& readset, & writeset, & highest);
+ wxTheSocketTable->FillSets( &readset, &writeset, &highest );
#endif
-
- if (select(highest+1, &readset, &writeset, NULL, & tv) == 0)
+
+ if (select( highest+1, &readset, &writeset, NULL, &tv ) == 0)
{
// Timed out, so no event to process
return TRUE;
else
{
// An X11 event was pending, so get it
- if (FD_ISSET(fd, & readset))
- XNextEvent((Display*) wxGetDisplay(), & event);
+ 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);
+ wxTheSocketTable->ProcessEvents( &readset, &writeset );
#endif
}
#endif
- } else
+ }
+ else
{
- XNextEvent((Display*) wxGetDisplay(), & event);
+ XNextEvent( wxGlobalDisplay(), &event );
}
-
- (void) m_impl->ProcessEvent(& event);
+
+
+ (void) m_impl->ProcessEvent( &event );
return TRUE;
}
projects / wxWidgets.git / blobdiff