]> SALOME platform Git repositories - modules/shaper.git/blob - src/ParametersPlugin/ParametersPlugin_WidgetParamsMgr.cpp
Salome HOME
[GITHUB #2] problem in export dialog - difference in STEP vs BREP
[modules/shaper.git] / 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 }