int main(){
Event* head = NULL;
head = createEvent("Asiakas saapui kauppaan", NULL);
createEvent("Asiakas osti leipää", head);
createEvent("Asiaskas lähti kaupasta", head);
createEvent("Kassaneitiä, vitutti", head);
}
void Fullscreen::enqueueErrorEvent(Element& element, RequestType requestType) {
Event* event;
if (requestType == UnprefixedRequest)
event = createEvent(EventTypeNames::fullscreenerror, element.document());
else
event = createEvent(EventTypeNames::webkitfullscreenerror, element);
m_eventQueue.append(event);
m_eventQueueTimer.startOneShot(0, BLINK_FROM_HERE);
}
void EventEditTest::shouldHaveCorrectStartEndDateTime()
{
MessageViewer::EventEdit edit;
KMime::Message::Ptr msg(new KMime::Message);
QString subject = QStringLiteral("Test Note");
msg->subject(true)->fromUnicodeString(subject, "us-ascii");
edit.setMessage(msg);
QDateTime currentDateTime = QDateTime::currentDateTime();
MessageViewer::EventDateTimeWidget *startDateTime = edit.findChild<MessageViewer::EventDateTimeWidget *>(QStringLiteral("startdatetimeedit"));
startDateTime->setDateTime(currentDateTime);
QDateTime endDt = currentDateTime.addDays(1);
MessageViewer::EventDateTimeWidget *endDateTime = edit.findChild<MessageViewer::EventDateTimeWidget *>(QStringLiteral("enddatetimeedit"));
endDateTime->setDateTime(endDt);
QLineEdit *noteedit = edit.findChild<QLineEdit *>(QStringLiteral("eventedit"));
QVERIFY(noteedit);
QSignalSpy spy(&edit, SIGNAL(createEvent(KCalCore::Event::Ptr,Akonadi::Collection)));
QTest::keyClick(noteedit, Qt::Key_Enter);
QCOMPARE(spy.count(), 1);
KCalCore::Event::Ptr eventPtr = spy.at(0).at(0).value<KCalCore::Event::Ptr>();
QVERIFY(eventPtr);
QCOMPARE(eventPtr->dtStart().date(), currentDateTime.date());
QCOMPARE(eventPtr->dtStart().time().hour(), currentDateTime.time().hour());
QCOMPARE(eventPtr->dtStart().time().minute(), currentDateTime.time().minute());
QCOMPARE(eventPtr->dtEnd().date(), endDt.date());
QCOMPARE(eventPtr->dtEnd().time().hour(), endDt.time().hour());
QCOMPARE(eventPtr->dtEnd().time().minute(), endDt.time().minute());
}
static void stream_destroy(dyad_Stream *stream) {
dyad_Event e;
dyad_Stream **next;
/* Close socket */
if (stream->sockfd != INVALID_SOCKET) {
close(stream->sockfd);
}
/* Emit destroy event */
e = createEvent(DYAD_EVENT_DESTROY);
e.msg = "the stream has been destroyed";
stream_emitEvent(stream, &e);
/* Remove from list and decrement count */
next = &dyad_streams;
while (*next != stream) {
next = &(*next)->next;
}
*next = stream->next;
dyad_streamCount--;
/* Destroy and free */
vec_deinit(&stream->listeners);
vec_deinit(&stream->lineBuffer);
vec_deinit(&stream->writeBuffer);
dyad_free(stream->address);
dyad_free(stream);
}
static void stream_acceptPendingConnections(dyad_Stream *stream) {
for (;;) {
dyad_Stream *remote;
dyad_Event e;
int err = 0;
dyad_Socket sockfd = accept(stream->sockfd, NULL, NULL);
if (sockfd == INVALID_SOCKET) {
err = errno;
if (err == EWOULDBLOCK) {
/* No more waiting sockets */
return;
}
}
/* Create client stream */
remote = dyad_newStream();
remote->state = DYAD_STATE_CONNECTED;
/* Set stream's socket */
stream_setSocket(remote, sockfd);
/* Emit accept event */
e = createEvent(DYAD_EVENT_ACCEPT);
e.msg = "accepted connection";
e.remote = remote;
stream_emitEvent(stream, &e);
/* Handle invalid socket -- the stream is still made and the ACCEPT event
* is still emitted, but its shut immediately with an error */
if (remote->sockfd == INVALID_SOCKET) {
stream_error(remote, "failed to create socket on accept", err);
return;
}
}
}
static
int
createDropEvent(NDBT_Context* ctx, NDBT_Step* step)
{
Ndb* pNdb = GETNDB(step);
NdbDictionary::Dictionary *myDict = pNdb->getDictionary();
if (ctx->getProperty("NoDDL", Uint32(0)) == 0)
{
for (unsigned i = 0; i<table_list.size(); i++)
{
int res = NDBT_OK;
const NdbDictionary::Table* tab = myDict->getTable(table_list[i].c_str());
if (tab == 0)
{
continue;
}
if ((res = createEvent(pNdb, *tab) != NDBT_OK))
{
return res;
}
if ((res = dropEvent(pNdb, *tab)) != NDBT_OK)
{
return res;
}
}
}
return NDBT_OK;
}
void PAnimationInstance::rewind()
{
if (m_manager == P_NULL)
{
PLOG_WARNINGX(P_LOG_CHANNEL_ANIMATION, "The animation has no parent manager");
return ;
}
// Reset the local timeline to the beginning.
m_timeline.reset();
m_startTime = m_manager->getCurrentTime();
if (isPaused())
{
// As the timeline is resetted, the timeline is active again (not paused).
// We need to pause the timeline.
m_timeline.pause();
// FIXME: to reset the target's value to the first frame
// even in the pause state.
}
PEvent *event = createEvent(P_EVENT__ANIMATION_REWOUND);
event->queue(reinterpret_cast<PObject *>(P_NULL));
}
void PTimer::update(pfloat32 deltaTime)
{
PASSERT(m_manager != P_NULL);
m_elapsedMillis += deltaTime;
if (m_fireMillis < m_elapsedMillis)
{
m_repeatedTimes++;
PEvent* event = createEvent(P_EVENT__TIMER_EXPIRED);
event->setParameter(P_EVENTPARAMETER__TIMER_ID, m_id);
event->setParameter(P_EVENTPARAMETER__TIMER_REPEAT_TIMES, m_repeatedTimes - 1);
event->setParameter(P_EVENTPARAMETER__TIMER_ELAPSED_MILLIS, m_elapsedMillis);
event->queue(reinterpret_cast<PObject *>(P_NULL));
if (m_callback != P_NULL)
{
m_callback->onTimerOut(m_id, m_repeatedTimes, m_elapsedMillis);
}
if (m_repeatedTimes - 1 >= m_repeatCount)
{
kill();
}
else
{
m_fireMillis += m_repeatMillis;
}
}
}
void SVGDocument::dispatchScrollEvent()
{
ExceptionCode ec = 0;
RefPtr<Event> event = createEvent("SVGEvents", ec);
event->initEvent(eventNames().scrollEvent, true, false);
rootElement()->dispatchEvent(event.release(), ec);
}
void XInputMTInputDevice::handleXIEvent(const XEvent& xEvent)
{
m_SDLLockFunc();
XGenericEventCookie* pCookie = (XGenericEventCookie*)&xEvent.xcookie;
if (pCookie->type == GenericEvent && pCookie->extension == m_XIOpcode) {
XIDeviceEvent* pDevEvent = (XIDeviceEvent*)(pCookie->data);
IntPoint pos(pDevEvent->event_x, pDevEvent->event_y);
int xid = pDevEvent->detail;
switch (pCookie->evtype) {
case XI_TouchBegin:
{
// cerr << "TouchBegin " << xid << ", " << pos << endl;
m_LastID++;
TouchEventPtr pEvent = createEvent(m_LastID, Event::CURSOR_DOWN, pos);
addTouchStatus(xid, pEvent);
}
break;
case XI_TouchUpdate:
{
// cerr << "TouchUpdate " << xid << ", " << pos << endl;
TouchEventPtr pEvent = createEvent(0, Event::CURSOR_MOTION, pos);
TouchStatusPtr pTouchStatus = getTouchStatus(xid);
AVG_ASSERT(pTouchStatus);
pTouchStatus->pushEvent(pEvent);
}
break;
case XI_TouchEnd:
{
// cerr << "TouchEnd " << xid << ", " << pos << endl;
TouchStatusPtr pTouchStatus = getTouchStatus(xid);
AVG_ASSERT(pTouchStatus);
TouchEventPtr pEvent = createEvent(0, Event::CURSOR_UP, pos);
pTouchStatus->pushEvent(pEvent);
}
break;
default:
;
// cerr << "Unhandled XInput event, type: "
// << cookieTypeToName(pCookie->evtype) << endl;
}
} else {
// cerr << "Unhandled X11 Event: " << xEvent.type << endl;
}
XFreeEventData(s_pDisplay, pCookie);
m_SDLUnlockFunc();
}
void SVGDocument::dispatchZoomEvent(float prevScale, float newScale)
{
RefPtr<SVGZoomEvent> event = static_pointer_cast<SVGZoomEvent>(createEvent("SVGZoomEvents", IGNORE_EXCEPTION));
event->initEvent(eventNames().zoomEvent, true, false);
event->setPreviousScale(prevScale);
event->setNewScale(newScale);
rootElement()->dispatchEvent(event.release(), IGNORE_EXCEPTION);
}
void CalendaringTest::testEventConflictSet()
{
std::vector<Kolab::Event> events;
events.push_back(createEvent(Kolab::cDateTime(2011,10,6,12,1,1,true), Kolab::cDateTime(2011,10,8,12,1,1,true)));
events.push_back(createEvent(Kolab::cDateTime(2011,10,7,12,1,1,true), Kolab::cDateTime(2011,10,10,12,1,1,true)));
events.push_back(createEvent(Kolab::cDateTime(2011,10,9,12,1,1,true), Kolab::cDateTime(2011,10,11,12,1,1,true)));
const std::vector< std::vector<Kolab::Event> > &result = Kolab::Calendaring::getConflictingSets(events);
std::vector< std::vector<Kolab::Event> > expectedResult;
std::vector<Kolab::Event> r1;
r1.push_back(createEvent(Kolab::cDateTime(2011,10,6,12,1,1,true), Kolab::cDateTime(2011,10,8,12,1,1,true)));
r1.push_back(createEvent(Kolab::cDateTime(2011,10,7,12,1,1,true), Kolab::cDateTime(2011,10,10,12,1,1,true)));
expectedResult.push_back(r1);
std::vector<Kolab::Event> r2;
r2.push_back(createEvent(Kolab::cDateTime(2011,10,7,12,1,1,true), Kolab::cDateTime(2011,10,10,12,1,1,true)));
r2.push_back(createEvent(Kolab::cDateTime(2011,10,9,12,1,1,true), Kolab::cDateTime(2011,10,11,12,1,1,true)));
expectedResult.push_back(r2);
for (std::size_t i = 0; i < result.size(); i++) {
const std::vector<Kolab::Event> &list = result.at(i);
qDebug() << "---------_Set--------------";
foreach(const Kolab::Event &event, list) {
qDebug() << QTest::toString(event.start()) << QTest::toString(event.end());
}
compareEvents(result.at(i), expectedResult.at(i));
}
void threadStart(T t) {
if (!prepareEvent) prepareEvent = createEvent();
if (!stopEvent) stopEvent = createEvent(true);
threadStop(threadTimeout);
::ResetEvent(stopEvent);
ThreadStartParam param = { this, prepareEvent, stopEvent, t };
threadHandle = (HANDLE)_beginthreadex(NULL, 0, &threadFunc, ¶m, 0, NULL);
if (threadHandle) {
HANDLE handles[] = { prepareEvent, threadHandle };
::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
if (::WaitForSingleObject(threadHandle, 0) == WAIT_OBJECT_0) {
::CloseHandle(threadHandle);
threadHandle = 0;
}
}
}
bool Object::sendEvent(TargetID targetID,
ChannelID channelID,
PacketType type,
ObjectID recipientID,
EventID eventID) const
{
PacketData event = createEvent(eventID, recipientID);
return sendEvent(targetID, channelID, type, event);
}
void SVGDocument::dispatchZoomEvent(float prevScale, float newScale)
{
ExceptionCode ec = 0;
RefPtr<SVGZoomEvent> event = static_pointer_cast<SVGZoomEvent>(createEvent("SVGZoomEvents", ec));
event->initEvent(eventNames().zoomEvent, true, false);
event->setPreviousScale(prevScale);
event->setNewScale(newScale);
rootElement()->dispatchEvent(event.release(), ec);
}
void Fullscreen::enqueueChangeEvent(Document& document,
RequestType requestType) {
Event* event;
if (requestType == UnprefixedRequest) {
event = createEvent(EventTypeNames::fullscreenchange, document);
} else {
DCHECK(document.hasFullscreenSupplement());
Fullscreen& fullscreen = from(document);
EventTarget* target = fullscreen.fullscreenElement();
if (!target)
target = fullscreen.currentFullScreenElement();
if (!target)
target = &document;
event = createEvent(EventTypeNames::webkitfullscreenchange, *target);
}
m_eventQueue.append(event);
// NOTE: The timer is started in
// didEnterFullscreenForElement/didExitFullscreen.
}
int main()
{
int pipefd[2];
int count = 15;
if(pipe(pipefd) < 0) return -1;
pid_t pid = fork();
if(pid < 0) return -1;
int pipeReadfd = pipefd[0];
int pipeWritefd = pipefd[1];
setFdNonblocking(pipeReadfd);
if(0 == pid){
int i = 0;
int epfd = createEvent();
if(addEvent(epfd, pipeReadfd, AE_READABLE) < -1) return -1;
struct epoll_event *e = calloc(1024, sizeof(struct epoll_event));
while(i++ < count){
int ret = 0;
if((ret = myRead(epfd, pipeReadfd, e)) < 0){
//Here we do not check the situation that the "ret" less than 0
//stracing or gdbing this process will trigger a siglarm which will cause "ret == -1"
}
// printf("ret val: %d\n", ret);
}
close(epfd);
free(e);
printf("child finished...\n");
}else{
int i = 0;
while(i++ < count){
usleep(100000);
// char buf[1204];
// memset(buf, 0x0, 1024);
// fgets(buf, 10, stdin);
write(pipeWritefd, "hello", 1024);
}
printf("parent finished...\n");
}
close(pipefd[0]);
close(pipefd[1]);
usleep(10000);
return 0;
}
void PyManager::initialize(const wchar_t *wszProgram, int siginit)
{
if (!Py_IsInitialized())
{
if(g_program)
Py_SetProgramName(const_cast<decltype(g_program)>(wszProgram));
Py_InitializeEx(siginit);
// Create default events
createEvent("register_event"); // Triggered when someone registers handler for an event
}
}
static void stream_error(dyad_Stream *stream, const char *msg, int err) {
char buf[256];
dyad_Event e = createEvent(DYAD_EVENT_ERROR);
if (err) {
sprintf(buf, "%.160s (%.80s)", msg, strerror(err));
e.msg = buf;
} else {
e.msg = msg;
}
stream_emitEvent(stream, &e);
dyad_close(stream);
}
bool CCrossSectionTask::initialize(const OutputFlag & of,
COutputHandler * pOutputHandler,
std::ostream * pOstream)
{
assert(mpProblem && mpMethod);
mpCrossSectionProblem = dynamic_cast<CCrossSectionProblem *>(mpProblem);
assert(mpCrossSectionProblem);
mpTrajectoryMethod = dynamic_cast<CTrajectoryMethod *>(mpMethod);
assert(mpTrajectoryMethod);
mpTrajectoryMethod->setProblem(mpCrossSectionProblem);
bool success = mpMethod->isValidProblem(mpProblem);
CCopasiParameter * pParameter = mpMethod->getParameter("Integrate Reduced Model");
if (pParameter != NULL)
mUpdateMoieties = *pParameter->getValue().pBOOL;
else
mUpdateMoieties = false;
pdelete(mpCurrentState);
mpCurrentState = new CState(mpCrossSectionProblem->getModel()->getState());
mpCurrentTime = &mpCurrentState->getTime();
//init the ring buffer for the states
mStatesRing.resize(RING_SIZE);
mStatesRingCounter = 0;
// Handle the time series as a regular output.
mTimeSeriesRequested = true;//mpCrossSectionProblem->timeSeriesRequested();
if ((pOutputHandler != NULL) &&
mTimeSeriesRequested &&
(of & CCopasiTask::TIME_SERIES))
{
mTimeSeries.allocate(20);
pOutputHandler->addInterface(&mTimeSeries);
}
else
{
mTimeSeries.clear();
}
createEvent();
if (!CCopasiTask::initialize(of, pOutputHandler, pOstream)) success = false;
return success;
}
int dyad_listenEx(
dyad_Stream *stream, const char *host, int port, int backlog
) {
struct addrinfo hints, *ai = NULL;
int err, optval;
char buf[64];
dyad_Event e;
/* Get addrinfo */
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE;
sprintf(buf, "%d", port);
err = getaddrinfo(host, buf, &hints, &ai);
if (err) {
stream_error(stream, "could not get addrinfo", errno);
goto fail;
}
/* Init socket */
err = stream_initSocket(stream, ai->ai_family, ai->ai_socktype,
ai->ai_protocol);
if (err) goto fail;
/* Set SO_REUSEADDR so that the socket can be immediately bound without
* having to wait for any closed socket on the same port to timeout */
optval = 1;
setsockopt(stream->sockfd, SOL_SOCKET, SO_REUSEADDR,
&optval, sizeof(optval));
/* Bind and listen */
err = bind(stream->sockfd, ai->ai_addr, ai->ai_addrlen);
if (err) {
stream_error(stream, "could not bind socket", errno);
goto fail;
}
err = listen(stream->sockfd, backlog);
if (err) {
stream_error(stream, "socket failed on listen", errno);
goto fail;
}
stream->state = DYAD_STATE_LISTENING;
stream->port = port;
stream_initAddress(stream);
/* Emit listening event */
e = createEvent(DYAD_EVENT_LISTEN);
e.msg = "socket is listening";
stream_emitEvent(stream, &e);
freeaddrinfo(ai);
return 0;
fail:
if (ai) freeaddrinfo(ai);
return -1;
}
/*!
* Чтение нового входящего сообщения.
*/
bool NodeMessages::read(PacketReader *reader)
{
if (ChatId(reader->sender()).type() != ChatId::UserId)
return cleanup();
m_sender = Ch::channel(reader->sender(), ChatId::UserId);
if (!m_sender)
return cleanup();
MessageNotice packet(m_type, reader);
m_packet = &packet;
const qint64 date = m_packet->date();
FeedEvent *event = createEvent();
if (event->status != Notice::OK) {
reject(event->status);
FeedEvents::start(event);
return cleanup();
}
if (packet.direction() == Notice::Internal) {
if (m_packet->command() == LS("ping"))
pong(date);
Core::i()->route(m_dest);
delete event;
return cleanup();
}
FeedPtr feed = m_dest->feed(FEED_NAME_MESSAGES, true, false);
event->diffTo = event->date;
event->date = m_packet->date();
if (m_dest->type() == ChatId::UserId && m_dest->status().value() == Status::Offline) {
event->status = Notice::ChannelOffline;
reject(event->status);
NodeMessagesDB::add(packet, event->status);
Ch::gc(m_dest);
}
else {
if (feed->get(MESSAGES_FEED_LOGGING_KEY).status == Notice::OK)
NodeMessagesDB::add(packet);
Core::i()->route(m_dest);
}
FeedStorage::save(feed, m_packet->date());
FeedEvents::start(event);
return cleanup();
}
void PAnimationInstance::pause()
{
if (m_manager == P_NULL)
{
PLOG_WARNINGX(P_LOG_CHANNEL_ANIMATION, "The animation has no parent manager");
return ;
}
m_timeline.pause();
m_state = P_ANIMATION_PAUSED;
m_manager->repositionAnimation(this);
// Send the paused event
PEvent *event = createEvent(P_EVENT__ANIMATION_PAUSED);
event->queue(reinterpret_cast<PObject *>(P_NULL));
}
void AppleTrackpadInputDevice::onData(int device, Finger* pFingers, int numFingers,
float timestamp, int frame)
{
boost::mutex::scoped_lock lock(getMutex());
for (int i = 0; i < numFingers; i++) {
Finger* pFinger = &pFingers[i];
TouchStatusPtr pTouchStatus = getTouchStatus(pFinger->identifier);
if (!pTouchStatus) {
m_LastID++;
TouchEventPtr pEvent = createEvent(m_LastID, pFinger, Event::CURSORDOWN);
addTouchStatus(pFinger->identifier, pEvent);
} else {
Event::Type eventType;
if (pFinger->state == 7) {
eventType = Event::CURSORUP;
removeTouchStatus(pFinger->identifier);
} else {
eventType = Event::CURSORMOTION;
}
TouchEventPtr pEvent = createEvent(0, pFinger, eventType);
pTouchStatus->pushEvent(pEvent);
}
}
}
void EventEditTest::shouldEventHasCorrectSubject()
{
MessageViewer::EventEdit edit;
KMime::Message::Ptr msg(new KMime::Message);
QString subject = QStringLiteral("Test Note");
msg->subject(true)->fromUnicodeString(subject, "us-ascii");
edit.setMessage(msg);
QLineEdit *noteedit = edit.findChild<QLineEdit *>(QStringLiteral("eventedit"));
QVERIFY(noteedit);
QSignalSpy spy(&edit, SIGNAL(createEvent(KCalCore::Event::Ptr,Akonadi::Collection)));
QTest::keyClick(noteedit, Qt::Key_Enter);
QCOMPARE(spy.count(), 1);
KCalCore::Event::Ptr eventPtr = spy.at(0).at(0).value<KCalCore::Event::Ptr>();
QVERIFY(eventPtr);
QCOMPARE(eventPtr->summary(), subject);
}
static void updateStreamTimeouts(void) {
double currentTime = dyad_getTime();
dyad_Stream *stream;
dyad_Event e = createEvent(DYAD_EVENT_TIMEOUT);
e.msg = "stream timed out";
stream = dyad_streams;
while (stream) {
if (stream->timeout) {
if (currentTime - stream->lastActivity > stream->timeout) {
stream_emitEvent(stream, &e);
dyad_close(stream);
}
}
stream = stream->next;
}
}
void dyad_close(dyad_Stream *stream) {
dyad_Event e;
if (stream->state == DYAD_STATE_CLOSED) return;
stream->state = DYAD_STATE_CLOSED;
/* Close socket */
if (stream->sockfd != INVALID_SOCKET) {
close(stream->sockfd);
stream->sockfd = INVALID_SOCKET;
}
/* Emit event */
e = createEvent(DYAD_EVENT_CLOSE);
e.msg = "stream closed";
stream_emitEvent(stream, &e);
/* Clear buffers */
vec_clear(&stream->lineBuffer);
vec_clear(&stream->writeBuffer);
}
int crashTestPlayers(int i, const segment2 *movement) {
int j, k;
int crash = 0;
Data *data = game->player[i].data;
segment2 *current = data->trails + data->trailOffset;
// debug: only test player0 against himself
// j = 0;
// if(i == 0) {
for(j = 0; j < game->players; j++) {
int crash = 0;
if(game->player[j].data->trail_height < TRAIL_HEIGHT)
continue;
for(k = 0; k < game->player[j].data->trailOffset + 1; k++) {
segment2 *wall;
vec2 v;
float t1, t2;
if(j == i && k >= game->player[j].data->trailOffset - 1)
break;
wall = game->player[j].data->trails + k;
if(segment2_Intersect(&v, &t1, &t2, movement, wall)) {
#if 0
printf("(%.2f, %.2f), (%.2f, %.2f), %.2f, %.2f\n",
data->posx, data->posy,
v.v[0], v.v[1],
t1, t2);
#endif
if(t1 >= 0 && t1 <= 1 && t2 >= 0 && t2 <= 1) {
current->vDirection.v[0] = v.v[0] - current->vStart.v[0];
current->vDirection.v[1] = v.v[1] - current->vStart.v[1];
createEvent(i, EVENT_CRASH);
crash = 1;
break;
}
}
}
if(crash)
break;
}
return crash;
}
void ai_right(int player, AI_Distances *distances) {
// printf("trying right turn...");
AI *ai = game->player[player].ai;
Data *data = game->player[player].data;
int level = gSettingsCache.ai_level;
float save_distance =
(ai_params.minTurnTime[level] * data->speed / 1000.0f) + 20;
if(distances->right > save_distance) {
createEvent(player, EVENT_TURN_RIGHT);
ai->tdiff--;
ai->lasttime = game2->time.current;
// printf("succeeded\n");
} else {
// printf("failed\n");
}
}
static void updateTickTimer(void) {
/* Update tick timer */
if (dyad_lastTick == 0) {
dyad_lastTick = dyad_getTime();
}
while (dyad_lastTick < dyad_getTime()) {
/* Emit event on all streams */
dyad_Stream *stream;
dyad_Event e = createEvent(DYAD_EVENT_TICK);
e.msg = "a tick has occured";
stream = dyad_streams;
while (stream) {
stream_emitEvent(stream, &e);
stream = stream->next;
}
dyad_lastTick += dyad_tickInterval;
}
}
