// Release the NAT void NiFreeNat(NAT *n) { // Validate arguments if (n == NULL) { return; } // Complete management command //NiFreeAdminAccept(n); // Stop if the virtual host is running Lock(n->lock); { if (n->Virtual != NULL) { StopVirtualHost(n->Virtual); ReleaseVirtual(n->Virtual); n->Virtual = NULL; } } Unlock(n->lock); // Release the settings NiFreeConfig(n); // Delete the object ReleaseCedar(n->Cedar); ReleaseEvent(n->HaltEvent); DeleteLock(n->lock); Free(n); }
// NAT の解放 void NiFreeNat(NAT *n) { // 引数チェック if (n == NULL) { return; } // 管理コマンド終了 //NiFreeAdminAccept(n); // 仮想ホストが動作中の場合は停止 Lock(n->lock); { if (n->Virtual != NULL) { StopVirtualHost(n->Virtual); ReleaseVirtual(n->Virtual); n->Virtual = NULL; } } Unlock(n->lock); // 設定の解放 NiFreeConfig(n); // オブジェクトの削除 ReleaseCedar(n->Cedar); ReleaseEvent(n->HaltEvent); DeleteLock(n->lock); Free(n); }
void MacOpMessageLoop::DispatchAllPostedMessagesNow() { #ifdef USE_UNTESTED_DISPATCH_CODE OpVector<EventRef> eventList; OSStatus err; EventRef nextEvent; do { nextEvent = FindSpecificEventInQueue(gMainEventQueue, OperaEventComparatorProc, NULL); if(nextEvent) { if(noErr == RemoveEventFromQueue(gMainEventQueue, nextEvent)) { eventList.Add(&nextEvent); } } } while(nextEvent); if(eventList.GetCount() > 0) { for(int i = 0; i < eventList.GetCount(); i++) { nextEvent = *eventList.Get(i); err = SendEventToEventTarget(nextEvent, GetEventDispatcherTarget()); ReleaseEvent(nextEvent); } } #endif }
// Release void NullPaFree(SESSION *s) { // Validate arguments NULL_LAN *n; BLOCK *b; if (s == NULL || (n = s->PacketAdapter->Param) == NULL) { return; } n->Halt = true; Set(n->Event); WaitThread(n->PacketGeneratorThread, INFINITE); ReleaseThread(n->PacketGeneratorThread); LockQueue(n->PacketQueue); { while (b = GetNext(n->PacketQueue)) { FreeBlock(b); } } UnlockQueue(n->PacketQueue); ReleaseQueue(n->PacketQueue); ReleaseCancel(n->Cancel); ReleaseEvent(n->Event); s->PacketAdapter->Param = NULL; Free(n); }
OSStatus TkMacOSXReceiveAndProcessEvent() { static EventTargetRef targetRef = NULL; EventRef eventRef; OSStatus err; /* * This is a poll, since we have already counted the events coming * into this routine, and are guaranteed to have one waiting. */ err = ReceiveNextEvent(0, NULL, kEventDurationNoWait, true, &eventRef); if (err == noErr) { if (!targetRef) { targetRef = GetEventDispatcherTarget(); } TkMacOSXStartTclEventLoopCarbonTimer(); err = SendEventToEventTarget(eventRef,targetRef); TkMacOSXStopTclEventLoopCarbonTimer(); #ifdef TK_MAC_DEBUG if (err != noErr && err != eventLoopTimedOutErr && err != eventNotHandledErr ) { char buf [256]; fprintf(stderr, "RCNE SendEventToEventTarget (%s) failed, %d\n", CarbonEventToAscii(eventRef, buf), (int)err); } #endif ReleaseEvent(eventRef); } return err; }
IEventQueueBuffer::Type OSXEventQueueBuffer::getEvent(Event& event, UInt32& dataID) { // release the previous event if (m_event != NULL) { ReleaseEvent(m_event); m_event = NULL; } // get the next event OSStatus error = ReceiveNextEvent(0, NULL, 0.0, true, &m_event); // handle the event if (error == eventLoopQuitErr) { event = Event(Event::kQuit); return kSystem; } else if (error != noErr) { return kNone; } else { UInt32 eventClass = GetEventClass(m_event); switch (eventClass) { case 'Syne': dataID = GetEventKind(m_event); return kUser; default: event = Event(Event::kSystem, m_eventQueue->getSystemTarget(), &m_event); return kSystem; } } }
OSXEventQueueBuffer::~OSXEventQueueBuffer() { // release the last event if (m_event != NULL) { ReleaseEvent(m_event); } }
bool OSXEventQueueBuffer::addEvent(UInt32 dataID) { EventRef event; OSStatus error = CreateEvent( kCFAllocatorDefault, 'Syne', dataID, 0, kEventAttributeNone, &event); if (error == noErr) { assert(m_carbonEventQueue != NULL); error = PostEventToQueue( m_carbonEventQueue, event, kEventPriorityStandard); ReleaseEvent(event); } return (error == noErr); }
/* Position the contentView (presumed to be a subview of the frameView) by asking the content view for its metrics and positioning it appropriately. */ OSStatus PositionContentViewWithMetrics(HIViewRef frameView, HIViewRef contentView) { HIViewFrameMetrics metrics = { 0, 0, 0, 0 }; EventRef getMetricsEvent = NULL; // First we check the frame metrics of the content view by asking it (politely) for the // metrics it wants verify_noerr(CreateEvent(NULL, kEventClassControl, kEventControlGetFrameMetrics, GetCurrentEventTime(), 0, &getMetricsEvent)); if(NULL != getMetricsEvent) { SetEventParameter(getMetricsEvent, kEventParamDirectObject, typeControlRef, sizeof(contentView), &contentView); SetEventParameter(getMetricsEvent, kEventParamControlFrameMetrics, typeControlFrameMetrics, sizeof(metrics), &metrics); OSStatus result = SendEventToEventTarget(getMetricsEvent, HIObjectGetEventTarget((HIObjectRef)contentView)); if(result == noErr) { verify_noerr(GetEventParameter(getMetricsEvent, kEventParamControlFrameMetrics, typeControlFrameMetrics, NULL, sizeof(metrics), NULL, &metrics)); } ReleaseEvent(getMetricsEvent); getMetricsEvent = NULL; } // Now we reposition the content view based on the metrics we got from it. HIRect bounds, contentRect; HIViewGetBounds(frameView, &bounds); contentRect.origin.x = metrics.left; contentRect.origin.y = metrics.top; contentRect.size.width = bounds.size.width - (metrics.left + metrics.right); contentRect.size.height = bounds.size.height - (metrics.top + metrics.bottom); HIViewSetFrame(contentView, &contentRect); return noErr; }
void MessagePump::dispatchAll() { _initReceiverQueue(); while( true ) { EventRef event; if( _needGlobalLock ) Global::enterCarbon(); const OSStatus status = ReceiveNextEvent( 0, 0, 0.0, true, &event ); if( status == eventLoopTimedOutErr ) break; if( status != noErr ) { EQWARN << "ReceiveNextEvent failed: " << status << std::endl; break; } EQVERB << "Dispatch Carbon event " << event << std::endl; if( !_needGlobalLock ) Global::enterCarbon(); const EventTargetRef target = GetEventDispatcherTarget(); SendEventToEventTarget( event, target ); Global::leaveCarbon(); ReleaseEvent( event ); } if( _needGlobalLock ) Global::leaveCarbon(); }
//----------------------------------------------------------------------------- // CreateCustomToolbarItem //----------------------------------------------------------------------------- // Our 'public' API to create our custom URL item. // HIToolbarItemRef CreateCustomToolbarItem( CFStringRef inIdentifier, CFTypeRef inURL ) { OSStatus err; EventRef event; UInt32 options = kHIToolbarItemAllowDuplicates; HIToolbarItemRef result = NULL; RegisterCustomToolbarItemClass(); err = CreateEvent( NULL, kEventClassHIObject, kEventHIObjectInitialize, GetCurrentEventTime(), 0, &event ); require_noerr( err, CantCreateEvent ); SetEventParameter( event, kEventParamToolbarItemIdentifier, typeCFStringRef, sizeof( CFStringRef ), &inIdentifier ); SetEventParameter( event, kEventParamAttributes, typeUInt32, sizeof( UInt32 ), &options ); if ( inURL ) SetEventParameter( event, kEventParamToolbarItemConfigData, typeCFTypeRef, sizeof( CFTypeRef ), &inURL ); err = HIObjectCreate( kCustomToolbarItemClassID, event, (HIObjectRef*)&result ); check_noerr( err ); ReleaseEvent( event ); CantCreateEvent: return result; }
void wxApp::MacDoOneEvent() { wxMacAutoreleasePool autoreleasepool; EventRef theEvent; s_inReceiveEvent = true ; OSStatus status = ReceiveNextEvent(0, NULL, sleepTime, true, &theEvent) ; s_inReceiveEvent = false ; switch (status) { case eventLoopTimedOutErr : if ( wxTheApp->ProcessIdle() ) sleepTime = kEventDurationNoWait ; else sleepTime = kEventDurationSecond; break; case eventLoopQuitErr : // according to QA1061 this may also occur // when a WakeUp Process is executed break; default: MacHandleOneEvent( theEvent ) ; ReleaseEvent( theEvent ); sleepTime = kEventDurationNoWait ; break; } // repeaters DeletePendingObjects() ; wxMacProcessNotifierAndPendingEvents() ; }
// Release of the Tick64 void FreeTick64() { UINT i; if (tk64 == NULL) { // Uninitialized return; } // Termination process tk64->Halt = true; Set(halt_tick_event); WaitThread(tk64->Thread, INFINITE); ReleaseThread(tk64->Thread); // Releasing process for (i = 0;i < LIST_NUM(tk64->AdjustTime);i++) { ADJUST_TIME *t = LIST_DATA(tk64->AdjustTime, i); Free(t); } ReleaseList(tk64->AdjustTime); DeleteLock(tk64->TickLock); Free(tk64); tk64 = NULL; ReleaseEvent(halt_tick_event); halt_tick_event = NULL; }
void wxApp::MacDoOneEvent() { EventRef theEvent; s_inReceiveEvent = true ; OSStatus status = ReceiveNextEvent(0, NULL,sleepTime,true,&theEvent) ; s_inReceiveEvent = false ; if ( status == eventLoopTimedOutErr ) { if ( wxTheApp->ProcessIdle() ) sleepTime = kEventDurationNoWait ; else sleepTime = kEventDurationSecond; } else if ( status == eventLoopQuitErr ) { // according to QA1061 this may also occur when a WakeUp Process // is executed } else { MacHandleOneEvent( theEvent ) ; ReleaseEvent(theEvent); sleepTime = kEventDurationNoWait ; } // repeaters DeletePendingObjects() ; wxMacProcessNotifierAndPendingEvents() ; }
bool wxApp::Yield(bool onlyIfNeeded) { if (s_inYield) { if ( !onlyIfNeeded ) { wxFAIL_MSG( wxT("wxYield called recursively" ) ); } return false; } #if wxUSE_THREADS // Yielding from a non-gui thread needs to bail out, otherwise we end up // possibly sending events in the thread too. if ( !wxThread::IsMain() ) { return true; } #endif // wxUSE_THREADS s_inYield = true; // by definition yield should handle all non-processed events EventRef theEvent; OSStatus status = noErr ; while ( status == noErr ) { s_inReceiveEvent = true ; status = ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent) ; s_inReceiveEvent = false ; if ( status == eventLoopTimedOutErr ) { // make sure next time the event loop will trigger idle events sleepTime = kEventDurationNoWait ; } else if ( status == eventLoopQuitErr ) { // according to QA1061 this may also occur when a WakeUp Process // is executed } else { MacHandleOneEvent( theEvent ) ; ReleaseEvent(theEvent); } } wxMacProcessNotifierAndPendingEvents() ; s_inYield = false; return true; }
void PostCustomEvent(DWORD id, void *data, DWORD size) { EventRef e; CreateEvent(NULL,'blah','blah',0,0,&e); SetEventParameter(e,'evid',0,sizeof(id),&id); SetEventParameter(e,'data',0,size,data); PostEventToQueue(GetMainEventQueue(),e,kEventPriorityHigh); ReleaseEvent(e); }
void QMacInputContext::setLastKeydownEvent(EventRef event) { EventRef tmpEvent = keydownEvent; keydownEvent = event; if (keydownEvent) RetainEvent(keydownEvent); if (tmpEvent) ReleaseEvent(tmpEvent); }
//--------------------------------------------------------------------------------// void WindowEventUtilities::messagePump() { #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32 // Windows Message Loop (NULL means check all HWNDs belonging to this context) MSG msg; while( PeekMessage( &msg, NULL, 0U, 0U, PM_REMOVE ) ) { TranslateMessage( &msg ); DispatchMessage( &msg ); } #elif OGRE_PLATFORM == OGRE_PLATFORM_LINUX //GLX Message Pump RenderWindowList::iterator win = _msWindows.begin(); RenderWindowList::iterator end = _msWindows.end(); Display* xDisplay = 0; // same for all windows for (; win != end; win++) { XID xid; XEvent event; if (!xDisplay) (*win)->getCustomAttribute("XDISPLAY", &xDisplay); (*win)->getCustomAttribute("WINDOW", &xid); while (XCheckWindowEvent (xDisplay, xid, StructureNotifyMask | VisibilityChangeMask | FocusChangeMask, &event)) { GLXProc(*win, event); } // The ClientMessage event does not appear under any Event Mask while (XCheckTypedWindowEvent (xDisplay, xid, ClientMessage, &event)) { GLXProc(*win, event); } } #elif OGRE_PLATFORM == OGRE_PLATFORM_APPLE && !defined __OBJC__ && !defined __LP64__ // OSX Message Pump EventRef event = NULL; EventTargetRef targetWindow; targetWindow = GetEventDispatcherTarget(); // If we are unable to get the target then we no longer care about events. if( !targetWindow ) return; // Grab the next event, process it if it is a window event while( ReceiveNextEvent( 0, NULL, kEventDurationNoWait, true, &event ) == noErr ) { // Dispatch the event SendEventToEventTarget( event, targetWindow ); ReleaseEvent( event ); } #endif }
void CL_DisplayWindow_OpenGL::keep_alive() { EventRef theEvent; while(ReceiveNextEvent(0, NULL,kEventDurationNoWait,true,&theEvent)== noErr) { SendEventToEventTarget (theEvent, target_ref); ReleaseEvent(theEvent); } }
OP_STATUS MacOpMessageLoop::PostMessage(UINT32 msg, void *data, UINT32 param1, UINT32 param2) { // if(!mh) // { // return OpStatus::OK; // } EventRef operaEvent = NULL; OSStatus err = CreateEvent(NULL, kEventClassOperaPlatformIndependent, kEventOperaMessage, 0, kEventAttributeUserEvent, &operaEvent); if(err == noErr) { err = SetEventParameter(operaEvent, kEventParamOperaMessage, typeInteger, sizeof(UINT32), &msg); err |= SetEventParameter(operaEvent, kEventParamOperaMessageData, typeInteger, sizeof(void *), &data); err |= SetEventParameter(operaEvent, kEventParamOperaMessageParam1, typeInteger, sizeof(UINT32), ¶m1); err |= SetEventParameter(operaEvent, kEventParamOperaMessageParam2, typeInteger, sizeof(UINT32), ¶m2); if (err == noErr) { EventPriority priority; if (msg >= MSG_LOW_PRI_START && msg <= MSG_LOW_PRI_END) { priority = kEventPriorityLow; } else { priority = kEventPriorityStandard; } PostEventToQueue(gMainEventQueue, operaEvent, priority); } } ReleaseEvent(operaEvent); return OpStatus::OK; }
static void DispatchAndReleaseEvent(EventRef theEvent) { if ( wxTheApp ) wxTheApp->MacSetCurrentEvent( theEvent, NULL ); OSStatus status = SendEventToEventTarget(theEvent, GetEventDispatcherTarget()); if (status == eventNotHandledErr && wxTheApp) wxTheApp->MacHandleUnhandledEvent(theEvent); ReleaseEvent( theEvent ); }
void _glfwPlatformPollEvents( void ) { EventRef event; EventTargetRef eventDispatcher = GetEventDispatcherTarget(); while ( ReceiveNextEvent( 0, NULL, 0.0, TRUE, &event ) == noErr ) { SendEventToEventTarget( event, eventDispatcher ); ReleaseEvent( event ); } }
void appleMultiContext::checkEvent() { // Event management for Apple EventRef theEvent; EventTargetRef theTarget; theTarget = GetEventDispatcherTarget(); while (ReceiveNextEvent(0, NULL,kEventDurationNoWait,true, &theEvent) == noErr) { SendEventToEventTarget (theEvent, theTarget); ReleaseEvent(theEvent); } }
bool MessagePumpLibevent::FileDescriptorWatcher::StopWatchingFileDescriptor() { event* e = ReleaseEvent(); if (e == NULL) return true; // event_del() is a no-op if the event isn't active. int rv = event_del(e); delete e; pump_ = NULL; watcher_ = NULL; return (rv == 0); }
// Release and stop the IPsec server void FreeIPsecServer(IPSEC_SERVER *s) { UINT i; IPSEC_SERVICES sl; // Validate arguments if (s == NULL) { return; } s->NoMoreChangeSettings = true; // Stopp the L2TP server StopL2TPServer(s->L2TP, false); // Stop the IKE server StopIKEServer(s->Ike); // Stop all the services explicitly Zero(&sl, sizeof(sl)); IPsecServerSetServices(s, &sl); // Releasing process FreeUdpListener(s->UdpListener); ReleaseCedar(s->Cedar); FreeL2TPServer(s->L2TP); FreeIKEServer(s->Ike); for (i = 0;i < LIST_NUM(s->EtherIPIdList);i++) { ETHERIP_ID *k = LIST_DATA(s->EtherIPIdList, i); Free(k); } ReleaseList(s->EtherIPIdList); // Stop the OS monitoring thread s->Halt = true; Set(s->OsServiceCheckThreadEvent); WaitThread(s->OsServiceCheckThread, INFINITE); ReleaseThread(s->OsServiceCheckThread); ReleaseEvent(s->OsServiceCheckThreadEvent); DeleteLock(s->LockSettings); Free(s); }
// Release the UDP acceleration function void FreeUdpAccel(UDP_ACCEL *a) { // Validate arguments if (a == NULL) { return; } while (true) { BLOCK *b = GetNext(a->RecvBlockQueue); if (b == NULL) { break; } FreeBlock(b); } ReleaseQueue(a->RecvBlockQueue); ReleaseSock(a->UdpSock); if (a->IsInCedarPortList) { LockList(a->Cedar->UdpPortList); { DelInt(a->Cedar->UdpPortList, a->MyPort); } UnlockList(a->Cedar->UdpPortList); } // Release of NAT-T related a->NatT_Halt = true; Set(a->NatT_HaltEvent); if (a->NatT_GetIpThread != NULL) { WaitThread(a->NatT_GetIpThread, INFINITE); ReleaseThread(a->NatT_GetIpThread); } ReleaseEvent(a->NatT_HaltEvent); DeleteLock(a->NatT_Lock); ReleaseCedar(a->Cedar); Free(a); }
void MCRevolutionStackViewRelink(WindowRef p_window, MCStack *p_new_stack) { EventRef t_event; CreateEvent(NULL, 'revo', 'rlnk', GetCurrentEventTime(), 0, &t_event); SetEventParameter(t_event, 'Stak', typeVoidPtr, sizeof(void *), &p_new_stack); HIViewRef t_root; GetRootControl(p_window, &t_root); HIViewRef t_view; GetIndexedSubControl(t_root, 1, &t_view); SendEventToEventTarget(t_event, GetControlEventTarget(t_view)); ReleaseEvent(t_event); }
QSize FilterWidget::sizeHint (void) const { HIRect optimalBounds; EventRef event; CreateEvent(0, kEventClassControl, kEventControlGetOptimalBounds, GetCurrentEventTime(), kEventAttributeUserEvent, &event); SendEventToEventTargetWithOptions(event, HIObjectGetEventTarget(HIObjectRef(winId())), kEventTargetDontPropagate); GetEventParameter(event, kEventParamControlOptimalBounds, typeHIRect, 0, sizeof(HIRect), 0, &optimalBounds); ReleaseEvent(event); return QSize(optimalBounds.size.width + 200, optimalBounds.size.height - 4); }
void TabbedWindow::Terminate( void ) { EventQueueRef eventQueue = GetMainEventQueue(); EventRef event; OSStatus status; status = CreateEvent( kCFAllocatorDefault, kEventClassApplication, kEventAppQuit, GetCurrentEventTime(), kEventAttributeNone, &event ); if ( status == noErr ) status = PostEventToQueue( eventQueue, event, kEventPriorityStandard ); ReleaseEvent( event ); }
/*----------------------------------------------------------------------------------------------------------*/ void myScrollingTextTimeProc(EventLoopTimerRef inTimer, void *inUserData) { ScrollingTextBoxData* myData = (ScrollingTextBoxData*)inUserData; HIPoint where = {0.0, myData->originPoint.y + myData->autoScrollAmount}; // If we reached the end of our text, let's start again if (where.y >= myData->height - 10.0) where.y = 0.0; // Creating and sending our ScrollTo event EventRef theEvent; CreateEvent(NULL, kEventClassScrollable, kEventScrollableScrollTo, GetCurrentEventTime(), kEventAttributeUserEvent, &theEvent); SetEventParameter(theEvent, kEventParamOrigin, typeHIPoint, sizeof(where), &where); SendEventToEventTarget(theEvent, GetControlEventTarget(myData->view)); ReleaseEvent(theEvent); }