src/ModuleBase/ModuleBase_WidgetMultiSelector.cpp

   1 // Copyright (C) 2014-2020  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 <ModuleBase_WidgetMultiSelector.h>
  21
  22 #include <GeomAPI_AISObject.h>
  23
  24 #include <ModuleBase_ActionIntParameter.h>
  25 #include <ModuleBase_Definitions.h>
  26 #include <ModuleBase_Events.h>
  27 #include <ModuleBase_IconFactory.h>
  28 #include <ModuleBase_IModule.h>
  29 #include <ModuleBase_ISelection.h>
  30 #include <ModuleBase_ISelectionActivate.h>
  31 #include <ModuleBase_IPropertyPanel.h>
  32 #include <ModuleBase_IViewer.h>
  33 #include <ModuleBase_IWorkshop.h>
  34 #include <ModuleBase_ListView.h>
  35 #include <ModuleBase_ResultPrs.h>
  36 #include <ModuleBase_Tools.h>
  37 #include <ModuleBase_ViewerPrs.h>
  38 #include <ModuleBase_WidgetShapeSelector.h>
  39 #include <ModuleBase_ChoiceCtrl.h>
  40 #include <ModuleBase_WidgetSelectionFilter.h>
  41
  42 #include <ModelAPI_Data.h>
  43 #include <ModelAPI_Object.h>
  44 #include <ModelAPI_AttributeSelectionList.h>
  45 #include <ModelAPI_AttributeRefList.h>
  46 #include <ModelAPI_AttributeRefAttrList.h>
  47 #include <ModelAPI_Tools.h>
  48 #include <ModelAPI_Events.h>
  49
  50 #include <Config_WidgetAPI.h>
  51
  52 #include <AIS_InteractiveObject.hxx>
  53
  54 #include <QGridLayout>
  55 #include <QLabel>
  56 #include <QListWidget>
  57 #include <QObject>
  58 #include <QString>
  59 #include <QComboBox>
  60 #include <QEvent>
  61 #include <QApplication>
  62 #include <QClipboard>
  63 #include <QTimer>
  64 #include <QMainWindow>
  65 #include <QCheckBox>
  66 #include <QPushButton>
  67
  68 #include <memory>
  69 #include <string>
  70
  71 //#define DEBUG_UNDO_REDO
  72
  73 #ifdef DEBUG_UNDO_REDO
  74 void printHistoryInfo(const QString& theMethodName, int theCurrentHistoryIndex,
  75   QList<QList<std::shared_ptr<ModuleBase_ViewerPrs> > > theSelectedHistoryValues)
  76 {
  77   QStringList aSizes;
  78   for (int i = 0; i < theSelectedHistoryValues.size(); i++)
  79     aSizes.append(QString::number(theSelectedHistoryValues[i].size()));
  80
  81   std::cout << theMethodName.toStdString()
  82             << "  current = " << theCurrentHistoryIndex
  83             << " size(history) =  " << theSelectedHistoryValues.size()
  84             << " (" << aSizes.join(", ").toStdString() << ")"
  85             << std::endl;
  86 }
  87 #endif
  88
  89
  90 QStringList getIconsList(const QStringList& theNames)
  91 {
  92   QStringList aIcons;
  93   foreach (QString aName, theNames) {
  94     QString aUName = aName.toUpper();
  95     if ((aUName == "VERTICES") || (aUName == "VERTEX"))
  96       aIcons << ":pictures/vertex32.png";
  97     else if ((aUName == "EDGES") || (aUName == "EDGE"))
  98       aIcons << ":pictures/edge32.png";
  99     else if ((aUName == "FACES") || (aUName == "FACE"))
 100       aIcons << ":pictures/face32.png";
 101     else if ((aUName == "SOLIDS") || (aUName == "SOLID"))
 102       aIcons << ":pictures/solid32.png";
 103   }
 104   return aIcons;
 105 }
 106
 107 /// Stores default values of selected option (selection mode)
 108 /// It is used only in case if myTypeCtrl is used
 109 static QMap<std::string, std::string> defaultValues;
 110
 111
 112 ModuleBase_WidgetMultiSelector::ModuleBase_WidgetMultiSelector(QWidget* theParent,
 113                                                                ModuleBase_IWorkshop* theWorkshop,
 114                                                                const Config_WidgetAPI* theData)
 115 : ModuleBase_WidgetSelector(theParent, theWorkshop, theData),
 116   myIsSetSelectionBlocked(false), myCurrentHistoryIndex(-1),
 117   myIsFirst(true), myFiltersWgt(0), myShowOnlyBtn(0)
 118 {
 119   std::string aPropertyTypes = theData->getProperty("shape_types");
 120   QString aTypesStr = aPropertyTypes.c_str();
 121   myShapeTypes = aTypesStr.split(' ', QString::SkipEmptyParts);
 122   myIsUseChoice = theData->getBooleanAttribute("use_choice", false);
 123
 124   QString aAllowedList(theData->getProperty("allow_objects").c_str());
 125   if (!aAllowedList.isEmpty())
 126     myAllowedObjects = aAllowedList.split(' ', QString::SkipEmptyParts);
 127
 128   myMainLayout = new QVBoxLayout(this);
 129   ModuleBase_Tools::adjustMargins(myMainLayout);
 130
 131
 132   QStringList aIconsList;
 133   std::string aIcons = theData->getProperty("type_icons");
 134   if (aIcons.size() > 0)
 135     aIconsList = QString(aIcons.c_str()).split(' ', QString::SkipEmptyParts);
 136
 137   if (aIconsList.size() != myShapeTypes.size())
 138     aIconsList = getIconsList(myShapeTypes);
 139
 140   myTypeCtrl = new ModuleBase_ChoiceCtrl(this, myShapeTypes, aIconsList);
 141   myTypeCtrl->setLabel(tr("Type"));
 142   if (!myShapeTypes.empty()) {
 143     std::string aDefType = theData->getProperty("default_type");
 144     if (aDefType.size() > 0) {
 145       bool aOk = false;
 146       int aId = QString(aDefType.c_str()).toInt(&aOk);
 147       if (aOk) {
 148         myTypeCtrl->setValue(aId);
 149         myDefMode = myShapeTypes.at(aId).toStdString();
 150       }
 151     }
 152     if (myDefMode.size() == 0) {
 153       myTypeCtrl->setValue(0);
 154       myDefMode = myShapeTypes.first().toStdString();
 155     }
 156   }
 157   myMainLayout->addWidget(myTypeCtrl);
 158
 159   // There is no sense to parameterize list of types while we can not parameterize selection mode
 160   // if the xml definition contains one type, the controls to select a type should not be shown
 161   if (myShapeTypes.size() <= 1 || !myIsUseChoice) {
 162     myTypeCtrl->setVisible(false);
 163   }
 164
 165   QString aLabelText = translate(theData->getProperty("label"));
 166   if (aLabelText.size() > 0) {
 167     QWidget* aLabelWgt = new QWidget(this);
 168     QHBoxLayout* aLabelLayout = new QHBoxLayout(aLabelWgt);
 169     aLabelLayout->setContentsMargins(0, 0, 0, 0);
 170     myMainLayout->addWidget(aLabelWgt);
 171
 172     QLabel* aListLabel = new QLabel(aLabelText, this);
 173     aLabelLayout->addWidget(aListLabel);
 174     // if the xml definition contains one type, an information label
 175     // should be shown near to the latest
 176     if (myShapeTypes.size() <= 1) {
 177       QString aLabelIcon = QString::fromStdString(theData->widgetIcon());
 178       if (!aLabelIcon.isEmpty()) {
 179         QLabel* aSelectedLabel = new QLabel("", this);
 180         aSelectedLabel->setPixmap(ModuleBase_IconFactory::loadPixmap(aLabelIcon));
 181         aLabelLayout->addWidget(aSelectedLabel);
 182         aLabelLayout->addStretch(1);
 183       }
 184     }
 185   }
 186
 187   QString aToolTip = translate(theData->widgetTooltip());
 188   QString anObjName = QString::fromStdString(attributeID());
 189   myListView = new ModuleBase_ListView(this, anObjName, aToolTip);
 190   connect(myListView->getControl(), SIGNAL(itemSelectionChanged()), SLOT(onListSelection()));
 191   connect(myListView, SIGNAL(deleteActionClicked()), SLOT(onDeleteItem()));
 192   connect(myListView, SIGNAL(listActivated()), SLOT(onListActivated()));
 193
 194   myMainLayout->addWidget(myListView->getControl());
 195   connect(myTypeCtrl, SIGNAL(valueChanged(int)), this, SLOT(onSelectionTypeChanged()));
 196
 197   myUseFilters = theData->getProperty("use_filters");
 198   if (myUseFilters.length() > 0) {
 199     QWidget* aFltrWgt = new QWidget(this);
 200     QHBoxLayout* aFltrLayout = new QHBoxLayout(aFltrWgt);
 201
 202     myFiltersWgt = new ModuleBase_FilterStarter(myUseFilters, aFltrWgt, theWorkshop);
 203     aFltrLayout->addWidget(myFiltersWgt);
 204
 205     aFltrLayout->addStretch();
 206
 207     myShowOnlyBtn = new QPushButton(tr("Show only"), aFltrWgt);
 208     myShowOnlyBtn->setCheckable(true);
 209     myShowOnlyBtn->setChecked(false);
 210     connect(myShowOnlyBtn, SIGNAL(toggled(bool)), SLOT(onShowOnly(bool)));
 211     aFltrLayout->addWidget(myShowOnlyBtn);
 212
 213     myMainLayout->addWidget(aFltrWgt);
 214   }
 215
 216   bool aSameTop = theData->getBooleanAttribute("same_topology", false);
 217   if (aSameTop) {
 218     myGeomCheck = new QCheckBox(tr("Add elements that share the same topology"), this);
 219     myMainLayout->addWidget(myGeomCheck);
 220     connect(myGeomCheck, SIGNAL(toggled(bool)), SLOT(onSameTopology(bool)));
 221   }
 222   else
 223     myGeomCheck = 0;
 224
 225   myIsNeutralPointClear = theData->getBooleanAttribute("clear_in_neutral_point", true);
 226   if (myShapeTypes.size() > 1 || myIsUseChoice) {
 227     if (defaultValues.contains(myFeatureId + attributeID())) {
 228       myDefMode = defaultValues[myFeatureId + attributeID()];
 229       myTypeCtrl->setValue(myDefMode.c_str());
 230     }
 231   }
 232 }
 233
 234 ModuleBase_WidgetMultiSelector::~ModuleBase_WidgetMultiSelector()
 235 {
 236 }
 237
 238 //********************************************************************
 239 void ModuleBase_WidgetMultiSelector::activateCustom()
 240 {
 241   ModuleBase_WidgetSelector::activateCustom();
 242
 243   ModuleBase_IModule* aModule = myWorkshop->module();
 244   aModule->activateCustomPrs(myFeature,
 245                             ModuleBase_IModule::CustomizeHighlightedObjects, true);
 246   clearSelectedHistory();
 247   if (myAllowedObjects.length() > 0) {
 248     Handle(SelectMgr_Filter) aFilter = aModule->selectionFilter(SF_GlobalFilter);
 249     if (!aFilter.IsNull()) {
 250       Handle(ModuleBase_ShapeDocumentFilter) aDocFilter =
 251         Handle(ModuleBase_ShapeDocumentFilter)::DownCast(aFilter);
 252       if (!aDocFilter.IsNull()) {
 253         QStringList aSelFilters = aDocFilter->nonSelectableTypes();
 254         foreach(QString aType, aSelFilters) {
 255           if (aSelFilters.contains(aType)) {
 256             aDocFilter->removeNonSelectableType(aType);
 257             myTmpAllowed.append(aType);
 258           }
 259         }
 260       }
 261     }
 262   }
 263 }
 264
 265 //********************************************************************
 266 void ModuleBase_WidgetMultiSelector::deactivate()
 267 {
 268   myWorkshop->module()->enableCustomModes();
 269
 270   ModuleBase_WidgetSelector::deactivate();
 271   if (myVisibleObjects.size())
 272     myShowOnlyBtn->setChecked(false);
 273
 274   myWorkshop->module()->deactivateCustomPrs(ModuleBase_IModule::CustomizeHighlightedObjects, true);
 275   clearSelectedHistory();
 276   if (myTmpAllowed.length() > 0) {
 277     ModuleBase_IModule* aModule = myWorkshop->module();
 278     Handle(SelectMgr_Filter) aFilter = aModule->selectionFilter(SF_GlobalFilter);
 279     if (!aFilter.IsNull()) {
 280       Handle(ModuleBase_ShapeDocumentFilter) aDocFilter =
 281         Handle(ModuleBase_ShapeDocumentFilter)::DownCast(aFilter);
 282       if (!aDocFilter.IsNull()) {
 283         foreach(QString aType, myTmpAllowed) {
 284           aDocFilter->addNonSelectableType(aType);
 285         }
 286       }
 287     }
 288     myTmpAllowed.clear();
 289   }
 290 }
 291
 292 //********************************************************************
 293 void ModuleBase_WidgetMultiSelector::updateAfterDeactivation()
 294 {
 295   // restore previous Undo/Redo workshop state
 296   myWorkshop->updateCommandStatus();
 297 }
 298
 299 //********************************************************************
 300 void ModuleBase_WidgetMultiSelector::updateAfterActivation()
 301 {
 302   // fill Undo/Redo actions with current information
 303   myWorkshop->updateCommandStatus();
 304 }
 305
 306 //********************************************************************
 307 bool ModuleBase_WidgetMultiSelector::storeValueCustom()
 308 {
 309   // the value is stored on the selection changed signal processing
 310   // A rare case when plugin was not loaded.
 311   if (!myFeature)
 312     return false;
 313
 314   AttributePtr anAttribute = myFeature->data()->attribute(attributeID());
 315   std::string aType = anAttribute->attributeType();
 316   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 317     AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
 318     if (myTypeCtrl->isVisible()) {
 319       std::string aMode = myTypeCtrl->textValue().toStdString();
 320       if (myIsFirst && (!myDefMode.empty()))
 321         aMode = myDefMode;
 322
 323       aSelectionListAttr->setSelectionType(aMode);
 324       myIsFirst = false;
 325     } else { // no type, set the type as a first element of the list shape type when it is appeared
 326       if (aSelectionListAttr->size()) {
 327         AttributeSelectionPtr aSel = aSelectionListAttr->value(0);
 328         GeomShapePtr aFirstVal = aSel->value();
 329         if (!aFirstVal.get() && aSel->context().get())
 330           aFirstVal = aSel->context()->shape();
 331         if (aFirstVal.get() && !aFirstVal->isNull())
 332           aSelectionListAttr->setSelectionType(aFirstVal->shapeTypeStr());
 333       }
 334     }
 335   }
 336   return true;
 337 }
 338
 339 //********************************************************************
 340 bool ModuleBase_WidgetMultiSelector::restoreValueCustom()
 341 {
 342   // A rare case when plugin was not loaded.
 343   if (!myFeature)
 344     return false;
 345
 346   AttributePtr anAttribute = myFeature->data()->attribute(attributeID());
 347   AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
 348   std::string aType = anAttribute->attributeType();
 349   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 350     // Restore shape type
 351     std::string aSelectionType = aSelectionListAttr->selectionType().c_str();
 352     if (aSelectionType.empty())
 353       aSelectionListAttr->setSelectionType(myDefMode);
 354     else {
 355       setCurrentShapeType(aSelectionType.c_str());
 356       myDefMode = aSelectionType;
 357       myIsFirst = false;
 358     }
 359   }
 360   if (myGeomCheck)
 361     myGeomCheck->setChecked(aSelectionListAttr->isGeometricalSelection());
 362   updateSelectionList();
 363   return true;
 364 }
 365
 366 //********************************************************************
 367 bool ModuleBase_WidgetMultiSelector::setSelection(QList<ModuleBase_ViewerPrsPtr>& theValues,
 368                                                   const bool theToValidate)
 369 {
 370   if (myIsSetSelectionBlocked)
 371     return false;
 372
 373   AttributeSelectionListPtr aSelectionListAttr;
 374   if (attribute()->attributeType() == ModelAPI_AttributeSelectionList::typeId())
 375     aSelectionListAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(attribute());
 376   if (aSelectionListAttr.get())
 377     aSelectionListAttr->cashValues(true);
 378
 379   /// remove unused objects from the model attribute.
 380   /// It should be performed before new attributes append.
 381   bool isDone = removeUnusedAttributeObjects(theValues);
 382
 383   QList<ModuleBase_ViewerPrsPtr> anInvalidValues;
 384   QList<ModuleBase_ViewerPrsPtr> anAttributeValues;
 385   QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
 386   for (; anIt != aLast; anIt++) {
 387     ModuleBase_ViewerPrsPtr aValue = *anIt;
 388     // do not validate and append to attribute selection presentation if it exists in the attribute
 389     ObjectPtr anObject;
 390     GeomShapePtr aShape;
 391     getGeomSelection(aValue, anObject, aShape);
 392     if (ModuleBase_Tools::hasObject(attribute(), anObject, aShape, myWorkshop, myIsInValidate)) {
 393       anAttributeValues.append(aValue);
 394       continue;
 395     }
 396     if (theToValidate && !isValidInFilters(aValue))
 397       anInvalidValues.append(aValue);
 398   }
 399   bool aHasInvalidValues = anInvalidValues.size() > 0;
 400
 401   for (anIt = theValues.begin(); anIt != aLast; anIt++) {
 402     ModuleBase_ViewerPrsPtr aValue = *anIt;
 403     bool aProcessed = false;
 404     if ((aHasInvalidValues && anInvalidValues.contains(aValue)) ||
 405         anAttributeValues.contains(aValue))
 406       continue;
 407     aProcessed = setSelectionCustom(aValue); /// it is not optimal as hasObject() is already checked
 408     // if there is at least one set, the result is true
 409     isDone = isDone || aProcessed;
 410   }
 411   // Check the selection with validators
 412   QString aError = getError();
 413   if (aError.length() > 0) {
 414     aSelectionListAttr->clear();
 415     isDone = false;
 416   }
 417   // updateObject - to update/redisplay feature
 418   // it is commented in order to perfom it outside the method
 419   //if (isDone) {
 420     //updateObject(myFeature);
 421     // this emit is necessary to call store/restore method an restore type of selection
 422     //emit valuesChanged();
 423   //}
 424
 425   if (aSelectionListAttr.get())
 426     aSelectionListAttr->cashValues(false);
 427
 428   theValues.clear();
 429   if (!anInvalidValues.empty())
 430     theValues.append(anInvalidValues);
 431
 432   if (isDone) // may be the feature's result is not displayed, but attributes should be
 433     myWorkshop->module()->customizeFeature(myFeature, ModuleBase_IModule::CustomizeArguments,
 434                              true);/// hope that something is redisplayed by object updated
 435
 436   return isDone;
 437 }
 438
 439 //********************************************************************
 440 void ModuleBase_WidgetMultiSelector::getHighlighted(QList<ModuleBase_ViewerPrsPtr>& theValues)
 441 {
 442   std::set<int> anAttributeIds;
 443   getSelectedAttributeIndices(anAttributeIds);
 444   if (!anAttributeIds.empty())
 445     convertIndicesToViewerSelection(anAttributeIds, theValues);
 446 }
 447
 448 //********************************************************************
 449 bool ModuleBase_WidgetMultiSelector::canProcessAction(ModuleBase_ActionType theActionType,
 450                                                       bool& isActionEnabled)
 451 {
 452   isActionEnabled = false;
 453   bool aCanProcess = false;
 454   switch (theActionType) {
 455     case ActionUndo:
 456     case ActionRedo: {
 457       aCanProcess = true;
 458       isActionEnabled = theActionType == ActionUndo ? myCurrentHistoryIndex > 0
 459           : (mySelectedHistoryValues.size() > 0 &&
 460              myCurrentHistoryIndex < mySelectedHistoryValues.size() - 1);
 461     }
 462     break;
 463     default:
 464       aCanProcess = ModuleBase_WidgetSelector::canProcessAction(theActionType, isActionEnabled);
 465     break;
 466   }
 467   return aCanProcess;
 468 }
 469
 470 //********************************************************************
 471 bool ModuleBase_WidgetMultiSelector::processAction(ModuleBase_ActionType theActionType,
 472                                                    const ActionParamPtr& theParam)
 473 {
 474   switch (theActionType) {
 475     case ActionUndo:
 476     case ActionRedo: {
 477       ActionIntParamPtr aParam =
 478         std::dynamic_pointer_cast<ModuleBase_ActionIntParameter>(theParam);
 479       int aNb = aParam->value();
 480       if (theActionType == ActionUndo)
 481         myCurrentHistoryIndex -= aNb;
 482       else
 483         myCurrentHistoryIndex += aNb;
 484       QList<ModuleBase_ViewerPrsPtr> aSelected = mySelectedHistoryValues[myCurrentHistoryIndex];
 485       // equal vertices should not be used here
 486       ModuleBase_ISelection::filterSelectionOnEqualPoints(aSelected);
 487       bool isDone = setSelection(aSelected,
 488                                  false /*need not validate because values already was in list*/);
 489       updateOnSelectionChanged(isDone);
 490
 491       myWorkshop->updateCommandStatus();
 492 #ifdef DEBUG_UNDO_REDO
 493       printHistoryInfo(QString("processAction %1").arg(theActionType == ActionUndo ? "Undo"
 494         : "Redo"), myCurrentHistoryIndex, mySelectedHistoryValues);
 495 #endif
 496       return true;
 497     }
 498     default:
 499       return ModuleBase_ModelWidget::processAction(theActionType, theParam);
 500   }
 501 }
 502
 503 //********************************************************************
 504 bool ModuleBase_WidgetMultiSelector::isValidSelectionCustom(const ModuleBase_ViewerPrsPtr& thePrs)
 505 {
 506   bool aValid = ModuleBase_WidgetSelector::isValidSelectionCustom(thePrs);
 507   if (aValid) {
 508     ResultPtr aResult = myWorkshop->selection()->getResult(thePrs);
 509     if (!aResult.get()) { // In case if a feature was selected
 510       FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(thePrs->object());
 511       if (aFeature.get())
 512         aResult = aFeature->firstResult();
 513     }
 514     aValid = aResult.get() != NULL;
 515     if (aValid) {
 516       if (myFeature) {
 517         // We can not select a result of our feature
 518         std::list<ResultPtr> aResults;
 519         ModelAPI_Tools::allResults(myFeature, aResults);
 520         std::list<ResultPtr>::const_iterator aIt;
 521         bool isSkipSelf = false;
 522         for (aIt = aResults.cbegin(); aIt != aResults.cend(); ++aIt) {
 523           if ((*aIt) == aResult) {
 524             isSkipSelf = true;
 525             break;
 526           }
 527         }
 528         if (isSkipSelf)
 529           aValid = false;
 530       }
 531     }
 532   }
 533   return aValid;
 534 }
 535
 536 //********************************************************************
 537 bool ModuleBase_WidgetMultiSelector::processDelete()
 538 {
 539   appendFirstSelectionInHistory();
 540
 541   // find attribute indices to delete
 542   std::set<int> anAttributeIds;
 543   getSelectedAttributeIndices(anAttributeIds);
 544
 545   QModelIndexList anIndices = myListView->getControl()->selectionModel()->selectedIndexes();
 546
 547   // refill attribute by the items which indices are not in the list of ids
 548   bool aDone = false;
 549   DataPtr aData = myFeature->data();
 550   AttributePtr anAttribute = aData->attribute(attributeID());
 551   std::string aType = anAttribute->attributeType();
 552   aDone = !anAttributeIds.empty();
 553   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 554     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 555     aSelectionListAttr->remove(anAttributeIds);
 556
 557   }
 558   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 559     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 560     aRefListAttr->remove(anAttributeIds);
 561   }
 562   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 563     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
 564     aRefAttrListAttr->remove(anAttributeIds);
 565   }
 566
 567   if (aDone) {
 568     // update object is necessary to flush update signal. It leads to objects references map update
 569     // and the operation presentation will not contain deleted items visualized as parameters of
 570     // the feature.
 571     updateObject(myFeature);
 572
 573     restoreValue();
 574     myWorkshop->setSelected(getAttributeSelection());
 575
 576     // may be the feature's result is not displayed, but attributes should be
 577     myWorkshop->module()->customizeFeature(myFeature, ModuleBase_IModule::CustomizeArguments,
 578                               true); /// hope that something is redisplayed by object updated
 579   }
 580
 581   // Restore selection
 582   myListView->restoreSelection(anIndices);
 583
 584   appendSelectionInHistory();
 585   return true/*aDone*/; // following #2438 Delete should be processed even if nothing is delete
 586 }
 587
 588 //********************************************************************
 589 QList<QWidget*> ModuleBase_WidgetMultiSelector::getControls() const
 590 {
 591   QList<QWidget*> result;
 592   if (myTypeCtrl->isVisible())
 593     result << myTypeCtrl;
 594   result << myListView->getControl();
 595   return result;
 596 }
 597
 598 //********************************************************************
 599 void ModuleBase_WidgetMultiSelector::onSelectionTypeChanged()
 600 {
 601   // Clear current selection in order to avoid updating of object browser with obsolete indexes
 602   // which can appear because of results deletetion after changing a type of selection
 603   QString aSelectionType = myTypeCtrl->textValue();
 604   QList<ModuleBase_ViewerPrsPtr> aEmptyList;
 605   myWorkshop->setSelected(aEmptyList);
 606
 607   updateSelectionModesAndFilters(true);
 608   myWorkshop->selectionActivate()->updateSelectionModes();
 609
 610   if (!myFeature)
 611     return;
 612   /// store the selected type
 613   AttributePtr anAttribute = myFeature->data()->attribute(attributeID());
 614   std::string aType = anAttribute->attributeType();
 615   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 616     AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
 617     aSelectionListAttr->setSelectionType(aSelectionType.toStdString());
 618   }
 619
 620   // clear attribute values
 621   DataPtr aData = myFeature->data();
 622   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 623     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 624     aSelectionListAttr->clear();
 625   }
 626   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 627     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 628     aRefListAttr->clear();
 629   }
 630   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 631     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
 632     aRefAttrListAttr->clear();
 633   }
 634
 635   // update object is necessary to flush update signal. It leads to objects references map update
 636   // and the operation presentation will not contain deleted items visualized as parameters of
 637   // the feature.
 638   updateObject(myFeature);
 639   restoreValue();
 640   myWorkshop->setSelected(getAttributeSelection());
 641   // may be the feature's result is not displayed, but attributes should be
 642   // hope that something is redisplayed by object updated
 643   myWorkshop->module()->customizeFeature(myFeature, ModuleBase_IModule::CustomizeArguments, false);
 644   myWorkshop->module()->customizeFeature(myFeature, ModuleBase_IModule::CustomizeResults, true);
 645   // clear history should follow after set selected to do not increase history by setSelected
 646   clearSelectedHistory();
 647
 648   if (myWorkshop->propertyPanel()->activeWidget() != this)
 649     myWorkshop->propertyPanel()->activateWidget(this);
 650 }
 651
 652 //********************************************************************
 653 bool ModuleBase_WidgetMultiSelector::processSelection()
 654 {
 655   if (!myIsNeutralPointClear) {
 656     QList<ModuleBase_ViewerPrsPtr> aSelected = getFilteredSelected();
 657     // do not clear selected object
 658     if (aSelected.size() == 0) {
 659       if (!getAttributeSelection().empty()) {
 660         // Restore selection in the viewer by the attribute selection list
 661         // it should be postponed to exit from the selectionChanged processing
 662         static Events_ID anEvent = Events_Loop::eventByName(EVENT_UPDATE_BY_WIDGET_SELECTION);
 663         ModelAPI_EventCreator::get()->sendUpdated(myFeature, anEvent);
 664         Events_Loop::loop()->flush(anEvent);
 665         return true;
 666       }
 667     }
 668   }
 669   appendFirstSelectionInHistory();
 670   bool aDone = ModuleBase_WidgetSelector::processSelection();
 671   appendSelectionInHistory();
 672   return aDone;
 673 }
 674
 675 void ModuleBase_WidgetMultiSelector::appendFirstSelectionInHistory()
 676 {
 677   if (mySelectedHistoryValues.empty()) {
 678     myCurrentHistoryIndex++;
 679     mySelectedHistoryValues.append(getAttributeSelection());
 680
 681 #ifdef DEBUG_UNDO_REDO
 682     printHistoryInfo("appendSelectionInHistory", myCurrentHistoryIndex, mySelectedHistoryValues);
 683 #endif
 684   }
 685 }
 686
 687 void ModuleBase_WidgetMultiSelector::appendSelectionInHistory()
 688 {
 689   while (myCurrentHistoryIndex != mySelectedHistoryValues.count() - 1)
 690     mySelectedHistoryValues.removeLast();
 691
 692   QList<ModuleBase_ViewerPrsPtr> aSelected = getFilteredSelected();
 693   myCurrentHistoryIndex++;
 694   mySelectedHistoryValues.append(aSelected);
 695   myWorkshop->updateCommandStatus();
 696
 697 #ifdef DEBUG_UNDO_REDO
 698   printHistoryInfo("appendSelectionInHistory", myCurrentHistoryIndex, mySelectedHistoryValues);
 699 #endif
 700 }
 701
 702 void ModuleBase_WidgetMultiSelector::clearSelectedHistory()
 703 {
 704   mySelectedHistoryValues.clear();
 705   myCurrentHistoryIndex = -1;
 706   myWorkshop->updateCommandStatus();
 707
 708 #ifdef DEBUG_UNDO_REDO
 709   printHistoryInfo("clearSelectedHistory", myCurrentHistoryIndex, mySelectedHistoryValues);
 710 #endif
 711 }
 712
 713 void ModuleBase_WidgetMultiSelector::updateFocus()
 714 {
 715   // Set focus to List control in order to make possible
 716   // to use Tab key for transfer the focus to next widgets
 717   ModuleBase_Tools::setFocus(myListView->getControl(),
 718                              "ModuleBase_WidgetMultiSelector::onSelectionTypeChanged()");
 719 }
 720
 721 //********************************************************************
 722 void ModuleBase_WidgetMultiSelector::updateSelectionName()
 723 {
 724 }
 725
 726 //********************************************************************
 727 void ModuleBase_WidgetMultiSelector::updateOnSelectionChanged(const bool theDone)
 728 {
 729   if (myIsSetSelectionBlocked)
 730     return;
 731   ModuleBase_WidgetSelector::updateOnSelectionChanged(theDone);
 732
 733   // according to #2154 we need to update OB selection when selection in the viewer happens
 734   // it is important to flush sinchronize selection signal after flush of Update/Create/Delete.
 735   // because we need that Object Browser has been already updated when synchronize happens.
 736
 737   // Restore selection in the viewer by the attribute selection list
 738   // it is possible that diring selection attribute filling, selection in Object Browser
 739   // is changed(some items were removed/added) and as result, selection in the viewer
 740   // differs from the selection come to this method. By next rows, we restore selection
 741   // in the viewer according to content of selection attribute. Case is Edge selection in Group
 742   myIsSetSelectionBlocked = true;
 743   static Events_ID anEvent = Events_Loop::eventByName(EVENT_UPDATE_BY_WIDGET_SELECTION);
 744   ModelAPI_EventCreator::get()->sendUpdated(myFeature, anEvent);
 745   Events_Loop::loop()->flush(anEvent);
 746   myIsSetSelectionBlocked = false;
 747 }
 748
 749 //********************************************************************
 750 QIntList ModuleBase_WidgetMultiSelector::shapeTypes() const
 751 {
 752   QIntList aShapeTypes;
 753
 754   if (myShapeTypes.length() > 1 && myIsUseChoice) {
 755     QStringList aTypes = myTypeCtrl->textValue().split("|", QString::SkipEmptyParts);
 756     for(QString aType: aTypes) {
 757       aShapeTypes.append(ModuleBase_Tools::shapeType(aType));
 758     }
 759   }
 760   else {
 761     foreach (QString aType, myShapeTypes) {
 762       QStringList aSubTypes = aType.split("|", QString::SkipEmptyParts);
 763       for(QString aSubType: aSubTypes) {
 764         aShapeTypes.append(ModuleBase_Tools::shapeType(aSubType));
 765       }
 766     }
 767   }
 768   return aShapeTypes;
 769 }
 770
 771 //********************************************************************
 772 void ModuleBase_WidgetMultiSelector::setCurrentShapeType(const QString& theShapeType)
 773 {
 774   int idx = 0;
 775   foreach (QString aShapeTypeName, myShapeTypes) {
 776     if(aShapeTypeName == theShapeType && idx != myTypeCtrl->value()) {
 777       updateSelectionModesAndFilters(false);
 778       bool isBlocked = myTypeCtrl->blockSignals(true);
 779       myTypeCtrl->setValue(idx);
 780       myTypeCtrl->blockSignals(isBlocked);
 781       updateSelectionModesAndFilters(true);
 782       break;
 783     }
 784     idx++;
 785   }
 786 }
 787
 788 QList<ModuleBase_ViewerPrsPtr> ModuleBase_WidgetMultiSelector::getAttributeSelection() const
 789 {
 790   QList<ModuleBase_ViewerPrsPtr> aSelected;
 791   convertIndicesToViewerSelection(std::set<int>(), aSelected);
 792   return aSelected;
 793 }
 794
 795 //********************************************************************
 796 void ModuleBase_WidgetMultiSelector::updateSelectionList()
 797 {
 798   myListView->getControl()->clear();
 799
 800   DataPtr aData = myFeature->data();
 801   AttributePtr anAttribute = aData->attribute(attributeID());
 802   std::string aType = anAttribute->attributeType();
 803   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 804     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 805     for (int i = 0; i < aSelectionListAttr->size(); i++) {
 806       AttributeSelectionPtr aAttr = aSelectionListAttr->value(i);
 807       myListView->addItem(QString::fromStdWString(aAttr->namingName()), i);
 808     }
 809   }
 810   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 811     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 812     for (int i = 0; i < aRefListAttr->size(); i++) {
 813       ObjectPtr anObject = aRefListAttr->object(i);
 814       if (anObject.get()) {
 815         myListView->addItem(QString::fromStdWString(anObject->data()->name()), i);
 816       }
 817     }
 818   }
 819   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 820     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
 821     for (int i = 0; i < aRefAttrListAttr->size(); i++) {
 822       AttributePtr anAttr = aRefAttrListAttr->attribute(i);
 823       QString aName;
 824       if (anAttr.get()) {
 825         std::wstring anAttrName = ModuleBase_Tools::generateName(anAttr, myWorkshop);
 826         aName = QString::fromStdWString(anAttrName);
 827       }
 828       else {
 829         ObjectPtr anObject = aRefAttrListAttr->object(i);
 830         if (anObject.get()) {
 831           aName = QString::fromStdWString(anObject->data()->name());
 832         }
 833       }
 834       myListView->addItem(aName, i);
 835     }
 836   }
 837
 838   // We have to call repaint because sometimes the List control is not updated
 839   myListView->getControl()->update();
 840 }
 841
 842 //********************************************************************
 843 std::string ModuleBase_WidgetMultiSelector::validatorType(const QString& theType) const
 844 {
 845   std::string aType;
 846
 847   if (theType == "Vertices")
 848     aType = "vertex";
 849   else if (theType == "Edges")
 850     aType = "edge";
 851   else if (theType == "Faces")
 852     aType = "face";
 853   else if (theType == "Solids")
 854     aType = "solid";
 855
 856   return aType;
 857 }
 858
 859 //********************************************************************
 860 void ModuleBase_WidgetMultiSelector::clearSelection()
 861 {
 862   bool isClearInNeutralPoint = myIsNeutralPointClear;
 863   myIsNeutralPointClear = true;
 864
 865   QList<ModuleBase_ViewerPrsPtr> anEmptyList;
 866   // This method will call Selection changed event which will call onSelectionChanged
 867   // To clear mySelection, myListView and storeValue()
 868   // So, we don't need to call it
 869   myWorkshop->setSelected(anEmptyList);
 870
 871   myIsNeutralPointClear = isClearInNeutralPoint;
 872 }
 873
 874 //********************************************************************
 875 void ModuleBase_WidgetMultiSelector::onDeleteItem()
 876 {
 877   processDelete();
 878 }
 879
 880 //********************************************************************
 881 void ModuleBase_WidgetMultiSelector::onListSelection()
 882 {
 883   myWorkshop->module()->customizeFeature(myFeature, ModuleBase_IModule::CustomizeHighlightedObjects,
 884                                          true);
 885 }
 886
 887 //********************************************************************
 888 void ModuleBase_WidgetMultiSelector::getSelectedAttributeIndices(std::set<int>& theAttributeIds)
 889 {
 890   myListView->getSelectedIndices(theAttributeIds);
 891 }
 892
 893 void ModuleBase_WidgetMultiSelector::convertIndicesToViewerSelection(std::set<int> theAttributeIds,
 894                                                    QList<ModuleBase_ViewerPrsPtr>& theValues) const
 895 {
 896   if(myFeature.get() == NULL)
 897     return;
 898
 899   DataPtr aData = myFeature->data();
 900   AttributePtr anAttribute = aData->attribute(attributeID());
 901   std::string aType = anAttribute->attributeType();
 902   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 903     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 904     for (int i = 0; i < aSelectionListAttr->size(); i++) {
 905       // filter by attribute indices only if the container is not empty otherwise return all items
 906       if (!theAttributeIds.empty() && theAttributeIds.find(i) == theAttributeIds.end())
 907         continue;
 908       AttributeSelectionPtr anAttr = aSelectionListAttr->value(i);
 909       ObjectPtr anObject = anAttr->contextObject();
 910       if (anObject.get())
 911         theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
 912                new ModuleBase_ViewerPrs(anObject, anAttr->value(), NULL)));
 913     }
 914   }
 915   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 916     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 917     for (int i = 0; i < aRefListAttr->size(); i++) {
 918       // filter by attribute indices only if the container is not empty otherwise return all items
 919       if (!theAttributeIds.empty() && theAttributeIds.find(i) == theAttributeIds.end())
 920         continue;
 921       ObjectPtr anObject = aRefListAttr->object(i);
 922       if (anObject.get()) {
 923         theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
 924                new ModuleBase_ViewerPrs(anObject, GeomShapePtr(), NULL)));
 925       }
 926     }
 927   }
 928   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 929     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
 930     for (int i = 0; i < aRefAttrListAttr->size(); i++) {
 931       // filter by attribute indices only if the container is not empty otherwise return all items
 932       if (!theAttributeIds.empty() && theAttributeIds.find(i) == theAttributeIds.end())
 933         continue;
 934       ObjectPtr anObject = aRefAttrListAttr->object(i);
 935       if (!anObject.get())
 936         continue;
 937       TopoDS_Shape aShape;
 938       AttributePtr anAttr = aRefAttrListAttr->attribute(i);
 939       if (anAttr.get()) {
 940         GeomShapePtr aGeomShape = ModuleBase_Tools::getShape(anAttr, myWorkshop);
 941         theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
 942                new ModuleBase_ViewerPrs(anObject, aGeomShape, NULL)));
 943       }
 944     }
 945   }
 946 }
 947
 948 bool ModuleBase_WidgetMultiSelector::removeUnusedAttributeObjects
 949                                                  (QList<ModuleBase_ViewerPrsPtr>& theValues)
 950 {
 951   bool isDone = false;
 952
 953   std::map<ObjectPtr, std::set<GeomShapePtr> > aGeomSelection = convertSelection(theValues);
 954   DataPtr aData = myFeature->data();
 955   AttributePtr anAttribute = aData->attribute(attributeID());
 956   std::string aType = anAttribute->attributeType();
 957   std::set<GeomShapePtr> aShapes;
 958   std::set<int> anIndicesToBeRemoved;
 959   FeaturePtr aFeature;
 960   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 961     // iteration through data model to find not selected elements to remove them
 962     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 963     for (int i = 0; i < aSelectionListAttr->size(); i++) {
 964       AttributeSelectionPtr anAttr = aSelectionListAttr->value(i);
 965       ObjectPtr aContextObject = anAttr->contextObject();
 966       GeomShapePtr aShape;
 967       aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aContextObject);
 968       if (!aFeature.get())
 969         aShape = anAttr->value();
 970
 971       bool aFound = findInSelection(aContextObject, aShape, aGeomSelection, myWorkshop);
 972       if (!aFound)
 973         anIndicesToBeRemoved.insert(i);
 974     }
 975     isDone = anIndicesToBeRemoved.size() > 0;
 976     if (isDone)
 977       aSelectionListAttr->remove(anIndicesToBeRemoved);
 978   }
 979   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 980     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 981     for (int i = 0; i < aRefListAttr->size(); i++) {
 982       ObjectPtr anObject = aRefListAttr->object(i);
 983       if (anObject.get()) {
 984         bool aFound = findInSelection(anObject, GeomShapePtr(), aGeomSelection,
 985                                       myWorkshop);
 986         if (!aFound)
 987           anIndicesToBeRemoved.insert(i);
 988       }
 989     }
 990     isDone = anIndicesToBeRemoved.size() > 0;
 991     aRefListAttr->remove(anIndicesToBeRemoved);
 992   }
 993   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 994     std::set<AttributePtr> anAttributes;
 995     QList<ModuleBase_ViewerPrsPtr>::const_iterator
 996       anIt = theValues.begin(), aLast = theValues.end();
 997     ObjectPtr anObject;
 998     GeomShapePtr aShape;
 999     for (; anIt != aLast; anIt++) {
1000       ModuleBase_ViewerPrsPtr aPrs = *anIt;
1001       getGeomSelection(aPrs, anObject, aShape);
1002       AttributePtr anAttr = myWorkshop->module()->findAttribute(anObject, aShape);
1003       if (anAttr.get() && anAttributes.find(anAttr) == anAttributes.end())
1004         anAttributes.insert(anAttr);
1005     }
1006
1007     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
1008     for (int i = 0; i < aRefAttrListAttr->size(); i++) {
1009       bool aFound = false;
1010       if (aRefAttrListAttr->isAttribute(i)) {
1011         AttributePtr anAttr = aRefAttrListAttr->attribute(i);
1012         aFound = anAttributes.find(anAttr) != anAttributes.end();
1013       }
1014       else {
1015         aFound = findInSelection(aRefAttrListAttr->object(i), GeomShapePtr(), aGeomSelection,
1016                                  myWorkshop);
1017       }
1018       if (!aFound)
1019         anIndicesToBeRemoved.insert(i);
1020     }
1021     isDone = anIndicesToBeRemoved.size() > 0;
1022     aRefAttrListAttr->remove(anIndicesToBeRemoved);
1023   }
1024
1025   return isDone;
1026 }
1027
1028 std::map<ObjectPtr, std::set<GeomShapePtr> > ModuleBase_WidgetMultiSelector::convertSelection
1029                                                      (QList<ModuleBase_ViewerPrsPtr>& theValues)
1030 {
1031   // convert prs list to objects map
1032   std::map<ObjectPtr, std::set<GeomShapePtr> > aGeomSelection;
1033   std::set<GeomShapePtr> aShapes;
1034   QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
1035   ObjectPtr anObject;
1036   GeomShapePtr aShape;
1037   GeomShapePtr anEmptyShape(new GeomAPI_Shape());
1038   for (; anIt != aLast; anIt++) {
1039     ModuleBase_ViewerPrsPtr aPrs = *anIt;
1040     getGeomSelection(aPrs, anObject, aShape);
1041     aShapes.clear();
1042     if (aGeomSelection.find(anObject) != aGeomSelection.end()) // found
1043       aShapes = aGeomSelection[anObject];
1044     // we need to know if there was an empty shape in selection for the object
1045     if (!aShape.get())
1046       aShape = anEmptyShape;
1047     if (aShape.get() && aShapes.find(aShape) == aShapes.end()) // not found
1048       aShapes.insert(aShape);
1049     aGeomSelection[anObject] = aShapes;
1050   }
1051   return aGeomSelection;
1052 }
1053
1054 bool ModuleBase_WidgetMultiSelector::findInSelection(const ObjectPtr& theObject,
1055                               GeomShapePtr theShape,
1056                               const std::map<ObjectPtr, std::set<GeomShapePtr> >& theGeomSelection,
1057                               ModuleBase_IWorkshop* theWorkshop)
1058 {
1059   if (!theObject.get())
1060     return false;
1061   // issue #2154: we should not remove from list objects hidden in the viewer if selection
1062   // was done with SHIFT button
1063   if (theWorkshop->hasSHIFTPressed() && !theObject->isDisplayed())
1064     return true;
1065
1066   bool aFound = false;
1067   GeomShapePtr aShape = theShape;
1068   if (!aShape.get()) {
1069     // #2429 (the preselection of a sketch is not taken into account)
1070     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
1071     if (aResult.get())
1072       aShape = aResult->shape();
1073   }
1074   if (theGeomSelection.find(theObject) != theGeomSelection.end()) {// found
1075     const std::set<GeomShapePtr>& aShapes = theGeomSelection.at(theObject);
1076     std::set<GeomShapePtr>::const_iterator anIt = aShapes.begin(), aLast = aShapes.end();
1077     for (; anIt != aLast && !aFound; anIt++) {
1078       GeomShapePtr aCShape = *anIt;
1079       if (aCShape.get())
1080       {
1081         // treat shape equal to context as null: 2219, keep order of shapes in list
1082         if (aCShape->isNull()) { // in selection, shape of result is equal to selected shape
1083           // if so, here we need to check shape of result
1084           ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
1085           if (aResult.get())
1086             aCShape = aResult->shape();
1087         }
1088         aFound = aCShape->isSame(aShape);
1089       }
1090     }
1091   }
1092
1093   // issue #2903: (Possibility to hide faces) - check whether given shape is a hidden sub-shape
1094   if (!aFound && theShape.get() && theWorkshop->hasSHIFTPressed() && theObject->isDisplayed()) {
1095     AISObjectPtr anAIS = theWorkshop->findPresentation(theObject);
1096     if (anAIS.get() != NULL) {
1097       Handle(AIS_InteractiveObject) anAISIO = anAIS->impl<Handle(AIS_InteractiveObject)>();
1098
1099       Handle(ModuleBase_ResultPrs) aResultPrs = Handle(ModuleBase_ResultPrs)::DownCast(anAISIO);
1100       if (!aResultPrs.IsNull() && aResultPrs->isSubShapeHidden(theShape->impl<TopoDS_Shape>()))
1101         return true;
1102     }
1103   }
1104
1105   return aFound;
1106 }
1107
1108 QList<ActionInfo>
1109   ModuleBase_WidgetMultiSelector::actionsList(ModuleBase_ActionType theActionType) const
1110 {
1111   QList<ActionInfo> aList;
1112   if (myCurrentHistoryIndex > -1) {
1113     int i = 0;
1114     QString aTitle("Selection %1 items");
1115     QString aTit("Selection %1 item");
1116     QIcon aIcon(":pictures/selection.png");
1117     int aNb;
1118     switch (theActionType) {
1119     case ActionUndo:
1120       i = 1;
1121       while (i <= myCurrentHistoryIndex) {
1122         aNb = mySelectedHistoryValues.at(i).count();
1123         if (aNb == 1) {
1124           ActionInfo aInfo(aIcon, aTit.arg(aNb));
1125           aList.insert(0, aInfo);
1126         } else {
1127           ActionInfo aInfo(aIcon, aTitle.arg(aNb));
1128           aList.insert(0, aInfo);
1129         }
1130         i++;
1131       }
1132       break;
1133     case ActionRedo:
1134       i = mySelectedHistoryValues.length() - 1;
1135       while (i > myCurrentHistoryIndex) {
1136         aNb = mySelectedHistoryValues.at(i).count();
1137         if (aNb == 1) {
1138           ActionInfo aInfo(aIcon, aTit.arg(mySelectedHistoryValues.at(i).count()));
1139           aList.insert(0, aInfo);
1140         } else {
1141           ActionInfo aInfo(aIcon, aTitle.arg(mySelectedHistoryValues.at(i).count()));
1142           aList.insert(0, aInfo);
1143         }
1144         i--;
1145       }
1146       break;
1147     default: // [to avoid compilation warning]
1148       break;
1149     }
1150   }
1151   return aList;
1152 }
1153
1154
1155 void ModuleBase_WidgetMultiSelector::onFeatureAccepted()
1156 {
1157   defaultValues[myFeatureId + attributeID()] = myDefMode;
1158 }
1159
1160 void ModuleBase_WidgetMultiSelector::onListActivated()
1161 {
1162   //focusTo();
1163   emitFocusInWidget();
1164 }
1165
1166 void ModuleBase_WidgetMultiSelector::onSameTopology(bool theOn)
1167 {
1168   AttributePtr anAttribute = myFeature->data()->attribute(attributeID());
1169   std::string aType = anAttribute->attributeType();
1170   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
1171     AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
1172     aSelectionListAttr->setGeometricalSelection(theOn);
1173     updateObject(myFeature);
1174   }
1175 }
1176
1177 void ModuleBase_WidgetMultiSelector::onShowOnly(bool theChecked)
1178 {
1179   std::list<ResultPtr> aResults = myFeature->results();
1180    std::list<ResultPtr>::const_iterator aIt;
1181   if (theChecked) {
1182     myVisibleObjects = myWorkshop->displayedObjects();
1183     for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
1184       myVisibleObjects.removeAll(*aIt);
1185     }
1186     myWorkshop->module()->disableCustomMode(ModuleBase_IModule::CustomizeArguments);
1187   }
1188   else
1189     myWorkshop->module()->enableCustomModes();
1190
1191   foreach(ObjectPtr aObj, myVisibleObjects) {
1192     aObj->setDisplayed(!theChecked);
1193   }
1194
1195   if (!theChecked) {
1196     // Hide and show the group result in order to make it above all objects
1197     bool aOldState = myWorkshop->enableUpdateViewer(false);
1198     for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
1199       (*aIt)->setDisplayed(false);
1200     }
1201     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
1202     for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
1203       (*aIt)->setDisplayed(true);
1204     }
1205     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
1206     myWorkshop->enableUpdateViewer(aOldState);
1207
1208     myVisibleObjects.clear();
1209   } else
1210     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
1211   myWorkshop->viewer()->update();
1212 }
1213
1214 bool ModuleBase_WidgetMultiSelector::isModified() const
1215 {
1216   return myListView->getControl()->count() > 0;
1217 }
1218
1219
1220 void ModuleBase_WidgetMultiSelector::setReadOnly(bool isReadOnly)
1221 {
1222   ModuleBase_WidgetSelector::setReadOnly(isReadOnly);
1223   if (myShowOnlyBtn)
1224     myShowOnlyBtn->hide();
1225   if (myFiltersWgt) {
1226     myFiltersWgt->hide();
1227
1228     AttributeSelectionListPtr aAttrList = feature()->selectionList(attributeID());
1229     if (aAttrList.get()) {
1230       FiltersFeaturePtr aFilters = aAttrList->filters();
1231       if (aFilters.get()) {
1232         ModuleBase_WidgetSelectionFilter::SelectorFeature = feature();
1233         ModuleBase_WidgetSelectionFilter::AttributeId = attributeID();
1234
1235         std::string aXmlCfg, aDescription;
1236         myWorkshop->module()->getXMLRepresentation(myUseFilters, aXmlCfg, aDescription);
1237
1238         ModuleBase_WidgetSelectionFilter* aWgt =
1239           new ModuleBase_WidgetSelectionFilter(this, myWorkshop,
1240             new Config_WidgetAPI(aDescription), true);
1241         aWgt->setFeature(aFilters);
1242         aWgt->restoreValue();
1243         myMainLayout->addWidget(aWgt);
1244       }
1245     }
1246   }
1247 }