cosmetics

src/AIS/AIS_ViewController.cxx

@@ -27,6 +27,8 @@
 #include <V3d_Viewer.hxx>
 #include <WNT_HIDSpaceMouse.hxx>
 
+#include <iostream>
+
 // =======================================================================
 // function : AIS_ViewController
 // purpose  :
@@ -2250,6 +2252,7 @@ void AIS_ViewController::handleCameraActions (const Handle(AIS_InteractiveContex
                                               const Handle(V3d_View)& theView,
                                               const AIS_WalkDelta& theWalk)
 {
+  std::cout << "handleCameraActions\n";
   // apply view actions
   if (myGL.Orientation.ToSetViewOrient)
   {
@@ -2266,6 +2269,12 @@ void AIS_ViewController::handleCameraActions (const Handle(AIS_InteractiveContex
     myGL.Orientation.ToFitAll = false;
   }
 
+  if (theView->Viewer()->Grid()->IsActive()
+   && theView->Viewer()->GridEcho())
+  {
+    theView->Viewer()->Grid()->Update();
+  }
+
   if (myGL.IsNewGesture)
   {
     if (myAnchorPointPrs1->HasInteractiveContext())
@@ -3101,6 +3110,7 @@ void AIS_ViewController::handleDynamicHighlight (const Handle(AIS_InteractiveCon
 void AIS_ViewController::handleMoveTo (const Handle(AIS_InteractiveContext)& theCtx,
                                        const Handle(V3d_View)& theView)
 {
+  std::cout << "handleMoveTo\n";
   handleSelectionPick   (theCtx, theView);
   handleDynamicHighlight(theCtx, theView);
   handleSelectionPoly   (theCtx, theView);

src/Aspect/Aspect_Grid.hxx

@@ -87,6 +87,9 @@ public:
   //! Display the grid at screen.
   Standard_EXPORT virtual void Display() = 0;
 
+  //! 
+  Standard_EXPORT virtual void Update() = 0;
+  
   //! Erase the grid from screen.
   Standard_EXPORT virtual void Erase() const = 0;
   

src/Aspect/Aspect_RectangularGrid.cxx

@@ -27,31 +27,35 @@ Aspect_RectangularGrid::Aspect_RectangularGrid(
                                const Standard_Real aFirstAngle,
                                const Standard_Real aSecondAngle,
                                const Standard_Real aRotationAngle)
-:Aspect_Grid(anXOrigin,anYOrigin,aRotationAngle),myXStep(aXStep),myYStep(aYStep),myFirstAngle(aFirstAngle),mySecondAngle(aSecondAngle)
+: Aspect_Grid (anXOrigin,anYOrigin,aRotationAngle),
-
+  myXStep (aXStep),
+  myYStep (aYStep),
+  myFirstAngle (aFirstAngle),
+  mySecondAngle (aSecondAngle)
 {
   Standard_NumericError_Raise_if (!CheckAngle (aFirstAngle, mySecondAngle),
                                   "networks are parallel");
-
+  Standard_NegativeValue_Raise_if (aXStep < 0.0, "invalid x step");
-  Standard_NegativeValue_Raise_if(aXStep < 0. , "invalid x step");
+  Standard_NegativeValue_Raise_if (aYStep < 0.0, "invalid y step");
-  Standard_NegativeValue_Raise_if(aYStep < 0. , "invalid y step");
+  Standard_NullValue_Raise_if (aXStep == 0.0, "invalid x step");
-  Standard_NullValue_Raise_if(aXStep == 0. , "invalid x step");
+  Standard_NullValue_Raise_if (aYStep == 0.0, "invalid y step");
-  Standard_NullValue_Raise_if(aYStep == 0. , "invalid y step");
 }
 
 
 
-void Aspect_RectangularGrid::SetXStep(const Standard_Real aStep) {
+void Aspect_RectangularGrid::SetXStep (const Standard_Real aStep)
-  Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
+{
-  Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
+  Standard_NegativeValue_Raise_if (aStep < 0.0, "invalid x step");
+  Standard_NullValue_Raise_if (aStep == 0.0, "invalid y step");
   myXStep = aStep;
   Init();
   UpdateDisplay();
 }
 
-void Aspect_RectangularGrid::SetYStep(const Standard_Real aStep) {
+void Aspect_RectangularGrid::SetYStep (const Standard_Real aStep)
-  Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
+{
-  Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
+  Standard_NegativeValue_Raise_if (aStep < 0.0, "invalid x step");
+  Standard_NullValue_Raise_if (aStep == 0.0, "invalid y step");
   myYStep = aStep;
   Init();
   UpdateDisplay();
@@ -73,15 +77,15 @@ void Aspect_RectangularGrid::SetGridValues(
   const Standard_Real theYOrigin,
   const Standard_Real theXStep,
   const Standard_Real theYStep,
-	const Standard_Real theRotationAngle) {
+  const Standard_Real theRotationAngle)
-
+{
   myXOrigin = theXOrigin;
   myYOrigin = theYOrigin;
-  Standard_NegativeValue_Raise_if(theXStep < 0. , "invalid x step");
+  Standard_NegativeValue_Raise_if (theXStep < 0.0, "invalid x step");
-  Standard_NullValue_Raise_if(theXStep == 0. , "invalid x step");
+  Standard_NullValue_Raise_if (theXStep == 0.0, "invalid x step");
   myXStep = theXStep;
-  Standard_NegativeValue_Raise_if(theYStep < 0. , "invalid y step");
+  Standard_NegativeValue_Raise_if (theYStep < 0.0, "invalid y step");
-  Standard_NullValue_Raise_if(theYStep == 0. , "invalid y step");
+  Standard_NullValue_Raise_if (theYStep == 0.0, "invalid y step");
   myYStep = theYStep;
   myRotationAngle = theRotationAngle;
   Init();
@@ -91,7 +95,8 @@ void Aspect_RectangularGrid::SetGridValues(
 void Aspect_RectangularGrid::Compute (const Standard_Real X,
                                       const Standard_Real Y,
                                       Standard_Real& gridX,
-                         Standard_Real& gridY) const {
+                                      Standard_Real& gridY) const
+{
     Standard_Real D1 = b1 * X - a1 * Y - c1;
     Standard_Real D2 = b2 * X - a2 * Y - c2;
     Standard_Integer n1 = Standard_Integer (Abs (D1) / myXStep + 0.5);
@@ -103,24 +108,28 @@ void Aspect_RectangularGrid::Compute(const Standard_Real X,
     gridY = (offset2 * b1 - offset1 * b2) / Delta;
 }
 
-Standard_Real Aspect_RectangularGrid::XStep() const {
+Standard_Real Aspect_RectangularGrid::XStep() const
+{
   return myXStep;
 }
 
-Standard_Real Aspect_RectangularGrid::YStep() const {
+Standard_Real Aspect_RectangularGrid::YStep() const
+{
   return myYStep;
 }
 
-Standard_Real Aspect_RectangularGrid::FirstAngle() const {
+Standard_Real Aspect_RectangularGrid::FirstAngle() const
+{
   return myFirstAngle;
 }
 
-Standard_Real Aspect_RectangularGrid::SecondAngle() const {
+Standard_Real Aspect_RectangularGrid::SecondAngle() const
+{
   return mySecondAngle;
 }
 
-void Aspect_RectangularGrid::Init () {
+void Aspect_RectangularGrid::Init()
-
+{
 //+zov Fixing CTS17856
 //  a1 = Cos (myFirstAngle + RotationAngle() ); 
 //  b1 = Sin (myFirstAngle + RotationAngle() );
@@ -132,28 +141,39 @@ void Aspect_RectangularGrid::Init () {
 
   Standard_Real angle1 = myFirstAngle + RotationAngle();
   Standard_Real angle2 = mySecondAngle + RotationAngle();
-  if ( angle1 != 0. ) {
+  if (angle1 != 0.0)
+  {
     a1 = -Sin (angle1);
     b1 = Cos (angle1);
     c1 = XOrigin() * b1 - YOrigin() * a1;
-  } else {
+  }
-    a1 = 0.; b1 = 1.; c1 = XOrigin();
+  else
+  {
+    a1 = 0.0;
+    b1 = 1.0;
+    c1 = XOrigin();
   }
 
-  if ( angle2 != 0. ) {
+  if (angle2 != 0.0)
-    angle2 += M_PI / 2.;
+  {
+    angle2 += M_PI / 2.0;
     a2 = -Sin (angle2);
     b2 = Cos (angle2);
     c2 = XOrigin() * b2 - YOrigin() * a2;
-  } else {
+  }
-    a2 = -1.; b2 = 0.; c2 = YOrigin();
+  else
+  {
+    a2 = -1.0;
+    b2 = 0.0;
+    c2 = YOrigin();
   }
 //-zov
 }
 
 Standard_Boolean Aspect_RectangularGrid::CheckAngle (const Standard_Real alpha,
-                                            const Standard_Real beta) const {
+                                                     const Standard_Real beta) const
-  return (Abs( Sin(alpha) * Cos(beta + M_PI / 2.) - Cos(alpha) * Sin(beta + M_PI / 2.)) != 0) ;
+{
+  return (Abs (Sin (alpha) * Cos (beta + M_PI / 2.0) - Cos (alpha) * Sin (beta + M_PI / 2.0)) != 0);
 }
 
 //=======================================================================

src/V3d/V3d_CircularGrid.cxx

@@ -91,7 +91,8 @@ V3d_CircularGrid::~V3d_CircularGrid()
 
 void V3d_CircularGrid::SetColors (const Quantity_Color& aColor, const Quantity_Color& aTenthColor)
 {
-  if( myColor != aColor || myTenthColor != aTenthColor ) {
+  if( myColor != aColor || myTenthColor != aTenthColor )
+  {
     myColor = aColor;
     myTenthColor = aTenthColor;
     myCurAreDefined = Standard_False;
@@ -106,6 +107,11 @@ void V3d_CircularGrid::Display ()
   UpdateDisplay();
 }
 
+void V3d_CircularGrid::Update()
+{
+  //
+}
+
 void V3d_CircularGrid::Erase() const
 {
   myStructure->Erase();
@@ -147,9 +153,11 @@ void V3d_CircularGrid::UpdateDisplay ()
           xdx != curxdx || xdy != curxdy || xdz != curxdz ||
           ydx != curydx || ydy != curydy || ydz != curydz ||
           dx  != curdx  || dy  != curdy  || dz  != curdz)
+      {
         MakeTransform = Standard_True;
       }
     }
+  }
 
   if (MakeTransform)
   {
@@ -173,7 +181,8 @@ void V3d_CircularGrid::UpdateDisplay ()
     myStructure->SetTransformation (new TopLoc_Datum3D (aTrsf));
 
     myCurAngle = RotationAngle();
-    myCurXo = XOrigin (), myCurYo = YOrigin ();
+    myCurXo = XOrigin();
+    myCurYo = YOrigin();
     myCurViewPlane = ThePlane;
   }
 
@@ -202,8 +211,7 @@ void V3d_CircularGrid::DefineLines ()
                                   || myCurDrawMode != Aspect_GDM_Lines
                                   || aDivision != myCurDivi
                                   || aStep     != myCurStep;
-  if (!toUpdate
+  if (!toUpdate && !myToComputePrs)
-   && !myToComputePrs)
   {
     return;
   }
@@ -224,8 +232,9 @@ void V3d_CircularGrid::DefineLines ()
 
   myGroup->SetGroupPrimitivesAspect (new Graphic3d_AspectLine3d (myTenthColor, Aspect_TOL_SOLID, 1.0));
   Handle(Graphic3d_ArrayOfSegments) aPrims1 = new Graphic3d_ArrayOfSegments (2 * nbpnts);
-  const gp_Pnt p0(0., 0., -myOffSet);
+  const gp_Pnt p0 (0.0, 0.0, -myOffSet);
-  for (Standard_Integer i=1; i<=nbpnts; i++) {
+  for (Standard_Integer i = 1; i <= nbpnts; i++)
+  {
     aPrims1->AddVertex (p0);
     aPrims1->AddVertex (Cos (alpha * i) * myRadius, Sin (alpha * i) * myRadius, -myOffSet);
   }
@@ -236,9 +245,11 @@ void V3d_CircularGrid::DefineLines ()
   alpha = M_PI / Division;
   Standard_Integer nblines = 0;
   TColgp_SequenceOfPnt aSeqLines, aSeqTenth;
-  for (Standard_Real r=aStep; r<=myRadius; r+=aStep, nblines++) {
+  for (Standard_Real r = aStep; r <= myRadius; r += aStep, nblines++)
+  {
     const Standard_Boolean isTenth = (Modulus (nblines, 10) == 0);
-    for (Standard_Integer i=0; i<nbpnts; i++) {
+    for (Standard_Integer i = 0; i < nbpnts; i++)
+    {
       const gp_Pnt pt (Cos (alpha * i) * r, Sin (alpha * i) * r, -myOffSet);
       (isTenth ? aSeqTenth : aSeqLines).Append (pt);
     }
@@ -249,11 +260,14 @@ void V3d_CircularGrid::DefineLines ()
     Standard_Integer n, np;
     const Standard_Integer nbl = aSeqTenth.Length() / nbpnts;
     Handle(Graphic3d_ArrayOfPolylines) aPrims2 = new Graphic3d_ArrayOfPolylines (aSeqTenth.Length(), nbl);
-    for (np = 1, n=0; n<nbl; n++) {
+    for (np = 1, n = 0; n < nbl; n++)
+    {
       aPrims2->AddBound (nbpnts);
       for (Standard_Integer i = 0; i < nbpnts; i++, np++)
+      {
         aPrims2->AddVertex (aSeqTenth (np));
       }
+    }
     myGroup->AddPrimitiveArray (aPrims2, Standard_False);
   }
   if (aSeqLines.Length())
@@ -262,16 +276,20 @@ void V3d_CircularGrid::DefineLines ()
     Standard_Integer n, np;
     const Standard_Integer nbl = aSeqLines.Length() / nbpnts;
     Handle(Graphic3d_ArrayOfPolylines) aPrims3 = new Graphic3d_ArrayOfPolylines (aSeqLines.Length(), nbl);
-    for (np = 1, n=0; n<nbl; n++) {
+    for (np = 1, n = 0; n < nbl; n++)
+    {
       aPrims3->AddBound(nbpnts);
       for (Standard_Integer i = 0; i < nbpnts; i++, np++)
+      {
         aPrims3->AddVertex (aSeqLines (np));
       }
+    }
     myGroup->AddPrimitiveArray (aPrims3, Standard_False);
   }
 
   myGroup->SetMinMaxValues (-myRadius, -myRadius, -myOffSet, myRadius, myRadius, -myOffSet);
-  myCurStep = aStep, myCurDivi = (Standard_Integer ) aDivision;
+  myCurStep = aStep;
+  myCurDivi = (Standard_Integer) aDivision;
 
   // update bounding box
   myStructure->CalculateBoundBox();
@@ -286,8 +304,7 @@ void V3d_CircularGrid::DefinePoints ()
                                   || myCurDrawMode != Aspect_GDM_Points
                                   || aDivision != myCurDivi
                                   || aStep     != myCurStep;
-  if (!toUpdate
+  if (!toUpdate && !myToComputePrs)
-   && !myToComputePrs)
   {
     return;
   }
@@ -303,34 +320,38 @@ void V3d_CircularGrid::DefinePoints ()
   Handle(Graphic3d_AspectMarker3d) MarkerAttrib = new Graphic3d_AspectMarker3d();
   MarkerAttrib->SetColor (myColor);
   MarkerAttrib->SetType (Aspect_TOM_POINT);
-  MarkerAttrib->SetScale (3.);
+  MarkerAttrib->SetScale (3.0);
 
   const Standard_Integer nbpnts = Standard_Integer (2 * aDivision);
-  Standard_Real r, alpha = M_PI / aDivision;
+  Standard_Real alpha = M_PI / aDivision;
 
   // diameters
   TColgp_SequenceOfPnt aSeqPnts;
   aSeqPnts.Append (gp_Pnt (0.0, 0.0, -myOffSet));
-  for (r=aStep; r<=myRadius; r+=aStep) {
+  for (Standard_Real r = aStep; r <= myRadius; r += aStep)
+  {
     for (Standard_Integer i = 0; i < nbpnts; i++)
+    {
       aSeqPnts.Append (gp_Pnt (Cos (alpha * i) * r, Sin (alpha * i) * r, -myOffSet));
     }
+  }
   myGroup->SetGroupPrimitivesAspect (MarkerAttrib);
   if (aSeqPnts.Length())
   {
     Standard_Real X,Y,Z;
     const Standard_Integer nbv = aSeqPnts.Length();
-    Handle(Graphic3d_ArrayOfPoints) Cercle = new Graphic3d_ArrayOfPoints (nbv);
+    Handle(Graphic3d_ArrayOfPoints) aCircle = new Graphic3d_ArrayOfPoints (nbv);
     for (Standard_Integer i = 1; i <= nbv; i++)
     {
       aSeqPnts (i).Coord (X,Y,Z);
-      Cercle->AddVertex (X,Y,Z);
+      aCircle->AddVertex (X,Y,Z);
     }
-    myGroup->AddPrimitiveArray (Cercle, Standard_False);
+    myGroup->AddPrimitiveArray (aCircle, Standard_False);
   }
   myGroup->SetMinMaxValues (-myRadius, -myRadius, -myOffSet, myRadius, myRadius, -myOffSet);
 
-  myCurStep = aStep, myCurDivi = (Standard_Integer ) aDivision;
+  myCurStep = aStep;
+  myCurDivi = (Standard_Integer) aDivision;
 
   // update bounding box
   myStructure->CalculateBoundBox();
@@ -345,19 +366,22 @@ void V3d_CircularGrid::GraphicValues (Standard_Real& theRadius, Standard_Real& t
 
 void V3d_CircularGrid::SetGraphicValues (const Standard_Real theRadius, const Standard_Real theOffSet)
 {
-  if (! myCurAreDefined) {
+  if (!myCurAreDefined)
+  {
     myRadius = theRadius;
     myOffSet = theOffSet;
   }
-  if (myRadius != theRadius) {
+  if (myRadius != theRadius)
+  {
     myRadius = theRadius;
     myCurAreDefined = Standard_False;
   }
-  if (myOffSet != theOffSet) {
+  if (myOffSet != theOffSet)
+  {
     myOffSet = theOffSet;
     myCurAreDefined = Standard_False;
   }
-  if( !myCurAreDefined ) UpdateDisplay();
+  if (!myCurAreDefined) { UpdateDisplay(); }
 }
 
 //=======================================================================

src/V3d/V3d_CircularGrid.hxx

@@ -41,6 +41,8 @@ public:
 
   Standard_EXPORT void Display() Standard_OVERRIDE;
 
+  Standard_EXPORT void Update() Standard_OVERRIDE;
+
   Standard_EXPORT void Erase() const Standard_OVERRIDE;
 
   Standard_EXPORT Standard_Boolean IsDisplayed() const Standard_OVERRIDE;

src/V3d/V3d_RectangularGrid.cxx

@@ -91,7 +91,8 @@ V3d_RectangularGrid::~V3d_RectangularGrid()
 
 void V3d_RectangularGrid::SetColors (const Quantity_Color& aColor, const Quantity_Color& aTenthColor)
 {
-  if( myColor != aColor || myTenthColor != aTenthColor ) {
+  if( myColor != aColor || myTenthColor != aTenthColor )
+  {
     myColor = aColor;
     myTenthColor = aTenthColor;
     myCurAreDefined = Standard_False;
@@ -106,6 +107,12 @@ void V3d_RectangularGrid::Display ()
   UpdateDisplay();
 }
 
+void V3d_RectangularGrid::Update()
+{
+  SetXStep (XStep() + 1);
+  UpdateDisplay();
+}
+
 void V3d_RectangularGrid::Erase() const
 {
   myStructure->Erase();
@@ -130,11 +137,17 @@ void V3d_RectangularGrid::UpdateDisplay ()
   ThePlane.YDirection().Coord (ydx, ydy, ydz);
   ThePlane.Direction ().Coord (dx,  dy,  dz);
   if (!myCurAreDefined)
+  {
     MakeTransform = Standard_True;
-  else {
+  }
+  else
+  {
     if (RotationAngle() != myCurAngle || XOrigin() != myCurXo || YOrigin() != myCurYo)
+    {
       MakeTransform = Standard_True;
-    if (! MakeTransform) {
+    }
+    if (!MakeTransform)
+    {
       Standard_Real curxl,  curyl,  curzl;
       Standard_Real curxdx, curxdy, curxdz;
       Standard_Real curydx, curydy, curydz;
@@ -147,9 +160,11 @@ void V3d_RectangularGrid::UpdateDisplay ()
           xdx != curxdx || xdy != curxdy || xdz != curxdz ||
           ydx != curydx || ydy != curydy || ydz != curydz ||
           dx  != curdx  || dy  != curdy  || dz  != curdz)
+      {
         MakeTransform = Standard_True;
       }
     }
+  }
 
   if (MakeTransform) {
     const Standard_Real CosAlpha = Cos (RotationAngle ());
@@ -172,7 +187,8 @@ void V3d_RectangularGrid::UpdateDisplay ()
     myStructure->SetTransformation (new TopLoc_Datum3D (aTrsf));
 
     myCurAngle = RotationAngle();
-    myCurXo = XOrigin (), myCurYo = YOrigin ();
+    myCurXo = XOrigin();
+    myCurYo = YOrigin();
     myCurViewPlane = ThePlane;
   }
 
@@ -201,8 +217,7 @@ void V3d_RectangularGrid::DefineLines ()
                                  || myCurDrawMode != Aspect_GDM_Lines
                                  || aXStep != myCurXStep
                                  || aYStep != myCurYStep;
-  if (!toUpdate
+  if (!toUpdate && !myToComputePrs)
-   && !myToComputePrs)
   {
     return;
   }
@@ -221,8 +236,8 @@ void V3d_RectangularGrid::DefineLines ()
   TColgp_SequenceOfPnt aSeqLines, aSeqTenth;
 
   // verticals
-  aSeqTenth.Append(gp_Pnt(0., -myYSize, -zl));
+  aSeqTenth.Append (gp_Pnt (0.0, -myYSize, -zl));
-  aSeqTenth.Append(gp_Pnt(0.,  myYSize, -zl));
+  aSeqTenth.Append (gp_Pnt (0.0,  myYSize, -zl));
   for (nblines = 1, xl = aXStep; xl < myXSize; xl += aXStep, nblines++)
   {
     TColgp_SequenceOfPnt &aSeq = (Modulus (nblines, 10) != 0) ? aSeqLines : aSeqTenth;
@@ -233,8 +248,8 @@ void V3d_RectangularGrid::DefineLines ()
   }
 
   // horizontals
-  aSeqTenth.Append(gp_Pnt(-myXSize, 0., -zl));
+  aSeqTenth.Append (gp_Pnt (-myXSize, 0.0, -zl));
-  aSeqTenth.Append(gp_Pnt( myXSize, 0., -zl));
+  aSeqTenth.Append (gp_Pnt ( myXSize, 0.0, -zl));
   for (nblines = 1, yl = aYStep; yl < myYSize; yl += aYStep, nblines++)
   {
     TColgp_SequenceOfPnt &aSeq = (Modulus (nblines, 10) != 0) ? aSeqLines : aSeqTenth;
@@ -250,9 +265,10 @@ void V3d_RectangularGrid::DefineLines ()
     myGroup->SetPrimitivesAspect (aLineAspect);
     const Standard_Integer nbv = aSeqLines.Length();
     Handle(Graphic3d_ArrayOfSegments) aPrims = new Graphic3d_ArrayOfSegments (nbv);
-    Standard_Integer n = 1;
+    for (Standard_Integer n = 1; n <= nbv; n++)
-    while (n<=nbv)
+    {
-      aPrims->AddVertex(aSeqLines(n++));
+      aPrims->AddVertex (aSeqLines (n));
+    }
     myGroup->AddPrimitiveArray (aPrims, Standard_False);
   }
   if (aSeqTenth.Length())
@@ -261,14 +277,16 @@ void V3d_RectangularGrid::DefineLines ()
     myGroup->SetPrimitivesAspect (aLineAspect);
     const Standard_Integer nbv = aSeqTenth.Length();
     Handle(Graphic3d_ArrayOfSegments) aPrims = new Graphic3d_ArrayOfSegments (nbv);
-    Standard_Integer n = 1;
+    for (Standard_Integer n = 1; n <= nbv; n++)
-    while (n<=nbv)
+    {
-      aPrims->AddVertex(aSeqTenth(n++));
+      aPrims->AddVertex (aSeqTenth (n));
+    }
     myGroup->AddPrimitiveArray (aPrims, Standard_False);
   }
 
   myGroup->SetMinMaxValues (-myXSize, -myYSize, -myOffSet, myXSize, myYSize, -myOffSet);
-  myCurXStep = aXStep, myCurYStep = aYStep;
+  myCurXStep = aXStep;
+  myCurYStep = aYStep;
 
   // update bounding box
   myStructure->CalculateBoundBox();
@@ -300,10 +318,12 @@ void V3d_RectangularGrid::DefinePoints ()
   // horizontals
   Standard_Real xl, yl;
   TColgp_SequenceOfPnt aSeqPnts;
-  for (xl = 0.0; xl <= myXSize; xl += aXStep) {
+  for (xl = 0.0; xl <= myXSize; xl += aXStep)
+  {
     aSeqPnts.Append (gp_Pnt ( xl, 0.0, -myOffSet));
     aSeqPnts.Append (gp_Pnt (-xl, 0.0, -myOffSet));
-    for (yl = aYStep; yl <= myYSize; yl += aYStep) {
+    for (yl = aYStep; yl <= myYSize; yl += aYStep)
+    {
       aSeqPnts.Append (gp_Pnt ( xl,  yl, -myOffSet));
       aSeqPnts.Append (gp_Pnt ( xl, -yl, -myOffSet));
       aSeqPnts.Append (gp_Pnt (-xl,  yl, -myOffSet));
@@ -328,7 +348,8 @@ void V3d_RectangularGrid::DefinePoints ()
   }
 
   myGroup->SetMinMaxValues (-myXSize, -myYSize, -myOffSet, myXSize, myYSize, -myOffSet);
-  myCurXStep = aXStep, myCurYStep = aYStep;
+  myCurXStep = aXStep;
+  myCurYStep = aYStep;
 
   // update bounding box
   myStructure->CalculateBoundBox();
@@ -344,24 +365,28 @@ void V3d_RectangularGrid::GraphicValues (Standard_Real& theXSize, Standard_Real&
 
 void V3d_RectangularGrid::SetGraphicValues (const Standard_Real theXSize, const Standard_Real theYSize, const Standard_Real theOffSet)
 {
-  if (! myCurAreDefined) {
+  if (! myCurAreDefined)
+  {
     myXSize = theXSize;
     myYSize = theYSize;
     myOffSet = theOffSet;
   }
-  if (myXSize != theXSize) {
+  if (myXSize != theXSize)
+  {
     myXSize = theXSize;
     myCurAreDefined = Standard_False;
   }
-  if (myYSize != theYSize) {
+  if (myYSize != theYSize)
+  {
     myYSize = theYSize;
     myCurAreDefined = Standard_False;
   }
-  if (myOffSet != theOffSet) {
+  if (myOffSet != theOffSet)
+  {
     myOffSet = theOffSet;
     myCurAreDefined = Standard_False;
   }
-  if( !myCurAreDefined ) UpdateDisplay();
+  if (!myCurAreDefined) { UpdateDisplay(); }
 }
 
 //=======================================================================

src/V3d/V3d_RectangularGrid.hxx

@@ -40,6 +40,8 @@ public:
 
   Standard_EXPORT virtual void Display() Standard_OVERRIDE;
 
+  Standard_EXPORT virtual void Update() Standard_OVERRIDE;
+
   Standard_EXPORT virtual void Erase() const Standard_OVERRIDE;
 
   Standard_EXPORT virtual Standard_Boolean IsDisplayed() const Standard_OVERRIDE;