#include <ModuleBase_Tools.h>
#include <ModuleBase_Definitions.h>
#include <ModuleBase_IModule.h>
+#include <ModuleBase_ViewerPrs.h>
#include <ModelAPI_Data.h>
#include <ModelAPI_Object.h>
#include <ModelAPI_AttributeSelectionList.h>
#include <ModelAPI_AttributeRefList.h>
#include <ModelAPI_AttributeRefAttrList.h>
+#include <ModelAPI_Tools.h>
#include <Config_WidgetAPI.h>
ModuleBase_WidgetMultiSelector::ModuleBase_WidgetMultiSelector(QWidget* theParent,
ModuleBase_IWorkshop* theWorkshop,
- const Config_WidgetAPI* theData,
- const std::string& theParentId)
- : ModuleBase_WidgetSelector(theParent, theWorkshop, theData, theParentId),
- mySelectionCount(0)
+ const Config_WidgetAPI* theData)
+: ModuleBase_WidgetSelector(theParent, theWorkshop, theData)
{
QGridLayout* aMainLay = new QGridLayout(this);
ModuleBase_Tools::adjustMargins(aMainLay);
QString aTypesStr = aPropertyTypes.c_str();
QStringList aShapeTypes = aTypesStr.split(' ', QString::SkipEmptyParts);
- myIsUseChoice = theData->getBooleanAttribute("use_choice", true);
+ myIsUseChoice = theData->getBooleanAttribute("use_choice", false);
if (!aShapeTypes.empty())
myTypeCombo->addItems(aShapeTypes);
}
//********************************************************************
-bool ModuleBase_WidgetMultiSelector::storeValueCustom() const
+bool ModuleBase_WidgetMultiSelector::storeValueCustom()
{
// the value is stored on the selection changed signal processing
// A rare case when plugin was not loaded.
if (aType == ModelAPI_AttributeSelectionList::typeId()) {
AttributeSelectionListPtr aSelectionListAttr = myFeature->data()->selectionList(attributeID());
// Restore shape type
- setCurrentShapeType(ModuleBase_Tools::shapeType(aSelectionListAttr->selectionType().c_str()));
+ std::string aSelectionType = aSelectionListAttr->selectionType().c_str();
+ if (!aSelectionType.empty())
+ setCurrentShapeType(ModuleBase_Tools::shapeType(aSelectionType.c_str()));
}
updateSelectionList();
return true;
}
//********************************************************************
-void ModuleBase_WidgetMultiSelector::storeAttributeValue()
-{
- ModuleBase_WidgetValidated::storeAttributeValue();
-
- DataPtr aData = myFeature->data();
- AttributePtr anAttribute = aData->attribute(attributeID());
- std::string aType = anAttribute->attributeType();
- if (aType == ModelAPI_AttributeSelectionList::typeId()) {
- AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
- mySelectionType = aSelectionListAttr->selectionType();
- mySelectionCount = aSelectionListAttr->size();
- }
- else if (aType == ModelAPI_AttributeRefList::typeId()) {
- AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
- mySelectionCount = aRefListAttr->size();
- }
- else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
- AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
- mySelectionCount = aRefAttrListAttr->size();
- }
-}
-
-//********************************************************************
-void ModuleBase_WidgetMultiSelector::restoreAttributeValue(bool theValid)
-{
- ModuleBase_WidgetValidated::restoreAttributeValue(theValid);
-
- DataPtr aData = myFeature->data();
- AttributePtr anAttribute = aData->attribute(attributeID());
- std::string aType = anAttribute->attributeType();
- if (aType == ModelAPI_AttributeSelectionList::typeId()) {
- AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
- aSelectionListAttr->setSelectionType(mySelectionType);
-
- // restore selection in the attribute. Indeed there is only one stored object
- int aCountAppened = aSelectionListAttr->size() - mySelectionCount;
- for (int i = 0; i < aCountAppened; i++)
- aSelectionListAttr->removeLast();
- }
- else if (aType == ModelAPI_AttributeRefList::typeId()) {
- AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
- // restore objects in the attribute. Indeed there is only one stored object
- int aCountAppened = aRefListAttr->size() - mySelectionCount;
- for (int i = 0; i < aCountAppened; i++)
- aRefListAttr->removeLast();
- }
- else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
- AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
- // restore objects in the attribute. Indeed there is only one stored object
- int aCountAppened = aRefAttrListAttr->size() - mySelectionCount;
- for (int i = 0; i < aCountAppened; i++)
- aRefAttrListAttr->removeLast();
- }
-}
-
-//********************************************************************
-void ModuleBase_WidgetMultiSelector::clearAttribute()
-{
- DataPtr aData = myFeature->data();
- AttributePtr anAttribute = aData->attribute(attributeID());
- std::string aType = anAttribute->attributeType();
- if (aType == ModelAPI_AttributeSelectionList::typeId()) {
- AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
- aSelectionListAttr->clear();
- }
- else if (aType == ModelAPI_AttributeRefList::typeId()) {
- AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
- aRefListAttr->clear();
- }
- else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
- AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
- aRefAttrListAttr->clear();
- }
-}
-
-//********************************************************************
-void ModuleBase_WidgetMultiSelector::setObject(ObjectPtr theSelectedObject,
- GeomShapePtr theShape)
-{
- DataPtr aData = myFeature->data();
- AttributePtr anAttribute = aData->attribute(attributeID());
- std::string aType = anAttribute->attributeType();
- if (aType == ModelAPI_AttributeSelectionList::typeId()) {
- AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
- ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theSelectedObject);
- aSelectionListAttr->append(aResult, theShape, myIsInValidate);
- }
- else if (aType == ModelAPI_AttributeRefList::typeId()) {
- AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
- aRefListAttr->append(theSelectedObject);
- }
- else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
- AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
-
- AttributePtr anAttribute = myWorkshop->module()->findAttribute(theSelectedObject, theShape);
- if (anAttribute.get())
- aRefAttrListAttr->append(anAttribute);
- else
- aRefAttrListAttr->append(theSelectedObject);
- }
-}
-
-//********************************************************************
-bool ModuleBase_WidgetMultiSelector::setSelection(QList<ModuleBase_ViewerPrs>& theValues,
+bool ModuleBase_WidgetMultiSelector::setSelection(QList<ModuleBase_ViewerPrsPtr>& theValues,
const bool theToValidate)
{
- QList<ModuleBase_ViewerPrs> aSkippedValues;
+ QList<ModuleBase_ViewerPrsPtr> aSkippedValues;
+
+ /// remove unused objects from the model attribute.
+ /// It should be performed before new attributes append.
+ removeUnusedAttributeObjects(theValues);
- QList<ModuleBase_ViewerPrs>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
+ QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
bool isDone = false;
for (; anIt != aLast; anIt++) {
- ModuleBase_ViewerPrs aValue = *anIt;
+ ModuleBase_ViewerPrsPtr aValue = *anIt;
bool aProcessed = false;
if (!theToValidate || isValidInFilters(aValue)) {
aProcessed = setSelectionCustom(aValue);
// this emit is necessary to call store/restore method an restore type of selection
//emit valuesChanged();
//}
+
theValues.clear();
if (!aSkippedValues.empty())
theValues.append(aSkippedValues);
}
//********************************************************************
-void ModuleBase_WidgetMultiSelector::getHighlighted(QList<ModuleBase_ViewerPrs>& theValues)
+void ModuleBase_WidgetMultiSelector::getHighlighted(QList<ModuleBase_ViewerPrsPtr>& theValues)
{
std::set<int> anAttributeIds;
getSelectedAttributeIndices(anAttributeIds);
}
//********************************************************************
-bool ModuleBase_WidgetMultiSelector::isValidSelectionCustom(const ModuleBase_ViewerPrs& thePrs)
+bool ModuleBase_WidgetMultiSelector::isValidSelectionCustom(const ModuleBase_ViewerPrsPtr& thePrs)
{
bool aValid = ModuleBase_WidgetSelector::isValidSelectionCustom(thePrs);
if (aValid) {
void ModuleBase_WidgetMultiSelector::onSelectionTypeChanged()
{
activateSelectionAndFilters(true);
- QList<ModuleBase_ViewerPrs> anEmptyList;
+ QList<ModuleBase_ViewerPrsPtr> anEmptyList;
// This method will call Selection changed event which will call onSelectionChanged
// To clear mySelection, myListControl and storeValue()
// So, we don't need to call it
aShapeTypeName = myTypeCombo->itemText(idx);
TopAbs_ShapeEnum aRefType = ModuleBase_Tools::shapeType(aShapeTypeName);
if(aRefType == theShapeType && idx != myTypeCombo->currentIndex()) {
- activateSelectionAndFilters(false);
+ bool aWasActivated = activateSelectionAndFilters(false);
bool isBlocked = myTypeCombo->blockSignals(true);
myTypeCombo->setCurrentIndex(idx);
myTypeCombo->blockSignals(isBlocked);
-
- activateSelectionAndFilters(true);
+ if (aWasActivated)
+ activateSelectionAndFilters(true);
break;
}
}
}
-QList<ModuleBase_ViewerPrs> ModuleBase_WidgetMultiSelector::getAttributeSelection() const
+QList<ModuleBase_ViewerPrsPtr> ModuleBase_WidgetMultiSelector::getAttributeSelection() const
{
- QList<ModuleBase_ViewerPrs> aSelected;
+ QList<ModuleBase_ViewerPrsPtr> aSelected;
convertIndicesToViewerSelection(std::set<int>(), aSelected);
return aSelected;
}
AttributePtr anAttribute = aRefAttrListAttr->attribute(i);
QString aName;
if (anAttribute.get()) {
- std::string anAttrName = generateName(anAttribute);
+ std::string anAttrName = generateName(anAttribute, myWorkshop);
aName = QString::fromStdString(anAttrName);
}
else {
}
void ModuleBase_WidgetMultiSelector::convertIndicesToViewerSelection(std::set<int> theAttributeIds,
- QList<ModuleBase_ViewerPrs>& theValues) const
+ QList<ModuleBase_ViewerPrsPtr>& theValues) const
{
if(myFeature.get() == NULL)
return;
continue;
AttributeSelectionPtr anAttr = aSelectionListAttr->value(i);
ResultPtr anObject = anAttr->context();
- if (anObject.get()) {
- TopoDS_Shape aShape;
- std::shared_ptr<GeomAPI_Shape> aShapePtr = anAttr->value();
- if (aShapePtr.get()) {
- aShape = aShapePtr->impl<TopoDS_Shape>();
- }
- theValues.append(ModuleBase_ViewerPrs(anObject, aShape, NULL));
- }
+ if (anObject.get())
+ theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
+ new ModuleBase_ViewerPrs(anObject, anAttr->value(), NULL)));
}
}
else if (aType == ModelAPI_AttributeRefList::typeId()) {
continue;
ObjectPtr anObject = aRefListAttr->object(i);
if (anObject.get()) {
- theValues.append(ModuleBase_ViewerPrs(anObject, TopoDS_Shape(), NULL));
+ theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
+ new ModuleBase_ViewerPrs(anObject, GeomShapePtr(), NULL)));
}
}
}
TopoDS_Shape aShape;
AttributePtr anAttribute = aRefAttrListAttr->attribute(i);
if (anAttribute.get()) {
- GeomShapePtr aGeomShape = myWorkshop->module()->findShape(anAttribute);
- if (aGeomShape.get()) {
- aShape = aGeomShape->impl<TopoDS_Shape>();
- }
- theValues.append(ModuleBase_ViewerPrs(anObject, aShape, NULL));
+ GeomShapePtr aGeomShape = ModuleBase_Tools::getShape(anAttribute, myWorkshop);
+ theValues.append(std::shared_ptr<ModuleBase_ViewerPrs>(
+ new ModuleBase_ViewerPrs(anObject, aGeomShape, NULL)));
}
}
}
}
+
+void ModuleBase_WidgetMultiSelector::removeUnusedAttributeObjects
+ (QList<ModuleBase_ViewerPrsPtr>& theValues)
+{
+ std::map<ObjectPtr, std::set<GeomShapePtr> > aGeomSelection = convertSelection(theValues);
+ DataPtr aData = myFeature->data();
+ AttributePtr anAttribute = aData->attribute(attributeID());
+ std::string aType = anAttribute->attributeType();
+ std::set<GeomShapePtr> aShapes;
+ std::set<int> anIndicesToBeRemoved;
+ if (aType == ModelAPI_AttributeSelectionList::typeId()) {
+ // iteration through data model to find not selected elements to remove them
+ AttributeSelectionListPtr aSelectionListAttr = aData->selectionList(attributeID());
+ for (int i = 0; i < aSelectionListAttr->size(); i++) {
+ AttributeSelectionPtr anAttr = aSelectionListAttr->value(i);
+ bool aFound = findInSelection(anAttr->context(), anAttr->value(), aGeomSelection);
+ if (!aFound)
+ anIndicesToBeRemoved.insert(i);
+ }
+ aSelectionListAttr->remove(anIndicesToBeRemoved);
+ }
+ else if (aType == ModelAPI_AttributeRefList::typeId()) {
+ AttributeRefListPtr aRefListAttr = aData->reflist(attributeID());
+ for (int i = 0; i < aRefListAttr->size(); i++) {
+ ObjectPtr anObject = aRefListAttr->object(i);
+ if (anObject.get()) {
+ bool aFound = findInSelection(anObject, GeomShapePtr(), aGeomSelection);
+ if (!aFound)
+ anIndicesToBeRemoved.insert(i);
+ }
+ }
+ aRefListAttr->remove(anIndicesToBeRemoved);
+ }
+ else if (aType == ModelAPI_AttributeRefAttrList::typeId()) {
+ std::set<AttributePtr> anAttributes;
+ QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
+ ObjectPtr anObject;
+ GeomShapePtr aShape;
+ for (; anIt != aLast; anIt++) {
+ ModuleBase_ViewerPrsPtr aPrs = *anIt;
+ getGeomSelection(aPrs, anObject, aShape);
+ AttributePtr anAttr = myWorkshop->module()->findAttribute(anObject, aShape);
+ if (anAttr.get() && anAttributes.find(anAttr) == anAttributes.end())
+ anAttributes.insert(anAttr);
+ }
+
+ AttributeRefAttrListPtr aRefAttrListAttr = aData->refattrlist(attributeID());
+ for (int i = 0; i < aRefAttrListAttr->size(); i++) {
+ bool aFound = false;
+ if (aRefAttrListAttr->isAttribute(i)) {
+ AttributePtr anAttribute = aRefAttrListAttr->attribute(i);
+ aFound = anAttributes.find(anAttribute) != anAttributes.end();
+ }
+ else {
+ aFound = findInSelection(aRefAttrListAttr->object(i), GeomShapePtr(), aGeomSelection);
+ }
+ if (!aFound)
+ anIndicesToBeRemoved.insert(i);
+ }
+ aRefAttrListAttr->remove(anIndicesToBeRemoved);
+ }
+}
+
+std::map<ObjectPtr, std::set<GeomShapePtr> > ModuleBase_WidgetMultiSelector::convertSelection
+ (QList<ModuleBase_ViewerPrsPtr>& theValues)
+{
+ // convert prs list to objects map
+ std::map<ObjectPtr, std::set<GeomShapePtr> > aGeomSelection;
+ std::set<GeomShapePtr> aShapes;
+ QList<ModuleBase_ViewerPrsPtr>::const_iterator anIt = theValues.begin(), aLast = theValues.end();
+ ObjectPtr anObject;
+ GeomShapePtr aShape;
+ GeomShapePtr anEmptyShape(new GeomAPI_Shape());
+ for (; anIt != aLast; anIt++) {
+ ModuleBase_ViewerPrsPtr aPrs = *anIt;
+ getGeomSelection(aPrs, anObject, aShape);
+ aShapes.clear();
+ if (aGeomSelection.find(anObject) != aGeomSelection.end()) // found
+ aShapes = aGeomSelection[anObject];
+ // we need to know if there was an empty shape in selection for the object
+ if (!aShape.get())
+ aShape = anEmptyShape;
+ if (aShape.get() && aShapes.find(aShape) == aShapes.end()) // not found
+ aShapes.insert(aShape);
+ aGeomSelection[anObject] = aShapes;
+ }
+ return aGeomSelection;
+}
+
+bool ModuleBase_WidgetMultiSelector::findInSelection(const ObjectPtr& theObject,
+ const GeomShapePtr& theShape,
+ const std::map<ObjectPtr, std::set<GeomShapePtr> >& theGeomSelection)
+{
+ bool aFound = false;
+ GeomShapePtr anEmptyShape(new GeomAPI_Shape());
+ GeomShapePtr aShape = theShape.get() ? theShape : anEmptyShape;
+ if (theGeomSelection.find(theObject) != theGeomSelection.end()) {// found
+ const std::set<GeomShapePtr>& aShapes = theGeomSelection.at(theObject);
+ std::set<GeomShapePtr>::const_iterator anIt = aShapes.begin(), aLast = aShapes.end();
+ for (; anIt != aLast && !aFound; anIt++) {
+ GeomShapePtr aCShape = *anIt;
+ if (aCShape.get())
+ aFound = aCShape->isEqual(aShape);
+ }
+ }
+ return aFound;
+}
