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