src/ParametersPlugin/ParametersPlugin_WidgetParamsMgr.cpp

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