src/ParametersPlugin/ParametersPlugin_WidgetParamsMgr.cpp

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