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