void GSocketGUIFunctionsTableConcrete::Install_Callback(GSocket *socket, GSocketEvent event)
{
int c;
struct MacGSocketData* data = _GSocket_Get_Mac_Socket(socket);
if (!data) return;
switch (event)
{
case GSOCK_CONNECTION:
if(socket->m_server)
c = kCFSocketReadCallBack;
else
c = kCFSocketConnectCallBack;
break;
case GSOCK_LOST:
case GSOCK_INPUT:
c = kCFSocketReadCallBack;
break;
case GSOCK_OUTPUT:
c = kCFSocketWriteCallBack;
break;
default:
c = 0;
}
CFSocketEnableCallBacks(data->socket, c);
}
void wxSocketManagerMac::Install_Callback(wxSocketImpl *socket_,
wxSocketNotify event)
{
wxSocketImplMac * const socket = static_cast<wxSocketImplMac *>(socket_);
CFSocketEnableCallBacks(socket->GetSocket(), GetCFCallback(socket, event));
}
static int _cf_runloop_schedule_write( void * info, int fd ) {
struct CFMIDIRunloop * runloop = info;
CFSocketRef socket;
MIDIAssert( runloop != NULL );
socket = CFSocketCreateWithNative( NULL, fd, kCFSocketWriteCallBack, &_cf_socket_callback, &(runloop->socket_context) );
CFSocketEnableCallBacks( socket, kCFSocketWriteCallBack );
CFRelease( socket );
return 0;
}
static void
xmmsc_io_cf_toggle_socket_flags (int toggle, void *userdata)
{
CFSocketRef sockRef = (CFSocketRef) userdata;
if (toggle)
CFSocketEnableCallBacks (sockRef, kCFSocketWriteCallBack);
else
CFSocketDisableCallBacks (sockRef, kCFSocketWriteCallBack);
}
static int _cf_source_schedule( struct MIDIRunloopSource * source, int event ) {
int i, created;
struct CFMIDIRunLoopSource * cf = source->scheduler;
CFSocketContext socket_context;
CFOptionFlags socket_cb_types = kCFSocketNoCallBack;
CFSocketRef socket;
if( event & MIDI_RUNLOOP_READ ) socket_cb_types |= kCFSocketReadCallBack;
if( event & MIDI_RUNLOOP_WRITE ) socket_cb_types |= kCFSocketWriteCallBack;
socket_context.version = 0;
socket_context.info = source;
socket_context.release = NULL;
socket_context.retain = NULL;
socket_context.copyDescription = NULL;
for( i=0; i<source->nfds; i++ ) {
created = 0;
if( FD_ISSET(i, &(source->readfds)) ) {
created = 1;
}
if( FD_ISSET(i, &(source->writefds)) ) {
created = 1;
}
if( created ) {
socket = CFSocketCreateWithNative( NULL, i, socket_cb_types, &_cf_socket_callback, &socket_context );
if( event & MIDI_RUNLOOP_INVALIDATE ) {
CFSocketInvalidate( socket );
} else if( socket_cb_types != kCFSocketNoCallBack ) {
CFSocketEnableCallBacks( socket, socket_cb_types );
}
CFRelease( socket );
}
}
return 0;
}
/*
Register a QSocketNotifier with the mac event system by creating a CFSocket with
with a read/write callback.
Qt has separate socket notifiers for reading and writing, but on the mac there is
a limitation of one CFSocket object for each native socket.
*/
void QEventDispatcherMac::registerSocketNotifier(QSocketNotifier *notifier)
{
Q_ASSERT(notifier);
int nativeSocket = notifier->socket();
int type = notifier->type();
#ifndef QT_NO_DEBUG
if (nativeSocket < 0 || nativeSocket > FD_SETSIZE) {
qWarning("QSocketNotifier: Internal error");
return;
} else if (notifier->thread() != thread()
|| thread() != QThread::currentThread()) {
qWarning("QSocketNotifier: socket notifiers cannot be enabled from another thread");
return;
}
#endif
Q_D(QEventDispatcherMac);
QEventDispatcherUNIX::registerSocketNotifier(notifier);
if (type == QSocketNotifier::Exception) {
qWarning("QSocketNotifier::Exception is not supported on Mac OS X");
return;
}
// Check if we have a CFSocket for the native socket, create one if not.
MacSocketInfo *socketInfo = d->macSockets.value(nativeSocket);
if (!socketInfo) {
socketInfo = new MacSocketInfo();
// Create CFSocket, specify that we want both read and write callbacks (the callbacks
// are enabled/disabled later on).
const int callbackTypes = kCFSocketReadCallBack | kCFSocketWriteCallBack;
CFSocketContext context = {0, this, NULL, NULL, NULL};
socketInfo->socket = CFSocketCreateWithNative(kCFAllocatorDefault, nativeSocket, callbackTypes, qt_mac_socket_callback, &context);
if (CFSocketIsValid(socketInfo->socket) == false) {
qWarning("QEventDispatcherMac::registerSocketNotifier: Failed to create CFSocket");
return;
}
CFOptionFlags flags = CFSocketGetSocketFlags(socketInfo->socket);
flags |= kCFSocketAutomaticallyReenableWriteCallBack; //QSocketNotifier stays enabled after a write
flags &= ~kCFSocketCloseOnInvalidate; //QSocketNotifier doesn't close the socket upon destruction/invalidation
CFSocketSetSocketFlags(socketInfo->socket, flags);
// Add CFSocket to runloop.
if(!(socketInfo->runloop = qt_mac_add_socket_to_runloop(socketInfo->socket))) {
qWarning("QEventDispatcherMac::registerSocketNotifier: Failed to add CFSocket to runloop");
CFSocketInvalidate(socketInfo->socket);
CFRelease(socketInfo->socket);
return;
}
// Disable both callback types by default. This must be done after
// we add the CFSocket to the runloop, or else these calls will have
// no effect.
CFSocketDisableCallBacks(socketInfo->socket, kCFSocketReadCallBack);
CFSocketDisableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);
d->macSockets.insert(nativeSocket, socketInfo);
}
// Increment read/write counters and select enable callbacks if necessary.
if (type == QSocketNotifier::Read) {
if (++socketInfo->read == 1)
CFSocketEnableCallBacks(socketInfo->socket, kCFSocketReadCallBack);
} else if (type == QSocketNotifier::Write) {
if (++socketInfo->write == 1)
CFSocketEnableCallBacks(socketInfo->socket, kCFSocketWriteCallBack);
}
}
