uint32_t MoveEvents::onItemMove(Item* item, Tile* tile, bool isAdd) { MoveEvent_t eventType1, eventType2; if (isAdd) { eventType1 = MOVE_EVENT_ADD_ITEM; eventType2 = MOVE_EVENT_ADD_ITEM_ITEMTILE; } else { eventType1 = MOVE_EVENT_REMOVE_ITEM; eventType2 = MOVE_EVENT_REMOVE_ITEM_ITEMTILE; } uint32_t ret = 1; MoveEvent* moveEvent = getEvent(tile, eventType1); if (moveEvent) { ret &= moveEvent->fireAddRemItem(item, nullptr, tile->getPosition()); } moveEvent = getEvent(item, eventType1); if (moveEvent) { ret &= moveEvent->fireAddRemItem(item, nullptr, tile->getPosition()); } for (size_t i = tile->getFirstIndex(), j = tile->getLastIndex(); i < j; ++i) { Thing* thing = tile->getThing(i); if (!thing) { continue; } Item* tileItem = thing->getItem(); if (!tileItem || tileItem == item) { continue; } moveEvent = getEvent(tileItem, eventType2); if (moveEvent) { ret &= moveEvent->fireAddRemItem(item, tileItem, tile->getPosition()); } } return ret; }
bool BaseEvents::loadFromXml() { if (m_loaded) { std::cout << "[Error - BaseEvents::loadFromXml] It's already loaded." << std::endl; return false; } std::string scriptsName = getScriptBaseName(); std::string basePath = "data/" + scriptsName + "/"; if (getScriptInterface().loadFile(basePath + "lib/" + scriptsName + ".lua") == -1) { std::cout << "[Warning - BaseEvents::loadFromXml] Can not load " << scriptsName << " lib/" << scriptsName << ".lua" << std::endl; } std::string filename = basePath + scriptsName + ".xml"; pugi::xml_document doc; pugi::xml_parse_result result = doc.load_file(filename.c_str()); if (!result) { printXMLError("Error - BaseEvents::loadFromXml", filename, result); return false; } m_loaded = true; for (auto node : doc.child(scriptsName.c_str()).children()) { Event* event = getEvent(node.name()); if (!event) { continue; } if (!event->configureEvent(node)) { std::cout << "[Warning - BaseEvents::loadFromXml] Failed to configure event" << std::endl; delete event; continue; } bool success; pugi::xml_attribute scriptAttribute = node.attribute("script"); if (scriptAttribute) { std::string scriptFile = "scripts/" + std::string(scriptAttribute.as_string()); success = event->checkScript(basePath, scriptsName, scriptFile) && event->loadScript(basePath + scriptFile); } else { success = event->loadFunction(node.attribute("function")); } if (!success || !registerEvent(event, node)) { delete event; } } return true; }
int CFrontend::setFrontend(const FrontendParameters *feparams, bool nowait) { struct dtv_property cmdargs[FE_COMMON_PROPS + FE_DVBT_PROPS]; // WARNING: increase when needed more space struct dtv_properties cmdseq; #ifdef PEDANTIC_VALGRIND_SETUP memset(&cmdargs, 0, sizeof(cmdargs)); memset(&cmdseq, 0, sizeof(cmdseq)); #endif cmdseq.num = FE_COMMON_PROPS; cmdseq.props = cmdargs; tuned = false; struct dvb_frontend_event ev; { // Erase previous events while (1) { if (ioctl(fd, FE_GET_EVENT, &ev) < 0) break; //printf("[fe%d] DEMOD: event status %d\n", fenumber, ev.status); } } if (!buildProperties(feparams, cmdseq)) return 0; { //FE_TIMER_INIT(); //FE_TIMER_START(); if ((ioctl(fd, FE_SET_PROPERTY, &cmdseq)) < 0) { ERROR("FE_SET_PROPERTY"); return false; } //FE_TIMER_STOP("FE_SET_PROPERTY took"); } if (nowait) return 0; { FE_TIMER_INIT(); FE_TIMER_START(); struct dvb_frontend_event event; event = getEvent(); if(tuned) { FE_TIMER_STOP("tuning took"); } } return tuned; }
uint32_t MoveEvents::onItemMove(Item* item, Tile* tile, bool isAdd) { MoveEvent_t eventType1; MoveEvent_t eventType2; if(isAdd){ eventType1 = MOVE_EVENT_ADD_ITEM; eventType2 = MOVE_EVENT_ADD_ITEM_ITEMTILE; } else{ eventType1 = MOVE_EVENT_REMOVE_ITEM; eventType2 = MOVE_EVENT_REMOVE_ITEM_ITEMTILE; } uint32_t ret = 1; MoveEvent* moveEvent = getEvent(tile, eventType1); if(moveEvent){ ret = ret & moveEvent->fireAddRemItem(item, NULL, tile->getPosition()); } moveEvent = getEvent(item, eventType1); if(moveEvent){ ret = ret & moveEvent->fireAddRemItem(item, NULL, tile->getPosition()); } int32_t j = tile->__getLastIndex(); Item* tileItem = NULL; for(int32_t i = tile->__getFirstIndex(); i < j; ++i){ Thing* thing = tile->__getThing(i); if(thing && (tileItem = thing->getItem()) && (tileItem != item)){ moveEvent = getEvent(tileItem, eventType2); if(moveEvent){ ret = ret & moveEvent->fireAddRemItem(item, tileItem, tile->getPosition()); } } } return ret; }
void EventHeader::toStream( std::ostream &stream ) { stream.write( reinterpret_cast<const char*>(&m_mode), 1 ); // convert number of events to 24bit little endian representation uint32 numev = getNumEvents( ); uint8 tmp[3]; tmp[0] = numev % 256; tmp[1] = (numev / 256) % 256; tmp[2] = (numev / 65536) % 256; stream.write( reinterpret_cast<const char*>(tmp), 3 ); writeLittleEndian( stream, getSamplingRate( ) ); if( getMode() == 1 ) { Mode1Event e; // write event positions for( size_t i=0; i<getNumEvents(); i++) { getEvent( i, e ); writeLittleEndian( stream, e.position ); } // write event types for( size_t i=0; i<getNumEvents(); i++) { getEvent( i, e ); writeLittleEndian( stream, e.type ); } } else if( getMode() == 3 ) { Mode3Event e; // write event positions for( size_t i=0; i<getNumEvents(); i++) { getEvent( i, e ); writeLittleEndian( stream, e.position ); } // write event types for( size_t i=0; i<getNumEvents(); i++) { getEvent( i, e ); writeLittleEndian( stream, e.type ); } // write event channels for( size_t i=0; i<getNumEvents(); i++) { getEvent( i, e ); writeLittleEndian( stream, e.channel ); } // write event durations for( size_t i=0; i<getNumEvents(); i++) { getEvent( i, e ); writeLittleEndian( stream, e.duration ); } } }
ushort TGroup::execute() { do { endState = 0; do { TEvent e; getEvent(e); handleEvent(e); if (e.what != evNothing) eventError(e); } while (endState == 0); } while (!valid(endState)); return endState; }
void AutomationGrid::resized () { // this code could be commonalified // - getEventRect is virtual on MidiGrid, takes MidiGridItem* replaces getNoteRect) // - getEvent could be common too for (int i = notes.size(); --i >= 0;) { AutomationEvent* note = getEvent (i); note->setBounds (getNoteRect (note)); } MidiGrid::resized(); }
uint32_t MoveEvents::onCreatureMove(Creature* creature, const Tile* tile, bool isIn) { MoveEvent_t eventType; if (isIn) { eventType = MOVE_EVENT_STEP_IN; } else { eventType = MOVE_EVENT_STEP_OUT; } Position pos(0, 0, 0); if (tile) { pos = tile->getPosition(); } uint32_t ret = 1; MoveEvent* moveEvent = getEvent(tile, eventType); if (moveEvent) { ret = ret & moveEvent->fireStepEvent(creature, NULL, pos); } for (int32_t i = tile->__getFirstIndex(), j = tile->__getLastIndex(); i < j; ++i) { Thing* thing = tile->__getThing(i); if (thing) { Item* tileItem = thing->getItem(); if (tileItem) { moveEvent = getEvent(tileItem, eventType); if (moveEvent) { ret = ret & moveEvent->fireStepEvent(creature, tileItem, pos); } } } } return ret; }
// Used to set the next time event, if any. void eventUpdate(ModelInstance* comp, fmi2EventInfo* eventInfo, int timeEvent, long h) { if (!isEmpty() && pos(0) == fmi2True) { r(status_) = getEvent(); hr(status_) = present_; hr(input_) = absent_; pos(0) = fmi2False; i(bs_) = i(bs_) - 1; } else { hr(status_) = absent_; } comp->eventInfo.nextEventTimeDefined = fmi2False; }
void GSOCells::runEvent(Particle& part, const double) { Sim->dynamics->updateParticle(part); Sim->ptrScheduler->popNextEvent(); Event iEvent = getEvent(part); #ifdef DYNAMO_DEBUG if (std::isnan(iEvent._dt)) M_throw() << "A NAN Interaction collision time has been found"; if (iEvent._dt == std::numeric_limits<float>::infinity()) M_throw() << "An infinite Interaction (not marked as NONE) collision time has been found\n"; #endif //Move the system forward to the time of the event Sim->systemTime += iEvent._dt; Sim->ptrScheduler->stream(iEvent._dt); Sim->stream(iEvent._dt); ++Sim->eventCount; Sim->dynamics->updateParticle(part); Vector pos = part.getPosition() - cell_origins[part.getID()]; Sim->BCs->applyBC(pos); //We don't apply the PBC, as //dout << "!Particle " << part.getID() << " at " << part.getPosition() / Sim->units.unitLength() << std::endl; //dout << "!Cell origin " << cell_origins[part.getID()] / Sim->units.unitLength() << std::endl; //dout << "!Normal " << pos.normal() / Sim->units.unitLength() << std::endl; //dout << "!Distance " << pos.nrm() / Sim->units.unitLength() << std::endl; //dout << "!CellD " << _cellD / Sim->units.unitLength() << std::endl; //dout << "!Relative distance " << pos.nrm() / _cellD << std::endl; //dout << "!Perp velocity " << (pos.normal() | part.getVelocity()) << std::endl; //Now execute the event NEventData EDat(Sim->dynamics->runPlaneEvent(part, pos.normal(), 1.0, _cellD)); //dout << "!Perp velocity post " << (pos.normal() | part.getVelocity()) << std::endl; //if (pos.nrm() > _cellD * 1.00000001) // derr << "Particle " << part.getID() << " outside the cell by " << (pos.nrm() - _cellD) / _cellD << std::endl; //if (pos.nrm() < _cellD * 0.99999999) // derr << "Particle " << part.getID() << " inside the cell by " << (pos.nrm() - _cellD) / _cellD << std::endl; //Now we're past the event update everything Sim->_sigParticleUpdate(EDat); Sim->ptrScheduler->fullUpdate(part); for (shared_ptr<OutputPlugin> & Ptr : Sim->outputPlugins) Ptr->eventUpdate(iEvent, EDat); }
//************************************************************************** void control_inst_t::Squash() { ASSERT( !getEvent( EVENT_FINALIZED ) ); ASSERT(m_stage != RETIRE_STAGE); if (Waiting()) { RemoveWaitQueue(); } UnwindRegisters( ); m_pseq->decrementSequenceNumber(m_proc); markEvent( EVENT_FINALIZED ); #ifdef PIPELINE_VIS m_pseq->out_log("squash %d\n", getWindowIndex()); #endif }
enum OpenAB_Storage::Storage::eGetItem EDSCalendarStorage::getEvents(const OpenAB::PIMItem::IDs & ids, std::vector<OpenAB::SmartPtr<OpenAB::PIMCalendarEventItem> > & items) { for (unsigned int i = 0; i < ids.size(); ++i) { OpenAB::SmartPtr<OpenAB::PIMCalendarEventItem> item; if (eGetItemOk != getEvent(ids[i], item)) { return eGetItemFail; } items.push_back(item); } return eGetItemOk; }
void SFXFMODEventSource::_onParameterEvent( SFXParameter* parameter, SFXParameterEvent event ) { Parent::_onParameterEvent( parameter, event ); // If it's a value-change on a custom parameter, // pass it along to FMOD. if( getEvent() && event == SFXParameterEvent_ValueChanged && parameter->getChannel() == SFXChannelUser0 ) { const char* name = parameter->getInternalName(); FMOD_EVENTPARAMETER* fmodParameter; if( SFXFMODDevice::smFunc->FMOD_Event_GetParameter( mHandle, name, &fmodParameter ) != FMOD_OK ) { Con::errorf( "SFXFMODEventSource::_onParameterEvent - could not access parameter '%s' of event '%s'", name, getEvent()->getQualifiedName().c_str() ); return; } SFXFMODDevice::smFunc->FMOD_EventParameter_SetValue( fmodParameter, parameter->getValue() ); } }
void SFXFMODEventSource::_updateStatus() { if( mStatus == SFXStatusPlaying ) { if( !getEvent() ) _setStatus( SFXStatusStopped ); else { FMOD_EVENT_STATE state; SFXFMODDevice::smFunc->FMOD_Event_GetState( mHandle, &state ); if( !( state & FMOD_EVENT_STATE_PLAYING ) ) _setStatus( SFXStatusStopped ); } } }
void Model::dealWithEvents(bool strict) { // if strict conversion want to unset L3 prioirty if (strict == true) { if (getNumEvents() > 0) { for (unsigned int i = 0; i < getNumEvents(); i++) { Event * e = getEvent(i); e->unsetPriority(); } } } }
const PlanOperation* PlanOperation::execute() { const bool recordPerformance = _performance_attr != nullptr; // Check if we really need this epoch_t startTime = 0; if (recordPerformance) startTime = get_epoch_nanoseconds(); PapiTracer pt; // Start the execution refreshInput(); setupPlanOperation(); if (recordPerformance) { pt.addEvent("PAPI_TOT_CYC"); pt.addEvent(getEvent()); pt.start(); } executePlanOperation(); if (recordPerformance) pt.stop(); teardownPlanOperation(); if (recordPerformance) { epoch_t endTime = get_epoch_nanoseconds(); std::string threadId = boost::lexical_cast<std::string>(std::this_thread::get_id()); size_t cardinality; if (getResultTable() != empty_result) cardinality = getResultTable()->size(); else // the cardinality is max(size_t) by convention if there is no return table cardinality = std::numeric_limits<size_t>::max(); *_performance_attr = (performance_attributes_t) {pt.value("PAPI_TOT_CYC"), pt.value(getEvent()), getEvent(), planOperationName(), _operatorId, startTime, endTime, threadId, cardinality}; } setState(OpSuccess); return this; }
void ResourceMonitorAndroid::uevent_read() { char buffer[1024]; int buffer_length = sizeof(buffer); uevent_type_t event_type; long battery_capacity = 100; ssize_t len = recv(uevent_fd, buffer, buffer_length, 0); if (len <= 0) { HAGGLE_ERR("Could not read uevent\n"); return; } //HAGGLE_DBG("UEvent: %s\n", buffer); event_type = getEvent(buffer); switch (event_type) { case UEVENT_AC: case UEVENT_USB: HAGGLE_DBG("Power state: %s\n", power_mode_str[getPowerMode()]); break; case UEVENT_BATTERY: case UEVENT_BATTERY_CAPACITY: battery_capacity = getBatteryPercent(); HAGGLE_DBG("Battery capacity is %ld\n", battery_capacity); if (battery_capacity > 0 && battery_capacity < 10 && getPowerMode() == POWER_MODE_BATTERY) { HAGGLE_DBG("Shutting down due to low power\n"); getManager()->getKernel()->shutdown(); } break; case UEVENT_BATTERY_STATUS: HAGGLE_DBG("Battery status\n"); break; case UEVENT_BATTERY_HEALTH: HAGGLE_DBG("Battery health\n"); break; case UEVENT_UNKNOWN: break; } }
void GParabolaSentinel::runEvent(const Particle& part, const double) const { Sim->dynamics.getLiouvillean().updateParticle(part); GlobalEvent iEvent(getEvent(part)); if (iEvent.getdt() == HUGE_VAL) { //We've numerically drifted slightly passed the parabola, so //just reschedule the particles events, no need to enforce anything Sim->ptrScheduler->fullUpdate(part); return; } #ifdef DYNAMO_DEBUG if (boost::math::isnan(iEvent.getdt())) M_throw() << "A NAN Interaction collision time has been found when recalculating this global" << iEvent.stringData(Sim); #endif Sim->dSysTime += iEvent.getdt(); Sim->ptrScheduler->stream(iEvent.getdt()); Sim->dynamics.stream(iEvent.getdt()); Sim->dynamics.getLiouvillean().enforceParabola(part); #ifdef DYNAMO_DEBUG iEvent.addTime(Sim->freestreamAcc); Sim->freestreamAcc = 0; NEventData EDat(ParticleEventData(part, Sim->dynamics.getSpecies(part), VIRTUAL)); Sim->signalParticleUpdate(EDat); BOOST_FOREACH(std::tr1::shared_ptr<OutputPlugin> & Ptr, Sim->outputPlugins) Ptr->eventUpdate(iEvent, EDat); #else Sim->freestreamAcc += iEvent.getdt(); #endif Sim->ptrScheduler->fullUpdate(part); }
void Database::reserveTicket(string eventId, string personName, int numSeats) { int i,sizex,totalSeat=0,maxSeats; vector<Ticket> ticketList; bool doesExist=false; ticketList=getEventTickets(eventId); //choose tickets belongs to eventId sizex=ticketList.size(); //get the size of list try{ for(i=0;i<sizex;i++) if(personName!=ticketList[i].getOwnerName()) //if ownernames are different totalSeat+=ticketList[i].getNumberOfSeats(); //calculate occupied seats else throw (SystemError) 6; //if they are same throw existence exception if(totalSeat) { maxSeats=getPlace(getEvent(eventId).getPlaceName()).getMaxSeats(); if(totalSeat + numSeats > maxSeats) //if there aren't enough place throw an error throw (SystemError) 5; } else { sizex=places.size(); //getting size of event vector for(i=0; i<sizex; i++) //find the placeName if it exists if(eventId==events[i].getEventId()) { doesExist=true; break; } if(!doesExist) //if place does not exist throw (SystemError) 3; //throw an existance exception } tickets.push_back(Ticket(eventId,personName,numSeats,true)); //add new ticket object } catch(SystemError x) { if(x==3) cout << "ERR_EVENT_NOT_EXISTS"<<endl; if(x==5) cout << "ERR_NOT_ENOUGH_SEATS"<<endl; if(x==6) cout << "ERR_TICKET_CUSTOMER_EXISTS"<<endl; } ticketList.clear(); //deleting the vector, and cleaning the buffer }
BOOL DialogEventClock::OnInitDialog() { CDialog::OnInitDialog(); // TODO: この位置に初期化の補足処理を追加してください CEvent *event = getEvent(); TimeSensorNode *tsensor = (TimeSensorNode *)event->getNode(); assert(tsensor->isTimeSensorNode() == true); if (tsensor->isTimeSensorNode() == false) return FALSE; char value[256]; sprintf(value, "%g", tsensor->getCycleInterval()); SetDlgItemText(IDC_INTREVAL_TIME, value); return TRUE; // コントロールにフォーカスを設定しないとき、戻り値は TRUE となります // 例外: OCX プロパティ ページの戻り値は FALSE となります }
void StateLogger::showAll() { Serial.print("Logger Head @ "); Serial.println(mHeadAddress); Serial.print("Logger Tail @ "); Serial.println(mTailAddress); reset(); while(1) { s_event evt = getEvent(); if(!evt.crc) break; evt.print(); } }
void Event::loopEvent() { Player &player = getPlayer(); Scene &scene = getScene(); SDL_Event &event = getEvent(); int x=0; int y=0; int n=0; while(SDL_PollEvent(&event)) { if(event.type==SDL_QUIT) { //quit_engine = true; } if(event.type==SDL_KEYDOWN) { switch(event.key.keysym.sym) { case SDLK_RIGHT: player.setState(1); Scene::walk = true; break; case SDLK_UP: player.setState(2); break; default: break; } } if (event.type==SDL_KEYUP) { switch(event.key.keysym.sym) { case SDLK_RIGHT: player.setState(0); Scene::walk = false; break; case SDLK_UP: player.setState(0); break; default: break; } } } }
void Game::run() { /*TODO:The timer should be an object, Game::run should not call * sdl functions directly */ LCVAR_Event gameEvent; gameEvent.type = NOTHING; int startTicks = 0; //TODO: Clean this up, do not hardcode turn = WHITE; bool gameEnd = false; short errorCode = 0; //TODO: Don't hardcode these settings engine->init(32, 600, 600, ".", errorCode); handleErrors(errorCode); drawEverything(); refreshScreen(); while (!gameEnd){ getEvent(gameEvent); if(gameEvent.type == QUIT){ gameEnd = true; }else if (gameEvent.type == MOVE){ parseUserInput(gameEvent); } drawEverything(); refreshScreen(); gameEvent.type = NOTHING; } }
int fightPlayer (getThetaFunction (*init_1)(const Game, void *), getThetaFunction (*init_2)(const Game, void *), void * arg1, void * arg2, char isGUI) { srand(clock()); Game game = game_new_game (); char newTheta_1, newTheta_2; clock_t delay, t = clock (); if (isGUI) initGUI (); getThetaFunction getTheta1 = init_1 (game, arg1); getThetaFunction getTheta2 = init_2 (game, arg2); while (!game->won) { if (isGUI && getEvent () == -1) break; newTheta_1 = (*getTheta1) (game, arg1); newTheta_1 = (newTheta_1 > 0 ? 1 : newTheta_1 == 0 ? 0 : -1); newTheta_2 = (*getTheta2) (game, arg2); newTheta_2 = (newTheta_2 > 0 ? 1 : newTheta_2 == 0 ? 0 : -1); game_update_game (game, newTheta_1, newTheta_2); if (isGUI) { delay = clock(); if ((delay - t) * IMAGES_PER_SEC < CLOCKS_PER_SEC) { struct timespec ts = {0, (1000 / IMAGES_PER_SEC - (delay - t) * 1000 / CLOCKS_PER_SEC) * 1000000}; nanosleep (&ts, NULL); } draw (game); t = clock (); } } int r = game->won; if (isGUI) quitGUI (); game_free_game (game); return r; }
//////////////////////////////////////////////////////////////////////// // // Description: // Called by a child dragger after dragStart. // // Figures out which dragger is active, then updates the feedback // accordingly // // Use: protected // void SoDragPointDragger::dragStart() // //////////////////////////////////////////////////////////////////////// { currentDragger = getActiveChildDragger(); // If there is no active child dragger, then we should just return. if ( currentDragger == NULL) return; shftDown = getEvent()->wasShiftDown(); // Save the starting point as expressed in local space. // We need to do this so that our feedback will work nicely. startLocalHitPt = getLocalStartingPoint(); updateLimitBoxAndFeedback(); }
void MVRenderArea::doubleBufferOn() /**************************************************************************** * * Function: MVRenderArea::doubleBufferOn * * Description: Turns on double buffering for the render area. This member * function should be called just before peforming any * animation in the render area. * ****************************************************************************/ { if (dc.doubleBuffer()) { MVEvent evt; // Force a quick repaint onto the hidden display page doubleBuffered = true; MVProgram::application->quickRepaint(); getEvent(evt,evRepaint); } }
void TaskD::exec() { // A dummy analysis example: JPetPhysSignal currSignal = (JPetPhysSignal&) (*getEvent()); // increment the counter of signals getStatistics().getCounter("No. initial signals")++; if (fSignals.empty()) { fSignals.push_back(currSignal); } else { if (fSignals[0].getTimeWindowIndex() == currSignal.getTimeWindowIndex()) { fSignals.push_back(currSignal); } else { getStatistics().getHisto1D("No. signals in TSlot").Fill(fSignals.size()); saveHits(createHits(fSignals)); //create LORs from previously saved signals fSignals.clear(); fSignals.push_back(currSignal); } } }
void DialogEventClock::OnOK() { // TODO: この位置にその他の検証用のコードを追加してください CEvent *event = getEvent(); TimeSensorNode *tsensor = (TimeSensorNode *)event->getNode(); assert(tsensor->isTimeSensorNode() == true); if (tsensor->isTimeSensorNode() == false) return; char optionString[256]; GetDlgItemText(IDC_INTREVAL_TIME, optionString, 255); float value; if (sscanf(optionString, "%f", &value) == 1) { sprintf(optionString, "%g", value); event->setOptionString(optionString); } else MessageBeep(0); CDialog::OnOK(); }
void MainWindow::addCurrentEvent() { MeshField* currentMesh = meshFields.at(ui->meshComboBox->currentIndex()); Event * currentEvent; try{ currentEvent = getEvent(ui->eventComboBox->currentIndex()); } catch(...) { warning("Invalid input arguments."); return; } currentMesh->addEvent(*currentEvent); ui->EventList->addItem(QString::fromStdString(currentEvent->getType())); if (running) { currentEvent->setLoopCyclePtr(mainMesh->getLoopCounter()); } }
const ControllerId& ErrorController::render() const & { const auto& context = getContext(); auto& window = context.getSfmlWindow(); window.draw(impl->text); setNextControllerId(animateScreenTransition(context)); auto& event = getEvent(); while(window.pollEvent(event)) { switch(event.type) { case sf::Event::KeyPressed: { switch(event.key.code) { case sf::Keyboard::Escape: { setExpectedControllerId(impl->previousControllerId); break; } default: { break; } } } default: { break; } } } return getNextControllerId(); }