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); } }