void Runtime::pause(int timeout) {
if (timeout == -1) {
pollEvents(true);
if (hasEvent()) {
MAEvent *event = popEvent();
processEvent(*event);
delete event;
}
} else {
int slept = 0;
while (1) {
pollEvents(false);
if (isBreak()) {
break;
} else if (hasEvent()) {
MAEvent *event = popEvent();
processEvent(*event);
delete event;
}
usleep(WAIT_INTERVAL * 1000);
slept += WAIT_INTERVAL;
if (timeout > 0 && slept > timeout) {
break;
}
}
}
}
void Model::Run()
{
m_bCanceled = false;
curTime = Time();
while(Event* e = popEvent())
{
curTime = e->getTime();
e->Process(this);
if(e->IsAutoDelete())
delete e;
if(m_bCanceled)
break;
}
//
while(Event* e = popEvent())
{
e->Cancel(this);
if(e->IsAutoDelete())
delete e;
}
}
//--------------------------------------------------------------
/// \brief wait for an event
/// \param[in] timeout Set an optional timeout delay. Can use these special values :
/// - pos_infin : no timeout
/// - min_date_time : no wait, function returns immediately
/// is set to min_date_time special value.
/// \return ID of the received event, or kTimeout if timeout was reached, or kNoEvent if no event is available
/// \throw boost::thread_interrupted if thread was interrupted
/// \note This function is blocking (if timeout is different to min_date_time).
/// This blocking state will be brake when thread is interrupted.
//--------------------------------------------------------------
int waitForEvents(const boost::posix_time::time_duration& timeout = boost::date_time::pos_infin)
{
// Prior check if thread stopping was requested
boost::this_thread::interruption_point();
// Clean last received message data
m_lastEvent.reset();
// Clean the time event list
timeEventListCleanup();
// If time events are elapsed, must post corresponding event to the queue
signalElapsedTimeEvents();
boost::recursive_mutex::scoped_lock lock(m_eventsQueueMutex);
// Don't wait if event is already present
if (!m_eventsQueue.empty())
return popEvent();
// No event is currently present
if (timeout == boost::date_time::min_date_time)
{
// No wait
return kNoEvent;
}
if (!hasRunningTimeEvents() && timeout == boost::date_time::pos_infin)
{
// Wait infinite for event
m_condition.wait(lock);
return popEvent();
}
// Have time event or timeout
boost::shared_ptr<ITimeEvent> closerTimeEvent = getNextTimeEventStopPoint();
if (!!closerTimeEvent && (closerTimeEvent->getNextStopPoint() < (currentTime::Provider().now() + timeout)))
{
// Next stop point will be the closer time event
if (!m_condition.timed_wait(lock, closerTimeEvent->getNextStopPoint() - currentTime::Provider().now()))
{
// No event ==> Signal time event
signalTimeEvent(closerTimeEvent);
}
}
else
{
// Next stop point will be the normal timeout
if (!m_condition.timed_wait(lock, timeout))
{
// No event ==> timeout
return kTimeout;
}
}
// Event occurs during wait or time event was signaled
return popEvent();
}
void CustomMenu::onEvent(const sf::Event& event) {
Component* triggered = nullptr;
while((triggered = popEvent(event))) {
math::u_id id = triggered->getID();
if(id == save->getID()) {
} else if(id == load->getID()) {
} else if(id == random->getID()) {
conv << (Utility::Random::getUnsignedRandom()%1001);
name_f->setText(SentenceGenerator::getWord(SentenceGenerator::Noun) +
SentenceGenerator::getWord(SentenceGenerator::Noun));
age_f->setText(conv.str());
gender->randomize();
//palette->randomize();
conv.str("");
} else if(id == back->getID())
MenuUtils::mainMenu();
else if(id == name_f->getID())
name.setColor(name_f->getColor());
else if(id == age_f->getID())
age.setColor(age_f->getColor());
else
std::cerr << "Auto-destruction sequence activated. Nooooo!!!" << std::endl;
}
}
MAEvent Runtime::processEvents(int waitFlag) {
switch (waitFlag) {
case 1:
// wait for an event
_output->flush(true);
pollEvents(true);
break;
case 2:
_output->flush(false);
pause(WAIT_INTERVAL);
break;
default:
pollEvents(false);
}
MAEvent event;
if (hasEvent()) {
MAEvent *nextEvent = popEvent();
processEvent(*nextEvent);
event = *nextEvent;
delete nextEvent;
} else {
event.type = 0;
}
return event;
}
/**
* retrieves the next event from the queue to be executed
* @param fd is ignored for the straight queue
* @return the event or NULL if there are none
* **/
baseEvent* straightQueue::popAvailableEvent( int fd )
{
if( !bExitWhenDone && (listSize==0) ) return NULL;
// feed persistent apps with end of queue commands so that they can detect the
// end of the queue when it is empty
if( bExitWhenDone && (listSize==0) )
{
baseEvent* pCommand = new baseEvent( baseEvent::EV_COMMAND );
pCommand->setCommand( baseEvent::CMD_END_OF_QUEUE );
log.info( log.LOGMOSTLY, "popAvailableEvent: generating a CMD_END_OF_QUEUE" );
return pCommand;
} // if
// retrieve an event from the queue
baseEvent* pEvent = NULL;
do
{
pEvent = popEvent();
pEvent = checkIfEventIsExpired( pEvent );
} while( (pEvent == NULL) && !eventList.empty() );
// updateQueuedStats( pEvent );
if( pEvent == NULL )
log.info( log.MIDLEVEL, "popAvailableEvent: queue:'%s' only had expired events", queueName.c_str() );
else
log.info( log.MIDLEVEL, "popAvailableEvent: qlen:%d", listSize );
return pEvent;
} // popAvailableEvent
void CCPomelo::dispatchEvent(){
lockEventQeueue();
CCPomeloEvent_ *event = popEvent();
if (event) {
CCPomeloContent_ * content = NULL;
if (event_content.find(event->event)!=event_content.end()) {
content = event_content[event->event];
}
if (content) {
CCObject *pTarget = content->pTarget;
SEL_CallFuncND pSelector = content->pSelector;
if (pTarget && pSelector)
{
CCPomeloReponse resp;
resp.status = event->status;
resp.docs = event->docs;
(pTarget->*pSelector)((CCNode *)this,&resp);
}
}else{
CCLOG("dispatch event::\r\n lost %s content",event->event.c_str());
}
json_decref(event->docs);
delete event;
}
unlockEventQeueue();
}
void pushEventToHistory(EventHistory_t* history,
time_t time,
const char* type, const char* origin,
const char** params, unsigned int paramCount)
{
// If our event history is currently too large, get rid of the oldest
// element.
if (json_array_size(history->root) >= history->maxSize)
{
popEvent(history);
}
json_t* eventObj = json_object();
json_object_set_new(eventObj, "time", json_integer(time));
json_object_set_new(eventObj, "type", json_string(type));
json_object_set_new(eventObj, "origin", json_string(origin));
json_object_set_new(eventObj, "params", json_array());
json_t* jsonParamArray = json_object_get(eventObj, "params");
// Fill our json parameter array.
for (unsigned int i = 0; i < paramCount; i++)
{
json_array_append(jsonParamArray, json_string(params[i]));
}
json_array_append(history->root, eventObj);
exportHistory(history, "messages.json");
}
bool GHOST_EventManager::dispatchEvent()
{
GHOST_IEvent* event = popEvent();
bool handled = false;
if (event) {
handled = dispatchEvent(event);
delete event;
}
return handled;
}
bool OSWindow::didTestEventFire()
{
Event topEvent;
while (popEvent(&topEvent))
{
if (topEvent.Type == Event::EVENT_TEST)
{
return true;
}
}
return false;
}
bool DInputEventQueue::popEvent( EventInfo& info, DKeyEvent& ke, DMouseEvent& me, DJoyStickEvent& je )
{
if (popEventInfo(info))
{
switch (info.eventType)
{
case IDT_Mouse:
popEvent(me);
break;
case IDT_Keyboard:
popEvent(ke);
break;
case IDT_JoyStick:
popEvent(je);
break;
default:
break;
}
return true;
}
return false;
}
void CCPomelo::dispatchEvent()
{
lockEventQeueue();
CCPomeloEvent_ *event = popEvent();
if (event)
{
std::map<std::string, std::function<void(Node*, void*)> >::iterator it = event_content.find(event->event);
if (it != event_content.end())
{
CCPomeloReponse resp;
resp.status = event->status;
resp.docs = event->docs;
(*it).second((Node*)this, &resp);
}
json_decref(event->docs);
delete event;
}
unlockEventQeueue();
}
void ANGLERenderTest::step(float dt, double totalTime)
{
stepBenchmark(dt, totalTime);
// Clear events that the application did not process from this frame
Event event;
while (popEvent(&event))
{
// If the application did not catch a close event, close now
if (event.Type == Event::EVENT_CLOSED)
{
mRunning = false;
}
}
if (mRunning)
{
draw();
mEGLWindow->swap();
mOSWindow->messageLoop();
}
}
void MainMenu::onEvent(const sf::Event& event) {
Component* triggered = nullptr;
while((triggered = popEvent(event))) {
math::u_id id = triggered->getID();
if(id == play->getID())
Settings::restart();
else if(id == options->getID())
std::cout << "OPTIONS!" << std::endl;
else if(id == customize->getID())
MenuUtils::setMenu(CustomMenu::generate());
else if(id == exit->getID())
Settings::terminate();
else
std::cerr << "Something went terribly wrong: You!" << std::endl;
if(event.type == sf::Event::KeyReleased)
if(event.key.code == sf::Keyboard::P)
Settings::pause();
}
}
int SampleApplication::run()
{
if (!mOSWindow->initialize(mName, mWidth, mHeight))
{
return -1;
}
mOSWindow->setVisible(true);
if (!mEGLWindow->initializeGL(mOSWindow.get()))
{
return -1;
}
mRunning = true;
int result = 0;
if (!initialize())
{
mRunning = false;
result = -1;
}
mTimer->start();
double prevTime = 0.0;
while (mRunning)
{
double elapsedTime = mTimer->getElapsedTime();
double deltaTime = elapsedTime - prevTime;
step(static_cast<float>(deltaTime), elapsedTime);
// Clear events that the application did not process from this frame
Event event;
while (popEvent(&event))
{
// If the application did not catch a close event, close now
if (event.Type == Event::EVENT_CLOSED)
{
exit();
}
}
if (!mRunning)
{
break;
}
draw();
swap();
mOSWindow->messageLoop();
prevTime = elapsedTime;
}
destroy();
mEGLWindow->destroyGL();
mOSWindow->destroy();
return result;
}
void Anchor::nextEvent(Event **ev) {
popEvent(ev);
}
static int dk_ioctl
(
struct inode *inode,
struct file *file,
unsigned int cmd,
unsigned long arg
)
{
INT32 ret=-1;
INT32 data;
struct cfg_op co;
INT32 cli_id;
INT32 i;
struct client_info ci;
struct event_op eo;
event_handle evt_hnd;
p_event_struct p_event;
p_atheros_dev p_client;
#ifdef DK_DEBUG
printk("DK::dk_ioctl \n");
#endif
cli_id = (int) ((unsigned long)file->private_data);
p_client = get_client(cli_id);
if (p_client == NULL) {
printk("DK:: Invalid client \n");
return -1;
}
switch (cmd) {
case DK_IOCTL_GET_VERSION:
#ifdef DK_DEBUG
printk("DK:: DK_IOCTL_GET_VERISION \n");
#endif
data = (DRV_MAJOR_VERSION << 16) | (DRV_MINOR_VERSION);
ret = put_user(data, (INT32 *)arg);
break;
case DK_IOCTL_GET_CLIENT_INFO:
#ifdef DK_DEBUG
printk("DK:: DK_IOCTL_GET_CLIENT_INFO \n");
#endif
if (get_cli_info(cli_id,&ci) < 0) {
printk("DK:: get_cli_info failed, cli_id : %d \n", cli_id);
ret = -1;
} else {
ret = copy_to_user((void *)arg,(void *)&ci,sizeof(ci));
}
ret = 0;
break;
case DK_IOCTL_CFG_READ:
#if !defined(P1020)
if (copy_from_user((void *)&co,(void *)arg,sizeof(co))) {
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK::Cfg read @ offset %x \n",co.offset);
#endif
#if defined(OWL_PB42) || defined(PYTHON_EMU)
#ifdef WASP_OSPREY
if(cli_id!=0){ // For DBDC operation, Wasp radio's client ID is zero;
#endif
if (cli_cfg_read(cli_id,co.offset,co.size,&co.value) < 0) {
ret = -1;
} else {
ret = copy_to_user((void *)arg,(void *)&co,sizeof(co));
}
#ifdef WASP_OSPREY
}
#endif
#endif
#else
ret = -1;
#endif
break;
case DK_IOCTL_RTC_REG_READ:
if (copy_from_user((void *)&co,(void *)arg,sizeof(co))) {
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK::Rtc reg read @ offset %x \n",co.offset);
#endif
#ifndef OCTEON
if (rtc_reg_read(cli_id,co.offset,&co.value) < 0) {
ret = -1;
} else {
ret = copy_to_user((void *)arg,(void *)&co,sizeof(co));
}
#endif
break;
case DK_IOCTL_GET_CHIP_ID:
if (copy_from_user((void *)&co,(void *)arg,sizeof(co))) {
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK::Reading Chio ID @ offset %x \n",co.offset);
#endif
#ifndef OCTEON
if (get_chip_id(cli_id,co.offset,co.size,&co.value) < 0) {
ret = -1;
} else {
ret = copy_to_user((void *)arg,(void *)&co,sizeof(co));
}
break;
#endif
case DK_IOCTL_CFG_WRITE:
if (copy_from_user((void *)&co,(void *)arg,sizeof(co))) {
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK::Cfg write @ offset %x : %x \n",co.offset,co.value);
#endif
#if defined(OWL_PB42) || defined(PYTHON_EMU)
#ifdef WASP_OSPREY
if(cli_id!=0){ // For DBDC operation, Wasp radio's client ID is zero;
#endif
if (cli_cfg_write(cli_id,co.offset,co.size,co.value) < 0) {
ret = -1;
} else {
ret = 0;
}
#ifdef WASP_OSPREY
}
#endif
#endif
break;
case DK_IOCTL_SYS_REG_WRITE_32:
case DK_IOCTL_FULL_ADDR_WRITE:
if (copy_from_user((void *)&co,(void *)arg,sizeof(co))) {
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK::full addr write @ address %x : %x \n",co.offset,co.value);
#endif
#ifdef AP83
if (full_addr_write(cli_id,co.offset,co.value) < 0) {
ret = -1;
} else {
ret = 0;
}
#endif
break;
case DK_IOCTL_SYS_REG_READ_32:
case DK_IOCTL_FULL_ADDR_READ:
if (copy_from_user((void *)&co,(void *)arg,sizeof(co))) {
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK::Full add read @ address %x \n",co.offset);
#endif
#ifdef AP83
if (full_addr_read(cli_id,co.offset,&co.value) < 0) {
ret = -1;
} else {
ret = copy_to_user((void *)arg,(void *)&co,sizeof(co));
}
#endif
break;
case DK_IOCTL_RTC_REG_WRITE:
if (copy_from_user((void *)&co,(void *)arg,sizeof(co))) {
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK::rtc write @ offset %x : %x \n",co.offset,co.value);
#endif
#ifdef AP83
#ifndef WASP
if (rtc_reg_write(cli_id,co.offset,co.value) < 0) {
ret = -1;
} else {
ret = 0;
}
#endif
#endif
break;
case DK_IOCTL_CREATE_EVENT:
#ifdef DK_DEBUG
printk("DK::Create event \n");
#endif
if (copy_from_user((void *)&eo,(void *)arg,sizeof(eo))) {
return -EFAULT;
}
ret = -1;
if (eo.valid) {
evt_hnd.eventID = eo.param[5] & 0xffff;
evt_hnd.f2Handle = (eo.param[5] >> 16) & 0xffff;
p_event = createEvent (eo.param[0], // type
eo.param[1], // persistent
eo.param[2], // param1
eo.param[3], // param2
eo.param[4], // param3
evt_hnd);
if (p_event != NULL) {
// need to look at the event type to see which queue
switch (p_event->type ) {
case ISR_INTERRUPT:
//if param1 is zero, we, by default
// set the "ISR IMR" to pass everything
if ( 0 == p_event->param1 ) {
p_event->param1 = 0xffffffff;
}
if (pushEvent(p_event, &p_client->isr_event_q,
TRUE) ) {
ret = 0;
} else {
printk("DK::Push Event Failed \n");
kfree(p_event);
}
break;
default:
printk("DK::Event Type %d not supported \n",p_event->type);
kfree(p_event);
break;
}
}
}
break;
case DK_IOCTL_GET_NEXT_EVENT:
#ifdef DK_DEBUG
printk("DK::Get next event \n");
#endif
ret = 0;
eo.valid = 0;
if (p_client->trigered_event_q.queueSize) {
if (checkForEvents(&p_client->trigered_event_q,TRUE)){
p_event = popEvent(&p_client->trigered_event_q,TRUE);
eo.valid = 1;
eo.param[0] = p_event->type;
eo.param[1] = p_event->persistent;
eo.param[2] = p_event->param1;
eo.param[3] = p_event->param2;
eo.param[4] = p_event->param3;
eo.param[5] = (p_event->eventHandle.f2Handle << 16) |
p_event->eventHandle.eventID;
for (i=0;i<6;i++) {
eo.param[6+i] = p_event->result[i];
}
#ifdef DK_DEBUG
printk("DK:: Pop event %x \n",(UINT32)p_event);
#endif
kfree(p_event);
}
}
ret = copy_to_user((void *)arg,(void *)&eo,sizeof(eo));
break;
case DK_IOCTL_FLASH_READ:
printk("DK:: Flash read is not supported any more from art driver\n");
break;
case DK_IOCTL_FLASH_WRITE:
printk("DK:: Flash read is not supported any more from art driver\n");
break;
/*
#ifdef OWL_PB42
case DK_IOCTL_MAC_WRITE:
#ifdef DK_DEBUG
printk("DK::Get DK_IOCTL_MAC_WRITE\n ");
#endif
if (copy_from_user((void *)&flashMac,(void *)arg,sizeof(flashMac))) {
printk("DK:: Copy_from_user failed 1\n");
return -EFAULT;
}
if (copy_from_user((void *)mac0Addr,(void *)flashMac.pAddr0, 6)){
printk("DK:: Copy_from_user failedi 2\n");
return -EFAULT;
}
if (copy_from_user((void *)mac1Addr,(void *)flashMac.pAddr1, 6)){
printk("DK:: Copy_from_user failed 3\n");
return -EFAULT;
}
#ifdef DK_DEBUG
printk("DK:: MAC Addr\n");
for(i=0; i<6; i++)
printk("%x ", mac0Addr[i]);
printk("\n");
for(i=0; i<6; i++)
printk("%x ", mac1Addr[i]);
printk("\n");
#endif
memcpy(&hw_mac_cfg, 0xbf7f0000, 16);
ar7100_spi_sector_erase(0x7f0000);
// Copy mac address to ath_hw_cfg structure
for(i=0; i<6; i++)
hw_mac_cfg.macAddr0[i] = mac0Addr[i];
for(i=0; i<6; i++)
hw_mac_cfg.macAddr1[i] = mac1Addr[i];
ar7100_spi_write_page(0x7f0000, &hw_mac_cfg, 256);
ret = 1;
break;
#endif
*/
default:
printk("DK::Unreconginzed ioctl command %d \n",cmd);
break;
}
