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