src/ParametersPlugin/ParametersPlugin_WidgetParamsMgr.cpp

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