void
TriggerPoint::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget)
{
Q_UNUSED(option);
Q_UNUSED(widget);
QRectF rect = boundingRect();
painter->save();
BasicBox *box = NULL;
if (_abstract->boxID() != NO_ID) {
if ((box = _scene->getBox(_abstract->boxID())) != NULL) {
QPen pen = painter->pen();
QBrush brush = painter->brush();
pen.setColor(box->color().darker());
pen.setWidth(isSelected() ? 1.5 * BasicBox::LINE_WIDTH : BasicBox::LINE_WIDTH / 2);
painter->setPen(pen);
if (_scene->playing()) {
if (!isWaiting()) {
drawFlag(painter, QColor("red"));
}
else {
if(!_scene->triggersQueueList()->isEmpty())
if (_scene->triggersQueueList()->first() == this) {
drawFlag(painter, QColor("green"));
this->setFocus();
}
else {
// brush.setColor(QColor("orange"));
// painter->setBrush(brush);
drawFlag(painter, QColor("orange"));
}
}
if (_abstract->waiting()) {
BasicBox *box = _scene->getBox(_abstract->boxID());
box->update();
switch (_abstract->boxExtremity()) {
case BOX_START:
painter->drawText(rect.topRight() + QPointF(0, rect.height() / 2), QString::fromStdString(_abstract->message()));
break;
case BOX_END:
painter->drawText(rect.topLeft() + QPointF(-QString::fromStdString(_abstract->message()).length() * 7, rect.height() / 2), QString::fromStdString(_abstract->message()));
break;
default:
break;
}
}
}
else {
drawFlag(painter, QColor(Qt::darkGray));
}
}
}
painter->restore();
}
void
ConditionalRelation::updateBoxesCoordinates(unsigned int boxId)
{
// Move related boxes, except boxId's box (already moved by user)
QList<BasicBox *>::iterator it;
BasicBox *box = _scene->getBox(boxId),
*curBox;
float curBoxX,
boxX = box->getLeftGripPoint().x();
for(it=_boxesAttached.begin() ; it!=_boxesAttached.end() ; it++)
{
curBox = *it;
if(curBox->ID() != box->ID())
{
curBoxX = curBox->getLeftGripPoint().x();
if(boxX != curBoxX)
{
curBox->moveBy(boxX - curBoxX, 0.);
_scene->boxMoved(curBox->ID());
}
}
}
}
void
AttributesEditor::startChanged()
{
// std::cout<<"--- startChanged ---"<<std::endl;
BasicBox * box = _scene->getBox(_boxEdited);
if (box != NULL) {
box->moveBy(_boxStartValue->value() * S_TO_MS / MaquetteScene::MS_PER_PIXEL - box->getTopLeft().x(), 0);
_scene->boxMoved(_boxEdited);
}
}
void
AttributesEditor::curveActivationChanged(QTreeWidgetItem *item, bool activated)
{
string address = _networkTree->getAbsoluteAddress(item).toStdString();
if (_boxEdited != NO_ID) {
Maquette::getInstance()->setCurveMuteState(_boxEdited, address, !activated);
BasicBox * box = _scene->getBox(_boxEdited);
box->curveActivationChanged(address, activated);
}
}
void GenLineMode::mouseReleaseEvent(QGraphicsSceneMouseEvent * event){
QTransform transform;
BasicBox* begin = dynamic_cast<BasicBox*>(canvas->itemAt(event->scenePos(), transform));
BasicBox* end = dynamic_cast<BasicBox*>(canvas->itemAt(event->buttonDownScenePos(Qt::LeftButton), transform));
if(begin && end){
GenLine* line = new GenLine();
line->setPorts(begin->getPort(event->scenePos()), end->getPort(event->buttonDownScenePos(Qt::LeftButton)));
canvas->addItem(line);
}
std::cout<<"genline released"<<std::endl;
}
void
AttributesEditor::lengthChanged()
{
// std::cout<<"--- length changed ---"<<std::endl;
BasicBox * box = _scene->getBox(_boxEdited);
if (box != NULL) {
box->resizeWidthEdition(_boxLengthValue->value() * S_TO_MS / MaquetteScene::MS_PER_PIXEL);
QPainterPath nullPath;
nullPath.addRect(QRectF(QPointF(0., 0.), QSizeF(0., 0.)));
_scene->setSelectionArea(nullPath);
box->setSelected(true);
_scene->setResizeBox(_boxEdited);
_scene->boxResized();
}
}
void
AttributesEditor::changeColor()
{
if (_boxEdited != NO_ID) {
BasicBox * box = _scene->getBox(_boxEdited);
QColor color = QColorDialog::getColor(box->currentColor(), this);
if (color.isValid()) {
_colorButtonPixmap->fill(color);
_generalColorButton->setIcon(QIcon(*_colorButtonPixmap));
box->changeColor(color);
}
}
else {
_scene->displayMessage("No box selected", INDICATION_LEVEL);
}
}
void
TriggerPoint::updatePosition()
{
if (_abstract->boxID() != NO_ID) {
BasicBox *box = _scene->getBox(_abstract->boxID());
if (box != NULL) {
if (_abstract->boxExtremity() == BOX_START) {
setPos(QPointF(box->getShapeTopLeft().x() + WIDTH / 2., box->getShapeTopLeft().y() - HEIGHT / 2.));
}
else if (_abstract->boxExtremity() == BOX_END) {
setPos(QPointF(box->getShapeTopRight().x() - WIDTH / 2., box->getShapeTopRight().y() - HEIGHT / 2.));
}
// setZValue(box->currentZvalue()-1);
}
}
update();
}
void
CurvesWidget::removeCurve(const string &address)
{
map<string, CurveWidget *>::iterator curveIt = _curveMap.find(address);
QString curveAddress = QString::fromStdString(address);
int index;
if (curveIt != _curveMap.end()) {
_curveMap.erase(curveIt);
index = _comboBox->findText(curveAddress);
if (index > -1) {
_comboBox->removeItem(index);
}
BasicBox *curveBox = Maquette::getInstance()->getBox(_boxID);
if (curveBox != NULL) {
curveBox->removeCurve(address);
}
}
}
void
ParentBox::updateDisplay(QString displayMode)
{
BasicBox *curBox;
std::map<unsigned int, BasicBox*>::iterator it;
if (displayMode == SCENARIO_MODE_TEXT) {
for (it = _children.begin(); it != _children.end(); ++it) {
curBox = it->second;
curBox->lower(false);
curBox->setEnabled(true);
}
}
else {
for (it = _children.begin(); it != _children.end(); ++it) {
curBox = it->second;
curBox->lower(true);
curBox->setEnabled(false);
}
}
}
void
AttributesEditor::endMessagesChanged(bool forceUpdate)
{
if (_scene->paused()) {
_scene->stopWithGoto();
}
if (_boxEdited != NO_ID) {
BasicBox * box = _scene->getBox(_boxEdited);
QMap<QTreeWidgetItem*, Data> items = _networkTree->assignedItems();
Maquette::getInstance()->setSelectedItemsToSend(_boxEdited, items);
Maquette::getInstance()->setEndMessagesToSend(_boxEdited, _networkTree->endMessages());
_networkTree->updateEndMsgsDisplay();
_networkTree->updateCurves(_boxEdited, forceUpdate);
box->updateCurves();
}
else {
_scene->displayMessage("No box selected", INDICATION_LEVEL);
}
}
void
Relation::mouseMoveEvent(QGraphicsSceneMouseEvent * event)
{
QGraphicsItem::mouseMoveEvent(event);
double eventPosX = mapFromScene(event->scenePos()).x();
double startX = mapFromScene(_start).x();
if (_leftHandleSelected) {
changeBounds(_abstract->maxBound() == NO_BOUND ? std::max(eventPosX - startX, 0.) : std::min((float)std::max(eventPosX - startX, 0.), _abstract->maxBound()), _abstract->maxBound());
_scene->changeRelationBounds(_abstract->ID(), NO_LENGTH, _abstract->minBound(), _abstract->maxBound());
update();
}
else if (_rightHandleSelected) {
_scene->changeRelationBounds(_abstract->ID(), NO_LENGTH, _abstract->minBound(), std::max((float)std::max(eventPosX - startX, 0.), _abstract->minBound()));
update();
}
else if (_middleHandleSelected) {
BasicBox *rightBox = _scene->getBox(_abstract->secondBox());
_scene->changeRelationBounds(_abstract->ID(), NO_LENGTH, NO_BOUND, NO_BOUND);
qreal factorX = 2 * (eventPosX - _mouseClickPosSave.x());
rightBox->moveBy(factorX, 0.);
rightBox->setTopLeft(rightBox->getTopLeft() + QPointF(factorX, 0.));
rightBox->updateStuff();
_scene->boxMoved(rightBox->ID());
}
}
void
AttributesEditor::endMessageChanged(QTreeWidgetItem *item)
{
if (_scene->paused()) {
_scene->stopWithGoto();
}
if (_boxEdited != NO_ID) {
QMap<QTreeWidgetItem*, Data> items = _networkTree->assignedItems();
Maquette::getInstance()->setSelectedItemsToSend(_boxEdited, items);
Maquette::getInstance()->setEndMessagesToSend(_boxEdited, _networkTree->endMessages());
_networkTree->updateCurve(item, _boxEdited, true);
_networkTree->updateEndMsgsDisplay();
BasicBox * box = _scene->getBox(_boxEdited);
box->updateCurve(_networkTree->getAbsoluteAddress(item).toStdString(), true);
}
else {
_scene->displayMessage("No box selected", INDICATION_LEVEL);
item->setText(NetworkTree::END_COLUMN, "");
}
}
void
AttributesEditor::nameChanged()
{
BasicBox * box = _scene->getBox(_boxEdited);
if (box != NULL) {
box->setName(_boxName->text());
_scene->update(box->getTopLeft().x(), box->getTopLeft().y(), box->width(), box->height() + 10);
}
}
void
Relation::updateCoordinates()
{
BasicBox *box = _scene->getBox(_abstract->firstBox());
if (box != NULL) {
switch (_abstract->firstExtremity()) {
case BOX_START:
_start = box->getLeftGripPoint();
break;
case BOX_END:
_start = box->getRightGripPoint();
break;
case NO_EXTREMITY:
_start = box->getCenter();
break;
}
}
box = _scene->getBox(_abstract->secondBox());
if (box != NULL) {
switch (_abstract->secondExtremity()) {
case BOX_START:
if (box != NULL) {
_end = box->getLeftGripPoint();
}
break;
case BOX_END:
if (box != NULL) {
_end = box->getRightGripPoint();
}
break;
case NO_EXTREMITY:
if (box != NULL) {
_end = box->getCenter();
}
break;
}
}
// std::cout<<"\t start = "<<_start.x()*MaquetteScene::MS_PER_PIXEL<<std::endl;
// std::cout<<"\t end = "<<_end.x()*MaquetteScene::MS_PER_PIXEL<<std::endl;
// std::cout<<"\t Length = "<<_abstract->_length*MaquetteScene::MS_PER_PIXEL<<std::endl;
_abstract->_length = _end.x() - _start.x();
setPos(getCenter());
}
void
AttributesEditor::updateWidgets(bool boxModified)
{
Q_UNUSED(boxModified);
BasicBox * box = _scene->getBox(_boxEdited);
if (box != NULL) {
box->update();
box->centerWidget();
_boxStartValue->setValue(box->beginPos() * MaquetteScene::MS_PER_PIXEL / S_TO_MS);
_boxLengthValue->setValue(box->width() * MaquetteScene::MS_PER_PIXEL / S_TO_MS);
_boxName->setText(box->name());
_colorButtonPixmap->fill(box->currentColor());
_generalColorButton->setIcon(QIcon(*_colorButtonPixmap));
}
update();
}
bool
CurvesWidget::updateCurve(const string &address, bool forceUpdate)
{
BasicBox *box = Maquette::getInstance()->getBox(_boxID);
if (box != NULL) { // Box Found
AbstractCurve *abCurve = box->getCurve(address);
map<string, CurveWidget *>::iterator curveIt2 = _curveMap.find(address);
bool curveFound = (curveIt2 != _curveMap.end());
unsigned int curveTabIndex = 0;
CurveWidget *curveTab = NULL;
if (curveFound) {
curveTab = curveIt2->second;
}
static const bool FORCE_SHOW = true;
static const bool FORCE_HIDE = false;
unsigned int sampleRate;
bool redundancy, interpolate;
vector<float> values, xPercents, yValues, coeff;
vector<string> argTypes;
vector<short> sectionType;
if (abCurve != NULL) { // Abstract Curve found
if (abCurve->_show) { // Abstract curve showing
if (curveFound) { // Curve tab existing
if (forceUpdate) { // Force updating through engines
bool getCurveSuccess = Maquette::getInstance()->getCurveAttributes(_boxID, address, 0, sampleRate, redundancy, interpolate, values, argTypes, xPercents, yValues, sectionType, coeff);
if (getCurveSuccess) {
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_SHOW, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
box->setCurve(address, curveTab->abstractCurve());
if (!_interpolation->updateLine(address, interpolate, sampleRate, redundancy, FORCE_SHOW)) {
_interpolation->addLine(address, interpolate, sampleRate, redundancy, FORCE_SHOW);
}
}
}
else { // No forcing : updating through abstract curve
curveTab->setAttributes(abCurve);
if (!_interpolation->updateLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show)) {
_interpolation->addLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show);
}
}
}
else { // Curve tab not existing
if (forceUpdate) { // Force creating through engines
bool getCurveSuccess = Maquette::getInstance()->getCurveAttributes(_boxID, address, 0, sampleRate, redundancy, interpolate, values, argTypes, xPercents, yValues, sectionType, coeff);
if (getCurveSuccess) {
// Create and set
curveTab = new CurveWidget(NULL);
_tabWidget->clear();
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_SHOW, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
QString curveAddressStr = QString::fromStdString(address);
// Add tab and store
addCurve(curveAddressStr, curveTab);
addToComboBox(curveAddressStr);
_curveMap[address] = curveTab;
displayCurve(_comboBox->currentText());
// Set box curve
box->setCurve(address, curveTab->abstractCurve());
if (!_interpolation->updateLine(address, interpolate, sampleRate, redundancy, FORCE_SHOW)) {
_interpolation->addLine(address, interpolate, sampleRate, redundancy, FORCE_SHOW);
}
}
}
else { // No forcing : create through abstract curve
// Create and set
curveTab = new CurveWidget(NULL);
curveTab->setAttributes(abCurve);
QString curveAddressStr = QString::fromStdString(address);
// Add tab and store
addCurve(curveAddressStr, curveTab);
_curveMap[address] = curveTab;
addToComboBox(curveAddressStr);
displayCurve(_comboBox->currentText());
if (!_interpolation->updateLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show)) {
_interpolation->addLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show);
}
}
}
}
else { // Abstract curve hiding
if (curveFound) { // Curve tab existing
if (forceUpdate) { // Force updating through engines
bool getCurveSuccess = Maquette::getInstance()->getCurveAttributes(_boxID, address, 0, sampleRate, redundancy, interpolate, values, argTypes, xPercents, yValues, sectionType, coeff);
if (getCurveSuccess) {
if (values.front() != values.back()) {
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_SHOW, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
}
else {
// Set and assign new abstract curve to box
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_HIDE, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
}
box->setCurve(address, curveTab->abstractCurve());
}
}
else {
// No forcing : updating through abstract curve
}
// Remove curve tab anyway
removeCurve(address);
_comboBox->setCurrentIndex(curveTabIndex);
displayCurve(_comboBox->currentText());
delete curveTab;
if (!_interpolation->updateLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show)) {
_interpolation->addLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show);
}
}
else { // Curve tab not existing
if (forceUpdate) { // Force updating through engines
bool getCurveSuccess = Maquette::getInstance()->getCurveAttributes(_boxID, address, 0, sampleRate, redundancy, interpolate, values, argTypes, xPercents, yValues, sectionType, coeff);
if (getCurveSuccess) {
// Create, set and assign new abstract curve to box
curveTab = new CurveWidget(NULL);
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_HIDE, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
box->setCurve(address, curveTab->abstractCurve());
if (!_interpolation->updateLine(address, interpolate, sampleRate, redundancy, FORCE_HIDE)) {
_interpolation->addLine(address, interpolate, sampleRate, redundancy, FORCE_HIDE);
}
delete curveTab;
}
}
else { // No forcing : updating through abstract curve
if (!_interpolation->updateLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show)) {
_interpolation->addLine(address, abCurve->_interpolate, abCurve->_sampleRate, abCurve->_redundancy, abCurve->_show);
}
}
}
}
}
else { // Abstract Curve not found
// Get attributes and determine if shown
bool show = true;
interpolate = true;
bool getCurveSuccess = Maquette::getInstance()->getCurveAttributes(_boxID, address, 0, sampleRate, redundancy, interpolate, values, argTypes, xPercents, yValues, sectionType, coeff);
if (getCurveSuccess) {
if (xPercents.empty() && yValues.empty() && values.size() >= 2) {
if (values.front() == values.back()) {
show = false;
interpolate = false;
}
}
if (show) { // Curve showing
if (!curveFound) { // Curve tab not existing
// Creating curve tab from engines anyway (no abstract curve)
// Create and set
curveTab = new CurveWidget(NULL);
QString curveAddressStr = QString::fromStdString(address);
// Add tab and store
addCurve(curveAddressStr, curveTab);
addToComboBox(curveAddressStr);
displayCurve(_comboBox->currentText());
}
else { // Curve tab existing
// Updating curve tab from engines anyway (no abstract curve)
}
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_SHOW, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
// Set box curve
box->setCurve(address, curveTab->abstractCurve());
if (!_interpolation->updateLine(address, interpolate, sampleRate, redundancy, FORCE_SHOW)) {
_interpolation->addLine(address, interpolate, sampleRate, redundancy, FORCE_SHOW);
}
}
else { // Curve hiding
if (curveFound) { // Curve tab existing
// Creating curve tab from engines anyway (no abstract curve)
// Set and assign new abstract curve to box
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_HIDE, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
box->setCurve(address, curveTab->abstractCurve());
// Remove curve tab
removeCurve(address);
}
else { // Curve tab not existing
// Creating curve tab from engines anyway (no abstract curve)
curveTab = new CurveWidget(NULL);
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, FORCE_HIDE, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
box->setCurve(address, curveTab->abstractCurve());
delete curveTab;
}
if (!_interpolation->updateLine(address, interpolate, sampleRate, redundancy, FORCE_HIDE)) {
_interpolation->addLine(address, interpolate, sampleRate, redundancy, FORCE_HIDE);
}
}
}
}
}
else { // Box Not Found
return false;
}
return false;
}
bool
BoxWidget::updateCurve(const string &address, bool forceUpdate)
{
Q_UNUSED(forceUpdate);
BasicBox *box = Maquette::getInstance()->getBox(_boxID);
if (box != NULL) { // Box Found
if (box->hasCurve(address)) {
AbstractCurve *abCurve = box->getCurve(address);
QMap<string, CurveWidget *>::iterator curveIt2 = _curveMap->find(address);
QString curveAddressStr = QString::fromStdString(address);
bool curveFound = (curveIt2 != _curveMap->end());
CurveWidget *curveTab = NULL;
unsigned int sampleRate;
bool redundancy, interpolate;
vector<float> values, xPercents, yValues, coeff;
vector<string> argTypes;
vector<short> sectionType;
bool getCurveSuccess = Maquette::getInstance()->getCurveAttributes(_boxID, address, 0, sampleRate, redundancy, interpolate, values, argTypes, xPercents, yValues, sectionType, coeff);
//--- PRINT ---
// std::cout<<"values : "<<std::endl;
// for (unsigned int i = 0; i < yValues.size() ; i++) {
// std::cout<<" "<<yValues[i]<<std::endl;
// }
// std::cout<<std::endl;
//-------------
if (getCurveSuccess) {
/********** Abstract Curve found ***********/
if (abCurve != NULL) {
if (curveFound) {
curveTab = curveIt2.value();
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, abCurve->_show, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
bool muteState = Maquette::getInstance()->getCurveMuteState(_boxID, address);
if (forceUpdate) {
if (!muteState) {
addCurve(curveAddressStr, curveTab);
}
else {
removeCurve(address);
}
}
}
else {
//Create
curveTab = new CurveWidget(NULL);
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, abCurve->_show, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
bool muteState = Maquette::getInstance()->getCurveMuteState(_boxID, address);
if (!muteState) {
addCurve(curveAddressStr, curveTab);
}
else {
removeCurve(address);
}
}
//Set attributes
box->setCurve(address, curveTab->abstractCurve());
}
/******* Abstract Curve not found ********/
else {
bool show = true;
// interpolate = !Maquette::getInstance()->getCurveMuteState(_boxID,address);
// if (xPercents.empty() && yValues.empty() && values.size() >= 2) {
// if (values.front() == values.back()) {
// show = false;
// interpolate = false;
// }
// }
//Set attributes
curveTab = new CurveWidget(NULL);
QString curveAddressStr = QString::fromStdString(address);
curveTab->setAttributes(_boxID, address, 0, values, sampleRate, redundancy, show, interpolate, argTypes, xPercents, yValues, sectionType, coeff);
if (interpolate) {
addCurve(curveAddressStr, curveTab);
box->setCurve(address, curveTab->abstractCurve());
}
}
}
}
else {
return false;
}
}
else { // Box Not Found
return false;
}
return false;
}
