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