OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-06-30 12:14:08 +03:00
Code

cosmetics

Browse Source
This commit is contained in:
mzernova 2020-08-25 13:17:04 +03:00
parent 2fa9309186
commit 7d0f638daa
8 changed files with 324 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/AIS/AIS_ViewController.cxx
View File

@ -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);

3
src/Aspect/Aspect_Grid.hxx
View File

@ -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;

90
src/Aspect/Aspect_RectangularGrid.cxx
View File

@ -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. , "invalid x step");
Standard_NegativeValue_Raise_if(aYStep < 0. , "invalid y step");
Standard_NullValue_Raise_if(aXStep == 0. , "invalid x step");
Standard_NullValue_Raise_if(aYStep == 0. , "invalid y step");
Standard_NegativeValue_Raise_if (aXStep < 0.0, "invalid x step");
Standard_NegativeValue_Raise_if (aYStep < 0.0, "invalid y step");
Standard_NullValue_Raise_if (aXStep == 0.0, "invalid x step");
Standard_NullValue_Raise_if (aYStep == 0.0, "invalid y step");
}
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");
void Aspect_RectangularGrid::SetXStep (const Standard_Real aStep)
{
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) {
Standard_NegativeValue_Raise_if(aStep < 0. , "invalid x step");
Standard_NullValue_Raise_if(aStep == 0. , "invalid y step");
void Aspect_RectangularGrid::SetYStep (const Standard_Real aStep)
{
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_NullValue_Raise_if(theXStep == 0. , "invalid x step");
Standard_NegativeValue_Raise_if (theXStep < 0.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_NullValue_Raise_if(theYStep == 0. , "invalid y step");
Standard_NegativeValue_Raise_if (theYStep < 0.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. ) {
angle2 += M_PI / 2.;
if (angle2 != 0.0)
{
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 {
return (Abs( Sin(alpha) * Cos(beta + M_PI / 2.) - Cos(alpha) * Sin(beta + M_PI / 2.)) != 0) ;
const Standard_Real beta) const
{
return (Abs (Sin (alpha) * Cos (beta + M_PI / 2.0) - Cos (alpha) * Sin (beta + M_PI / 2.0)) != 0);
}
//=======================================================================

72
src/V3d/V3d_CircularGrid.cxx
View File

@ -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
&& !myToComputePrs)
if (!toUpdate && !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);
for (Standard_Integer i=1; i<=nbpnts; i++) {
const gp_Pnt p0 (0.0, 0.0, -myOffSet);
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
&& !myToComputePrs)
if (!toUpdate && !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(); }
}
//=======================================================================

2
src/V3d/V3d_CircularGrid.hxx
View File

@ -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;

75
src/V3d/V3d_RectangularGrid.cxx
View File

@ -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
&& !myToComputePrs)
if (!toUpdate && !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., myYSize, -zl));
aSeqTenth.Append (gp_Pnt (0.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., -zl));
aSeqTenth.Append (gp_Pnt (-myXSize, 0.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;
while (n<=nbv)
aPrims->AddVertex(aSeqLines(n++));
for (Standard_Integer n = 1; n <= nbv; 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;
while (n<=nbv)
aPrims->AddVertex(aSeqTenth(n++));
for (Standard_Integer n = 1; n <= nbv; 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(); }
}
//=======================================================================

2
src/V3d/V3d_RectangularGrid.hxx
View File

@ -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;