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