Merge branch 'master' of newgeom:newgeom.git

diff --git a/src/Model/Model_ResultBody.cpp b/src/Model/Model_ResultBody.cpp
index 7e504953170efd29fb1f71ab9f57a2937acd8a44..3b9fb24abef3004bff582b8146d8ed0e51b87249 100644 (file)
--- a/src/Model/Model_ResultBody.cpp
+++ b/src/Model/Model_ResultBody.cpp
@@ -6,7 +6,9 @@
 #include <Model_Data.h>
 #include <TNaming_Builder.hxx>
 #include <TNaming_NamedShape.hxx>
+#include <TopoDS.hxx>
 #include <TopoDS_Shape.hxx>
+#include <TopoDS_Face.hxx>
 #include <TDF_ChildIterator.hxx>
 #include <TopTools_MapOfShape.hxx>
 #include <TopExp_Explorer.hxx>
@@ -14,7 +16,13 @@
 #include <TopTools_ListIteratorOfListOfShape.hxx>
 #include <TopTools_DataMapOfShapeListOfShape.hxx>
 #include <TopTools_DataMapIteratorOfDataMapOfShapeListOfShape.hxx>
+#include <TopTools_DataMapIteratorOfDataMapOfShapeShape.hxx>
 #include <TopTools_MapIteratorOfMapOfShape.hxx>
+#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <TopTools_IndexedMapOfShape.hxx>
+#include <TopTools_DataMapOfShapeShape.hxx>
+#include <TopExp.hxx>
+#include <BRepTools.hxx>
 #include <GeomAPI_Shape.h>
 #include <GeomAlgoAPI_MakeShape.h>
 // DEB
@@ -244,12 +252,136 @@ void Model_ResultBody::loadAndOrientGeneratedShapes (
   }
 }
 
-void Model_ResultBody::loadFirstLevel(boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag)
+//=======================================================================
+int getDangleShapes(const TopoDS_Shape&           theShapeIn, 
+                                       const TopAbs_ShapeEnum        theGeneratedFrom,
+                                   TopTools_DataMapOfShapeShape& theDangles) 
 {
+  theDangles.Clear();
+  TopTools_IndexedDataMapOfShapeListOfShape subShapeAndAncestors;
+  TopAbs_ShapeEnum GeneratedTo;
+  if (theGeneratedFrom == TopAbs_FACE) GeneratedTo = TopAbs_EDGE;
+  else if (theGeneratedFrom == TopAbs_EDGE) GeneratedTo = TopAbs_VERTEX;
+  else return Standard_False;
+  TopExp::MapShapesAndAncestors(theShapeIn, GeneratedTo, theGeneratedFrom, subShapeAndAncestors);
+  for (Standard_Integer i = 1; i <= subShapeAndAncestors.Extent(); i++) {
+    const TopoDS_Shape& mayBeDangle = subShapeAndAncestors.FindKey(i);
+    const TopTools_ListOfShape& ancestors = subShapeAndAncestors.FindFromIndex(i);
+    if (ancestors.Extent() == 1) theDangles.Bind(ancestors.First(), mayBeDangle);
+  }
+  return theDangles.Extent();
+}
+
+//=======================================================================
+void loadGeneratedDangleShapes(
+                                                          const TopoDS_Shape&      theShapeIn,
+                                              const TopAbs_ShapeEnum   theGeneratedFrom,
+                                              TNaming_Builder *        theBuilder)
+{
+  TopTools_DataMapOfShapeShape dangles;
+  if (!getDangleShapes(theShapeIn, theGeneratedFrom, dangles)) return;
+  TopTools_DataMapIteratorOfDataMapOfShapeShape itr(dangles);
+  for (; itr.More(); itr.Next()) 
+       theBuilder->Generated(itr.Key(), itr.Value());
+}
 
+//=======================================================================
+void Model_ResultBody::loadNextLevels(boost::shared_ptr<GeomAPI_Shape> theShape, 
+                                         int&  theTag)
+{
+  if(theShape->isNull()) return;
+  TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();    
+  if (aShape.ShapeType() == TopAbs_SOLID) {                
+    TopExp_Explorer expl(aShape, TopAbs_FACE);
+    for (; expl.More(); expl.Next())      
+         builder(++theTag)->Generated(expl.Current());     
+  }
+  else if (aShape.ShapeType() == TopAbs_SHELL || aShape.ShapeType() == TopAbs_FACE) {
+    // load faces and all the free edges
+    TopTools_IndexedMapOfShape Faces;
+    TopExp::MapShapes(aShape, TopAbs_FACE, Faces);
+    if (Faces.Extent() > 1 || (aShape.ShapeType() == TopAbs_SHELL && Faces.Extent() == 1)) {
+      TopExp_Explorer expl(aShape, TopAbs_FACE);
+      for (; expl.More(); expl.Next()) 
+                 builder(++theTag)->Generated(expl.Current());          
+       }
+    TopTools_IndexedDataMapOfShapeListOfShape anEdgeAndNeighbourFaces;
+    TopExp::MapShapesAndAncestors(aShape, TopAbs_EDGE, TopAbs_FACE, anEdgeAndNeighbourFaces);
+    for (Standard_Integer i = 1; i <= anEdgeAndNeighbourFaces.Extent(); i++) 
+       {
+      const TopTools_ListOfShape& aLL = anEdgeAndNeighbourFaces.FindFromIndex(i);
+      if (aLL.Extent() < 2) {
+           builder(++theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));    
+      } else {
+         TopTools_ListIteratorOfListOfShape anIter(aLL);
+         const TopoDS_Face& aFace = TopoDS::Face(anIter.Value());
+         anIter.Next();
+         if(aFace.IsEqual(anIter.Value())) {
+               builder(++theTag)->Generated(anEdgeAndNeighbourFaces.FindKey(i));
+         }
+         }
+       }
+  } else if (aShape.ShapeType() == TopAbs_WIRE) {
+    TopTools_IndexedMapOfShape Edges;
+    BRepTools::Map3DEdges(aShape, Edges);
+    if (Edges.Extent() == 1) {
+         builder(++theTag)->Generated(Edges.FindKey(1));
+      TopExp_Explorer expl(aShape, TopAbs_VERTEX);
+      for (; expl.More(); expl.Next()) {
+           builder(++theTag)->Generated(expl.Current());
+         }
+       } else {
+      TopExp_Explorer expl(aShape, TopAbs_EDGE); 
+      for (; expl.More(); expl.Next()) {       
+               builder(++theTag)->Generated(expl.Current());
+         }   
+      // and load generated vertices.
+      TopTools_DataMapOfShapeShape generated;
+      if (getDangleShapes(aShape, TopAbs_EDGE, generated)) 
+         {
+               TNaming_Builder* pBuilder = builder(++theTag);
+               loadGeneratedDangleShapes(aShape, TopAbs_EDGE, pBuilder);  
+         }
+       }
+  } else if (aShape.ShapeType() == TopAbs_EDGE) {
+    TopExp_Explorer expl(aShape, TopAbs_VERTEX);
+    for (; expl.More(); expl.Next()) {      
+               builder(++theTag)->Generated(expl.Current());
+       }
+  }
+}
+//=======================================================================
+void Model_ResultBody::loadFirstLevel(
+                    boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag)
+{
+ if(theShape->isNull()) return;
+ TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();    
+  if (aShape.ShapeType() == TopAbs_COMPOUND || aShape.ShapeType() == TopAbs_COMPSOLID) {
+    TopoDS_Iterator itr(aShape);
+    for (; itr.More(); itr.Next()) {
+         builder(++theTag)->Generated(itr.Value());     
+      if (itr.Value().ShapeType() == TopAbs_COMPOUND || 
+                 itr.Value().ShapeType() == TopAbs_COMPSOLID) 
+         {
+               boost::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+        itrShape->setImpl(new TopoDS_Shape(itr.Value()));
+           loadFirstLevel(itrShape, theTag);
+      } else {
+               boost::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+        itrShape->setImpl(new TopoDS_Shape(itr.Value()));
+               loadNextLevels(itrShape, theTag);
+         }
+    }
+  } else {
+    boost::shared_ptr<GeomAPI_Shape> itrShape(new GeomAPI_Shape());
+    itrShape->setImpl(new TopoDS_Shape(aShape));
+       loadNextLevels(itrShape, theTag); 
+  }
 }
 
-void Model_ResultBody::loadDisconnectedEdges(boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag)
+//=======================================================================
+void Model_ResultBody::loadDisconnectedEdges(
+                    boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag)
 {
   if(theShape->isNull()) return;
   TopoDS_Shape aShape = theShape->impl<TopoDS_Shape>();  

diff --git a/src/Model/Model_ResultBody.h b/src/Model/Model_ResultBody.h
index 6526b9d554971e0e60dd80fb2a57d81661882d8d..45330a31e7bfff1198c6587c07e15483c87e6c3a 100644 (file)
--- a/src/Model/Model_ResultBody.h
+++ b/src/Model/Model_ResultBody.h
@@ -83,13 +83,13 @@ public:
                                                const int  theTag,
                                                GeomAPI_DataMapOfShapeShape& theSubShapes);
   
-  /// load shapes of the first level (to be used during shape import)
+  /// Loads shapes of the first level (to be used during shape import)
   MODEL_EXPORT virtual void loadFirstLevel(boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag);
   
-  /// load disconnected edges
+  /// Loads disconnected edges
   MODEL_EXPORT virtual void loadDisconnectedEdges(boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag);
 
-  /// load disconnected vetexes
+  /// Loads disconnected vetexes
   MODEL_EXPORT virtual void loadDisconnectedVertexes(boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag);
 
   /// Removes the stored builders
@@ -105,6 +105,10 @@ protected:
   /// Returns (creates if necessary) the builder created on the needed tag of sub-label
   TNaming_Builder* builder(const int theTag);
 
+private:
+  /// Loads shapes of the next level (to be used during shape import)
+  void loadNextLevels(boost::shared_ptr<GeomAPI_Shape> theShape, int&  theTag);
+
   friend class Model_Document;
 };
 

diff --git a/src/Model/Model_Update.cpp b/src/Model/Model_Update.cpp
index 7209c8aeffe0d05ca30e402ddab216210b3bb5f1..b6a4a9553860f80e52cb95204d788390132c45a0 100644 (file)
--- a/src/Model/Model_Update.cpp
+++ b/src/Model/Model_Update.cpp
@@ -159,6 +159,7 @@ bool Model_Update::updateFeature(FeaturePtr theFeature)
   if (myUpdated.find(theFeature) != myUpdated.end())
     return myUpdated[theFeature];
   // check all features this feature depended on (recursive call of updateFeature)
+  ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators();
   bool aMustbeUpdated = myInitial.find(theFeature) != myInitial.end();
   if (theFeature) {  // only real feature contains references to other objects
     if (theFeature->data()->mustBeUpdated()) aMustbeUpdated = true;
@@ -172,6 +173,12 @@ bool Model_Update::updateFeature(FeaturePtr theFeature)
         if (updateFeature(aComposite->subFeature(a)))
           aMustbeUpdated = true;
       }
+      if (aMustbeUpdated) {
+        for(int a = 0; a < aSubsNum; a++) {
+          if (aComposite->subFeature(a) && aFactory->validate(aComposite->subFeature(a)))
+            aComposite->subFeature(a)->execute();
+        }
+      }
     }
     // check all references: if referenced objects are updated, this object also must be updated
     std::list<std::pair<std::string, std::list<ObjectPtr> > > aRefs;
@@ -192,7 +199,6 @@ bool Model_Update::updateFeature(FeaturePtr theFeature)
     if (aMustbeUpdated) {
       if (boost::dynamic_pointer_cast<Model_Document>(theFeature->document())->executeFeatures() ||
           !theFeature->isPersistentResult()) {
-        ModelAPI_ValidatorsFactory* aFactory = ModelAPI_Session::get()->validators();
         if (aFactory->validate(theFeature)) {
           if (isAutomatic || (myJustCreatedOrUpdated.find(theFeature) != myJustCreatedOrUpdated.end()) ||
             !theFeature->isPersistentResult() /* execute quick, not persistent results */) 
@@ -254,32 +260,31 @@ bool Model_Update::updateFeature(FeaturePtr theFeature)
   return aMustbeUpdated;
 }
 
-bool Model_Update::updateObject(boost::shared_ptr<ModelAPI_Object> theObject)
+bool Model_Update::updateObject(boost::shared_ptr<ModelAPI_Object> theObject, const bool theCyclic)
 {
   if (myUpdated.find(theObject) != myUpdated.end())
     return myUpdated[theObject];  // already processed
-  return myInitial.find(theObject) != myInitial.end();
 
-  /* remove algorithm for update of all features by dependencies tree
-  if (!theObject)
-    return false;
-  FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
-  if (aFeature) {  // for feature just call update Feature
-    return updateFeature(aFeature);
-  }
-  // check general object, possible just a result
-  if (myUpdated.find(theObject) != myUpdated.end())
-    return myUpdated[theObject];  // already processed
-  // check the feature of this object must be executed
-  ResultPtr aResult = boost::dynamic_pointer_cast<ModelAPI_Result>(theObject);
-  if (aResult) {
-    FeaturePtr aResFeature = aResult->document()->feature(aResult);
-    if (aResFeature) {
-      return updateFeature(aResFeature);
+  /*
+  if (theCyclic) { // algorithm for update of all features by dependencies tree
+    if (!theObject)
+      return false;
+    FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(theObject);
+    if (aFeature) {  // for feature just call update Feature
+      return updateFeature(aFeature);
+    }
+    // check general object, possible just a result
+    if (myUpdated.find(theObject) != myUpdated.end())
+      return myUpdated[theObject];  // already processed
+    // check the feature of this object must be executed
+    ResultPtr aResult = boost::dynamic_pointer_cast<ModelAPI_Result>(theObject);
+    if (aResult) {
+      FeaturePtr aResFeature = aResult->document()->feature(aResult);
+      if (aResFeature) {
+        return updateFeature(aResFeature);
+      }
     }
   }
-  if (myInitial.find(theObject) != myInitial.end())
-    return true;
-  return false;  // nothing is known
   */
+  return myInitial.find(theObject) != myInitial.end();
 }

diff --git a/src/Model/Model_Update.h b/src/Model/Model_Update.h
index a29d67d8df8992286a268f6a05ee7e740236984a..ab4e4c8ff1cfeb9a4956d08b37e7f30e20329838 100644 (file)
--- a/src/Model/Model_Update.h
+++ b/src/Model/Model_Update.h
@@ -46,7 +46,7 @@ class Model_Update : public Events_Listener
 
   /// Recoursively checks and updates the object (result or feature) if needed (calls updateFeature)
   /// Returns true if object was updated.
-  bool updateObject(boost::shared_ptr<ModelAPI_Object> theObject);
+  bool updateObject(boost::shared_ptr<ModelAPI_Object> theObject, const bool theCyclic = true);
   /// Sends the redisplay events for feature and results, updates the updated status
   void redisplayWithResults(boost::shared_ptr<ModelAPI_Feature> theFeature);
 };

diff --git a/src/PartSet/PartSet_OperationFeatureEdit.cpp b/src/PartSet/PartSet_OperationFeatureEdit.cpp
index cedba1c9551be28147a4390da5470b9ce2c5eafb..c91e91b851ca127bea8839c108982e73ed4f3148 100644 (file)
--- a/src/PartSet/PartSet_OperationFeatureEdit.cpp
+++ b/src/PartSet/PartSet_OperationFeatureEdit.cpp
@@ -46,7 +46,7 @@ PartSet_OperationFeatureEdit::PartSet_OperationFeatureEdit(const QString& theId,
                                                            QObject* theParent,
                                                            CompositeFeaturePtr theFeature)
     : PartSet_OperationFeatureBase(theId, theParent, theFeature),
-      myIsBlockedSelection(false)
+      myIsBlockedSelection(false), myIsBlockedByDoubleClick(false)
 {
   myIsEditing = true;
 }
@@ -320,6 +320,11 @@ void PartSet_OperationFeatureEdit::mouseReleased(
     QMouseEvent* theEvent, ModuleBase_IViewer* theViewer,
     ModuleBase_ISelection* theSelection)
 {
+  // the block is processed in order to do not commit the transaction until the started
+  // double click functionality is performed. It is reproduced on Linux only
+  if (myIsBlockedByDoubleClick)
+    return;
+
   theViewer->enableSelection(true);
   // the next code is commented because it is obsolete by the multi edit operation realization here
   //if (myIsMultiOperation) {
@@ -365,6 +370,7 @@ void PartSet_OperationFeatureEdit::mouseDoubleClick(
     QMouseEvent* theEvent, Handle_V3d_View theView,
     ModuleBase_ISelection* theSelection)
 {
+  myIsBlockedByDoubleClick = true;
   // TODO the functionality is important only for constraint feature. Should be moved in another place
   QList<ModuleBase_ViewerPrs> aSelected = theSelection->getSelected();
   if (!aSelected.empty()) {
@@ -383,6 +389,7 @@ void PartSet_OperationFeatureEdit::mouseDoubleClick(
       }
     }
   }
+  myIsBlockedByDoubleClick  = false;
 }
 
 void PartSet_OperationFeatureEdit::startOperation()

diff --git a/src/PartSet/PartSet_OperationFeatureEdit.h b/src/PartSet/PartSet_OperationFeatureEdit.h
index a4bec4ef755da085c964743590ad3dc2dba96122..7f948d5c7a1ed62126a1457c0f80132e4cdf76cb 100644 (file)
--- a/src/PartSet/PartSet_OperationFeatureEdit.h
+++ b/src/PartSet/PartSet_OperationFeatureEdit.h
@@ -143,6 +143,8 @@ Q_OBJECT
 
   Point myCurPoint;  ///< the current 3D point clicked or moved
   bool myIsBlockedSelection;  ///< the state of the last state of selection blocked signal
+  bool myIsBlockedByDoubleClick;  ///< the block value by double click is processed to avoid
+  ///< the mouse button release processing before the double click is finished
 };
 
 #endif

diff --git a/src/PartSet/PartSet_Tools.cpp b/src/PartSet/PartSet_Tools.cpp
index 0344269bb22e4dbf1e31fd6d3b78420619048a79..b5407f6f78a49a442fa64411b5d11eedcd93b7bc 100644 (file)
--- a/src/PartSet/PartSet_Tools.cpp
+++ b/src/PartSet/PartSet_Tools.cpp
@@ -231,7 +231,7 @@ double PartSet_Tools::featureValue(FeaturePtr theFeature, const std::string& the
                                    bool& isValid)
 {
   isValid = false;
-  double aValue;
+  double aValue = 0;
   if (theFeature) {
     boost::shared_ptr<ModelAPI_Data> aData = theFeature->data();
     AttributeDoublePtr anAttribute = boost::dynamic_pointer_cast<ModelAPI_AttributeDouble>(

diff --git a/src/PartSet/PartSet_WidgetSketchLabel.cpp b/src/PartSet/PartSet_WidgetSketchLabel.cpp
index 0c4d5ccf5e158772760f62ea28fe2f8197f0c8cd..44228fdeca844f59f71fb46242f43250b712bb73 100644 (file)
--- a/src/PartSet/PartSet_WidgetSketchLabel.cpp
+++ b/src/PartSet/PartSet_WidgetSketchLabel.cpp
@@ -18,10 +18,10 @@ PartSet_WidgetSketchLabel::PartSet_WidgetSketchLabel(QWidget* theParent,
     : ModuleBase_ModelWidget(theParent, theData, theParentId)
 {
   myText = QString::fromStdString(theData->getProperty("title"));
-  myLabel = new QLabel(myText, theParent);
+  myLabel = new QLabel("", theParent);
   myLabel->setWordWrap(true);
   myTooltip = QString::fromStdString(theData->getProperty("tooltip"));
-  myLabel->setToolTip(myTooltip);
+  myLabel->setToolTip("");
   myLabel->setIndent(5);
 }