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