void ProjectileOccurrence::updatePhysicData(float time, RenderWindow& app)
{
setActivity(app);
if(_isActive)
{
if(_lifeTime.GetElapsedTime() > 0)
{
/* Submissions */
if(_projectile->getSubmission() & PhysicConstants::GRAVITY_SUBMISSION)
gravity(_speed, time);
/* Update physic position */
/* Save actual position in previous position */
_previousPosition = _position;
/* Compute new position */
updatePositions(_hitboxPosition.x + time * _speed.x, _hitboxPosition.y + time * _speed.y);
/* If it falls in hole */
/*if(_hitboxPosition.y + _hitboxSize.y < 0)
_projectile->removeProjectileOccurrence(this);*/
if(_hitboxPosition.y < 0)
_hitboxPosition.y = 0;
}
else
{
//_projectile->removeProjectileOccurrence(this);
}
}
}
void Checkpoint::updateGraphicData(RenderWindow& app)
{
setActivity(app);
if(_isActive)
_animation.update();
}
void InstrumentWidgetMaskTab::showEvent(QShowEvent *) {
setActivity();
m_instrWidget->setMouseTracking(true);
enableApplyButtons();
m_instrWidget->updateInstrumentView(true);
m_instrWidget->getSurface()->changeBorderColor(getShapeBorderColor());
}
void CharacterController::setNextActivity(std::unique_ptr<Activity> activity) {
if (_currentActivity == nullptr) {
setActivity(std::move(activity));
_nextActivity = nullptr;
} else {
_nextActivity.swap(activity);
}
}
void CharacterController::skipActivity() {
// Some activities can't be cancelled, such as the final phase of entering a
// vehicle
// or jumping.
if (getCurrentActivity() != nullptr &&
getCurrentActivity()->canSkip(character, this))
setActivity(nullptr);
}
void BlockOccurrence::updatePhysicData(float, RenderWindow& app)
{
setActivity(app);
if(_isActive)
{
_previousHitboxPosition = _hitboxPosition;
}
}
void CharacterController::setNextActivity(CharacterController::Activity* activity)
{
if( _currentActivity == nullptr ) {
setActivity(activity);
_nextActivity = nullptr;
}
else {
if(_nextActivity) delete _nextActivity;
_nextActivity = activity;
}
}
void CharacterController::update(float dt)
{
if( character->getCurrentVehicle() ) {
// Nevermind, the player is in a vehicle.
auto& d = character->getMovement();
if( character->getCurrentSeat() == 0 )
{
character->getCurrentVehicle()->setSteeringAngle(d.y);
if( std::abs(d.x) > 0.01f )
{
character->getCurrentVehicle()->setHandbraking(false);
}
character->getCurrentVehicle()->setThrottle(d.x);
}
if( _currentActivity == nullptr ) {
if( glm::length( d ) <= 0.1f )
{
vehicleIdle += dt;
}
else
{
vehicleIdle = 0.f;
}
if( vehicleIdle >= 1.f )
{
// If character is idle in vehicle, try to close the door.
auto v = character->getCurrentVehicle();
auto entryDoor = v->getSeatEntryDoor(character->getCurrentSeat());
if( entryDoor && entryDoor->constraint )
{
character->getCurrentVehicle()->setPartTarget(entryDoor, true, entryDoor->closedAngle);
}
}
}
}
if( updateActivity() ) {
character->activityFinished();
if( _currentActivity ) {
delete _currentActivity;
_currentActivity = nullptr;
}
if( _nextActivity ) {
setActivity( _nextActivity );
_nextActivity = nullptr;
}
}
}
void Process::addValue( libecs::Param<Real>::type aValue )
{
setActivity( aValue );
// Increase or decrease variables, skipping zero coefficients.
std::for_each( theVariableReferenceVector.begin(),
theZeroVariableReferenceIterator,
boost::bind( &VariableReference::addValue, _1, aValue ) );
std::for_each( thePositiveVariableReferenceIterator,
theVariableReferenceVector.end(),
boost::bind( &VariableReference::addValue, _1, aValue ) );
}
void Pipe::updatePhysicData(float, RenderWindow& app)
{
setActivity(app);
if(_isActive && _monster != nullptr)
{
if(_monsterExitDuration.getElapsedTime().asMilliseconds() >= MONSTER_EXIT_TIME)
{
switch(_direction)
{
case TO_TOP:
_monster->addNewMonsterOccurrence(
Vector2f(_position.x + BLOCK_WIDTH / 2, _position.y),
Vector2f(0, MonsterConstants::MONSTER_EXIT_PIPE_SPEED_Y),
MonsterOccurrence::GET_OUT_FROM_PIPE,
MonsterOccurrence::LEFT_SIDE);
break;
case TO_BOTTOM:
_monster->addNewMonsterOccurrence(
Vector2f(_position.x + BLOCK_WIDTH / 2, _position.y),
Vector2f(0, -MonsterConstants::MONSTER_EXIT_PIPE_SPEED_Y),
MonsterOccurrence::GET_OUT_FROM_PIPE,
MonsterOccurrence::LEFT_SIDE);
break;
case TO_LEFT:
_monster->addNewMonsterOccurrence(
Vector2f(_position.x + BLOCK_WIDTH / 2, _position.y),
Vector2f(-MonsterConstants::MONSTER_EXIT_PIPE_SPEED_Y, 0),
MonsterOccurrence::GET_OUT_FROM_PIPE,
MonsterOccurrence::LEFT_SIDE);
break;
case TO_RIGHT:
_monster->addNewMonsterOccurrence(
Vector2f(_position.x + BLOCK_WIDTH / 2, _position.y),
Vector2f(MonsterConstants::MONSTER_EXIT_PIPE_SPEED_Y, 0),
MonsterOccurrence::GET_OUT_FROM_PIPE,
MonsterOccurrence::RIGHT_SIDE);
break;
default:
break;
}
//occ_m->tps_sortie_tuyau = occ_m->type_monstre->tps_sortie_tuyau;
_monsterExitDuration.restart();
}
}
}
RosterAvatarFrame::RosterAvatarFrame(QWidget *parent)
: QFrame(parent)
, statusMessage_("")
{
ui_.setupUi(this);
layout()->setMargin(PsiOptions::instance()->getOption("options.ui.contactlist.roster-avatar-frame.avatar.margin").toInt());
layout()->setSpacing(0);
setMoodIcon("mood/");
setActivityIcon("activities/other");
setFont();
connect(ui_.le_status_text, SIGNAL(returnPressed()), this, SLOT(statusMessageReturnPressed()));
connect(ui_.tb_mood, SIGNAL(pressed()), this, SIGNAL(setMood()));
connect(ui_.tb_activity, SIGNAL(pressed()), this, SIGNAL(setActivity()));
connect(PsiOptions::instance(), SIGNAL(optionChanged(QString)),this, SLOT(optionChanged(QString)));
}
bool Mops_Rec::configureHook(){
// Set component activitiy
if(setActivity(new RTT::Activity(ORO_SCHED_RT,
_priority,
0,
_cpu,
0,
getName())) == false){
if(_verbose)
std::cout << "Unable to set activity!" << std::endl;
return false;
}
connectToMOPS();
if(_verbose)
std::cout << "Mops_Rec configured !" <<std::endl;
return true;
}
void InstrumentWindowMaskTab::selectTool(Activity tool)
{
switch(tool)
{
case Move: m_move->setChecked(true);
break;
case Select: m_pointer->setChecked(true);
break;
case DrawEllipse: m_ellipse->setChecked(true);
break;
case DrawRectangle: m_rectangle->setChecked(true);
break;
case DrawEllipticalRing: m_ring_ellipse->setChecked(true);
break;
case DrawRectangularRing: m_ring_rectangle->setChecked(true);
break;
default: throw std::invalid_argument("Invalid tool type.");
}
setActivity();
}
void GillespieProcess::fire()
{
Real velocity( getk() * N_A );
velocity *= getSuperSystem()->getSize();
for( VariableReferenceVector::const_iterator
s( theVariableReferenceVector.begin() );
s != theZeroVariableReferenceIterator; ++s )
{
VariableReference aVariableReference( *s );
Integer aCoefficient( aVariableReference.getCoefficient() );
do
{
++aCoefficient;
velocity *= aVariableReference.getVariable()->getMolarConc();
}
while( aCoefficient != 0 );
}
setActivity( velocity );
}
InstrumentWindowMaskTab::InstrumentWindowMaskTab(InstrumentWindow* instrWindow):
InstrumentWindowTab(instrWindow),
m_activity(Select),
m_hasMaskToApply(false),
m_userEditing(true)
{
// main layout
QVBoxLayout* layout=new QVBoxLayout(this);
m_activeTool = new QLabel(this);
layout->addWidget(m_activeTool);
// Create the tool buttons
m_move = new QPushButton();
m_move->setCheckable(true);
m_move->setAutoExclusive(true);
m_move->setIcon(QIcon(":/PickTools/zoom.png"));
m_move->setToolTip("Move the instrument (Ctrl+Alt+M)");
m_move->setShortcut(QKeySequence("Ctrl+Alt+M"));
m_pointer = new QPushButton();
m_pointer->setCheckable(true);
m_pointer->setAutoExclusive(true);
m_pointer->setIcon(QIcon(":/MaskTools/selection-edit.png"));
m_pointer->setToolTip("Select and edit shapes (Ctrl+Alt+P)");
m_pointer->setShortcut(QKeySequence("Ctrl+Alt+P"));
m_ellipse = new QPushButton();
m_ellipse->setCheckable(true);
m_ellipse->setAutoExclusive(true);
m_ellipse->setIcon(QIcon(":/MaskTools/selection-circle.png"));
m_ellipse->setToolTip("Draw an ellipse (Ctrl+Alt+E)");
m_ellipse->setShortcut(QKeySequence("Ctrl+Alt+E"));
m_rectangle = new QPushButton();
m_rectangle->setCheckable(true);
m_rectangle->setAutoExclusive(true);
m_rectangle->setIcon(QIcon(":/MaskTools/selection-box.png"));
m_rectangle->setToolTip("Draw a rectangle (Ctrl+Alt+R)");
m_rectangle->setShortcut(QKeySequence("Ctrl+Alt+R"));
m_ring_ellipse = new QPushButton();
m_ring_ellipse->setCheckable(true);
m_ring_ellipse->setAutoExclusive(true);
m_ring_ellipse->setIcon(QIcon(":/MaskTools/selection-circle-ring.png"));
m_ring_ellipse->setToolTip("Draw an elliptical ring (Shift+Alt+E)");
m_ring_ellipse->setShortcut(QKeySequence("Shift+Alt+E"));
m_ring_rectangle = new QPushButton();
m_ring_rectangle->setCheckable(true);
m_ring_rectangle->setAutoExclusive(true);
m_ring_rectangle->setIcon(QIcon(":/MaskTools/selection-box-ring.png"));
m_ring_rectangle->setToolTip("Draw a rectangular ring (Shift+Alt+R)");
m_ring_rectangle->setShortcut(QKeySequence("Shift+Alt+R"));
QHBoxLayout* toolBox = new QHBoxLayout();
toolBox->addWidget(m_move);
toolBox->addWidget(m_pointer);
toolBox->addWidget(m_ellipse);
toolBox->addWidget(m_rectangle);
toolBox->addWidget(m_ring_ellipse);
toolBox->addWidget(m_ring_rectangle);
toolBox->addStretch();
toolBox->setSpacing(2);
toolBox->setMargin(0);
connect(m_move,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_pointer,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_ellipse,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_rectangle,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_ring_ellipse,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_ring_rectangle,SIGNAL(clicked()),this,SLOT(setActivity()));
m_move->setChecked(true);
QFrame* toolGroup = new QFrame();
toolGroup->setLayout(toolBox);
layout->addWidget(toolGroup);
// create mask/group switch
m_masking_on = new QRadioButton("Mask");
m_grouping_on = new QRadioButton("Group");
m_masking_on->setChecked(true);
connect(m_masking_on,SIGNAL(toggled(bool)),this,SLOT(toggleMaskGroup(bool)));
QHBoxLayout* radioLayout = new QHBoxLayout();
radioLayout->addWidget(m_masking_on);
radioLayout->addWidget(m_grouping_on);
radioLayout->setMargin(0);
QWidget* radioGroup = new QWidget();
radioGroup->setLayout(radioLayout);
layout->addWidget(radioGroup);
// Create property browser
/* Create property managers: they create, own properties, get and set values */
m_groupManager = new QtGroupPropertyManager(this);
m_doubleManager = new QtDoublePropertyManager(this);
connect(m_doubleManager,SIGNAL(propertyChanged(QtProperty*)),this,SLOT(doubleChanged(QtProperty*)));
/* Create editors and assign them to the managers */
DoubleEditorFactory *doubleEditorFactory = new DoubleEditorFactory(this);
m_browser = new QtTreePropertyBrowser();
m_browser->setFactoryForManager(m_doubleManager, doubleEditorFactory);
layout->addWidget(m_browser);
// Algorithm buttons
m_apply = new QPushButton("Apply to Data");
m_apply->setToolTip("Apply current mask to the data workspace. Cannot be reverted.");
connect(m_apply,SIGNAL(clicked()),this,SLOT(applyMask()));
m_apply_to_view = new QPushButton("Apply to View");
m_apply_to_view->setToolTip("Apply current mask to the view.");
connect(m_apply_to_view,SIGNAL(clicked()),this,SLOT(applyMaskToView()));
m_clear_all = new QPushButton("Clear All");
m_clear_all->setToolTip("Clear all masking that have not been applied to the data.");
connect(m_clear_all,SIGNAL(clicked()),this,SLOT(clearMask()));
m_save_as_workspace_exclude = new QAction("As Mask to workspace",this);
m_save_as_workspace_exclude->setToolTip("Save current mask to mask workspace.");
connect(m_save_as_workspace_exclude,SIGNAL(activated()),this,SLOT(saveMaskToWorkspace()));
m_save_as_workspace_include = new QAction("As ROI to workspace",this);
m_save_as_workspace_include->setToolTip("Save current mask as ROI to mask workspace.");
connect(m_save_as_workspace_include,SIGNAL(activated()),this,SLOT(saveInvertedMaskToWorkspace()));
m_save_as_file_exclude = new QAction("As Mask to file",this);
m_save_as_file_exclude->setToolTip("Save current mask to mask file.");
connect(m_save_as_file_exclude,SIGNAL(activated()),this,SLOT(saveMaskToFile()));
m_save_as_file_include = new QAction("As ROI to file",this);
m_save_as_file_include->setToolTip("Save current mask as ROI to mask file.");
connect(m_save_as_file_include,SIGNAL(activated()),this,SLOT(saveInvertedMaskToFile()));
m_save_as_cal_file_exclude = new QAction("As Mask to cal file",this);
m_save_as_cal_file_exclude->setToolTip("Save current mask to cal file.");
connect(m_save_as_cal_file_exclude,SIGNAL(activated()),this,SLOT(saveMaskToCalFile()));
m_save_as_cal_file_include = new QAction("As ROI to cal file",this);
m_save_as_cal_file_include->setToolTip("Save current mask as ROI to cal file.");
connect(m_save_as_cal_file_include,SIGNAL(activated()),this,SLOT(saveInvertedMaskToCalFile()));
m_save_as_table_xrange_exclude = new QAction("As Mask to table", this);
m_save_as_table_xrange_exclude->setToolTip("Save current mask to a table workspace with x-range. "
"The name of output table workspace is 'MaskBinTable'. "
"If the output table workspace has alrady exist, then "
"the newly masked detectors will be added to output workspace.");
connect(m_save_as_table_xrange_exclude, SIGNAL(activated()), this, SLOT(saveMaskToTable()));
m_save_group_file_include = new QAction("As include group to file",this);
m_save_group_file_include->setToolTip("Save current mask as include group to a file.");
connect(m_save_group_file_include,SIGNAL(activated()),this,SLOT(saveIncludeGroupToFile()));
m_save_group_file_exclude = new QAction("As exclude group to file",this);
m_save_group_file_exclude->setToolTip("Save current mask as exclude group to a file.");
connect(m_save_group_file_exclude,SIGNAL(activated()),this,SLOT(saveExcludeGroupToFile()));
m_extract_to_workspace = new QAction("Extract detectors to workspace",this);
m_extract_to_workspace->setToolTip("Extract detectors to workspace.");
connect(m_extract_to_workspace,SIGNAL(activated()),this,SLOT(extractDetsToWorkspace()));
m_sum_to_workspace = new QAction("Sum detectors to workspace",this);
m_sum_to_workspace->setToolTip("Sum detectors to workspace.");
connect(m_sum_to_workspace,SIGNAL(activated()),this,SLOT(sumDetsToWorkspace()));
// Save button and its menus
m_saveButton = new QPushButton("Apply and Save");
m_saveButton->setToolTip("Save current masking/grouping to a file or a workspace.");
m_saveMask = new QMenu(this);
m_saveMask->addAction(m_save_as_workspace_include);
m_saveMask->addAction(m_save_as_workspace_exclude);
m_saveMask->addSeparator();
m_saveMask->addAction(m_save_as_file_include);
m_saveMask->addAction(m_save_as_file_exclude);
m_saveMask->addSeparator();
m_saveMask->addAction(m_save_as_cal_file_include);
m_saveMask->addAction(m_save_as_cal_file_exclude);
m_saveMask->addSeparator();
m_saveMask->addAction(m_save_as_table_xrange_exclude);
connect(m_saveMask,SIGNAL(hovered(QAction*)),this,SLOT(showSaveMenuTooltip(QAction*)));
m_saveButton->setMenu(m_saveMask);
m_saveGroup = new QMenu(this);
m_saveGroup->addAction(m_extract_to_workspace);
m_saveGroup->addAction(m_sum_to_workspace);
m_saveGroup->addSeparator();
m_saveGroup->addAction(m_save_group_file_include);
m_saveGroup->addAction(m_save_group_file_exclude);
connect(m_saveGroup,SIGNAL(hovered(QAction*)),this,SLOT(showSaveMenuTooltip(QAction*)));
QGroupBox *box = new QGroupBox("View");
QGridLayout* buttons = new QGridLayout();
buttons->addWidget(m_apply_to_view,0,0,1,2);
buttons->addWidget(m_saveButton,1,0);
buttons->addWidget(m_clear_all,1,1);
box->setLayout(buttons);
layout->addWidget(box);
box = new QGroupBox("Workspace");
buttons = new QGridLayout();
buttons->addWidget(m_apply,0,0);
box->setLayout(buttons);
layout->addWidget(box);
}
/*------------------------------------------------------------------------------------
----------------------------switchActivity--------------------------------------------
------------------------------------------------------------------------------------*/
void MainMenu::switchActivity() //switch the activity of the main menu
{
setActivity(!isActive);
}
void InstrumentWindowMaskTab::showEvent (QShowEvent *)
{
setActivity();
m_instrumentDisplay->setMouseTracking(true);
}
InstrumentWindowMaskTab::InstrumentWindowMaskTab(InstrumentWindow* instrWindow):
QFrame(instrWindow),
m_instrumentWindow(instrWindow),
m_activity(Select),
m_userEditing(true)
{
m_instrumentDisplay = m_instrumentWindow->getInstrumentDisplay();
// main layout
QVBoxLayout* layout=new QVBoxLayout(this);
// Create the tool buttons
m_move = new QPushButton();
m_move->setCheckable(true);
m_move->setAutoExclusive(true);
m_move->setIcon(QIcon(":/PickTools/selection-tube.png"));
m_move->setToolTip("Move the instrument");
m_pointer = new QPushButton();
m_pointer->setCheckable(true);
m_pointer->setAutoExclusive(true);
m_pointer->setIcon(QIcon(":/MaskTools/selection-pointer.png"));
m_pointer->setToolTip("Select and edit shapes");
m_ellipse = new QPushButton();
m_ellipse->setCheckable(true);
m_ellipse->setAutoExclusive(true);
m_ellipse->setIcon(QIcon(":/MaskTools/selection-circle.png"));
m_ellipse->setToolTip("Draw an ellipse");
m_rectangle = new QPushButton();
m_rectangle->setCheckable(true);
m_rectangle->setAutoExclusive(true);
m_rectangle->setIcon(QIcon(":/MaskTools/selection-box.png"));
m_rectangle->setToolTip("Draw a rectangle");
m_ring_ellipse = new QPushButton();
m_ring_ellipse->setCheckable(true);
m_ring_ellipse->setAutoExclusive(true);
m_ring_ellipse->setIcon(QIcon(":/MaskTools/selection-circle.png"));
m_ring_ellipse->setToolTip("Draw an elliptical ring");
m_ring_rectangle = new QPushButton();
m_ring_rectangle->setCheckable(true);
m_ring_rectangle->setAutoExclusive(true);
m_ring_rectangle->setIcon(QIcon(":/MaskTools/selection-box.png"));
m_ring_rectangle->setToolTip("Draw a rectangular ring ");
QHBoxLayout* toolBox = new QHBoxLayout();
toolBox->addWidget(m_move);
toolBox->addWidget(m_pointer);
toolBox->addWidget(m_ellipse);
toolBox->addWidget(m_rectangle);
toolBox->addWidget(m_ring_ellipse);
toolBox->addWidget(m_ring_rectangle);
toolBox->addStretch();
toolBox->setSpacing(2);
connect(m_move,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_pointer,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_ellipse,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_rectangle,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_ring_ellipse,SIGNAL(clicked()),this,SLOT(setActivity()));
connect(m_ring_rectangle,SIGNAL(clicked()),this,SLOT(setActivity()));
m_move->setChecked(true);
layout->addLayout(toolBox);
// Create property browser
/* Create property managers: they create, own properties, get and set values */
m_groupManager = new QtGroupPropertyManager(this);
m_doubleManager = new QtDoublePropertyManager(this);
connect(m_doubleManager,SIGNAL(propertyChanged(QtProperty*)),this,SLOT(doubleChanged(QtProperty*)));
/* Create editors and assign them to the managers */
DoubleEditorFactory *doubleEditorFactory = new DoubleEditorFactory(this);
m_browser = new QtTreePropertyBrowser();
m_browser->setFactoryForManager(m_doubleManager, doubleEditorFactory);
layout->addWidget(m_browser);
// Algorithm buttons
m_apply = new QPushButton("Apply");
connect(m_apply,SIGNAL(clicked()),this,SLOT(applyMask()));
m_clear_all = new QPushButton("Clear All");
connect(m_clear_all,SIGNAL(clicked()),this,SLOT(clearMask()));
m_save_as_workspace_include = new QAction("Save As Workspace (include)",this);
connect(m_save_as_workspace_include,SIGNAL(activated()),this,SLOT(saveMaskToWorkspaceInclude()));
m_save_as_workspace_exclude = new QAction("Save As Workspace (exclude)",this);
connect(m_save_as_workspace_exclude,SIGNAL(activated()),this,SLOT(saveMaskToWorkspaceExclude()));
m_save_as_file_include = new QAction("Save As File (include)",this);
connect(m_save_as_file_include,SIGNAL(activated()),this,SLOT(saveMaskToFileInclude()));
m_save_as_file_exclude = new QAction("Save As File (exclude)",this);
connect(m_save_as_file_exclude,SIGNAL(activated()),this,SLOT(saveMaskToFileExclude()));
QPushButton* saveButton = new QPushButton("Save");
QMenu* saveMenu = new QMenu(this);
saveMenu->addAction(m_save_as_workspace_include);
saveMenu->addAction(m_save_as_workspace_exclude);
saveMenu->addAction(m_save_as_file_include);
saveMenu->addAction(m_save_as_file_exclude);
saveButton->setMenu(saveMenu);
QGridLayout* buttons = new QGridLayout();
buttons->addWidget(m_apply,0,0);
buttons->addWidget(m_clear_all,0,1);
buttons->addWidget(saveButton,1,0,1,2);
layout->addLayout(buttons);
}
virtual void fire()
{
setActivity( theVirtualMachine.execute( *theCompiledCode ) );
}
void CharacterController::skipActivity()
{
setActivity(nullptr);
}
