Issue #1834: Fix length of lines

diff --git a/src/GeomAPI/GeomAPI_Angle.h b/src/GeomAPI/GeomAPI_Angle.h
index f926ba9124ee0ee02453216538d18114e9d4af0c..8d87433519904b43f70e5afeba94cc63c25e1e9f 100644 (file)
--- a/src/GeomAPI/GeomAPI_Angle.h
+++ b/src/GeomAPI/GeomAPI_Angle.h
@@ -47,7 +47,8 @@ public:
   GEOMAPI_EXPORT double angleRadian();
 
   /// Returns \c true if the line is reversed during angle calculation.
-  /// If theIndex = 0, the result corresponds to the first line, if theIndex = 1, the to the second line
+  /// If theIndex = 0, the result corresponds to the first line,
+  /// if theIndex = 1, the to the second line
   GEOMAPI_EXPORT bool isReversed(int theIndex);
 };
 

diff --git a/src/GeomAPI/GeomAPI_Angle2d.h b/src/GeomAPI/GeomAPI_Angle2d.h
index eb69856245c83d28c8436abd4b68ae4d4b8f9bba..f7000e0a9d2683b981a9e68e7f2b12c0e7cf8946 100644 (file)
--- a/src/GeomAPI/GeomAPI_Angle2d.h
+++ b/src/GeomAPI/GeomAPI_Angle2d.h
@@ -47,7 +47,8 @@ public:
   GEOMAPI_EXPORT double angleRadian();
 
   /// Returns \c true if the line is reversed during angle calculation.
-  /// If theIndex = 0, the result corresponds to the first line, if theIndex = 1, the to the second line
+  /// If theIndex = 0, the result corresponds to the first line, 
+  /// if theIndex = 1, the to the second line
   GEOMAPI_EXPORT bool isReversed(int theIndex);
 };
 

diff --git a/src/GeomAPI/GeomAPI_Ax1.cpp b/src/GeomAPI/GeomAPI_Ax1.cpp
index 65bc65bb4f60d98b1992494de568347fa9bbe073..8068a3d2cb6ea4a91676545262eb1635f2bc2062 100644 (file)
--- a/src/GeomAPI/GeomAPI_Ax1.cpp
+++ b/src/GeomAPI/GeomAPI_Ax1.cpp
@@ -60,7 +60,9 @@ void GeomAPI_Ax1::reverse()
 std::shared_ptr<GeomAPI_Ax1> GeomAPI_Ax1::reversed()
 {
   gp_Ax1 anAxis = MY_AX1->Reversed();
-  std::shared_ptr<GeomAPI_Pnt> aPnt(new GeomAPI_Pnt(anAxis.Location().X(), anAxis.Location().Y(), anAxis.Location().Z()));
-  std::shared_ptr<GeomAPI_Dir> aDir(new GeomAPI_Dir(anAxis.Direction().X(), anAxis.Direction().Y(), anAxis.Direction().Z()));
+  std::shared_ptr<GeomAPI_Pnt> aPnt(
+    new GeomAPI_Pnt(anAxis.Location().X(), anAxis.Location().Y(), anAxis.Location().Z()));
+  std::shared_ptr<GeomAPI_Dir> aDir(
+    new GeomAPI_Dir(anAxis.Direction().X(), anAxis.Direction().Y(), anAxis.Direction().Z()));
   return std::shared_ptr<GeomAPI_Ax1>(new GeomAPI_Ax1(aPnt, aDir));
 }

diff --git a/src/GeomAPI/GeomAPI_Circ.cpp b/src/GeomAPI/GeomAPI_Circ.cpp
index 4346391bd457e6cec033ed857763870f12106d63..8988870caa4353d03e5cbeb454513e61837cd08a 100644 (file)
--- a/src/GeomAPI/GeomAPI_Circ.cpp
+++ b/src/GeomAPI/GeomAPI_Circ.cpp
@@ -90,7 +90,8 @@ const bool GeomAPI_Circ::parameter(const std::shared_ptr<GeomAPI_Pnt> thePoint,
                                    double& theParameter) const
 {
   Handle(Geom_Circle) aCurve = new Geom_Circle(*MY_CIRC);
-  return GeomLib_Tool::Parameter(aCurve, thePoint->impl<gp_Pnt>(), theTolerance, theParameter) == Standard_True;
+  return GeomLib_Tool::Parameter(aCurve, thePoint->impl<gp_Pnt>(), 
+                                 theTolerance, theParameter) == Standard_True;
 }
 
 //=================================================================================================

diff --git a/src/GeomAPI/GeomAPI_Circ2d.cpp b/src/GeomAPI/GeomAPI_Circ2d.cpp
index cbb16dd4be9757a23c4c84b90dc6cef6553a33ca..5edbab178a47cf77eeac99025a51608f603dc488 100644 (file)
--- a/src/GeomAPI/GeomAPI_Circ2d.cpp
+++ b/src/GeomAPI/GeomAPI_Circ2d.cpp
@@ -157,7 +157,8 @@ const bool GeomAPI_Circ2d::parameter(const std::shared_ptr<GeomAPI_Pnt2d> thePoi
                                    double& theParameter) const
 {
   Handle(Geom2d_Circle) aCurve = new Geom2d_Circle(*MY_CIRC2D);
-  return GeomLib_Tool::Parameter(aCurve, thePoint->impl<gp_Pnt2d>(), theTolerance, theParameter) == Standard_True;
+  return GeomLib_Tool::Parameter(aCurve, thePoint->impl<gp_Pnt2d>(),
+                                 theTolerance, theParameter) == Standard_True;
 }
 
 //=================================================================================================

diff --git a/src/GeomAPI/GeomAPI_DataMapOfShapeMapOfShapes.h b/src/GeomAPI/GeomAPI_DataMapOfShapeMapOfShapes.h
index 1d2c55911c524851fdf2697bbd0499a51b5d92b8..a2c020c2767e6cdce1327bbc58f6912c0a93e146 100644 (file)
--- a/src/GeomAPI/GeomAPI_DataMapOfShapeMapOfShapes.h
+++ b/src/GeomAPI/GeomAPI_DataMapOfShapeMapOfShapes.h
@@ -22,7 +22,8 @@ public:
 
   /// \brief Binds list of shapes to the key shape.
   /// \param[in] theKey key shape.
-  /// \param[in] theItems list of shapes. If shapes have duplications in list only one will be stored.
+  /// \param[in] theItems list of shapes. 
+  ///                     If shapes have duplications in list only one will be stored.
   /// \returns true if items bound successfully.
   GEOMAPI_EXPORT bool bind(const std::shared_ptr<GeomAPI_Shape> theKey,
                            const ListOfShape& theItems);

diff --git a/src/GeomAPI/GeomAPI_DataMapOfShapeShape.cpp b/src/GeomAPI/GeomAPI_DataMapOfShapeShape.cpp
index a21ac5f04297702f079461ee8e642134d5239984..a5b88c5223fe0d328fc77f099f253c51b448777d 100644 (file)
--- a/src/GeomAPI/GeomAPI_DataMapOfShapeShape.cpp
+++ b/src/GeomAPI/GeomAPI_DataMapOfShapeShape.cpp
@@ -25,11 +25,13 @@ int GeomAPI_DataMapOfShapeShape::size()
   return implPtr<TopTools_DataMapOfShapeShape>()->Extent();
 }
 
-bool GeomAPI_DataMapOfShapeShape::bind (std::shared_ptr<GeomAPI_Shape> theKey, std::shared_ptr<GeomAPI_Shape> theItem)
+bool GeomAPI_DataMapOfShapeShape::bind(std::shared_ptr<GeomAPI_Shape> theKey, 
+                                       std::shared_ptr<GeomAPI_Shape> theItem)
 {
   bool flag(false);
-  if(implPtr<TopTools_DataMapOfShapeShape>()->Bind(theKey->impl<TopoDS_Shape>(), theItem->impl<TopoDS_Shape>()))
-  flag = true;
+  if (implPtr<TopTools_DataMapOfShapeShape>()->Bind(theKey->impl<TopoDS_Shape>(), 
+                                                    theItem->impl<TopoDS_Shape>()))
+    flag = true;
   return flag;
 }
 
@@ -42,7 +44,8 @@ void GeomAPI_DataMapOfShapeShape::merge(const GeomAPI_DataMapOfShapeShape& theDa
   }
 }
 
-void GeomAPI_DataMapOfShapeShape::merge(const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theDataMap)
+void GeomAPI_DataMapOfShapeShape::
+  merge(const std::shared_ptr<GeomAPI_DataMapOfShapeShape> theDataMap)
 {
   if(theDataMap.get()) {
     merge(*theDataMap.get());
@@ -57,10 +60,12 @@ bool GeomAPI_DataMapOfShapeShape::isBound (std::shared_ptr<GeomAPI_Shape> theKey
   return flag;
 }
 
-const std::shared_ptr<GeomAPI_Shape> GeomAPI_DataMapOfShapeShape::find(std::shared_ptr<GeomAPI_Shape> theKey)
+const std::shared_ptr<GeomAPI_Shape> 
+  GeomAPI_DataMapOfShapeShape::find(std::shared_ptr<GeomAPI_Shape> theKey)
 {
   std::shared_ptr<GeomAPI_Shape> aShape(new GeomAPI_Shape());  
-  aShape->setImpl(new TopoDS_Shape(impl<TopTools_DataMapOfShapeShape>().Find(theKey->impl<TopoDS_Shape>())));
+  aShape->setImpl(
+    new TopoDS_Shape(impl<TopTools_DataMapOfShapeShape>().Find(theKey->impl<TopoDS_Shape>())));
   return aShape;
 }  
 

diff --git a/src/GeomAPI/GeomAPI_DataMapOfShapeShape.h b/src/GeomAPI/GeomAPI_DataMapOfShapeShape.h
index 2e11b8574831bc82f563262c7fde1a585429a2ba..a507f6ed27ca96574e34f5e603c7505749501b76 100644 (file)
--- a/src/GeomAPI/GeomAPI_DataMapOfShapeShape.h
+++ b/src/GeomAPI/GeomAPI_DataMapOfShapeShape.h
@@ -33,7 +33,8 @@ class GeomAPI_DataMapOfShapeShape : public GeomAPI_Interface
 
   /// Adds \a theKey to me with \a theItem. Returns True if the Key  was not already in the map.
   GEOMAPI_EXPORT
-  bool bind (const std::shared_ptr<GeomAPI_Shape> theKey, const std::shared_ptr<GeomAPI_Shape> theItem);
+  bool bind (const std::shared_ptr<GeomAPI_Shape> theKey, 
+             const std::shared_ptr<GeomAPI_Shape> theItem);
 
   /// Merges two maps.
   GEOMAPI_EXPORT void merge(const GeomAPI_DataMapOfShapeShape& theDataMap);

diff --git a/src/GeomAPI/GeomAPI_Dir.cpp b/src/GeomAPI/GeomAPI_Dir.cpp
index d9963d46cdd1c7d84dc59fc2fbfd033cd64bba7f..52cab10c0794dec65413957b979aefd33d9ab9a3 100644 (file)
--- a/src/GeomAPI/GeomAPI_Dir.cpp
+++ b/src/GeomAPI/GeomAPI_Dir.cpp
@@ -63,7 +63,8 @@ double GeomAPI_Dir::angle(const std::shared_ptr<GeomAPI_Dir>& theArg) const
   return MY_DIR->Angle(theArg->impl<gp_Dir>());
 }
 
-bool GeomAPI_Dir::isParallel(const std::shared_ptr<GeomAPI_Dir> theDir, const double theTolerance) const
+bool GeomAPI_Dir::isParallel(const std::shared_ptr<GeomAPI_Dir> theDir, 
+                             const double theTolerance) const
 {
   return MY_DIR->IsParallel(theDir->impl<gp_Dir>(), theTolerance) == Standard_True;
 }

diff --git a/src/GeomAPI/GeomAPI_Dir.h b/src/GeomAPI/GeomAPI_Dir.h
index 9b9d4f354facae598c966060af591be57614145b..6a84d1c4068a0d7598e1929ab1f8f27f4bc0672d 100644 (file)
--- a/src/GeomAPI/GeomAPI_Dir.h
+++ b/src/GeomAPI/GeomAPI_Dir.h
@@ -55,9 +55,11 @@ class GeomAPI_Dir : public GeomAPI_Interface
   GEOMAPI_EXPORT 
   double angle(const std::shared_ptr<GeomAPI_Dir>& theArg) const;
 
-  /// \return true if the angle between this unit vector and theDir unit vector is equal to 0 or to Pi.
+  /// \return true if the angle between this unit vector and 
+  /// theDir unit vector is equal to 0 or to Pi.
   GEOMAPI_EXPORT 
-  bool isParallel(const std::shared_ptr<GeomAPI_Dir> theDir, const double theTolerance = 1.e-7) const;
+  bool isParallel(const std::shared_ptr<GeomAPI_Dir> theDir, 
+                  const double theTolerance = 1.e-7) const;
 
 
 };

diff --git a/src/GeomAPI/GeomAPI_ICustomPrs.h b/src/GeomAPI/GeomAPI_ICustomPrs.h
index 2c2520ba9508f42935358c4ff69e55165113b3e8..1129c1014003383f8632cb93076913369dd01be3 100644 (file)
--- a/src/GeomAPI/GeomAPI_ICustomPrs.h
+++ b/src/GeomAPI/GeomAPI_ICustomPrs.h
@@ -26,7 +26,8 @@ public:
   GEOMAPI_EXPORT virtual ~GeomAPI_ICustomPrs();
 
   /// Modifies the given presentation in the custom way.
-  virtual bool customisePresentation(std::shared_ptr<ModelAPI_Result> theResult, AISObjectPtr thePrs,
+  virtual bool customisePresentation(std::shared_ptr<ModelAPI_Result> theResult, 
+                                     AISObjectPtr thePrs,
                                      std::shared_ptr<GeomAPI_ICustomPrs> theDefaultPrs) = 0;
 };
 

diff --git a/src/GeomAPI/GeomAPI_Lin.cpp b/src/GeomAPI/GeomAPI_Lin.cpp
index 40e456e592f7905833d6d9c37af8affb7f9e01ea..1c980e01733dbbb97b91cb07d6eee77a6f96437d 100644 (file)
--- a/src/GeomAPI/GeomAPI_Lin.cpp
+++ b/src/GeomAPI/GeomAPI_Lin.cpp
@@ -105,7 +105,8 @@ const std::shared_ptr<GeomAPI_Pnt> GeomAPI_Lin::project(
   return std::shared_ptr<GeomAPI_Pnt>(new GeomAPI_Pnt(aResult.X(), aResult.Y(), aResult.Z()));
 }
 
-bool GeomAPI_Lin::contains(const std::shared_ptr<GeomAPI_Pnt> thePoint, const double theLinearTolerance) const
+bool GeomAPI_Lin::contains(const std::shared_ptr<GeomAPI_Pnt> thePoint,
+                           const double theLinearTolerance) const
 {
   if(!thePoint.get()) {
     return false;
@@ -116,7 +117,8 @@ bool GeomAPI_Lin::contains(const std::shared_ptr<GeomAPI_Pnt> thePoint, const do
 
 bool GeomAPI_Lin::isParallel(const std::shared_ptr<GeomAPI_Lin> theLin) const
 {
-  return MY_LIN->Direction().IsParallel(theLin->impl<gp_Lin>().Direction(), Precision::Confusion()) == Standard_True;
+  return MY_LIN->Direction().IsParallel(theLin->impl<gp_Lin>().Direction(), 
+                                        Precision::Confusion()) == Standard_True;
 }
 
 bool GeomAPI_Lin::isCoplanar(const std::shared_ptr<GeomAPI_Lin> theLin) const

diff --git a/src/GeomAPI/GeomAPI_Lin.h b/src/GeomAPI/GeomAPI_Lin.h
index e9e35296a91dc2ec4ce26602168278898605f706..520c87a91fc53d9744a1b9006d8bb99ddb59d6bf 100644 (file)
--- a/src/GeomAPI/GeomAPI_Lin.h
+++ b/src/GeomAPI/GeomAPI_Lin.h
@@ -54,10 +54,12 @@ class GeomAPI_Lin : public GeomAPI_Interface
   const std::shared_ptr<GeomAPI_Pnt> project(
       const std::shared_ptr<GeomAPI_Pnt>& thePoint) const;
 
-  /// \return true if this line contains thePoint, that is, if the distance between thePoint and this line
+  /// \return true if this line contains thePoint, that is, 
+  /// if the distance between thePoint and this line
   ///         is less than or equal to theLinearTolerance.
   GEOMAPI_EXPORT
-  bool contains(const std::shared_ptr<GeomAPI_Pnt> thePoint, const double theLinearTolerance = 1.e-7) const;
+  bool contains(const std::shared_ptr<GeomAPI_Pnt> thePoint,
+                const double theLinearTolerance = 1.e-7) const;
 
   /// \return true if lines are parallel.
   GEOMAPI_EXPORT

diff --git a/src/GeomAPI/GeomAPI_Lin2d.cpp b/src/GeomAPI/GeomAPI_Lin2d.cpp
index 2d97bd6c8747d49e9af1346e2397eef2f003a089..51849328db187b0e2647f65da3d11937e9ac6cd8 100644 (file)
--- a/src/GeomAPI/GeomAPI_Lin2d.cpp
+++ b/src/GeomAPI/GeomAPI_Lin2d.cpp
@@ -103,5 +103,6 @@ std::shared_ptr<GeomAPI_Pnt2d> GeomAPI_Lin2d::shiftedLocation(double theShift) c
   aVec.Reverse();
   aVec.Scale(theShift);
   gp_Lin2d aLin = MY_LIN2D->Translated(aVec);
-  return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aLin.Location().X(), aLin.Location().Y()));
+  return std::shared_ptr<GeomAPI_Pnt2d>(new GeomAPI_Pnt2d(aLin.Location().X(), 
+                                                          aLin.Location().Y()));
 }

diff --git a/src/GeomAPI/GeomAPI_Lin2d.h b/src/GeomAPI/GeomAPI_Lin2d.h
index 7aef4793773b048eb126e8bc9ab98cd2d163073b..91cc546b71a224c1d12e346ae7d9c8c29fd8f3ed 100644 (file)
--- a/src/GeomAPI/GeomAPI_Lin2d.h
+++ b/src/GeomAPI/GeomAPI_Lin2d.h
@@ -53,7 +53,8 @@ class GeomAPI_Lin2d : public GeomAPI_Interface
   GEOMAPI_EXPORT 
   const std::shared_ptr<GeomAPI_Pnt2d> project(
       const std::shared_ptr<GeomAPI_Pnt2d>& thePoint) const;
-  /// Computes the cross product of the line direction and a vector from the line start point to the point
+  /// Computes the cross product of the line direction and a vector 
+  /// from the line start point to the point
   GEOMAPI_EXPORT 
   bool isRight(const std::shared_ptr<GeomAPI_Pnt2d>& thePoint) const;
 

diff --git a/src/GeomAPI/GeomAPI_Pln.cpp b/src/GeomAPI/GeomAPI_Pln.cpp
index b562a0c41a181b6525ef28ba5583f31c966d9396..41bf4e1c45de4cb3ac099c818e350da862a8b0d5 100644 (file)
--- a/src/GeomAPI/GeomAPI_Pln.cpp
+++ b/src/GeomAPI/GeomAPI_Pln.cpp
@@ -56,7 +56,8 @@ void GeomAPI_Pln::coefficients(double& theA, double& theB, double& theC, double&
   impl<gp_Pln>().Coefficients(theA, theB, theC, theD);
 }
 
-bool GeomAPI_Pln::isCoincident(const std::shared_ptr<GeomAPI_Pln> thePlane, const double theTolerance)
+bool GeomAPI_Pln::isCoincident(const std::shared_ptr<GeomAPI_Pln> thePlane, 
+                               const double theTolerance)
 {
   if(!thePlane.get()) {
     return false;
@@ -64,7 +65,8 @@ bool GeomAPI_Pln::isCoincident(const std::shared_ptr<GeomAPI_Pln> thePlane, cons
 
   const gp_Pln& aMyPln = impl<gp_Pln>();
   const gp_Pln& anOtherPln = thePlane->impl<gp_Pln>();
-  return (aMyPln.Contains(anOtherPln.Location(), theTolerance) && aMyPln.Axis().IsParallel(anOtherPln.Axis(), theTolerance));
+  return (aMyPln.Contains(anOtherPln.Location(), theTolerance) && 
+    aMyPln.Axis().IsParallel(anOtherPln.Axis(), theTolerance));
 }
 
 bool GeomAPI_Pln::isParallel(const std::shared_ptr<GeomAPI_Lin> theLine)
@@ -79,7 +81,8 @@ bool GeomAPI_Pln::isParallel(const std::shared_ptr<GeomAPI_Lin> theLine)
   return Abs(aDot) < Precision::SquareConfusion();
 }
 
-std::shared_ptr<GeomAPI_Pnt> GeomAPI_Pln::intersect(const std::shared_ptr<GeomAPI_Lin>& theLine) const
+std::shared_ptr<GeomAPI_Pnt> 
+  GeomAPI_Pln::intersect(const std::shared_ptr<GeomAPI_Lin>& theLine) const
 {
   std::shared_ptr<GeomAPI_XYZ> aLineDir = theLine->direction()->xyz();
   std::shared_ptr<GeomAPI_XYZ> aLineLoc = theLine->location()->xyz();
@@ -92,10 +95,12 @@ std::shared_ptr<GeomAPI_Pnt> GeomAPI_Pln::intersect(const std::shared_ptr<GeomAP
     return std::shared_ptr<GeomAPI_Pnt>();
 
   double aParam = aNormal->dot(aLocation->decreased(aLineLoc)) / aDot;
-  return std::shared_ptr<GeomAPI_Pnt>(new GeomAPI_Pnt(aLineLoc->added(aLineDir->multiplied(aParam))));
+  return std::shared_ptr<GeomAPI_Pnt>(
+    new GeomAPI_Pnt(aLineLoc->added(aLineDir->multiplied(aParam))));
 }
 
-std::shared_ptr<GeomAPI_Pnt> GeomAPI_Pln::project(const std::shared_ptr<GeomAPI_Pnt>& thePoint) const
+std::shared_ptr<GeomAPI_Pnt> 
+  GeomAPI_Pln::project(const std::shared_ptr<GeomAPI_Pnt>& thePoint) const
 {
   std::shared_ptr<GeomAPI_XYZ> aNormal = direction()->xyz();
   std::shared_ptr<GeomAPI_XYZ> aLocation = location()->xyz();
@@ -123,7 +128,8 @@ void GeomAPI_Pln::translate(const std::shared_ptr<GeomAPI_Dir> theDir, double th
   implPtr<gp_Pln>()->Translate(aVec);
 }
 
-std::shared_ptr<GeomAPI_Lin> GeomAPI_Pln::intersect(const std::shared_ptr<GeomAPI_Pln> thePlane) const
+std::shared_ptr<GeomAPI_Lin>
+  GeomAPI_Pln::intersect(const std::shared_ptr<GeomAPI_Pln> thePlane) const
 {
   std::shared_ptr<GeomAPI_Lin> aRes;
 

diff --git a/src/GeomAPI/GeomAPI_Shape.cpp b/src/GeomAPI/GeomAPI_Shape.cpp
index 5a520fb7cc6b1c43681cd04eac5b33979a2a5c49..31cb110865df2e86b133897fbad114647aa0c2fb 100644 (file)
--- a/src/GeomAPI/GeomAPI_Shape.cpp
+++ b/src/GeomAPI/GeomAPI_Shape.cpp
@@ -117,7 +117,8 @@ bool GeomAPI_Shape::isConnectedTopology() const
   const TopoDS_Shape& aShape = const_cast<GeomAPI_Shape*>(this)->impl<TopoDS_Shape>();
   if (aShape.IsNull() || aShape.ShapeType() != TopAbs_COMPOUND)
     return false;
-  NCollection_List<TopoDS_Shape> aNotConnected; // list of simple elements that are not detected in connection to others
+  // list of simple elements that are not detected in connection to others
+  NCollection_List<TopoDS_Shape> aNotConnected; 
   addSimpleToList(aShape, aNotConnected);
   if (aNotConnected.IsEmpty()) // an empty compound
     return false;
@@ -140,7 +141,8 @@ bool GeomAPI_Shape::isConnectedTopology() const
       bool aConnected =  false;
       NCollection_List<TopoDS_Shape>::Iterator aNewIter(aNewConnected);
       for(; !aConnected && aNewIter.More(); aNewIter.Next()) {
-        // checking topological connecion of aNotIter and aNewIter (if shapes are connected, vertices are connected for sure)
+        // checking topological connecion of aNotIter and aNewIter 
+        // (if shapes are connected, vertices are connected for sure)
         TopExp_Explorer anExp2(aNewIter.Value(), TopAbs_VERTEX);
         for(; !aConnected && anExp2.More(); anExp2.Next()) {
           NCollection_List<TopoDS_Shape>::Iterator aNotIter(aNotVertices);
@@ -207,7 +209,8 @@ bool GeomAPI_Shape::isPlanar() const
     Handle(Standard_Type) aType = aSurface->DynamicType();
 
     if(aType == STANDARD_TYPE(Geom_RectangularTrimmedSurface)) {
-      Handle(Geom_RectangularTrimmedSurface) aTrimSurface = Handle(Geom_RectangularTrimmedSurface)::DownCast(aSurface);
+      Handle(Geom_RectangularTrimmedSurface) aTrimSurface =
+        Handle(Geom_RectangularTrimmedSurface)::DownCast(aSurface);
       aType = aTrimSurface->BasisSurface()->DynamicType();
     }
     return (aType == STANDARD_TYPE(Geom_Plane)) == Standard_True;

diff --git a/src/GeomAPI/GeomAPI_ShapeExplorer.h b/src/GeomAPI/GeomAPI_ShapeExplorer.h
index 44320fa641f122c653fab52a3a437c791394e4cc..896a65b5a21d871730e58a93fb53db4481ced00f 100644 (file)
--- a/src/GeomAPI/GeomAPI_ShapeExplorer.h
+++ b/src/GeomAPI/GeomAPI_ShapeExplorer.h
@@ -49,11 +49,13 @@ public:
   GEOMAPI_EXPORT
   bool more() const;
 
-  /// Moves to the next Shape in the exploration or do nothing if there are no more shapes to explore.
+  /// Moves to the next Shape in the exploration or do nothing
+  /// if there are no more shapes to explore.
   GEOMAPI_EXPORT
   void next();
 
-  /// \return the current shape in the exploration or empty pointer if this explorer has no more shapes to explore.
+  /// \return the current shape in the exploration or empty pointer
+  /// if this explorer has no more shapes to explore.
   GEOMAPI_EXPORT
   std::shared_ptr<GeomAPI_Shape> current();
 

diff --git a/src/GeomAPI/GeomAPI_ShapeIterator.h b/src/GeomAPI/GeomAPI_ShapeIterator.h
index 098f1710e25e005b50acbbb0452a49f6b1764ee1..25a40590de6cd056068836d6be1ca9c7e345405b 100644 (file)
--- a/src/GeomAPI/GeomAPI_ShapeIterator.h
+++ b/src/GeomAPI/GeomAPI_ShapeIterator.h
@@ -12,7 +12,8 @@
 
 /// \class GeomAPI_ShapeIterator
 /// \ingroup DataModel
-/// \brief Iterates on the underlying shape underlying a given GeomAPI_Shape object, providing access
+/// \brief Iterates on the underlying shape underlying a given GeomAPI_Shape object, 
+///        providing access
 ///        to its component sub-shapes. Each component shape is returned as a GeomAPI_Shape with
 ///        an orientation, and a compound of the original values and the relative values.
 class GeomAPI_ShapeIterator : public GeomAPI_Interface

diff --git a/src/GeomData/GeomData_Point.cpp b/src/GeomData/GeomData_Point.cpp
index 9ceced262ea3fa533b192dd00e79dee5471b0732..8f5923df1a85b469687b7ca81f2c807f018f0543 100644 (file)
--- a/src/GeomData/GeomData_Point.cpp
+++ b/src/GeomData/GeomData_Point.cpp
@@ -125,7 +125,8 @@ std::string GeomData_Point::expressionError(int theComponent)
   return myExpression[theComponent]->error();
 }
 
-void GeomData_Point::setUsedParameters(int theComponent, const std::set<std::string>& theUsedParameters)
+void GeomData_Point::setUsedParameters(int theComponent,
+                                       const std::set<std::string>& theUsedParameters)
 {
   assert(theComponent >= 0 && theComponent < NUM_COMPONENTS);
   myExpression[theComponent]->setUsedParameters(theUsedParameters);

diff --git a/src/GeomData/GeomData_Point.h b/src/GeomData/GeomData_Point.h
index 8936ffef82462bb4abdf1bac10f12fb502544f68..e6dc4ba55f8411abc90c2c3f5d8771376f236615 100644 (file)
--- a/src/GeomData/GeomData_Point.h
+++ b/src/GeomData/GeomData_Point.h
@@ -21,7 +21,8 @@ class ModelAPI_ExpressionDouble;
 class GeomData_Point : public GeomDataAPI_Point
 {
   enum { NUM_COMPONENTS = 3 };
-  std::shared_ptr<ModelAPI_ExpressionDouble> myExpression[NUM_COMPONENTS]; ///< Expressions for X, Y and Z 
+  /// Expressions for X, Y and Z 
+  std::shared_ptr<ModelAPI_ExpressionDouble> myExpression[NUM_COMPONENTS]; 
  public:
   /// Defines the double value
   GEOMDATA_EXPORT virtual void setValue(const double theX, const double theY, const double theZ);
@@ -38,7 +39,8 @@ class GeomData_Point : public GeomDataAPI_Point
   GEOMDATA_EXPORT virtual std::shared_ptr<GeomAPI_Pnt> pnt();
 
   /// Defines the calculated double value
-  GEOMDATA_EXPORT virtual void setCalculatedValue(const double theX, const double theY, const double theZ);
+  GEOMDATA_EXPORT virtual 
+    void setCalculatedValue(const double theX, const double theY, const double theZ);
 
   /// Defines the text values
   GEOMDATA_EXPORT virtual void setText(const std::string& theX,

diff --git a/src/GeomData/GeomData_Point2D.cpp b/src/GeomData/GeomData_Point2D.cpp
index 7c9cb73e31de9b7c7f36962aa99145366aa62da5..6873674b073f3cb9b0d0dfc718dd38f91ac8e42a 100644 (file)
--- a/src/GeomData/GeomData_Point2D.cpp
+++ b/src/GeomData/GeomData_Point2D.cpp
@@ -114,7 +114,8 @@ std::string GeomData_Point2D::expressionError(int theComponent)
   return myExpression[theComponent]->error();
 }
 
-void GeomData_Point2D::setUsedParameters(int theComponent, const std::set<std::string>& theUsedParameters)
+void GeomData_Point2D::setUsedParameters(int theComponent, 
+                                         const std::set<std::string>& theUsedParameters)
 {
   assert(theComponent >= 0 && theComponent < NUM_COMPONENTS);
   myExpression[theComponent]->setUsedParameters(theUsedParameters);

diff --git a/src/GeomDataAPI/GeomDataAPI_Point.h b/src/GeomDataAPI/GeomDataAPI_Point.h
index ffa07285da1df05d445247c5f30eefba756d4aee..a68e0762b7e734deeae3e0f1bbb686599e6077c2 100644 (file)
--- a/src/GeomDataAPI/GeomDataAPI_Point.h
+++ b/src/GeomDataAPI/GeomDataAPI_Point.h
@@ -23,7 +23,8 @@ class GeomDataAPI_Point : public ModelAPI_Attribute
 {
  public:
   /// Defines the double value
-  GEOMDATAAPI_EXPORT virtual void setValue(const double theX, const double theY, const double theZ) = 0;
+  GEOMDATAAPI_EXPORT virtual 
+    void setValue(const double theX, const double theY, const double theZ) = 0;
   /// Defines the point
   GEOMDATAAPI_EXPORT virtual void setValue(const std::shared_ptr<GeomAPI_Pnt>& thePoint) = 0;
 
@@ -37,7 +38,8 @@ class GeomDataAPI_Point : public ModelAPI_Attribute
   GEOMDATAAPI_EXPORT virtual std::shared_ptr<GeomAPI_Pnt> pnt() = 0;
 
   /// Defines the calculated double value
-  GEOMDATAAPI_EXPORT virtual void setCalculatedValue(const double theX, const double theY, const double theZ) = 0;
+  GEOMDATAAPI_EXPORT virtual 
+    void setCalculatedValue(const double theX, const double theY, const double theZ) = 0;
   
   /// Defines the text values
   GEOMDATAAPI_EXPORT virtual void setText(const std::string& theX,
@@ -64,7 +66,8 @@ class GeomDataAPI_Point : public ModelAPI_Attribute
   GEOMDATAAPI_EXPORT virtual bool expressionInvalid(int theComponent) = 0;
 
   /// Allows to set expression (text) error (by the parameters listener)
-  GEOMDATAAPI_EXPORT virtual void setExpressionError(int theComponent, const std::string& theError) = 0;
+  GEOMDATAAPI_EXPORT virtual 
+    void setExpressionError(int theComponent, const std::string& theError) = 0;
 
   /// Returns an expression error
   GEOMDATAAPI_EXPORT virtual std::string expressionError(int theComponent) = 0;

diff --git a/src/GeomDataAPI/GeomDataAPI_Point2D.h b/src/GeomDataAPI/GeomDataAPI_Point2D.h
index 633ef82559676141f9cf52c9d24ab22490fc8aa4..fa8a571585f04aa8cfc2e9592c68ad31081f60c8 100644 (file)
--- a/src/GeomDataAPI/GeomDataAPI_Point2D.h
+++ b/src/GeomDataAPI/GeomDataAPI_Point2D.h
@@ -59,7 +59,8 @@ class GeomDataAPI_Point2D : public ModelAPI_Attribute
   GEOMDATAAPI_EXPORT virtual bool expressionInvalid(int theComponent) = 0;
 
   /// Allows to set expression (text) error (by the parameters listener)
-  GEOMDATAAPI_EXPORT virtual void setExpressionError(int theComponent, const std::string& theError) = 0;
+  GEOMDATAAPI_EXPORT virtual 
+    void setExpressionError(int theComponent, const std::string& theError) = 0;
 
   /// Returns an expression error
   GEOMDATAAPI_EXPORT virtual std::string expressionError(int theComponent) = 0;

diff --git a/src/GeomValidators/GeomValidators_BodyShapes.cpp b/src/GeomValidators/GeomValidators_BodyShapes.cpp
index 504daa4afda22792eb6f04cd8881092d173e6621..56068837aa9a90bc81e791632ceef4c410506bdf 100644 (file)
--- a/src/GeomValidators/GeomValidators_BodyShapes.cpp
+++ b/src/GeomValidators/GeomValidators_BodyShapes.cpp
@@ -26,7 +26,8 @@ bool GeomValidators_BodyShapes::isValid(const AttributePtr& theAttribute,
       return false;
     }
 
-    ResultConstructionPtr aResultConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
+    ResultConstructionPtr aResultConstruction =
+      std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
     if(aResultConstruction.get()) {
       theError = "Error: Result construction selected.";
       return false;

diff --git a/src/GeomValidators/GeomValidators_BooleanArguments.cpp b/src/GeomValidators/GeomValidators_BooleanArguments.cpp
index 1db13e60781757bc3043e877fe1bb9da7beaa294..92a598c7b722a9a0dc36f504613ff1cf98e52be8 100644 (file)
--- a/src/GeomValidators/GeomValidators_BooleanArguments.cpp
+++ b/src/GeomValidators/GeomValidators_BooleanArguments.cpp
@@ -54,7 +54,8 @@ bool GeomValidators_BooleanArguments::isValid(const std::shared_ptr<ModelAPI_Fea
 }
 
 //=================================================================================================
-bool GeomValidators_BooleanArguments::isNotObligatory(std::string theFeature, std::string theAttribute)
+bool GeomValidators_BooleanArguments::isNotObligatory(std::string theFeature, 
+                                                      std::string theAttribute)
 {
   if(theAttribute == "main_objects" || theAttribute == "tool_objects") {
     return true;

diff --git a/src/GeomValidators/GeomValidators_BooleanArguments.h b/src/GeomValidators/GeomValidators_BooleanArguments.h
index 42a46d53a2d6ae91c20c59e2019431050106fd38..645eee951ca915db616da56a94d8d1e3aafebcbe 100644 (file)
--- a/src/GeomValidators/GeomValidators_BooleanArguments.h
+++ b/src/GeomValidators/GeomValidators_BooleanArguments.h
@@ -29,7 +29,8 @@ public:
                                              Events_InfoMessage& theError) const;
 
   /// \return true if the attribute in feature is not obligatory for the feature execution.
-  GEOMVALIDATORS_EXPORT virtual bool isNotObligatory(std::string theFeature, std::string theAttribute);
+  GEOMVALIDATORS_EXPORT virtual 
+    bool isNotObligatory(std::string theFeature, std::string theAttribute);
 };
 
 #endif

diff --git a/src/GeomValidators/GeomValidators_Different.cpp b/src/GeomValidators/GeomValidators_Different.cpp
index 8c324f40b70ec2ce2c9d2a8560cc340f7a8e0535..1f75317b3885af38e613e6ac227e5989bbe9fc3f 100644 (file)
--- a/src/GeomValidators/GeomValidators_Different.cpp
+++ b/src/GeomValidators/GeomValidators_Different.cpp
@@ -69,7 +69,8 @@ bool GeomValidators_Different::isValid(const std::shared_ptr<ModelAPI_Feature>&
   }
 
   // Search differences inside each attribute list
-  std::map<std::string, std::list<AttributePtr> >::const_iterator anAttributesMapIt = anAttributesMap.begin();
+  std::map<std::string, std::list<AttributePtr> >::const_iterator 
+    anAttributesMapIt = anAttributesMap.begin();
   for (; anAttributesMapIt != anAttributesMap.end(); ++anAttributesMapIt) {
     const std::list<AttributePtr>& anAttributes = anAttributesMapIt->second;
     // for the list of attributes check that all elements are unique
@@ -81,7 +82,8 @@ bool GeomValidators_Different::isValid(const std::shared_ptr<ModelAPI_Feature>&
         std::list<AttributePtr>::const_iterator aFindIt =
             std::find_if(aNextIt, anAttributes.end(), IsEqual(*anAttributeIt));
         if (aFindIt != anAttributes.end()) {
-          theError = "Attributes " + (*anAttributeIt)->id() + " and " + (*aFindIt)->id() + " are equal." ;
+          theError = "Attributes " + (*anAttributeIt)->id() + " and " + 
+            (*aFindIt)->id() + " are equal." ;
           return false;
         }
         ++anAttributeIt;

diff --git a/src/GeomValidators/GeomValidators_Different.h b/src/GeomValidators/GeomValidators_Different.h
index e5d7e15bf5ddb7f5177af0bd564c0e996e4b0424..61fbeb0d760e98d5ab1622f341a3a736159107f8 100644 (file)
--- a/src/GeomValidators/GeomValidators_Different.h
+++ b/src/GeomValidators/GeomValidators_Different.h
@@ -28,7 +28,8 @@ public:
                                              const std::list<std::string>& theArguments,
                                              Events_InfoMessage& theError) const;
 
-  GEOMVALIDATORS_EXPORT virtual bool isNotObligatory(std::string theFeature, std::string theAttribute);
+  GEOMVALIDATORS_EXPORT virtual 
+    bool isNotObligatory(std::string theFeature, std::string theAttribute);
 };
 
 #endif

diff --git a/src/GeomValidators/GeomValidators_Finite.cpp b/src/GeomValidators/GeomValidators_Finite.cpp
index 67f8d70c94687efd4e836ed10ad9d8589e9928ea..c8f5d02ad17121e3a4707accc5f64f789fa9607d 100755 (executable)
--- a/src/GeomValidators/GeomValidators_Finite.cpp
+++ b/src/GeomValidators/GeomValidators_Finite.cpp
@@ -20,9 +20,11 @@ bool GeomValidators_Finite::isValid(const AttributePtr& theAttribute,
   const std::string anAttributeType = theAttribute->attributeType();
 
   if(anAttributeType == ModelAPI_AttributeSelection::typeId()) {
-    AttributeSelectionPtr aSelectionAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+    AttributeSelectionPtr aSelectionAttr = 
+      std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
     ResultPtr aResult = aSelectionAttr->context();
-    ResultConstructionPtr aConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aResult);
+    ResultConstructionPtr aConstruction = 
+      std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aResult);
     if (aConstruction.get() && aConstruction->isInfinite()) {
       aValid = false;
       theError = "Infinite result is selected.";
@@ -34,7 +36,8 @@ bool GeomValidators_Finite::isValid(const AttributePtr& theAttribute,
       AttributeSelectionPtr aSelectAttr = aSelectionListAttr->value(i);
       ResultPtr aResult = aSelectAttr->context();
       if (aResult.get() && aResult->groupName() == ModelAPI_ResultConstruction::group()) {
-        ResultConstructionPtr aConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aResult);
+        ResultConstructionPtr aConstruction = 
+          std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aResult);
         if (aConstruction.get() && aConstruction->isInfinite()) {
           aValid = false;
           theError = "Infinite result is selected.";

diff --git a/src/GeomValidators/GeomValidators_IntersectionSelection.cpp b/src/GeomValidators/GeomValidators_IntersectionSelection.cpp
index 039b0eda7b8484991d5bb3ded885bf7147c864e8..9e108be806edc1d468a64d67ac231cb8cfbe8170 100644 (file)
--- a/src/GeomValidators/GeomValidators_IntersectionSelection.cpp
+++ b/src/GeomValidators/GeomValidators_IntersectionSelection.cpp
@@ -21,7 +21,8 @@ bool GeomValidators_IntersectionSelection::isValid(const AttributePtr& theAttrib
     return false;
   }
   FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttribute->owner());
-  AttributeSelectionListPtr anAttrSelectionList = std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
+  AttributeSelectionListPtr anAttrSelectionList = 
+    std::dynamic_pointer_cast<ModelAPI_AttributeSelectionList>(theAttribute);
   for(int anIndex = 0; anIndex < anAttrSelectionList->size(); ++anIndex) {
     AttributeSelectionPtr anAttrSelection = anAttrSelectionList->value(anIndex);
     if(!anAttrSelection.get()) {

diff --git a/src/GeomValidators/GeomValidators_MinObjectsSelected.cpp b/src/GeomValidators/GeomValidators_MinObjectsSelected.cpp
index 29167f8d06c59517ae2e5406a2a515a890fc1b57..31f8d0c3d79fe05047d7d418a111841238ef700c 100644 (file)
--- a/src/GeomValidators/GeomValidators_MinObjectsSelected.cpp
+++ b/src/GeomValidators/GeomValidators_MinObjectsSelected.cpp
@@ -17,7 +17,8 @@ bool GeomValidators_MinObjectsSelected::isValid(const std::shared_ptr<ModelAPI_F
                                                 Events_InfoMessage& theError) const
 {
   if(theArguments.size() != 2) {
-    theError = "Error: Wrong number of arguments (expected 2): selection list id and min number of objects";
+    theError = 
+      "Error: Wrong number of arguments (expected 2): selection list id and min number of objects";
     return false;
   }
 
@@ -41,8 +42,9 @@ bool GeomValidators_MinObjectsSelected::isValid(const std::shared_ptr<ModelAPI_F
   return true;
 }
 
-//=================================================================================================
-bool GeomValidators_MinObjectsSelected::isNotObligatory(std::string theFeature, std::string theAttribute)
+//================================================================================================
+bool GeomValidators_MinObjectsSelected::isNotObligatory(std::string theFeature, 
+                                                        std::string theAttribute)
 {
   return false;
 }

diff --git a/src/GeomValidators/GeomValidators_MinObjectsSelected.h b/src/GeomValidators/GeomValidators_MinObjectsSelected.h
index 27f860c8184bdc9fa8202374dc8632de7f47489b..45f889348230f9a0b923433a4b5d373ef0b0e440 100644 (file)
--- a/src/GeomValidators/GeomValidators_MinObjectsSelected.h
+++ b/src/GeomValidators/GeomValidators_MinObjectsSelected.h
@@ -27,7 +27,8 @@ public:
                                              Events_InfoMessage& theError) const;
 
   /// \return true if the attribute in feature is not obligatory for the feature execution.
-  GEOMVALIDATORS_EXPORT virtual bool isNotObligatory(std::string theFeature, std::string theAttribute);
+  GEOMVALIDATORS_EXPORT virtual bool isNotObligatory(std::string theFeature,
+                                                     std::string theAttribute);
 };
 
 #endif

diff --git a/src/GeomValidators/GeomValidators_PartitionArguments.cpp b/src/GeomValidators/GeomValidators_PartitionArguments.cpp
index 9d017b017e3857fb9a285735af85bf8bc115580b..ab60b8ea682887d51bd02b71a4eba105cb3263ac 100644 (file)
--- a/src/GeomValidators/GeomValidators_PartitionArguments.cpp
+++ b/src/GeomValidators/GeomValidators_PartitionArguments.cpp
@@ -43,7 +43,8 @@ bool GeomValidators_PartitionArguments::isValid(const std::shared_ptr<ModelAPI_F
     isCombine = anAttrBool->value();
   }
 
-  if((anObjectsNb > 0 && aToolsNb > 0) || (isCombine && anObjectsNb != 0 && (anObjectsNb + aToolsNb > 1))) {
+  if((anObjectsNb > 0 && aToolsNb > 0) || 
+     (isCombine && anObjectsNb != 0 && (anObjectsNb + aToolsNb > 1))) {
     return true;
   }
 
@@ -52,7 +53,8 @@ bool GeomValidators_PartitionArguments::isValid(const std::shared_ptr<ModelAPI_F
 }
 
 //=================================================================================================
-bool GeomValidators_PartitionArguments::isNotObligatory(std::string theFeature, std::string theAttribute)
+bool GeomValidators_PartitionArguments::isNotObligatory(std::string theFeature, 
+                                                        std::string theAttribute)
 {
   if(theAttribute == "tool_objects") {
     return true;

diff --git a/src/GeomValidators/GeomValidators_PartitionArguments.h b/src/GeomValidators/GeomValidators_PartitionArguments.h
index 6d7c3a8336d623f7c7efbe08d84095fcd51b6a09..23397a117b526cfc0a578341f1c354b2d3dd1f4a 100644 (file)
--- a/src/GeomValidators/GeomValidators_PartitionArguments.h
+++ b/src/GeomValidators/GeomValidators_PartitionArguments.h
@@ -29,7 +29,8 @@ public:
                                              Events_InfoMessage& theError) const;
 
   /// \return true if the attribute in feature is not obligatory for the feature execution.
-  GEOMVALIDATORS_EXPORT virtual bool isNotObligatory(std::string theFeature, std::string theAttribute);
+  GEOMVALIDATORS_EXPORT virtual 
+    bool isNotObligatory(std::string theFeature, std::string theAttribute);
 };
 
 #endif

diff --git a/src/GeomValidators/GeomValidators_Plugin.cpp b/src/GeomValidators/GeomValidators_Plugin.cpp
index 9b99ffc852230d5d43f259e6262172cfe818016a..e231c32a78b48678933b778a5683ce577ae7f93e 100644 (file)
--- a/src/GeomValidators/GeomValidators_Plugin.cpp
+++ b/src/GeomValidators/GeomValidators_Plugin.cpp
@@ -29,18 +29,24 @@ GeomValidators_Plugin::GeomValidators_Plugin()
   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
 
   aFactory->registerValidator("GeomValidators_BodyShapes", new GeomValidators_BodyShapes);
-  aFactory->registerValidator("GeomValidators_BooleanArguments", new GeomValidators_BooleanArguments);
-  aFactory->registerValidator("GeomValidators_ConstructionComposite", new GeomValidators_ConstructionComposite);
+  aFactory->registerValidator("GeomValidators_BooleanArguments",
+                              new GeomValidators_BooleanArguments);
+  aFactory->registerValidator("GeomValidators_ConstructionComposite",
+                              new GeomValidators_ConstructionComposite);
   aFactory->registerValidator("GeomValidators_Different", new GeomValidators_Different);
-  aFactory->registerValidator("GeomValidators_DifferentShapes", new GeomValidators_DifferentShapes);
+  aFactory->registerValidator("GeomValidators_DifferentShapes",
+                              new GeomValidators_DifferentShapes);
   aFactory->registerValidator("GeomValidators_Face", new GeomValidators_Face);
   aFactory->registerValidator("GeomValidators_Finite", new GeomValidators_Finite);
-  aFactory->registerValidator("GeomValidators_PartitionArguments", new GeomValidators_PartitionArguments);
+  aFactory->registerValidator("GeomValidators_PartitionArguments",
+                              new GeomValidators_PartitionArguments);
   aFactory->registerValidator("GeomValidators_ShapeType", new GeomValidators_ShapeType);
   aFactory->registerValidator("GeomValidators_ZeroOffset", new GeomValidators_ZeroOffset);
-  aFactory->registerValidator("GeomValidators_IntersectionSelection", new GeomValidators_IntersectionSelection);
+  aFactory->registerValidator("GeomValidators_IntersectionSelection", 
+                              new GeomValidators_IntersectionSelection);
   aFactory->registerValidator("GeomValidators_FeatureKind", new GeomValidators_FeatureKind);
-  aFactory->registerValidator("GeomValidators_MinObjectsSelected", new GeomValidators_MinObjectsSelected);
+  aFactory->registerValidator("GeomValidators_MinObjectsSelected", 
+                              new GeomValidators_MinObjectsSelected);
 
   // register this plugin
   ModelAPI_Session::get()->registerPlugin(this);

diff --git a/src/GeomValidators/GeomValidators_ShapeType.cpp b/src/GeomValidators/GeomValidators_ShapeType.cpp
index 4991b92255b5a93d81c8b9ad393c1a656381eed3..022704317c4107941729ab8fe14e06488a8c9621 100755 (executable)
--- a/src/GeomValidators/GeomValidators_ShapeType.cpp
+++ b/src/GeomValidators/GeomValidators_ShapeType.cpp
@@ -22,7 +22,8 @@
 typedef std::map<std::string, GeomValidators_ShapeType::TypeOfShape> EdgeTypes;
 
 static EdgeTypes MyShapeTypes;
-GeomValidators_ShapeType::TypeOfShape GeomValidators_ShapeType::shapeType(const std::string& theType)
+GeomValidators_ShapeType::TypeOfShape 
+  GeomValidators_ShapeType::shapeType(const std::string& theType)
 {
   if (MyShapeTypes.size() == 0) {
     MyShapeTypes["empty"]     = Empty;
@@ -51,8 +52,8 @@ std::string getShapeTypeDescription(const GeomValidators_ShapeType::TypeOfShape&
   std::string aValue = "";
 
   if (MyShapeTypes.size() != 0) {
-    std::map<std::string, GeomValidators_ShapeType::TypeOfShape>::const_iterator anIt = MyShapeTypes.begin(),
-                                                                                 aLast = MyShapeTypes.end();
+    std::map<std::string, GeomValidators_ShapeType::TypeOfShape>::const_iterator 
+      anIt = MyShapeTypes.begin(), aLast = MyShapeTypes.end();
     for (; anIt != aLast; anIt++) {
       if (anIt->second == theType)
         aValue = anIt->first;
@@ -90,7 +91,8 @@ bool GeomValidators_ShapeType::isValid(const AttributePtr& theAttribute,
       if (!aTypes.empty())
         aTypes += ", ";
     }
-    theError = "It does not contain element with acceptable shape type. The type should be one of the next: %1";
+    theError = "It does not contain element with acceptable shape type. \
+ The type should be one of the next: %1";
     theError.arg(aTypes);
   }
 
@@ -105,7 +107,8 @@ bool GeomValidators_ShapeType::isValidAttribute(const AttributePtr& theAttribute
 
   std::string anAttributeType = theAttribute->attributeType();
   if (anAttributeType == ModelAPI_AttributeSelection::typeId()) {
-    AttributeSelectionPtr anAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+    AttributeSelectionPtr anAttr = 
+      std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
     GeomShapePtr aShape = anAttr->value();
     if (aShape.get())
       aValid = isValidShape(aShape, theShapeType, theError);
@@ -175,7 +178,8 @@ bool GeomValidators_ShapeType::isValidObject(const ObjectPtr& theObject,
     ResultPtr aResult = std::dynamic_pointer_cast<ModelAPI_Result>(theObject);
     if( theShapeType==Plane )
     {
-      ResultConstructionPtr aResultConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(theObject);
+      ResultConstructionPtr aResultConstruction = 
+        std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(theObject);
       FeaturePtr aFeature = ModelAPI_Feature::feature(theObject);
       const std::string& aKind = aFeature->getKind();
       return aResult.get() != NULL && aKind == "Plane";

diff --git a/src/GeomValidators/GeomValidators_Tools.cpp b/src/GeomValidators/GeomValidators_Tools.cpp
index ef49c197d24bd69d48ae8108bb351b6c4509252e..d9136fe2fa4b1121f611102f8c3f19584aced617 100644 (file)
--- a/src/GeomValidators/GeomValidators_Tools.cpp
+++ b/src/GeomValidators/GeomValidators_Tools.cpp
@@ -19,17 +19,20 @@ namespace GeomValidators_Tools {
     ObjectPtr anObject;
     std::string anAttrType = theAttribute->attributeType();
     if (anAttrType == ModelAPI_AttributeRefAttr::typeId()) {
-      AttributeRefAttrPtr anAttr = std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
+      AttributeRefAttrPtr anAttr = 
+        std::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
       if (anAttr != NULL && anAttr->isObject())
         anObject = anAttr->object();
     }
     if (anAttrType == ModelAPI_AttributeSelection::typeId()) {
-      AttributeSelectionPtr anAttr = std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
+      AttributeSelectionPtr anAttr = 
+        std::dynamic_pointer_cast<ModelAPI_AttributeSelection>(theAttribute);
       if (anAttr != NULL)
         anObject = anAttr->context();
     }
     if (anAttrType == ModelAPI_AttributeReference::typeId()) {
-      AttributeReferencePtr anAttr = std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
+      AttributeReferencePtr anAttr = 
+        std::dynamic_pointer_cast<ModelAPI_AttributeReference>(theAttribute);
       if (anAttr.get() != NULL)
         anObject = anAttr->value();
     }

diff --git a/src/GeomValidators/GeomValidators_ZeroOffset.cpp b/src/GeomValidators/GeomValidators_ZeroOffset.cpp
index e66cc4333b21256e55797b78894ddb9da9adad57..34aec623f19c73f82b40afca3c36832132c64af2 100644 (file)
--- a/src/GeomValidators/GeomValidators_ZeroOffset.cpp
+++ b/src/GeomValidators/GeomValidators_ZeroOffset.cpp
@@ -43,11 +43,13 @@ bool GeomValidators_ZeroOffset::isValid(const std::shared_ptr<ModelAPI_Feature>&
   ListOfShape aFacesList;
   if(theFeature->selection(*anIt)) {
     AttributeSelectionPtr aFaceSelection = theFeature->selection(*anIt);
-    ResultConstructionPtr aConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aFaceSelection->context());
+    ResultConstructionPtr aConstruction = 
+      std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aFaceSelection->context());
     if(aConstruction.get()) {
       int aSketchFacesNum = aConstruction->facesNum();
       for(int aFaceIndex = 0; aFaceIndex < aSketchFacesNum; aFaceIndex++) {
-        std::shared_ptr<GeomAPI_Shape> aFace = std::dynamic_pointer_cast<GeomAPI_Shape>(aConstruction->face(aFaceIndex));
+        std::shared_ptr<GeomAPI_Shape> aFace = 
+          std::dynamic_pointer_cast<GeomAPI_Shape>(aConstruction->face(aFaceIndex));
         if(aFace->isFace() && aFace->isPlanar()) {
           aFacesList.push_back(aFace);
         }
@@ -68,7 +70,8 @@ bool GeomValidators_ZeroOffset::isValid(const std::shared_ptr<ModelAPI_Feature>&
         if(!aContextShape.get()) {
           break;
         }
-        ResultConstructionPtr aConstruction = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
+        ResultConstructionPtr aConstruction = 
+          std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(aContext);
         if(!aConstruction.get()) {
           break;
         }
@@ -175,7 +178,8 @@ bool GeomValidators_ZeroOffset::isValid(const std::shared_ptr<ModelAPI_Feature>&
     }
     std::shared_ptr<GeomAPI_Pln> aPln = aFace->getPlane();
     if(aPln.get()) {
-      for(ListOfShape::const_iterator anIter = aFacesList.cbegin(); anIter != aFacesList.cend(); anIter++) {
+      for(ListOfShape::const_iterator 
+          anIter = aFacesList.cbegin(); anIter != aFacesList.cend(); anIter++) {
         std::shared_ptr<GeomAPI_Shape> aSketchShape = *anIter;
         std::shared_ptr<GeomAPI_Face> aSketchFace(new GeomAPI_Face(aSketchShape));
         std::shared_ptr<GeomAPI_Pln>  aSketchPln = aSketchFace->getPlane();

diff --git a/src/GeomValidators/GeomValidators_ZeroOffset.h b/src/GeomValidators/GeomValidators_ZeroOffset.h
index 3d5c3b864178d6ac94adba36cdb0ebec0f00bb15..06348e14592087157a74534cdfa331f081d806f7 100644 (file)
--- a/src/GeomValidators/GeomValidators_ZeroOffset.h
+++ b/src/GeomValidators/GeomValidators_ZeroOffset.h
@@ -29,7 +29,8 @@ public:
                                              Events_InfoMessage& theError) const;
 
   /// \return true if the attribute in feature is not obligatory for the feature execution.
-  GEOMVALIDATORS_EXPORT virtual bool isNotObligatory(std::string theFeature, std::string theAttribute);
+  GEOMVALIDATORS_EXPORT virtual 
+    bool isNotObligatory(std::string theFeature, std::string theAttribute);
 };
 
 #endif

diff --git a/src/InitializationPlugin/InitializationPlugin_Plugin.cpp b/src/InitializationPlugin/InitializationPlugin_Plugin.cpp
index 93b60ffd2fc316daefd759d540d6f0a46b80aae6..a82ff65e4d2ea442416b9dd2c7b0d6d6831e6984 100644 (file)
--- a/src/InitializationPlugin/InitializationPlugin_Plugin.cpp
+++ b/src/InitializationPlugin/InitializationPlugin_Plugin.cpp
@@ -97,7 +97,8 @@ FeaturePtr InitializationPlugin_Plugin::createPlane(DocumentPtr theDoc, double t
   } else if (theZ) {
     aPlane->data()->setName("XOY");
   }
-  aPlane->setInHistory(aPlane, false);  // don't show automatically created feature in the features history
+    // don't show automatically created feature in the features history
+  aPlane->setInHistory(aPlane, false);
 
   // the plane should be executed in order to build the feature result immediatelly
   // the results are to be hidden in the plugin
@@ -119,7 +120,8 @@ FeaturePtr InitializationPlugin_Plugin::createPoint(DocumentPtr theDoc, const st
   aPoint->real("y")->setValue(theY);
   aPoint->real("z")->setValue(theZ);
   aPoint->data()->setName(theName);
-  aPoint->setInHistory(aPoint, false);  // don't show automatically created feature in the features history
+  // don't show automatically created feature in the features history
+  aPoint->setInHistory(aPoint, false);
 
   // the point should be executed in order to build the feature result immediatelly
   // the results are to be hidden in the plugin
@@ -150,7 +152,8 @@ FeaturePtr InitializationPlugin_Plugin::createAxis(DocumentPtr theDoc, FeaturePt
   } else if (theZ != 0) {
     aAxis->data()->setName("OZ");
   }
-  aAxis->setInHistory(aAxis, false);  // don't show automatically created feature in the features history
+   // don't show automatically created feature in the features history
+  aAxis->setInHistory(aAxis, false); 
   aAxis->execute();
   aAxis->data()->execState(ModelAPI_StateDone);
   aAxis->firstResult()->data()->execState(ModelAPI_StateDone);