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