src/ParametersPlugin/ParametersPlugin_WidgetParamsMgr.cpp

   1 // Copyright (C) 2014-20xx CEA/DEN, EDF R&D -->
   2
   3 // File:        ParametersPlugin_WidgetParamsMgr.cpp
   4 // Created:     11 Apr 2016
   5 // Author:      Vitaly SMETANNIKOV
   6
   7 #include "ParametersPlugin_WidgetParamsMgr.h"
   8 #include "ParametersPlugin_Parameter.h"
   9 #include "ParametersPlugin_Validators.h"
  10
  11 #include <ModelAPI_ResultParameter.h>
  12 #include <ModelAPI_AttributeString.h>
  13 #include <ModelAPI_AttributeRefList.h>
  14 #include <ModelAPI_AttributeDouble.h>
  15 #include <ModelAPI_AttributeInteger.h>
  16 #include <ModelAPI_Events.h>
  17 #include <ModelAPI_Session.h>
  18
  19 #include <ModuleBase_Tools.h>
  20
  21 #include <Events_Loop.h>
  22
  23 #include <QLayout>
  24 #include <QPushButton>
  25 #include <QToolButton>
  26 #include <QStyledItemDelegate>
  27 #include <QPainter>
  28 #include <QMessageBox>
  29 #include <QTimer>
  30 #include <QEvent>
  31 #include <QKeyEvent>
  32
  33 enum ColumnType {
  34   Col_Name,
  35   Col_Equation,
  36   Col_Result,
  37   Col_Comment
  38 };
  39
  40 const char* NoName = "<NoName>";
  41 const char* NoValue = "<NoValue>";
  42 const char* NotValid = "<NotValid>";
  43
  44 class ParametersPlugin_ItemDelegate : public QStyledItemDelegate
  45 {
  46 public:
  47   ParametersPlugin_ItemDelegate(QObject* thaParent) :
  48       QStyledItemDelegate(thaParent) {}
  49
  50   virtual void paint(QPainter* painter,
  51     const QStyleOptionViewItem& option,
  52     const QModelIndex& index ) const;
  53
  54   virtual QWidget* createEditor(QWidget* parent,
  55                                 const QStyleOptionViewItem& option,
  56                                 const QModelIndex& index) const;
  57
  58   bool isEditable(const QModelIndex& theIndex) const;
  59
  60   QModelIndex editIndex() const { return myEditingIdx; }
  61
  62 private:
  63   mutable QModelIndex myEditingIdx;
  64 };
  65
  66 bool ParametersPlugin_ItemDelegate::isEditable(const QModelIndex& theIndex) const
  67 {
  68   QModelIndex aParent = theIndex.parent();
  69   if (aParent.isValid() && (aParent.row() == 0)) {
  70     if (theIndex.column() == 2)
  71       return false;
  72   } else
  73     return false;
  74   return true;
  75 }
  76
  77 void ParametersPlugin_ItemDelegate::paint(QPainter* painter,
  78                                           const QStyleOptionViewItem& option,
  79                                           const QModelIndex& index ) const
  80 {
  81   QBrush aBrush = painter->brush();
  82   QPen aPen = painter->pen();
  83 //  if (!isEditable(index))
  84   if (!index.parent().isValid())
  85     painter->setBrush(Qt::lightGray);
  86
  87   painter->setPen(Qt::lightGray);
  88   painter->drawRect(option.rect);
  89   painter->setPen(aPen);
  90
  91   QStyledItemDelegate::paint(painter, option, index);
  92   painter->setBrush(aBrush);
  93 }
  94
  95 QWidget* ParametersPlugin_ItemDelegate::createEditor(QWidget* parent,
  96                                                      const QStyleOptionViewItem& option,
  97                                                      const QModelIndex& index) const
  98 {
  99   myEditingIdx = index;
 100   return QStyledItemDelegate::createEditor(parent, option, index);
 101 }
 102
 103 /////////////////////////////////////////////////////////////////////////////////////////////////
 104 void ParametersPlugin_TreeWidget::closeEditor(QWidget* theEditor, QAbstractItemDelegate::EndEditHint theHint)
 105 {
 106   if (theHint == QAbstractItemDelegate::EditNextItem) {
 107     QModelIndex aCurrent = currentIndex();
 108     QModelIndex aParent = model()->index(0, 0);
 109     int aNbRows = model()->rowCount(aParent);
 110     QModelIndex aIdx;
 111     switch (aCurrent.column()) {
 112     case 0:
 113       aIdx = model()->index(aCurrent.row(), 1, aParent);
 114       break;
 115     case 1:
 116       if (aCurrent.row() < (aNbRows - 1))
 117         aIdx = model()->index(aCurrent.row() + 1, 0, aParent);
 118       else {
 119         QTreeWidget::closeEditor(theEditor, QAbstractItemDelegate::NoHint);
 120         return;
 121       }
 122       break;
 123     case 3:
 124       QTreeWidget::closeEditor(theEditor, theHint);
 125       return;
 126     }
 127     if (aIdx.isValid()) {
 128       QTreeWidget::closeEditor(theEditor, QAbstractItemDelegate::NoHint);
 129       setCurrentIndex(aIdx);
 130       edit(aIdx);
 131       return;
 132     }
 133   }
 134   QTreeWidget::closeEditor(theEditor, theHint);
 135 }
 136
 137 /////////////////////////////////////////////////////////////////////////////////////////////////
 138
 139 ParametersPlugin_WidgetParamsMgr::ParametersPlugin_WidgetParamsMgr(QWidget* theParent, const Config_WidgetAPI* theData)
 140   : ModuleBase_ModelWidget(theParent, theData)
 141 {
 142   QVBoxLayout* aLayout = new QVBoxLayout(this);
 143
 144   myTable = new ParametersPlugin_TreeWidget(this);
 145   myTable->setColumnCount(4);
 146   QStringList aHeaders;
 147   aHeaders << tr("Name") << tr("Equation") << tr("Result") << tr("Comment");
 148   myTable->setHeaderLabels(aHeaders);
 149   myTable->setColumnWidth(Col_Name, 200);
 150   myTable->setColumnWidth(Col_Equation, 100);
 151   myTable->setColumnWidth(Col_Result, 80);
 152   myTable->setColumnWidth(Col_Comment, 200);
 153   myTable->setMinimumWidth(600);
 154   myTable->setEditTriggers(QAbstractItemView::NoEditTriggers);
 155   myTable->setSelectionMode(QAbstractItemView::SingleSelection);
 156
 157   connect(myTable, SIGNAL(doubleClicked(const QModelIndex&)),
 158           SLOT(onDoubleClick(const QModelIndex&)));
 159   connect(myTable, SIGNAL(itemSelectionChanged()), SLOT(onSelectionChanged()));
 160
 161   myDelegate = new ParametersPlugin_ItemDelegate(myTable);
 162   connect(myDelegate, SIGNAL(closeEditor(QWidget*, QAbstractItemDelegate::EndEditHint)),
 163           SLOT(onCloseEditor(QWidget*, QAbstractItemDelegate::EndEditHint)));
 164
 165   myTable->setItemDelegate(myDelegate);
 166   aLayout->addWidget(myTable);
 167
 168   // Define root nodes
 169   QStringList aNames;
 170   aNames<<tr("Parameters");
 171   myParameters = new QTreeWidgetItem(aNames);
 172   myParameters->setFlags(Qt::ItemIsEnabled);
 173   myTable->addTopLevelItem(myParameters);
 174
 175   aNames.clear();
 176   aNames<<tr("Features");
 177   myFeatures = new QTreeWidgetItem(aNames);
 178   myFeatures->setFlags(Qt::ItemIsEnabled);
 179   myTable->addTopLevelItem(myFeatures);
 180
 181   QHBoxLayout* aBtnLayout = new QHBoxLayout(this);
 182
 183   myUpBtn = new QToolButton(this);
 184   myUpBtn->setArrowType(Qt::UpArrow);
 185   connect(myUpBtn, SIGNAL(clicked(bool)), SLOT(onUp()));
 186   aBtnLayout->addWidget(myUpBtn);
 187
 188   myDownBtn = new QToolButton(this);
 189   myDownBtn->setArrowType(Qt::DownArrow);
 190   connect(myDownBtn, SIGNAL(clicked(bool)), SLOT(onDown()));
 191   aBtnLayout->addWidget(myDownBtn);
 192
 193   aBtnLayout->addStretch();
 194
 195   myAddBtn = new QPushButton(tr("Add"), this);
 196   connect(myAddBtn, SIGNAL(clicked(bool)), SLOT(onAdd()));
 197   aBtnLayout->addWidget(myAddBtn);
 198
 199   myInsertBtn = new QPushButton(tr("Insert"), this);
 200   connect(myInsertBtn, SIGNAL(clicked(bool)), SLOT(onInsert()));
 201   aBtnLayout->addWidget(myInsertBtn);
 202
 203   myRemoveBtn = new QPushButton(tr("Remove"), this);
 204   connect(myRemoveBtn, SIGNAL(clicked(bool)), SLOT(onRemove()));
 205   aBtnLayout->addWidget(myRemoveBtn);
 206
 207   aLayout->addLayout(aBtnLayout);
 208
 209   onSelectionChanged();
 210 }
 211
 212 QList<QWidget*> ParametersPlugin_WidgetParamsMgr::getControls() const
 213 {
 214   QList<QWidget*> aList;
 215
 216   return aList;
 217 }
 218
 219 void ParametersPlugin_WidgetParamsMgr::selectItemScroll(QTreeWidgetItem* aItem)
 220 {
 221   myTable->clearSelection();
 222   QModelIndex aParent = myTable->model()->index(0, 0);
 223   int aChildIdx = myParameters->indexOfChild(aItem);
 224   QModelIndex aIndex = myTable->model()->index(aChildIdx, Col_Name, aParent);
 225   myTable->selectionModel()->select(aIndex,
 226     QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
 227   myTable->scrollToItem(aItem);
 228 }
 229
 230
 231 bool ParametersPlugin_WidgetParamsMgr::storeValueCustom()
 232 {
 233   ParametersPlugin_ExpressionValidator aValidator;
 234   std::list<std::string> aArgs;
 235   std::string aAttrId = ParametersPlugin_Parameter::VARIABLE_ID();
 236   std::string aErr;
 237   int aId = 0;
 238   foreach(FeaturePtr aFeature, myParametersList) {
 239     if (!aValidator.isValid(aFeature->attribute(aAttrId), aArgs, aErr)) {
 240       QMessageBox::warning(this, tr("Warning"), aErr.c_str());
 241       selectItemScroll(myParameters->child(aId));
 242       return false;
 243     }
 244     aId++;
 245   }
 246   return true;
 247 }
 248
 249 bool ParametersPlugin_WidgetParamsMgr::restoreValueCustom()
 250 {
 251   return true;
 252 }
 253
 254 void ParametersPlugin_WidgetParamsMgr::activateCustom()
 255 {
 256   updateParametersFeatures();
 257   updateParametersPart();
 258   updateFeaturesPart();
 259
 260   myFeatures->setExpanded(true);
 261   myParameters->setExpanded(true);
 262 }
 263
 264 void ParametersPlugin_WidgetParamsMgr::updateParametersFeatures()
 265 {
 266   myParametersList.clear();
 267   FeaturePtr aFeature = feature();
 268   DocumentPtr aDoc = aFeature->document();
 269   ObjectPtr aObj;
 270   FeaturePtr aParamFeature;
 271   int aNbFeatures = aDoc->numInternalFeatures();
 272   for (int i = 0; i < aNbFeatures; i++) {
 273     aParamFeature = aDoc->internalFeature(i);
 274     if (aParamFeature->getKind() == ParametersPlugin_Parameter::ID()) {
 275       myParametersList.append(aParamFeature);
 276     }
 277   }
 278 }
 279
 280 void ParametersPlugin_WidgetParamsMgr::updateFeaturesPart()
 281 {
 282   updateItem(myFeatures, featuresItems(myParametersList));
 283 }
 284
 285 void ParametersPlugin_WidgetParamsMgr::updateParametersPart()
 286 {
 287   updateItem(myParameters, parametersItems(myParametersList));
 288   bool aIsValid = checkIsValid();
 289   enableButtons(aIsValid);
 290 }
 291
 292
 293 QList<QStringList> ParametersPlugin_WidgetParamsMgr::
 294   featuresItems(const QList<FeaturePtr>& theFeatures) const
 295 {
 296   QList<QStringList> aItemsList;
 297   ResultParameterPtr aParam;
 298   QList<FeaturePtr> aFeatures;
 299   foreach(FeaturePtr aParameter, theFeatures) {
 300     aParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aParameter->firstResult());
 301     const std::set<std::shared_ptr<ModelAPI_Attribute>>& aRefs = aParam->data()->refsToMe();
 302     std::set<std::shared_ptr<ModelAPI_Attribute> >::const_iterator aIt;
 303     for(aIt = aRefs.cbegin(); aIt != aRefs.cend(); aIt++) {
 304       std::shared_ptr<ModelAPI_Attribute> aAttr = (*aIt);
 305       FeaturePtr aReferenced = std::dynamic_pointer_cast<ModelAPI_Feature>(aAttr->owner());
 306       if (aReferenced.get()) {
 307         if (aReferenced->getKind() == ParametersPlugin_Parameter::ID()) {
 308           // Find referenced feature Recursive
 309           QList<FeaturePtr> aList;
 310           aList.append(aReferenced);
 311           QList<QStringList> aItems = featuresItems(aList);
 312           aItemsList.append(aItems);
 313         } else {
 314           if (!aFeatures.contains(aReferenced)) {
 315             QStringList aValNames;
 316             aValNames << aReferenced->data()->name().c_str();
 317
 318             AttributeDoublePtr aDouble = std::dynamic_pointer_cast<ModelAPI_AttributeDouble>(aAttr);
 319             if (aDouble.get()) {
 320               aValNames << aDouble->text().c_str();
 321               aValNames << QString::number(aDouble->value());
 322             } else {
 323               AttributeIntegerPtr aInt = std::dynamic_pointer_cast<ModelAPI_AttributeInteger>(aAttr);
 324               if (aInt.get()) {
 325                 aValNames << aInt->text().c_str();
 326                 aValNames << QString::number(aInt->value());
 327               }
 328             }
 329             aItemsList.append(aValNames);
 330             aFeatures.append(aReferenced);
 331           }
 332         }
 333       }
 334     }
 335   }
 336   return aItemsList;
 337 }
 338
 339
 340 QList<QStringList> ParametersPlugin_WidgetParamsMgr::
 341   parametersItems(const QList<FeaturePtr>& theFeatures) const
 342 {
 343   std::list<std::string> aArgs;
 344   std::string aErr;
 345   QList<QStringList> aItemsList;
 346   foreach(FeaturePtr aParameter, theFeatures) {
 347     ResultPtr aParam = aParameter->firstResult();
 348     QStringList aValues;
 349
 350     std::string aName = aParameter->string(ParametersPlugin_Parameter::VARIABLE_ID())->value();
 351     if (aName.empty()) {
 352       aValues << NoName;
 353     } else
 354       aValues << aName.c_str();
 355
 356     std::string aExpr = aParameter->string(ParametersPlugin_Parameter::EXPRESSION_ID())->value();
 357     if (aName.empty()) {
 358       aValues << NoValue;
 359     } else
 360       aValues << aExpr.c_str();
 361
 362     std::string aErr = aParameter->data()->string(ParametersPlugin_Parameter::EXPRESSION_ERROR_ID())->value();
 363     if (aErr.empty()) {
 364       AttributeDoublePtr aValueAttribute = aParam->data()->real(ModelAPI_ResultParameter::VALUE());
 365       aValues << QString::number(aValueAttribute->value());
 366     } else {
 367       aValues << aErr.c_str();
 368     }
 369     aValues << aParameter->string(ParametersPlugin_Parameter::COMMENT_ID())->value().c_str();
 370     aItemsList.append(aValues);
 371   }
 372   return aItemsList;
 373 }
 374
 375
 376 void ParametersPlugin_WidgetParamsMgr::onDoubleClick(const QModelIndex& theIndex)
 377 {
 378   if (myDelegate->isEditable(theIndex)) {
 379     myTable->setCurrentIndex(theIndex);
 380     myTable->edit(theIndex);
 381   }
 382 }
 383
 384 void ParametersPlugin_WidgetParamsMgr::onCloseEditor(QWidget* theEditor,
 385                                                      QAbstractItemDelegate::EndEditHint theHint)
 386 {
 387   FeaturePtr aFeature = myParametersList.at(myDelegate->editIndex().row());
 388   QTreeWidgetItem* aItem = myParameters->child(myDelegate->editIndex().row());
 389   int aColumn = myDelegate->editIndex().column();
 390   QString aText = aItem->text(aColumn);
 391   bool isModified = false;
 392
 393   switch (aColumn) {
 394   case Col_Name:
 395     {
 396       AttributeStringPtr aStringAttr = aFeature->string(ParametersPlugin_Parameter::VARIABLE_ID());
 397       if (!aText.isEmpty()) {
 398         while (aText.indexOf(" ") != -1) {
 399           aText.replace(" ", "");
 400         }
 401         if (hasName(aText)) {
 402           myMessage = tr("Name %1 already exists.").arg(aText);
 403           QTimer::singleShot(50, this, SLOT(sendWarning()));
 404           return;
 405         }
 406         aStringAttr->setValue(aText.toStdString());
 407         isModified = true;
 408       }
 409     }
 410     break;
 411   case Col_Equation:
 412     {
 413       AttributeStringPtr aStringAttr = aFeature->string(ParametersPlugin_Parameter::EXPRESSION_ID());
 414       if (!aText.isEmpty()) {
 415         if (aText != aStringAttr->value().c_str()) {
 416           aStringAttr->setValue(aText.toStdString());
 417           aFeature->execute();
 418           isModified = true;
 419         }
 420       }
 421     }
 422     break;
 423   case Col_Comment:
 424     {
 425       AttributeStringPtr aStringAttr = aFeature->string(ParametersPlugin_Parameter::COMMENT_ID());
 426       aStringAttr->setValue(aText.toStdString());
 427       isModified = true;
 428     }
 429     break;
 430   }
 431
 432   if (!isModified)
 433     return;
 434   Events_Loop* aLoop = Events_Loop::loop();
 435   aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
 436   aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
 437   aLoop->flush(Events_Loop::eventByName(EVENT_OBJECT_DELETED));
 438
 439   if (aColumn == Col_Equation)
 440     updateParametersPart();
 441   updateFeaturesPart();
 442 }
 443
 444 void ParametersPlugin_WidgetParamsMgr::updateItem(QTreeWidgetItem* theItem,
 445                                                   const QList<QStringList>& theFeaturesList)
 446 {
 447   if (theFeaturesList.count() != theItem->childCount()) {
 448     if (theItem->childCount()  < theFeaturesList.count()) {
 449       while (theItem->childCount() != theFeaturesList.count())
 450         theItem->addChild(createNewItem(theItem));
 451     } else {
 452       while (theItem->childCount() != theFeaturesList.count())
 453         theItem->removeChild(theItem->child(theItem->childCount() - 1));
 454     }
 455   }
 456   int i = 0;
 457   foreach(QStringList aFeature, theFeaturesList) {
 458     int aCol = 0;
 459     foreach(QString aText, aFeature) {
 460       if (aText.length() > 0) {
 461         theItem->child(i)->setText(aCol, aText);
 462         theItem->child(i)->setToolTip(aCol, aText);
 463       }
 464       aCol++;
 465     }
 466     i++;
 467   }
 468 }
 469
 470 FeaturePtr ParametersPlugin_WidgetParamsMgr::createParameter() const
 471 {
 472   SessionPtr aMgr = ModelAPI_Session::get();
 473   std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
 474
 475   FeaturePtr aFeature = aDoc->addFeature(ParametersPlugin_Parameter::ID());
 476   if (aFeature.get()) {
 477     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_CREATED));
 478     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_UPDATED));
 479   }
 480   return aFeature;
 481 }
 482
 483
 484 QTreeWidgetItem* ParametersPlugin_WidgetParamsMgr::createNewItem(QTreeWidgetItem* theParent) const
 485 {
 486   QStringList aValues;
 487   aValues << NoName;
 488   aValues << NoValue;
 489
 490   QTreeWidgetItem* aItem = new QTreeWidgetItem(aValues);
 491   if (theParent == myParameters)
 492     aItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled);
 493   else
 494     aItem->setFlags(Qt::NoItemFlags);
 495   return aItem;
 496 }
 497
 498
 499 void ParametersPlugin_WidgetParamsMgr::onAdd()
 500 {
 501   FeaturePtr aFeature = createParameter();
 502   if (!aFeature.get())
 503     return;
 504
 505   myParametersList.append(aFeature);
 506   updateParametersPart();
 507
 508   QTreeWidgetItem* aItem = myParameters->child(myParameters->childCount() - 1);
 509
 510   myTable->scrollToItem(aItem);
 511   myTable->setCurrentItem(aItem);
 512   myTable->editItem(aItem);
 513
 514   enableButtons(false);
 515 }
 516
 517 QTreeWidgetItem* ParametersPlugin_WidgetParamsMgr::selectedItem() const
 518 {
 519   QList<QTreeWidgetItem*> aItemsList = myTable->selectedItems();
 520   if (aItemsList.count() == 0)
 521     return 0;
 522
 523   QTreeWidgetItem* aCurrentItem = aItemsList.first();
 524   if (aCurrentItem->parent() != myParameters)
 525     return 0;
 526
 527   return aCurrentItem;
 528 }
 529
 530
 531 void ParametersPlugin_WidgetParamsMgr::onInsert()
 532 {
 533   QTreeWidgetItem* aCurrentItem = selectedItem();
 534   if (!aCurrentItem)
 535     return;
 536
 537   SessionPtr aMgr = ModelAPI_Session::get();
 538   std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
 539
 540   FeaturePtr aNewFeature = createParameter();
 541   if (!aNewFeature.get())
 542     return;
 543
 544   int aCurrentPos = myParameters->indexOfChild(aCurrentItem);
 545   if (aCurrentPos == 0) {
 546     aDoc->moveFeature(aNewFeature, FeaturePtr());
 547   } else {
 548     FeaturePtr aCurFeature = myParametersList.at(aCurrentPos - 1);
 549     aDoc->moveFeature(aNewFeature, aCurFeature);
 550   }
 551   updateParametersFeatures();
 552   updateParametersPart();
 553
 554   myTable->scrollToItem(aCurrentItem);
 555   myTable->setCurrentItem(aCurrentItem);
 556   myTable->editItem(aCurrentItem);
 557 }
 558
 559 void ParametersPlugin_WidgetParamsMgr::onRemove()
 560 {
 561   QTreeWidgetItem* aCurrentItem = selectedItem();
 562   if (!aCurrentItem)
 563     return;
 564
 565   SessionPtr aMgr = ModelAPI_Session::get();
 566   std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
 567
 568   int aCurrentPos = myParameters->indexOfChild(aCurrentItem);
 569   FeaturePtr aCurFeature = myParametersList.at(aCurrentPos);
 570
 571   QObjectPtrList anObjects;
 572   anObjects.append(aCurFeature);
 573
 574   std::set<FeaturePtr> aDirectRefFeatures, aIndirectRefFeatures;
 575   ModuleBase_Tools::findReferences(anObjects, aDirectRefFeatures, aIndirectRefFeatures);
 576
 577   bool doDeleteReferences = true;
 578   if (ModuleBase_Tools::isDeleteFeatureWithReferences(anObjects, aDirectRefFeatures,
 579       aIndirectRefFeatures, this, doDeleteReferences)) {
 580
 581     std::set<FeaturePtr> aFeaturesToDelete;
 582     if (doDeleteReferences) {
 583       aFeaturesToDelete = aDirectRefFeatures;
 584       aFeaturesToDelete.insert(aIndirectRefFeatures.begin(), aIndirectRefFeatures.end());
 585     }
 586     aDoc->removeFeature(aCurFeature);
 587     std::set<FeaturePtr>::const_iterator anIt = aFeaturesToDelete.begin(),
 588                                          aLast = aFeaturesToDelete.end();
 589     for (; anIt != aLast; anIt++) {
 590       FeaturePtr aFeature = (*anIt);
 591       DocumentPtr aDoc = aFeature->document();
 592       aDoc->removeFeature(aFeature);
 593     }
 594
 595     Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED));
 596     Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
 597     updateParametersFeatures();
 598     updateFeaturesPart();
 599     updateParametersPart();
 600   }
 601 }
 602
 603 void ParametersPlugin_WidgetParamsMgr::onUp()
 604 {
 605   QTreeWidgetItem* aCurrentItem = selectedItem();
 606   if (!aCurrentItem)
 607     return;
 608
 609   int aCurrentPos = myParameters->indexOfChild(aCurrentItem);
 610   if (aCurrentPos == 0)
 611     return;
 612   FeaturePtr aCurFeature = myParametersList.at(aCurrentPos);
 613
 614   SessionPtr aMgr = ModelAPI_Session::get();
 615   std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
 616
 617   if (aCurrentPos == 1)
 618     aDoc->moveFeature(aCurFeature, FeaturePtr());
 619   else
 620     aDoc->moveFeature(aCurFeature, myParametersList.at(aCurrentPos - 2));
 621
 622   // add the updated also the feature that goes down
 623   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED));
 624   static Events_ID EVENT_UPD = Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED);
 625   ModelAPI_EventCreator::get()->sendUpdated(myParametersList.at(aCurrentPos - 1), EVENT_UPD);
 626   Events_Loop::loop()->flush(EVENT_UPD);
 627   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED));
 628   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED));
 629   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
 630   updateParametersFeatures();
 631   updateParametersPart();
 632   updateFeaturesPart();
 633
 634   if (aCurrentPos > 0) {
 635     aCurrentItem = myParameters->child(aCurrentPos - 1);
 636     myTable->setCurrentItem(aCurrentItem);
 637     selectItemScroll(aCurrentItem);
 638   }
 639 }
 640
 641 void ParametersPlugin_WidgetParamsMgr::onDown()
 642 {
 643   QTreeWidgetItem* aCurrentItem = selectedItem();
 644   if (!aCurrentItem)
 645     return;
 646
 647   int aCurrentPos = myParameters->indexOfChild(aCurrentItem);
 648   if (aCurrentPos == (myParametersList.count() - 1))
 649     return;
 650   FeaturePtr aCurFeature = myParametersList.at(aCurrentPos);
 651
 652   SessionPtr aMgr = ModelAPI_Session::get();
 653   std::shared_ptr<ModelAPI_Document> aDoc = aMgr->activeDocument();
 654   aDoc->moveFeature(aCurFeature, myParametersList.at(aCurrentPos + 1));
 655   // add the updated also the feature that goes up
 656   static Events_ID EVENT_UPD = Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED);
 657   ModelAPI_EventCreator::get()->sendUpdated(myParametersList.at(aCurrentPos + 1), EVENT_UPD);
 658
 659   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED));
 660   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_UPDATED));
 661   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_CREATED));
 662   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_DELETED));
 663   Events_Loop::loop()->flush(Events_Loop::loop()->eventByName(EVENT_OBJECT_TO_REDISPLAY));
 664   updateParametersFeatures();
 665   updateParametersPart();
 666   updateFeaturesPart();
 667
 668   if (aCurrentPos < myParameters->childCount() - 1) {
 669     aCurrentItem = myParameters->child(aCurrentPos + 1);
 670     myTable->setCurrentItem(aCurrentItem);
 671     selectItemScroll(aCurrentItem);
 672   }
 673 }
 674
 675
 676 bool ParametersPlugin_WidgetParamsMgr::hasName(const QString& theName) const
 677 {
 678   int aCurrent = myDelegate->editIndex().row();
 679   int i = 0;
 680   foreach(FeaturePtr aFeature, myParametersList) {
 681     if ((i != aCurrent) && (aFeature->data()->name() == theName.toStdString()))
 682       return true;
 683     i++;
 684   }
 685   return false;
 686 }
 687
 688 void ParametersPlugin_WidgetParamsMgr::sendWarning()
 689 {
 690   QMessageBox::warning(this, tr("Warning"), myMessage);
 691 }
 692
 693 void ParametersPlugin_WidgetParamsMgr::onSelectionChanged()
 694 {
 695   bool isValid = checkIsValid();
 696   if (isValid) {
 697     QList<QTreeWidgetItem*> aItemsList = myTable->selectedItems();
 698     bool isParameter = false;
 699     foreach(QTreeWidgetItem* aItem, aItemsList) {
 700       if (aItem->parent() == myParameters) {
 701         isParameter = true;
 702         break;
 703       }
 704     }
 705     myInsertBtn->setEnabled(isParameter);
 706     myRemoveBtn->setEnabled(isParameter);
 707     myUpBtn->setEnabled(isParameter);
 708     myDownBtn->setEnabled(isParameter);
 709   } else {
 710     myInsertBtn->setEnabled(false);
 711     myRemoveBtn->setEnabled(false);
 712     myUpBtn->setEnabled(false);
 713     myDownBtn->setEnabled(false);
 714   }
 715 }
 716
 717 void ParametersPlugin_WidgetParamsMgr::enableButtons(bool theEnable)
 718 {
 719   myAddBtn->setEnabled(theEnable);
 720   if (theEnable)
 721     onSelectionChanged();
 722   else {
 723     myInsertBtn->setEnabled(theEnable);
 724     myRemoveBtn->setEnabled(theEnable);
 725     myUpBtn->setEnabled(theEnable);
 726     myDownBtn->setEnabled(theEnable);
 727   }
 728 }
 729
 730 bool ParametersPlugin_WidgetParamsMgr::checkIsValid()
 731 {
 732   QTreeWidgetItem* aItem;
 733   bool aIsValid = true;
 734   for(int i = 0; i < myParameters->childCount(); i++) {
 735     aItem = myParameters->child(i);
 736     if ((aItem->text(Col_Name) == NoName) || (aItem->text(Col_Equation) == NoValue)) {
 737       aIsValid = false;
 738       break;
 739     }
 740   }
 741   return aIsValid;
 742 }
 743