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