void RemoveEmptyBlocks()
{
// Start on first->next to prevent removing the first dummy BEGIN event
struct Event *begin = first;
// Find BEGINs
while (begin)
{
if (begin->type == BEGIN)
{
int destroy = 0;
// Find it's matching END
struct Event *end = begin->next;
while (end)
{
if (end->type == CELL && end->nestingLevel == begin->nestingLevel)
{
// There is a CELL within the current BEGIN. Don't remove it!
break;
}
else if (end->type == END && end->nestingLevel == begin->nestingLevel - 1)
{
// We found the matching end!
destroy = 1;
break;
}
end = end->next;
}
// Let's destroy the pair, if necessary.
if (destroy)
{
// Adjust nesting levels
struct Event *aux = begin->next;
while (aux != end)
{
aux->nestingLevel--;
aux = aux->next;
}
struct Event *next = begin->next;
if (begin != first)
removeEvent(begin);
begin = next;
if (end != last)
removeEvent(end);
continue;
}
}
begin = begin->next;
}
}
void MainWindow::makeConnections() {
connect(&storage, SIGNAL(eventAdded(CalendarEvent)),
calendar, SLOT(addEvent(CalendarEvent)));
connect(&storage, SIGNAL(eventRemoved(CalendarEvent)),
calendar, SLOT(removeEvent(CalendarEvent)));
connect(calendar, SIGNAL(eventRemoved(CalendarEvent)),
&storage, SLOT(removeEvent(CalendarEvent)));
connect(calendar, SIGNAL(eventUpdated(CalendarEvent,CalendarEvent)),
&storage, SLOT(updateEvent(CalendarEvent,CalendarEvent)));
}
// --------------------------------------------------------------------------------
// Processes the events that are ready
void Events::doEvents(void)
{
for (uint8_t i = 0; i < _total; i++)
{
event_t * event = &_events[i];
// skip null or already processed events
if (!(event->flags & (1<<EVENT_FLAG_PROCESS)))
continue;
// skip high-priority events
if ((event->flags & (1<<EVENT_PRIORITY_HIGH)))
continue;
// process event
if (event->func)
event->func(event->state);
// mark event as processed
event->flags &= ~(1<<EVENT_FLAG_PROCESS);
// remove one-shot events
if (0 != (event->flags & (1<<EVENT_FLAG_ONESHOT)))
removeEvent(i);
}
}
bool WorkerEventQueue::cancelEvent(Event* event) {
if (!removeEvent(event))
return false;
InspectorInstrumentation::asyncTaskCanceled(
event->target()->getExecutionContext(), event);
return true;
}
void epoll::suspendRead( EventReactor* pHandler )
{
if ( pHandler->getEvents() & POLLIN )
{
removeEvent( pHandler, POLLIN );
}
}
void epoll::suspendWrite( EventReactor* pHandler )
{
if ( pHandler->getEvents() & POLLOUT )
{
removeEvent( pHandler, POLLOUT );
}
}
void
CEventQueue::addEvent(const CEvent& event)
{
// discard bogus event types
switch (event.getType()) {
case CEvent::kUnknown:
case CEvent::kSystem:
case CEvent::kTimer:
return;
default:
break;
}
if ((event.getFlags() & CEvent::kDeliverImmediately) != 0) {
dispatchEvent(event);
CEvent::deleteData(event);
}
else {
CArchMutexLock lock(m_mutex);
// store the event's data locally
UInt32 eventID = saveEvent(event);
// add it
if (!m_buffer->addEvent(eventID)) {
// failed to send event
removeEvent(eventID);
CEvent::deleteData(event);
}
}
}
void Screen::handleDelete()
{
if( _currentCell->getLord() ) {
GenericLord * lord = _currentCell->getLord();
if(lord->getOwner()){
lord->getOwner()->removeLord(lord);
}
lord->setCell( NULL );
} else if( _currentCell->getCreature() ) {
GenericMapCreature * creature = _currentCell->getCreature();
removeMapCreature(creature);
_currentCell->setCreature( NULL );
} else if( _currentCell->getBuilding() ) {
GenericBuilding * build = _currentCell->getBuilding();
removeBuilding( build );
_currentCell->setBuilding( NULL );
} else if( _currentCell->getBase() ) {
GenericBase * base = _currentCell->getBase();
removeBase( base );
_currentCell->setBase( NULL );
} else if( _currentCell->getEvent() ) {
Event * event = (Event *)( _currentCell->getEvent() );
removeEvent( event );
_currentCell->setEvent( NULL );
}
_currentCell->setDecoration( 0, 0 );
_currentCell->setTransition( 0 );
_currentCell->setTransitionCellType( 0 );
cellChanged( _currentCell );
}
CFileLPT::~CFileLPT () {
// close file
if(fileOpen)
fclose(file);
// remove tick handler
removeEvent(0);
}
void undo() const override
{
auto& scenar = m_scenarioPath.find();
auto& globalTn = scenar.timeNode(m_destinationTnId);
Deserializer<DataStream> s{m_serializedTimeNode};
auto recreatedTn = new TimeNodeModel{s, &scenar};
auto events_in_timenode = recreatedTn->events();
// we remove and re-add events in recreated Tn
// to ensure correct parentship between elements.
for(auto evId : events_in_timenode)
{
recreatedTn->removeEvent(evId);
globalTn.removeEvent(evId);
}
for(auto evId : events_in_timenode)
{
recreatedTn->addEvent(evId);
}
scenar.timeNodes.add(recreatedTn);
globalTn.trigger()->setExpression(m_targetTrigger);
globalTn.trigger()->setActive(m_targetTriggerActive);
m_moveCommand->undo();
updateTimeNodeExtent(m_destinationTnId, scenar);
}
// --------------------------------------------------------------------------------
// Removes an event from the event list and frees up it's allocation
void Events::eventsUnregisterEvent(fEventCallback fprt)
{
for (uint8_t i = 0; i < _total; i++)
{
if (_events[i].func == fprt)
removeEvent(i);
}
}
void WorkerEventQueue::dispatchEvent(Event* event,
ExecutionContext* executionContext) {
if (!event || !removeEvent(event))
return;
InspectorInstrumentation::AsyncTask asyncTask(executionContext, event);
event->target()->dispatchEvent(event);
}
void ONScripter::waitEventSub(int count)
{
remaining_time = count;
timerEvent();
runEventLoop();
removeEvent( ONS_BREAK_EVENT );
}
void Timer::removePluginEvents(Script *p)
{
for(uint i= 1; i< MAX_TIMER_COUNT; i++)
{
if( isIDValid(i) && (events[i].plugin==p) )
removeEvent(i);
}
}
bool
CEventQueue::getEvent(CEvent& event, double timeout)
{
CStopwatch timer(true);
retry:
// if no events are waiting then handle timers and then wait
while (m_buffer->isEmpty()) {
// handle timers first
if (hasTimerExpired(event)) {
return true;
}
// get time remaining in timeout
double timeLeft = timeout - timer.getTime();
if (timeout >= 0.0 && timeLeft <= 0.0) {
return false;
}
// get time until next timer expires. if there is a timer
// and it'll expire before the client's timeout then use
// that duration for our timeout instead.
double timerTimeout = getNextTimerTimeout();
if (timeout < 0.0 || (timerTimeout >= 0.0 && timerTimeout < timeLeft)) {
timeLeft = timerTimeout;
}
// wait for an event
m_buffer->waitForEvent(timeLeft);
}
// get the event
UInt32 dataID;
IEventQueueBuffer::Type type = m_buffer->getEvent(event, dataID);
switch (type) {
case IEventQueueBuffer::kNone:
if (timeout < 0.0 || timeout <= timer.getTime()) {
// don't want to fail if client isn't expecting that
// so if getEvent() fails with an infinite timeout
// then just try getting another event.
goto retry;
}
return false;
case IEventQueueBuffer::kSystem:
return true;
case IEventQueueBuffer::kUser:
{
CArchMutexLock lock(m_mutex);
event = removeEvent(dataID);
return true;
}
default:
assert(0 && "invalid event type");
return false;
}
}
static foreign_t
remove_alarm(term_t alarm)
{ Event ev = NULL;
if ( !get_timer(alarm, &ev) )
return FALSE;
return removeEvent(ev);
}
// Remove this event from the event queue, as well as all other
// events that share the same timestamp, as well as destination actor.
void removeAndPropagateSameTagEvents(Event* thisEvent) {
Event* nextEvent = thisEvent->nextEvent;
Event* lastEvent = thisEvent;
*(thisEvent->sinkEvent) = (Event*)thisEvent;
removeEvent(thisEvent);
// Now find the next event see we should process it at the same time.
while(nextEvent && (compareTime(nextEvent->tag.timestamp, thisEvent->tag.timestamp) == EQUAL)
&& (nextEvent->tag.microstep == thisEvent->tag.microstep) && nextEvent->fireMethod == thisEvent->fireMethod) {
*(nextEvent->sinkEvent) = (Event*)nextEvent;
removeEvent(nextEvent);
lastEvent = nextEvent;
nextEvent = nextEvent->nextEvent;
}
// Make this linked list semi-circular by pointing
// the prevEvent of thisEvent to the end of the list.
// This is used later in freeEvent().
thisEvent->prevEvent = lastEvent;
}
CNullModem::~CNullModem() {
if (serversocket) delete serversocket;
if (clientsocket) delete clientsocket;
// remove events
for(Bit16u i = SERIAL_BASE_EVENT_COUNT+1;
i <= SERIAL_NULLMODEM_EVENT_COUNT; i++) {
removeEvent(i);
}
}
bool WorkerEventQueue::cancelEvent(Event* event)
{
EventDispatcherTask* task = m_eventTaskMap.get(event);
if (!task)
return false;
task->cancel();
removeEvent(event);
return true;
}
void
EventList::removeAllEventsForObject(QObject *widget)
{
EventList::ConstIterator endIt = constEnd();
for (EventList::ConstIterator it = constBegin(); it != endIt; ++it) {
if (((*it)->sender() == widget) || ((*it)->receiver() == widget))
removeEvent(*it);
}
}
void CTimerManager::cancelShutdownOnWakeup()
{
pthread_mutex_lock(&tm_eventsMutex);
if (shutdown_eventID > -1) {
removeEvent(shutdown_eventID);
shutdown_eventID = -1;
}
*wakeup = false;
pthread_mutex_unlock(&tm_eventsMutex);
}
/*
* Under win32, it seems that fd is not allocated continously.
* Sorry for windows guys:'(
*/
bool SocketRegistryImpl::poll(time_t now)
{
FdSet fdset;
int fds[FD_SIZE];
int nfds = 0;
FD_ENTRY *e;
// Set in the fd_set from 0 to maxfd
for (e = fdTable + maxfd; e >= fdTable; e--) {
if (e->fd < 0)
continue;
// Check timeout
if (e->timeout && e->timeout <= now) {
// Reset timer
e->timeout = 0;
e->listener->onSocketTimeout();
} else if (e->event) {
fdset.setFd(e->fd, e->event);
fds[nfds++] = e->fd;
}
}
int n = fdset.poll();
if (n < 0)
return false;
// Returns if no sockets event
if (n == 0)
return true;
// Dispatch socket events
for (int i = 0; i < nfds; i++) {
int events = fdset.getEventsReady(i, fds[i]);
e = fdTable + fds[i];
if (events & SOCKET_READ) {
// Do not poll on this fd any more if an error occurs
if (!e->listener->onSocketRead()) {
e->event = 0;
continue;
}
}
if (events & SOCKET_WRITE) {
// We remove write event mask here. clients may add it again
// in onSocketWrite()
removeEvent(e->fd, SOCKET_WRITE);
e->timeout = 0;
e->listener->onSocketWrite();
}
}
return true;
}
CSerialModem::~CSerialModem() {
if(serversocket) delete serversocket;
if(clientsocket) delete clientsocket;
if(waitingclientsocket) delete waitingclientsocket;
delete rqueue;
delete tqueue;
// remove events
for(Bitu i = SERIAL_BASE_EVENT_COUNT+1; i <= SERIAL_MODEM_EVENT_COUNT; i++)
removeEvent(i);
}
void CNullModem::Disconnect() {
removeEvent(SERIAL_POLLING_EVENT);
removeEvent(SERIAL_RX_EVENT);
// it was disconnected; free the socket and restart the server socket
LOG_MSG("Serial%d: Disconnected.",COMNUMBER);
delete clientsocket;
clientsocket=0;
setDSR(false);
setCTS(false);
setCD(false);
if (serverport) {
serversocket = new TCPServerSocket(serverport);
if (serversocket->isopen)
setEvent(SERIAL_SERVER_POLLING_EVENT, 50);
else delete serversocket;
} else if (dtrrespect) {
setEvent(SERIAL_NULLMODEM_DTR_EVENT,50);
DTR_delta = getDTR(); // try to reconnect the next time DTR is set
}
}
void EventModel::addEvent(boost::shared_ptr<StanzaEvent> event, bool active) {
beginResetModel();
if (active) {
activeEvents_.push_front(new QtEvent(event, active));
} else {
inactiveEvents_.push_front(new QtEvent(event, active));
if (inactiveEvents_.size() > inactiveEventsLimit) {
removeEvent(inactiveEvents_[inactiveEventsLimit]->getEvent());
}
}
endResetModel();
}
void runLoop(EventLoop *loop, bool *run)
{
struct kevent *ke;
Event *evt;
/* PRINT("booooooooool %p", run); */
if(loop == NULL)
die("EventLoop not initialized");
int n, i;
while (*run)
{
/* n=epoll_wait(loop->efd, loop->events, loop->maxEvent, -1); */
n = kevent(loop->efd, NULL, 0, loop->events, loop->maxEvent, NULL);
PRINT("event %d", n);
if (n == -1)
die("kevent error");
for (i = 0; i < n; i++)
{
ke = &loop->events[i];
evt = (Event*) ke->udata;
if (evt == NULL)
die("Whaat !!!???");
/* PRINT("event %p", evt); */
/* PRINT("lloop %d", loop->events[i].events); */
if (ke->flags & EV_EOF)
{
PRINT("DISCONNECT %d == %d", evt->fd, ke->ident);
removeEvent(loop, evt);
close(evt->fd);
}
else if (ke->flags & EVFILT_READ)
{
PRINT("EPOLLIN");
evt->watch=EV_READ;
PRINT("EPOLLIN");
evt->callback(loop, evt);
}
else if (ke->flags & EVFILT_WRITE)
{
PRINT("EPOLLOUT");
evt->watch=EV_WRITE;
evt->callback(loop, evt);
}
else
PRINT("Unexpected");
++i;
}
}
}
void
EventQueue::addEventToBuffer(const Event& event)
{
ArchMutexLock lock(m_mutex);
// store the event's data locally
UInt32 eventID = saveEvent(event);
// add it
if (!m_buffer->addEvent(eventID)) {
// failed to send event
removeEvent(eventID);
Event::deleteData(event);
}
}
/**
* Remove an object from the engine's list of objects based on
* ID. Returns a pointer to the object that was removed. If no
* object with the given ID exists the return value will be NULL.
*/
Object* CoreEngine::removeObject(int objectID){
Object* discarded_object;
if (objectID < 0){
throw Error(objectType(), "removeObject", "object ID cannot be negative");
}
if (objectID >= objects.size()){
throw Error(objectType(), "removeObject", "object ID larger than internal object vector");
}
removeEvent(objects[objectID], ALL_EVENTS);
int s = objects.size();
discarded_object = objects[objectID];
objects[objectID] = objects[s-1];
objects[objectID]->ID = objectID;
objects.pop_back();
return discarded_object;
}
void plugin::eventDateTime ( const QString& id_, const QString& sceneid_, const QString& date, const QString& time) {
if (sceneid_.isEmpty()) {
removeEvent(id_);
return;
}
// recalculate next event
EventTimeStructure s;
s.eventid = id_;
s.sceneid = sceneid_;
s.date = QDate::fromString(date, Qt::ISODate);
s.time = QTime::fromString(time, QLatin1String("h:m"));
QDateTime datetime(s.date, s.time);
if (QDateTime::currentDateTime()>datetime)
return;
addToEvents(datetime, s);
}
OMX_ERRORTYPE Component::addEvent(OMX_EVENTTYPE eEvent, OMX_U32 nData1, OMX_U32 nData2)
{
OMXEvent event;
event.eEvent = eEvent;
event.nData1 = nData1;
event.nData2 = nData2;
pthread_mutex_lock(&event_mutex);
removeEvent(eEvent, nData1, nData2);
omxEvents.push_back(event);
// this allows (all) blocked tasks to be awoken
pthread_cond_broadcast(&m_omx_event_cond);
pthread_mutex_unlock(&event_mutex);
return OMX_ErrorNone;
}
