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(ModuleBase_Tools::shapeType(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     aShapeTypes.append(ModuleBase_Tools::shapeType(myTypeCtrl->textValue()));
 756   }
 757   else {
 758     foreach (QString aType, myShapeTypes) {
 759       aShapeTypes.append(ModuleBase_Tools::shapeType(aType));
 760     }
 761   }
 762   return aShapeTypes;
 763 }
 764
 765 //********************************************************************
 766 void ModuleBase_WidgetMultiSelector::setCurrentShapeType(const int theShapeType)
 767 {
 768   int idx = 0;
 769   foreach (QString aShapeTypeName, myShapeTypes) {
 770     int aRefType = ModuleBase_Tools::shapeType(aShapeTypeName);
 771     if(aRefType == theShapeType && idx != myTypeCtrl->value()) {
 772       updateSelectionModesAndFilters(false);
 773       bool isBlocked = myTypeCtrl->blockSignals(true);
 774       myTypeCtrl->setValue(idx);
 775       myTypeCtrl->blockSignals(isBlocked);
 776       updateSelectionModesAndFilters(true);
 777       break;
 778     }
 779     idx++;
 780   }
 781 }
 782
 783 QList<ModuleBase_ViewerPrsPtr> ModuleBase_WidgetMultiSelector::getAttributeSelection() const
 784 {
 785   QList<ModuleBase_ViewerPrsPtr> aSelected;
 786   convertIndicesToViewerSelection(std::set<int>(), aSelected);
 787   return aSelected;
 788 }
 789
 790 //********************************************************************
 791 void ModuleBase_WidgetMultiSelector::updateSelectionList()
 792 {
 793   myListView->getControl()->clear();
 794
 795   DataPtr aData = myFeature->data();
 796   AttributePtr anAttribute = aData->attribute(attributeID());
 797   std::string aType = anAttribute->attributeType();
 798   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 799     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 800     for (int i = 0; i < aSelectionListAttr->size(); i++) {
 801       AttributeSelectionPtr aAttr = aSelectionListAttr->value(i);
 802       myListView->addItem(QString::fromStdWString(aAttr->namingName()), i);
 803     }
 804   }
 805   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 806     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 807     for (int i = 0; i < aRefListAttr->size(); i++) {
 808       ObjectPtr anObject = aRefListAttr->object(i);
 809       if (anObject.get()) {
 810         myListView->addItem(QString::fromStdWString(anObject->data()->name()), i);
 811       }
 812     }
 813   }
 814   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 815     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
 816     for (int i = 0; i < aRefAttrListAttr->size(); i++) {
 817       AttributePtr anAttr = aRefAttrListAttr->attribute(i);
 818       QString aName;
 819       if (anAttr.get()) {
 820         std::wstring anAttrName = ModuleBase_Tools::generateName(anAttr, myWorkshop);
 821         aName = QString::fromStdWString(anAttrName);
 822       }
 823       else {
 824         ObjectPtr anObject = aRefAttrListAttr->object(i);
 825         if (anObject.get()) {
 826           aName = QString::fromStdWString(anObject->data()->name());
 827         }
 828       }
 829       myListView->addItem(aName, i);
 830     }
 831   }
 832
 833   // We have to call repaint because sometimes the List control is not updated
 834   myListView->getControl()->update();
 835 }
 836
 837 //********************************************************************
 838 std::string ModuleBase_WidgetMultiSelector::validatorType(const QString& theType) const
 839 {
 840   std::string aType;
 841
 842   if (theType == "Vertices")
 843     aType = "vertex";
 844   else if (theType == "Edges")
 845     aType = "edge";
 846   else if (theType == "Faces")
 847     aType = "face";
 848   else if (theType == "Solids")
 849     aType = "solid";
 850
 851   return aType;
 852 }
 853
 854 //********************************************************************
 855 void ModuleBase_WidgetMultiSelector::clearSelection()
 856 {
 857   bool isClearInNeutralPoint = myIsNeutralPointClear;
 858   myIsNeutralPointClear = true;
 859
 860   QList<ModuleBase_ViewerPrsPtr> anEmptyList;
 861   // This method will call Selection changed event which will call onSelectionChanged
 862   // To clear mySelection, myListView and storeValue()
 863   // So, we don't need to call it
 864   myWorkshop->setSelected(anEmptyList);
 865
 866   myIsNeutralPointClear = isClearInNeutralPoint;
 867 }
 868
 869 //********************************************************************
 870 void ModuleBase_WidgetMultiSelector::onDeleteItem()
 871 {
 872   processDelete();
 873 }
 874
 875 //********************************************************************
 876 void ModuleBase_WidgetMultiSelector::onListSelection()
 877 {
 878   myWorkshop->module()->customizeFeature(myFeature, ModuleBase_IModule::CustomizeHighlightedObjects,
 879                                          true);
 880 }
 881
 882 //********************************************************************
 883 void ModuleBase_WidgetMultiSelector::getSelectedAttributeIndices(std::set<int>& theAttributeIds)
 884 {
 885   myListView->getSelectedIndices(theAttributeIds);
 886 }
 887
 888 void ModuleBase_WidgetMultiSelector::convertIndicesToViewerSelection(std::set<int> theAttributeIds,
 889                                                    QList<ModuleBase_ViewerPrsPtr>& theValues) const
 890 {
 891   if(myFeature.get() == NULL)
 892     return;
 893
 894   DataPtr aData = myFeature->data();
 895   AttributePtr anAttribute = aData->attribute(attributeID());
 896   std::string aType = anAttribute->attributeType();
 897   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 898     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 899     for (int i = 0; i < aSelectionListAttr->size(); i++) {
 900       // filter by attribute indices only if the container is not empty otherwise return all items
 901       if (!theAttributeIds.empty() && theAttributeIds.find(i) == theAttributeIds.end())
 902         continue;
 903       AttributeSelectionPtr anAttr = aSelectionListAttr->value(i);
 904       ObjectPtr anObject = anAttr->contextObject();
 905       if (anObject.get())
 906         theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
 907                new ModuleBase_ViewerPrs(anObject, anAttr->value(), NULL)));
 908     }
 909   }
 910   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 911     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 912     for (int i = 0; i < aRefListAttr->size(); i++) {
 913       // filter by attribute indices only if the container is not empty otherwise return all items
 914       if (!theAttributeIds.empty() && theAttributeIds.find(i) == theAttributeIds.end())
 915         continue;
 916       ObjectPtr anObject = aRefListAttr->object(i);
 917       if (anObject.get()) {
 918         theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
 919                new ModuleBase_ViewerPrs(anObject, GeomShapePtr(), NULL)));
 920       }
 921     }
 922   }
 923   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 924     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
 925     for (int i = 0; i < aRefAttrListAttr->size(); i++) {
 926       // filter by attribute indices only if the container is not empty otherwise return all items
 927       if (!theAttributeIds.empty() && theAttributeIds.find(i) == theAttributeIds.end())
 928         continue;
 929       ObjectPtr anObject = aRefAttrListAttr->object(i);
 930       if (!anObject.get())
 931         continue;
 932       TopoDS_Shape aShape;
 933       AttributePtr anAttr = aRefAttrListAttr->attribute(i);
 934       if (anAttr.get()) {
 935         GeomShapePtr aGeomShape = ModuleBase_Tools::getShape(anAttr, myWorkshop);
 936         theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
 937                new ModuleBase_ViewerPrs(anObject, aGeomShape, NULL)));
 938       }
 939     }
 940   }
 941 }
 942
 943 bool ModuleBase_WidgetMultiSelector::removeUnusedAttributeObjects
 944                                                  (QList<ModuleBase_ViewerPrsPtr>& theValues)
 945 {
 946   bool isDone = false;
 947
 948   std::map<ObjectPtr, std::set<GeomShapePtr> > aGeomSelection = convertSelection(theValues);
 949   DataPtr aData = myFeature->data();
 950   AttributePtr anAttribute = aData->attribute(attributeID());
 951   std::string aType = anAttribute->attributeType();
 952   std::set<GeomShapePtr> aShapes;
 953   std::set<int> anIndicesToBeRemoved;
 954   FeaturePtr aFeature;
 955   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
 956     // iteration through data model to find not selected elements to remove them
 957     AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
 958     for (int i = 0; i < aSelectionListAttr->size(); i++) {
 959       AttributeSelectionPtr anAttr = aSelectionListAttr->value(i);
 960       ObjectPtr aContextObject = anAttr->contextObject();
 961       GeomShapePtr aShape;
 962       aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(aContextObject);
 963       if (!aFeature.get())
 964         aShape = anAttr->value();
 965
 966       bool aFound = findInSelection(aContextObject, aShape, aGeomSelection, myWorkshop);
 967       if (!aFound)
 968         anIndicesToBeRemoved.insert(i);
 969     }
 970     isDone = anIndicesToBeRemoved.size() > 0;
 971     if (isDone)
 972       aSelectionListAttr->remove(anIndicesToBeRemoved);
 973   }
 974   else if (aType == ModelAPI_AttributeRefList::typeId()) {
 975     AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
 976     for (int i = 0; i < aRefListAttr->size(); i++) {
 977       ObjectPtr anObject = aRefListAttr->object(i);
 978       if (anObject.get()) {
 979         bool aFound = findInSelection(anObject, GeomShapePtr(), aGeomSelection,
 980                                       myWorkshop);
 981         if (!aFound)
 982           anIndicesToBeRemoved.insert(i);
 983       }
 984     }
 985     isDone = anIndicesToBeRemoved.size() > 0;
 986     aRefListAttr->remove(anIndicesToBeRemoved);
 987   }
 988   else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
 989     std::set<AttributePtr> anAttributes;
 990     QList<ModuleBase_ViewerPrsPtr>::const_iterator
 991       anIt = theValues.begin(), aLast = theValues.end();
 992     ObjectPtr anObject;
 993     GeomShapePtr aShape;
 994     for (; anIt != aLast; anIt++) {
 995       ModuleBase_ViewerPrsPtr aPrs = *anIt;
 996       getGeomSelection(aPrs, anObject, aShape);
 997       AttributePtr anAttr = myWorkshop->module()->findAttribute(anObject, aShape);
 998       if (anAttr.get() && anAttributes.find(anAttr) == anAttributes.end())
 999         anAttributes.insert(anAttr);
1000     }
1001
1002     AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
1003     for (int i = 0; i < aRefAttrListAttr->size(); i++) {
1004       bool aFound = false;
1005       if (aRefAttrListAttr->isAttribute(i)) {
1006         AttributePtr anAttr = aRefAttrListAttr->attribute(i);
1007         aFound = anAttributes.find(anAttr) != anAttributes.end();
1008       }
1009       else {
1010         aFound = findInSelection(aRefAttrListAttr->object(i), GeomShapePtr(), aGeomSelection,
1011                                  myWorkshop);
1012       }
1013       if (!aFound)
1014         anIndicesToBeRemoved.insert(i);
1015     }
1016     isDone = anIndicesToBeRemoved.size() > 0;
1017     aRefAttrListAttr->remove(anIndicesToBeRemoved);
1018   }
1019
1020   return isDone;
1021 }
1022
1023 std::map<ObjectPtr, std::set<GeomShapePtr> > ModuleBase_WidgetMultiSelector::convertSelection
1024                                                      (QList<ModuleBase_ViewerPrsPtr>& theValues)
1025 {
1026   // convert prs list to objects map
1027   std::map<ObjectPtr, std::set<GeomShapePtr> > aGeomSelection;
1028   std::set<GeomShapePtr> aShapes;
1029   QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
1030   ObjectPtr anObject;
1031   GeomShapePtr aShape;
1032   GeomShapePtr anEmptyShape(new GeomAPI_Shape());
1033   for (; anIt != aLast; anIt++) {
1034     ModuleBase_ViewerPrsPtr aPrs = *anIt;
1035     getGeomSelection(aPrs, anObject, aShape);
1036     aShapes.clear();
1037     if (aGeomSelection.find(anObject) != aGeomSelection.end()) // found
1038       aShapes = aGeomSelection[anObject];
1039     // we need to know if there was an empty shape in selection for the object
1040     if (!aShape.get())
1041       aShape = anEmptyShape;
1042     if (aShape.get() && aShapes.find(aShape) == aShapes.end()) // not found
1043       aShapes.insert(aShape);
1044     aGeomSelection[anObject] = aShapes;
1045   }
1046   return aGeomSelection;
1047 }
1048
1049 bool ModuleBase_WidgetMultiSelector::findInSelection(const ObjectPtr& theObject,
1050                               GeomShapePtr theShape,
1051                               const std::map<ObjectPtr, std::set<GeomShapePtr> >& theGeomSelection,
1052                               ModuleBase_IWorkshop* theWorkshop)
1053 {
1054   if (!theObject.get())
1055     return false;
1056   // issue #2154: we should not remove from list objects hidden in the viewer if selection
1057   // was done with SHIFT button
1058   if (theWorkshop->hasSHIFTPressed() && !theObject->isDisplayed())
1059     return true;
1060
1061   bool aFound = false;
1062   GeomShapePtr aShape = theShape;
1063   if (!aShape.get()) {
1064     // #2429 (the preselection of a sketch is not taken into account)
1065     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
1066     if (aResult.get())
1067       aShape = aResult->shape();
1068   }
1069   if (theGeomSelection.find(theObject) != theGeomSelection.end()) {// found
1070     const std::set<GeomShapePtr>& aShapes = theGeomSelection.at(theObject);
1071     std::set<GeomShapePtr>::const_iterator anIt = aShapes.begin(), aLast = aShapes.end();
1072     for (; anIt != aLast && !aFound; anIt++) {
1073       GeomShapePtr aCShape = *anIt;
1074       if (aCShape.get())
1075       {
1076         // treat shape equal to context as null: 2219, keep order of shapes in list
1077         if (aCShape->isNull()) { // in selection, shape of result is equal to selected shape
1078           // if so, here we need to check shape of result
1079           ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
1080           if (aResult.get())
1081             aCShape = aResult->shape();
1082         }
1083         aFound = aCShape->isSame(aShape);
1084       }
1085     }
1086   }
1087
1088   // issue #2903: (Possibility to hide faces) - check whether given shape is a hidden sub-shape
1089   if (!aFound && theShape.get() && theWorkshop->hasSHIFTPressed() && theObject->isDisplayed()) {
1090     AISObjectPtr anAIS = theWorkshop->findPresentation(theObject);
1091     if (anAIS.get() != NULL) {
1092       Handle(AIS_InteractiveObject) anAISIO = anAIS->impl<Handle(AIS_InteractiveObject)>();
1093
1094       Handle(ModuleBase_ResultPrs) aResultPrs = Handle(ModuleBase_ResultPrs)::DownCast(anAISIO);
1095       if (!aResultPrs.IsNull() && aResultPrs->isSubShapeHidden(theShape->impl<TopoDS_Shape>()))
1096         return true;
1097     }
1098   }
1099
1100   return aFound;
1101 }
1102
1103 QList<ActionInfo>
1104   ModuleBase_WidgetMultiSelector::actionsList(ModuleBase_ActionType theActionType) const
1105 {
1106   QList<ActionInfo> aList;
1107   if (myCurrentHistoryIndex > -1) {
1108     int i = 0;
1109     QString aTitle("Selection %1 items");
1110     QString aTit("Selection %1 item");
1111     QIcon aIcon(":pictures/selection.png");
1112     int aNb;
1113     switch (theActionType) {
1114     case ActionUndo:
1115       i = 1;
1116       while (i <= myCurrentHistoryIndex) {
1117         aNb = mySelectedHistoryValues.at(i).count();
1118         if (aNb == 1) {
1119           ActionInfo aInfo(aIcon, aTit.arg(aNb));
1120           aList.insert(0, aInfo);
1121         } else {
1122           ActionInfo aInfo(aIcon, aTitle.arg(aNb));
1123           aList.insert(0, aInfo);
1124         }
1125         i++;
1126       }
1127       break;
1128     case ActionRedo:
1129       i = mySelectedHistoryValues.length() - 1;
1130       while (i > myCurrentHistoryIndex) {
1131         aNb = mySelectedHistoryValues.at(i).count();
1132         if (aNb == 1) {
1133           ActionInfo aInfo(aIcon, aTit.arg(mySelectedHistoryValues.at(i).count()));
1134           aList.insert(0, aInfo);
1135         } else {
1136           ActionInfo aInfo(aIcon, aTitle.arg(mySelectedHistoryValues.at(i).count()));
1137           aList.insert(0, aInfo);
1138         }
1139         i--;
1140       }
1141       break;
1142     default: // [to avoid compilation warning]
1143       break;
1144     }
1145   }
1146   return aList;
1147 }
1148
1149
1150 void ModuleBase_WidgetMultiSelector::onFeatureAccepted()
1151 {
1152   defaultValues[myFeatureId + attributeID()] = myDefMode;
1153 }
1154
1155 void ModuleBase_WidgetMultiSelector::onListActivated()
1156 {
1157   //focusTo();
1158   emitFocusInWidget();
1159 }
1160
1161 void ModuleBase_WidgetMultiSelector::onSameTopology(bool theOn)
1162 {
1163   AttributePtr anAttribute = myFeature->data()->attribute(attributeID());
1164   std::string aType = anAttribute->attributeType();
1165   if (aType == ModelAPI_AttributeSelectionList::typeId()) {
1166     AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
1167     aSelectionListAttr->setGeometricalSelection(theOn);
1168     updateObject(myFeature);
1169   }
1170 }
1171
1172 void ModuleBase_WidgetMultiSelector::onShowOnly(bool theChecked)
1173 {
1174   std::list<ResultPtr> aResults = myFeature->results();
1175    std::list<ResultPtr>::const_iterator aIt;
1176   if (theChecked) {
1177     myVisibleObjects = myWorkshop->displayedObjects();
1178     for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
1179       myVisibleObjects.removeAll(*aIt);
1180     }
1181     myWorkshop->module()->disableCustomMode(ModuleBase_IModule::CustomizeArguments);
1182   }
1183   else
1184     myWorkshop->module()->enableCustomModes();
1185
1186   foreach(ObjectPtr aObj, myVisibleObjects) {
1187     aObj->setDisplayed(!theChecked);
1188   }
1189
1190   if (!theChecked) {
1191     // Hide and show the group result in order to make it above all objects
1192     bool aOldState = myWorkshop->enableUpdateViewer(false);
1193     for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
1194       (*aIt)->setDisplayed(false);
1195     }
1196     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
1197     for (aIt = aResults.cbegin(); aIt != aResults.cend(); aIt++) {
1198       (*aIt)->setDisplayed(true);
1199     }
1200     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
1201     myWorkshop->enableUpdateViewer(aOldState);
1202
1203     myVisibleObjects.clear();
1204   } else
1205     Events_Loop::loop()->flush(Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY));
1206   myWorkshop->viewer()->update();
1207 }
1208
1209 bool ModuleBase_WidgetMultiSelector::isModified() const
1210 {
1211   return myListView->getControl()->count() > 0;
1212 }
1213
1214
1215 void ModuleBase_WidgetMultiSelector::setReadOnly(bool isReadOnly)
1216 {
1217   ModuleBase_WidgetSelector::setReadOnly(isReadOnly);
1218   if (myShowOnlyBtn)
1219     myShowOnlyBtn->hide();
1220   if (myFiltersWgt) {
1221     myFiltersWgt->hide();
1222
1223     AttributeSelectionListPtr aAttrList = feature()->selectionList(attributeID());
1224     if (aAttrList.get()) {
1225       FiltersFeaturePtr aFilters = aAttrList->filters();
1226       if (aFilters.get()) {
1227         ModuleBase_WidgetSelectionFilter::SelectorFeature = feature();
1228         ModuleBase_WidgetSelectionFilter::AttributeId = attributeID();
1229
1230         std::string aXmlCfg, aDescription;
1231         myWorkshop->module()->getXMLRepresentation(myUseFilters, aXmlCfg, aDescription);
1232
1233         ModuleBase_WidgetSelectionFilter* aWgt =
1234           new ModuleBase_WidgetSelectionFilter(this, myWorkshop,
1235             new Config_WidgetAPI(aDescription), true);
1236         aWgt->setFeature(aFilters);
1237         aWgt->restoreValue();
1238         myMainLayout->addWidget(aWgt);
1239       }
1240     }
1241   }
1242 }