src/ParametersPlugin/ParametersPlugin_WidgetParamsMgr.cpp

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