OpenCascade/occt
1
0
Fork 0
mirror of https://git.dev.opencascade.org/repos/occt.git synced 2025-08-19 13:40:49 +03:00
Code Activity

Coding, TKDEIGES - Translation to English (#678)

Browse Source 
- Updated comments in IGESGeom_ToolCircularArc, IGESGeom_ToolCurveOnSurface, IGESGeom_ToolOffsetCurve, IGESGeom_ToolPlane, IGESGeom_ToolSplineSurface, IGESGeom_ToolTransformationMatrix, IGESGraph_ToolColor, IGESGraph_ToolDrawingUnits, IGESSelect, IGESSelect_Activator, IGESSelect_RebuildGroups, IGESSelect_SelectBypassGroup, IGESSelect_SelectBypassSubfigure, IGESSelect_SignStatus, IGESSelect_ViewSorter, IGESSelect_WorkLibrary, IGESToBRep, IGESToBRep_BRepEntity, IGESToBRep_BasicCurve, IGESToBRep_BasicSurface, IGESToBRep_TopoCurve, IGESToBRep_TopoSurface to improve readability and understanding.
- Translated French comments to English where applicable.
- Ensured comments accurately reflect the functionality and intent of the code.
This commit is contained in:
Pasukhin Dmitry
2025-08-17 09:53:01 +01:00
committed by GitHub
parent 314527f5c0
commit 45eefc4134
106 changed files with 692 additions and 693 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/DataExchange/TKDEIGES/BRepToIGES/BRepToIGES_BREntity.cxx
View File

@@ -140,8 +140,8 @@ Handle(IGESData_IGESEntity) BRepToIGES_BREntity::TransferShape(
}
else
{
// la fonction suivante force les surfaces indirectes en
// surfaces directes (obligatoire dans IGES)
// the following function forces indirect surfaces to
// direct surfaces (mandatory in IGES)
// theShape = ShapeCustom::DirectFaces(start);
// sprintf(Name,"res_%d",Nb++);
// DBRep::Set(Name,theShape);
@@ -183,7 +183,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BREntity::TransferShape(
}
else
{
// message d`erreur
// error message
}
}

6
src/DataExchange/TKDEIGES/BRepToIGES/BRepToIGES_BRShell.cxx
View File

@@ -93,7 +93,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferShell(
}
else
{
// message d`erreur
// error message
}
return res;
}
@@ -113,7 +113,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferFace(const TopoDS_Face&
return res;
}
// pour explorer la face , il faut la mettre fORWARD.
// to explore the face, it must be set to FORWARD.
TopoDS_Face aFace = start;
// Associates the input face (start) and its sub-shapes with the reversed variant,
// if the input face has a Reversed orientation
@@ -242,7 +242,7 @@ Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferFace(const TopoDS_Face&
if (!Surf.IsNull())
{
Standard_Real U1, U2, V1, V2;
// pour limiter les surfaces de base
// to limit the base surfaces
BRepTools::UVBounds(aFace, U1, U2, V1, V2);
GeomToIGES_GeomSurface GS;
GS.SetModel(GetModel());

2
src/DataExchange/TKDEIGES/BRepToIGESBRep/BRepToIGESBRep_Entity.cxx
View File

@@ -14,7 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// modif le 25/03/96 mjm
// modification on 25/03/96 mjm
// implement ShapeCustom::DirectModification for indirect surfaces (out of norm IGES)
//: l4 abv 12 Jan 99: CTS22022-2: correct writing reversed shells
//: n3 abv 8 Feb 99: PRO17820: BRepTools::OuterWire() -> ShapeAnalysis::OuterWire

2
src/DataExchange/TKDEIGES/Geom2dToIGES/Geom2dToIGES_Geom2dCurve.cxx
View File

@@ -46,7 +46,7 @@ Geom2dToIGES_Geom2dCurve::Geom2dToIGES_Geom2dCurve(const Geom2dToIGES_Geom2dEnti
}
//=============================================================================
// Transfer des Entites Curve de Geom2d vers IGES
// Transfer of Curve Entities from Geom2d to IGES
// Transfer2dCurve
//=============================================================================

4
src/DataExchange/TKDEIGES/Geom2dToIGES/Geom2dToIGES_Geom2dPoint.cxx
View File

@@ -38,7 +38,7 @@ Geom2dToIGES_Geom2dPoint::Geom2dToIGES_Geom2dPoint(const Geom2dToIGES_Geom2dEnti
}
//=============================================================================
// Transfer de Point2d de Geom2d vers IGES
// Transfer of Point2d from Geom2d to IGES
// Tranfer2dPoint
//=============================================================================
@@ -59,7 +59,7 @@ Handle(IGESGeom_Point) Geom2dToIGES_Geom2dPoint::Transfer2dPoint(const Handle(Ge
}
//=============================================================================
// Transfer de CartesianPoint de Geom2d vers IGES
// Transfer of CartesianPoint from Geom2d to IGES
// Tranfer2dPoint
//=============================================================================

6
src/DataExchange/TKDEIGES/Geom2dToIGES/Geom2dToIGES_Geom2dVector.cxx
View File

@@ -40,7 +40,7 @@ Geom2dToIGES_Geom2dVector::Geom2dToIGES_Geom2dVector(const Geom2dToIGES_Geom2dEn
}
//=============================================================================
// Transfer des Entites Vector de Geom2d vers IGES
// Transfer of Vector Entities from Geom2d to IGES
// Transfer2dVector
//=============================================================================
@@ -68,7 +68,7 @@ Handle(IGESGeom_Direction) Geom2dToIGES_Geom2dVector::Transfer2dVector(
}
//=============================================================================
// Transfer des Entites VectorWithMagnitude de Geom2d vers IGES
// Transfer of VectorWithMagnitude Entities from Geom2d to IGES
// Transfer2dVector
//=============================================================================
@@ -89,7 +89,7 @@ Handle(IGESGeom_Direction) Geom2dToIGES_Geom2dVector::Transfer2dVector(
}
//=============================================================================
// Transfer des Entites Direction de Geom2d vers IGES
// Transfer of Direction Entities from Geom2d to IGES
// Transfer2dVector
//=============================================================================

14
src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomCurve.cxx
View File

@@ -69,9 +69,9 @@
#include <TColStd_HArray1OfReal.hxx>
// Pour toutes les courbes infinies soit
// Udeb <= -Precision::Infinite() et/ou Ufin >= Precision::Infinite()
// on choisit arbitrairement de les construire entre
// Udeb = -Precision::Infinite() et Ufin = Precision::Infinite()
// Udeb <= -Precision::Infinite() and/or Ufin >= Precision::Infinite()
// we arbitrarily choose to construct them between
// Udeb = -Precision::Infinite() and Ufin = Precision::Infinite()
//=============================================================================
// GeomToIGES_GeomCurve
//=============================================================================
@@ -285,8 +285,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve(
Standard_Boolean IPlan = Standard_False;
gp_XYZ Norm = gp_XYZ(0., 0., 1.);
// Si la courbe est periodique, on passe par une fonction pour recuperer tous
// les parametres necessaires a l`ecriture IGES.
// If the curve is periodic, we go through a function to recover all
// the parameters necessary for IGES writing.
Standard_Boolean IPerio = start->IsPeriodic();
@@ -349,7 +349,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve(
Standard_Integer Index = Nbpoles - 1;
// Sequence des Knots de [-Deg, Index+1] dans IGESGeom.
// et de [1, Nbpoles+Deg+1] dans Geom
// and from [1, Nbpoles+Deg+1] in Geom
Standard_Integer Knotindex;
Standard_Real rtampon;
TColStd_Array1OfReal K(1, Nbpoles + Deg + 1);
@@ -909,7 +909,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomCurve::TransferCurve(
(start->Offset() / GetUnit()),
0.,
// clang-format off
start->Direction().XYZ().Reversed(), U1, U2); //%11 pdn 12.01.99 // valeur (0,0,1) pour l'instant
start->Direction().XYZ().Reversed(), U1, U2); //%11 pdn 12.01.99 // value (0,0,1) for now
// clang-format on
res = OffsetC;

8
src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomPoint.cxx
View File

@@ -12,8 +12,8 @@
// commercial license or contractual agreement.
// modif du 14/09/95 mjm
// prise en compte de l'unite choisi par l'utilisateur
// pour l'ecriture du fichier IGES.
// taking into account the unit chosen by the user
// for writing the IGES file.
#include <Geom_CartesianPoint.hxx>
#include <Geom_Point.hxx>
@@ -41,7 +41,7 @@ GeomToIGES_GeomPoint::GeomToIGES_GeomPoint()
}
//=============================================================================
// Transfer de Point de Geom vers IGES
// Transfer of Point from Geom to IGES
// TranferPoint
//=============================================================================
@@ -61,7 +61,7 @@ Handle(IGESGeom_Point) GeomToIGES_GeomPoint::TransferPoint(const Handle(Geom_Poi
}
//=============================================================================
// Transfer de Point de Geom vers IGES
// Transfer of Point from Geom to IGES
// TranferPoint
//=============================================================================

70
src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomSurface.cxx
View File

@@ -11,8 +11,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// modif du 22/10/96 mjm
// ajout du champ TheLength
// modification of 22/10/96 mjm
// addition of TheLength field
//: l6 abv 15.01.99: CTS22022: writing full tori
// szv#4:S4163:12Mar99
// S4181 pdn 20.04.99 implementing of writing IGES elementary surfaces.
@@ -104,7 +104,7 @@ GeomToIGES_GeomSurface::GeomToIGES_GeomSurface(const GeomToIGES_GeomEntity& GE)
}
//=============================================================================
// Transfer des Entites Surface de Geom vers IGES
// Transfer of Surface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -146,7 +146,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites BoundedSurface de Geom vers IGES
// Transfer of BoundedSurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -183,7 +183,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites BSplineSurface de Geom vers IGES
// Transfer of BSplineSurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -334,7 +334,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
Standard_Boolean Polynom = !(RationU || RationV); // szv#10:PRO19566:05Oct99 && was wrong
// filling knots array for U :
// Sequence des Knots de [-DegU, IndexU+1] dans IGESGeom.
// Knots sequence from [-DegU, IndexU+1] in IGESGeom.
Standard_Integer Knotindex;
Standard_Real rtampon;
Standard_Integer itampon;
@@ -350,7 +350,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
// filling knots array for V :
// Sequence des Knots de [-DegV, IndexV+1] dans IGESGeom.
// Knots sequence from [-DegV, IndexV+1] in IGESGeom.
TColStd_Array1OfReal KV(1, NbVPoles + DegV + 1);
mysurface->VKnotSequence(KV);
itampon = -DegV;
@@ -362,7 +362,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
itampon++;
}
// filling Weights array de [0, IndexU, 0, IndexV]
// filling Weights array from [0, IndexU, 0, IndexV]
// ----------------------------------------------
Handle(TColStd_HArray2OfReal) Weights = new TColStd_HArray2OfReal(0, IndexU, 0, IndexV);
Standard_Integer WeightRow = Weights->LowerRow();
@@ -390,7 +390,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
}
// filling Poles array de [0, IndexU, 0, IndexV]
// filling Poles array from [0, IndexU, 0, IndexV]
// ---------------------------------------------
Handle(TColgp_HArray2OfXYZ) Poles = new TColgp_HArray2OfXYZ(0, IndexU, 0, IndexV);
Standard_Integer UIndex = Poles->LowerRow();
@@ -433,7 +433,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites BezierSurface de Geom vers IGES
// Transfer of BezierSurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -458,7 +458,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites RectangularTrimmedSurface de Geom vers IGES
// Transfer of RectangularTrimmedSurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -478,8 +478,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
Handle(Geom_Surface) st = start->BasisSurface();
if (st->IsKind(STANDARD_TYPE(Geom_RectangularTrimmedSurface)))
{
// message d'erreur pas de trimmed a partir d'une trimmed ,
// on peut eventuellement ecrire la surface de base : st.
// error message no trimmed from a trimmed,
// we can possibly write the base surface: st.
return res;
}
@@ -488,7 +488,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites ElementarySurface de Geom vers IGES
// Transfer of ElementarySurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -555,7 +555,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites Plane de Geom vers IGES
// Transfer of Plane Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -565,7 +565,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle
const Standard_Real Vdeb,
const Standard_Real Vfin)
{
// on va ecrire une BSplineSurface pour pouvoir etre coherent avec les courbes 2d
// we will write a BSplineSurface to be able to be coherent with 2d curves
Handle(IGESData_IGESEntity) res;
TheLength = 1;
if (start.IsNull())
@@ -640,7 +640,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(const Handle
}
//=============================================================================
// Transfer des Entites CylindricalSurface de Geom vers IGES
// Transfer of CylindricalSurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -678,7 +678,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
if (Precision::IsPositiveInfinite(Vfin))
V2 = Precision::Infinite();
// creation de la generatrice : Generatrix
// creation of the generatrix : Generatrix
Handle(Geom_Line) Ligne =
new Geom_Line(gp_Pnt(start->Cylinder().Radius(), 0.0, 0.0), gp_Dir(0.0, 0.0, 1.0));
GeomToIGES_GeomCurve GC(*this);
@@ -687,7 +687,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
gp_Pnt gen2 = Ligne->Value(V2);
TheLength = gen1.Distance(gen2);
// creation de l`axe : Axis .
// creation of the axis : Axis .
Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
// #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
// Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -695,8 +695,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
Axis->Init(gp_XYZ(0, 0, 1.), gp_XYZ(0, 0, 0));
Surf->Init(Axis, Generatrix, 2 * M_PI - U2, 2 * M_PI - U1);
// creation de la Trsf (#124)
// il faut tenir compte de l`unite pour la matrice de transformation
// creation of the Trsf (#124)
// we must take into account the unit for the transformation matrix
// (partie translation).
IGESConvGeom_GeomBuilder Build;
Standard_Real xloc, yloc, zloc;
@@ -717,7 +717,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites ConicalSurface de Geom vers IGES
// Transfer of ConicalSurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -755,7 +755,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
if (Precision::IsPositiveInfinite(Vfin))
V2 = Precision::Infinite();
// creation de la generatrice : Generatrix
// creation of the generatrix : Generatrix
Handle(Geom_Line) Ligne =
new Geom_Line(gp_Pnt(start->Cone().RefRadius(), 0.0, 0.0),
gp_Dir(sin(start->Cone().SemiAngle()), 0., cos(start->Cone().SemiAngle())));
@@ -766,7 +766,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
// TheLength = gen1.Distance(gen2)*Cos(start->Cone().SemiAngle());
TheLength = gen1.Distance(gen2);
// creation de l`axe : Axis .
// creation of the axis : Axis .
Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
// #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
// Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -774,8 +774,8 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
Axis->Init(gp_XYZ(0, 0, 1.), gp_XYZ(0, 0, 0));
Surf->Init(Axis, Generatrix, 2 * M_PI - U2, 2 * M_PI - U1);
// creation de la Trsf (#124)
// il faut tenir compte de l`unite pour la matrice de transformation
// creation of the Trsf (#124)
// we must take into account the unit for the transformation matrix
// (partie translation).
IGESConvGeom_GeomBuilder Build;
Standard_Real xloc, yloc, zloc;
@@ -796,7 +796,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites SphericalSurface de Geom vers IGES
// Transfer of SphericalSurface Entities from Geom to IGES
// TransferSurface
//=============================================================================
@@ -833,13 +833,13 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
Standard_Real V1 = Vdeb;
Standard_Real V2 = Vfin;
// creation de la generatrice : Generatrix (1/2 cercle)
// creation of the generatrix : Generatrix (1/2 cercle)
gp_Ax2 Axe(gp::Origin(), -gp::DY(), gp::DX());
Handle(Geom_Circle) Cercle = new Geom_Circle(Axe, start->Sphere().Radius());
GeomToIGES_GeomCurve GC(*this);
Handle(IGESData_IGESEntity) Gen = GC.TransferCurve(Cercle, V1, V2);
// creation de l`axe : Axis .
// creation of the axis : Axis .
Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
// #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
// Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -900,13 +900,13 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
Standard_Real V1 = Vdeb;
Standard_Real V2 = Vfin;
// creation de la generatrice : Generatrix (cercle)
// creation of the generatrix : Generatrix (cercle)
gp_Ax2 Axe = gp_Ax2(gp_Pnt((start->Torus().MajorRadius()), 0., 0.), -gp::DY(), gp::DX());
Handle(Geom_Circle) Cercle = new Geom_Circle(Axe, start->Torus().MinorRadius());
GeomToIGES_GeomCurve GC(*this);
Handle(IGESData_IGESEntity) Gen = GC.TransferCurve(Cercle, V1, V2);
// creation de l`axe : Axis .
// creation of the axis : Axis .
Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
// #30 rln 19.10.98 IGES axis = reversed CAS.CADE axis
// Axis->Init(gp_XYZ(0.0, 0.0, 0.0), gp_XYZ(0.0, 0.0, 1.0/GetUnit()));
@@ -1014,7 +1014,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
// dans IGES l'origine de la generatrice est identique a l'origine
// de la directrice , il faut translater la courbe si les deux
// points ne sont pas confondus dans Geom et donc la copier !!!!!!!
// points are not coincident in Geom and therefore copy it !!!!!!!
gp_Pnt TheEnd = start->Value(U1, V2);
Standard_Real Xe, Ye, Ze;
TheEnd.Coord(Xe, Ye, Ze);
@@ -1085,7 +1085,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
if (Precision::IsPositiveInfinite(Vfin))
V2 = Precision::Infinite();
// creation de la generatrice : Generatrix
// creation of the generatrix : Generatrix
Handle(Geom_Curve) Curve = start->BasisCurve();
GeomToIGES_GeomCurve GC(*this);
Handle(IGESData_IGESEntity) Generatrix = GC.TransferCurve(Curve, V1, V2);
@@ -1104,7 +1104,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
TheLength = gen1.Distance(gen2);
}
// creation de l`axe : Axis .
// creation of the axis : Axis .
Handle(IGESGeom_Line) Axis = new IGESGeom_Line;
gp_Ax1 Axe = start->Axis();
Standard_Real X1, Y1, Z1, X2, Y2, Z2;
@@ -1170,7 +1170,7 @@ Handle(IGESData_IGESEntity) GeomToIGES_GeomSurface::TransferSurface(
}
//=============================================================================
// Transfer des Entites Plane de Geom vers IGESSolid
// Transfer of Plane Entities from Geom to IGESSolid
// TransferPlaneSurface
//=============================================================================

10
src/DataExchange/TKDEIGES/GeomToIGES/GeomToIGES_GeomVector.cxx
View File

@@ -12,8 +12,8 @@
// commercial license or contractual agreement.
// modif du 14/09/95 mjm
// prise en compte de l'unite choisi par l'utilisateur
// pour l'ecriture du fichier IGES.
// taking into account the unit chosen by the user
// for writing the IGES file.
#include <Geom_Direction.hxx>
#include <Geom_Vector.hxx>
@@ -42,7 +42,7 @@ GeomToIGES_GeomVector::GeomToIGES_GeomVector(const GeomToIGES_GeomEntity& GE)
}
//=============================================================================
// Transfer des Entites Vector de Geom vers IGES
// Transfer of Vector Entities from Geom to IGES
// TransferVector
//=============================================================================
@@ -69,7 +69,7 @@ Handle(IGESGeom_Direction) GeomToIGES_GeomVector::TransferVector(const Handle(Ge
}
//=============================================================================
// Transfer des Entites VectorWithMagnitude de Geom vers IGES
// Transfer of VectorWithMagnitude Entities from Geom to IGES
// TransferVector
//=============================================================================
@@ -90,7 +90,7 @@ Handle(IGESGeom_Direction) GeomToIGES_GeomVector::TransferVector(
}
//=============================================================================
// Transfer des Entites Direction de Geom vers IGES
// Transfer of Direction Entities from Geom to IGES
// TransferVector
//=============================================================================

2
src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolDrilledHole.cxx
View File

@@ -104,7 +104,7 @@ Standard_Boolean IGESAppli_ToolDrilledHole::OwnCorrect(
Handle(IGESData_LevelListEntity) nulevel;
ent->InitLevel(nulevel, 0);
res = Standard_True;
} // NbPropertyvalues = 5 + RAZ level selon subordinate
} // NbPropertyvalues = 5 + RAZ level according to subordinate
return res;
}

4
src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolElementResults.cxx
View File

@@ -473,8 +473,8 @@ void IGESAppli_ToolElementResults::OwnDump(const Handle(IGESAppli_ElementResults
S << "\nResult Data Locations : ";
S << " TO BE DONE ";
// ?? A VERIFIER DE PRES, pas du tout sur que ce soit bon
// cf aussi Write et Copy
// ?? TO VERIFY CLOSELY, not at all sure this is correct
// see also Write and Copy
if (level <= 4)
S << " [ ask level > 4 for more, > 5 for complete ]\n";
else

2
src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolLineWidening.cxx
View File

@@ -108,7 +108,7 @@ Standard_Boolean IGESAppli_ToolLineWidening::OwnCorrect(
ent->InitLevel(nulevel, 0);
res = Standard_True;
}
return res; // nbpropertyvalues = 5 + RAZ level selon subordinate
return res; // nbpropertyvalues = 5 + reset level according to subordinate
}
IGESData_DirChecker IGESAppli_ToolLineWidening::DirChecker(

2
src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolPinNumber.cxx
View File

@@ -80,7 +80,7 @@ Standard_Boolean IGESAppli_ToolPinNumber::OwnCorrect(const Handle(IGESAppli_PinN
Handle(IGESData_LevelListEntity) nulevel;
ent->InitLevel(nulevel, 0);
}
return res; // RAZ level selon subordibate
return res; // RAZ level according to subordinate
}
IGESData_DirChecker IGESAppli_ToolPinNumber::DirChecker(

2
src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolReferenceDesignator.cxx
View File

@@ -89,7 +89,7 @@ Standard_Boolean IGESAppli_ToolReferenceDesignator::OwnCorrect(
ent->InitLevel(nulevel, 0);
res = Standard_True;
}
return res; // + RAZ level selon subordibate
return res; // + RAZ level according to subordinate
}
IGESData_DirChecker IGESAppli_ToolReferenceDesignator::DirChecker(

2
src/DataExchange/TKDEIGES/IGESAppli/IGESAppli_ToolRegionRestriction.cxx
View File

@@ -91,7 +91,7 @@ Standard_Boolean IGESAppli_ToolRegionRestriction::OwnCorrect(
ent->InitLevel(nulevel, 0);
res = Standard_True;
}
return res; // + RAZ level selon subordibate
return res; // + reset level according to subordinate
}
IGESData_DirChecker IGESAppli_ToolRegionRestriction::DirChecker(

2
src/DataExchange/TKDEIGES/IGESBasic/IGESBasic_ExternalRefFileName.cxx
View File

@@ -30,7 +30,7 @@ void IGESBasic_ExternalRefFileName::Init(const Handle(TCollection_HAsciiString)&
theExtRefFileIdentifier = aFileIdent;
theExtRefEntitySymbName = anExtName;
InitTypeAndForm(416, FormNumber());
// FormNumber 0-2 : sens pas clair. Pourrait etre 0:Definition 2:Entity
// FormNumber 0-2 : meaning not clear. Could be 0:Definition 2:Entity
}
void IGESBasic_ExternalRefFileName::SetForEntity(const Standard_Boolean F)

4
src/DataExchange/TKDEIGES/IGESControl/IGESControl_ActorWrite.cxx
View File

@@ -107,8 +107,8 @@ Handle(Transfer_Binder) IGESControl_ActorWrite::Transfer(const Handle(Transfer_F
DeclareAndCast(Geom_Curve, Curve, geom);
DeclareAndCast(Geom_Surface, Surf, geom);
// On reconnait : Curve et Surface de Geom
// quid de Point; Geom2d ?
// We recognize: Curve and Surface from Geom
// what about Point; Geom2d ?
// GeomToIGES_GeomPoint GP;
GeomToIGES_GeomCurve GC;

14
src/DataExchange/TKDEIGES/IGESControl/IGESControl_Controller.cxx
View File

@@ -92,7 +92,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
flf->SetDefault(12);
AddSessionItem(flf, "iges-float-digits-12", Standard_True);
// -- Sender Product Identification -- (pas un statique ...)
// -- Sender Product Identification -- (not a static ...)
Handle(IGESSelect_SetGlobalParameter) set3 = new IGESSelect_SetGlobalParameter(3);
Handle(TCollection_HAsciiString) pa3 =
Interface_Static::Static("write.iges.header.product")->HStringValue();
@@ -102,7 +102,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
AddSessionItem(new IGESSelect_UpdateFileName, "iges-update-file-name", Standard_True);
// -- Receiver -- Acces par Static, ajustable
// -- Receiver -- Access by Static, adjustable
Handle(IGESSelect_SetGlobalParameter) set12 = new IGESSelect_SetGlobalParameter(12);
Handle(TCollection_HAsciiString) pa12 =
Interface_Static::Static("write.iges.header.receiver")->HStringValue();
@@ -110,7 +110,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
AddSessionItem(pa12, "iges-header-val-receiver");
AddSessionItem(set12, "iges-header-set-receiver", Standard_True);
// -- Auteur -- acces par Static (demarre par whoami), ajustable
// -- Author -- access by Static (started by whoami), adjustable
Handle(IGESSelect_SetGlobalParameter) set21 = new IGESSelect_SetGlobalParameter(21);
Handle(TCollection_HAsciiString) pa21 =
Interface_Static::Static("write.iges.header.author")->HStringValue();
@@ -118,7 +118,7 @@ IGESControl_Controller::IGESControl_Controller(const Standard_Boolean mod)
AddSessionItem(pa21, "iges-header-val-author");
AddSessionItem(set21, "iges-header-set-author", Standard_True);
// -- Compagnie (de l auteur) -- acces par Static, ajustable
// -- Company (of the author) -- access by Static, adjustable
Handle(IGESSelect_SetGlobalParameter) set22 = new IGESSelect_SetGlobalParameter(22);
Handle(TCollection_HAsciiString) pa22 =
Interface_Static::Static("write.iges.header.company")->HStringValue();
@@ -301,7 +301,7 @@ void IGESControl_Controller::Customise(Handle(XSControl_WorkSession)& WS)
Handle(Interface_InterfaceModel) IGESControl_Controller::NewModel() const
{
// On prend un modele qu on prepare avec les statiques enregistres
// We take a model that we prepare with registered statics
DeclareAndCast(IGESData_IGESModel, igm, Interface_InterfaceModel::Template("iges"));
IGESData_GlobalSection GS = igm->GlobalSection();
@@ -332,8 +332,8 @@ Handle(Transfer_ActorOfTransientProcess) IGESControl_Controller::ActorRead(
return myAdaptorRead;
}
// #### TRANSFERT (ECRITURE SHAPE) ####
// modetrans : 0 <5.1 (groupe de faces), 1 BREP-5.1
// #### TRANSFER (SHAPE WRITING) ####
// modetrans : 0 <5.1 (group of faces), 1 BREP-5.1
//=================================================================================================

4
src/DataExchange/TKDEIGES/IGESControl/IGESControl_Reader.cxx
View File

@@ -105,7 +105,7 @@ Standard_Integer IGESControl_Reader::NbRootsForTransfer()
Handle(IGESData_IGESEntity) ent = model->Entity(i);
if (SH.IsShared(ent) || !actor->Recognize(ent))
continue;
// on ajoute un traitement pour ne prendre que les entites visibles
// add processing to take only visible entities
if (!theReadOnlyVisible || ent->BlankStatus() == 0)
{
theroots.Append(ent);
@@ -115,7 +115,7 @@ Standard_Integer IGESControl_Reader::NbRootsForTransfer()
return theroots.Length();
}
// #### Reliquat de methodes a reprendre ####
// #### Remainder of methods to be reworked ####
//=======================================================================
// Function : PrintTransferInfo

6
src/DataExchange/TKDEIGES/IGESControl/IGESControl_Writer.cxx
View File

@@ -186,8 +186,8 @@ Standard_Boolean IGESControl_Writer::AddGeom(const Handle(Standard_Transient)& g
DeclareAndCast(Geom_Surface, Surf, geom);
Handle(IGESData_IGESEntity) ent;
// On reconnait : Curve et Surface de Geom
// quid de Point; Geom2d ?
// We recognize: Curve and Surface from Geom
// what about Point; Geom2d ?
// GeomToIGES_GeomPoint GP;
GeomToIGES_GeomCurve GC;
@@ -254,7 +254,7 @@ Standard_Boolean IGESControl_Writer::Write(Standard_OStream& S, const Standard_B
if (!nbEnt)
return Standard_False;
IGESData_IGESWriter IW(myModel);
// ne pas oublier le mode fnes ... a transmettre a IW
// do not forget the fnes mode ... to transmit to IW
IW.SendModel(IGESSelect_WorkLibrary::DefineProtocol());
if (fnes)
IW.WriteMode() = 10;

8
src/DataExchange/TKDEIGES/IGESConvGeom/IGESConvGeom.cxx
View File

@@ -41,12 +41,12 @@ Standard_Integer IGESConvGeom::SplineCurveFromIGES(const Handle(IGESGeom_SplineC
{
Standard_Integer returned = 0;
// on recupere le degre
// we retrieve the degree
Standard_Integer degree = st->SplineType();
if (degree > 3)
degree = 3;
// on recupere le nombre de segments.
// we retrieve the number of segments.
Standard_Integer nbSegs = st->NbSegments();
if (nbSegs < 1)
return 5; // FAIL : no segment
@@ -71,8 +71,8 @@ Standard_Integer IGESConvGeom::SplineCurveFromIGES(const Handle(IGESGeom_SplineC
TColgp_Array1OfPnt bspoles(1, nbSegs * degree + 1);
Standard_Integer ibspole = bspoles.Lower() - 1; // Bspole Index.
// il faut reparametrer avant de passer dans PLib.
// on est entre[0, T(i+1)-T(i)] et on veut [0,1]
// we need to reparameterize before passing to PLib.
// we are between [0, T(i+1)-T(i)] and we want [0,1]
for (i = 1; i <= nbSegs; i++)
{

6
src/DataExchange/TKDEIGES/IGESConvGeom/IGESConvGeom_GeomBuilder.cxx
View File

@@ -78,7 +78,7 @@ Handle(IGESGeom_CopiousData) IGESConvGeom_GeomBuilder::MakeCopiousData(
if (datatype < 1 || datatype > 3 || nb == 0 || (polyline && datatype == 3))
throw Standard_DomainError("IGESConvGeom_GeomBuilder : MakeCopiousData");
Standard_Integer nbd = datatype + 1; // 1->2 2->3 et 3->6
Standard_Integer nbd = datatype + 1; // 1->2 2->3 and 3->6
if (datatype == 3)
nbd = 6;
Handle(TColStd_HArray1OfReal) data = new TColStd_HArray1OfReal(1, nb * nbd);
@@ -144,7 +144,7 @@ Standard_Boolean IGESConvGeom_GeomBuilder::IsIdentity() const
{
if (thepos.Form() == gp_Identity)
return Standard_True;
// sinon, regarder de plus pres ...
// otherwise, look more closely ...
if (!IsTranslation())
return Standard_False;
if (!thepos.TranslationPart().IsEqual(gp_XYZ(0., 0., 0.), epsl))
@@ -156,7 +156,7 @@ Standard_Boolean IGESConvGeom_GeomBuilder::IsTranslation() const
{
if (thepos.Form() == gp_Identity || thepos.Form() == gp_Translation)
return Standard_True;
// sinon, regarder de plus pres ...
// otherwise, look more closely ...
Standard_Integer i, j;
for (i = 1; i <= 3; i++)

10
src/DataExchange/TKDEIGES/IGESData/IGESData.cxx
View File

@@ -39,7 +39,7 @@ void IGESData::Init()
stmod = new IGESData_DefaultGeneral;
if (speci.IsNull())
speci = new IGESData_DefaultSpecific;
// et modele template "iges"
// and template model "iges"
if (Interface_InterfaceModel::HasTemplate("iges"))
return;
@@ -206,9 +206,9 @@ void IGESData::Init()
(host.SystemVersion().ToCString());
#endif
// SendName : nom significatif de la piece transmise par exemple
// SystemId : c est MDTV etc
// InterfaceVersion : la version en cours de XSTEP; incluant la plateforme
// SendName : significant name of the transmitted part for example
// SystemId : it is MDTV etc
// InterfaceVersion : the current version of XSTEP; including the platform
char nomsys[100]; int istat; long lstat;
struct utsname infosy;
@@ -261,7 +261,7 @@ void IGESData::Init()
// new TCollection_HAsciiString (process.UserName());
GS.SetCompanyName(Interface_Static::Static("write.iges.header.company")->HStringValue());
// new TCollection_HAsciiString("Matra Datavision");
GS.SetIGESVersion(11); // pour IGES-5.3 //gka 19.01.99
GS.SetIGESVersion(11); // for IGES-5.3 //gka 19.01.99
GS.SetDraftingStandard(0);
GS.SetLastChangeDate(datestr);
GS.SetApplicationProtocol(new TCollection_HAsciiString("")); // gka 19.01.99

56
src/DataExchange/TKDEIGES/IGESData/IGESData_BasicEditor.cxx
View File

@@ -69,7 +69,7 @@ Handle(IGESData_IGESModel) IGESData_BasicEditor::Model() const
return themodel;
}
// #### Travaux sur le Header (GlobalSection) ####
// #### Work on the Header (GlobalSection) ####
Standard_Boolean IGESData_BasicEditor::SetUnitFlag(const Standard_Integer flag)
{
@@ -96,7 +96,7 @@ Standard_Boolean IGESData_BasicEditor::SetUnitValue(const Standard_Real val)
Standard_Real vmm = val * themodel->GlobalSection().CascadeUnit();
// #73 rln 10.03.99 S4135: "read.scale.unit" does not affect GlobalSection
// if (Interface_Static::IVal("read.scale.unit") == 1) vmm = vmm * 1000.;
// vmm est exprime en MILLIMETRES
// vmm is expressed in MILLIMETERS
Standard_Integer aFlag = GetFlagByValue(vmm);
return (aFlag > 0) ? SetUnitFlag(aFlag) : Standard_False;
}
@@ -170,7 +170,7 @@ void IGESData_BasicEditor::ApplyUnit(const Standard_Boolean enforce)
theunit = Standard_False;
}
// #### Travaux globaux sur les entites ####
// #### Global work on entities ####
void IGESData_BasicEditor::ComputeStatus()
{
@@ -184,34 +184,34 @@ void IGESData_BasicEditor::ComputeStatus()
Interface_Graph G(themodel, theglib); // gere & memorise UseFlag
G.ResetStatus();
// 2 phases : d abord on fait un calcul d ensemble. Ensuite on applique
// Tout le modele est traite, pas de jaloux
// 2 phases : first we do an overall calculation. Then we apply
// The whole model is processed, no favorites
// Chaque entite va donner une contribution sur ses descendents propres :
// pour Subordinate (1 ou 2 cumulables), pour UseFlag (1 a 6 exclusifs)
// (6 depuis IGES-5.2)
// Each entity will give a contribution on its own descendants :
// for Subordinate (1 or 2 cumulative), for UseFlag (1 to 6 exclusive)
// (6 since IGES-5.2)
// Pour Subordinate : Drawing et 402 (sauf p-e dimensioned geometry ?) donnent
// Logical, le reste implique Physical (sur descendants directs propres)
// For Subordinate : Drawing and 402 (except maybe dimensioned geometry ?) give
// Logical, the rest implies Physical (on direct descendants)
// Pour UseFlag, un peu plus complique :
// D une part, les UseFlag se propagent aux descendants directs ou non
// D autre part les cas sont plus compliques (et pas aussi clairs)
// For UseFlag, a bit more complicated :
// On one hand, UseFlags propagate to direct descendants or not
// On the other hand cases are more complicated (and not as clear)
// ATTENTION, on ne peut traiter que ce qui se deduit du graphe en s appuyant
// sur les "IGES Type Number", on n a pas le droit ici d acceder a la
// description specifique des differents types : traites par AutoCorrect.
// Exemple : une courbe est 3D ou parametrique 2D(UV), non seulement selon son
// ascendant, mais selon le role qu elle y joue (ex. pour CurveOnSurface :
// WARNING, we can only process what can be deduced from the graph by relying
// on "IGES Type Number", we don't have the right here to access the
// specific description of different types : handled by AutoCorrect.
// Example : a curve is 3D or parametric 2D(UV), not only according to its
// ancestor, but according to the role it plays there (ex. for CurveOnSurface :
// CurveUV/Curve3D)
// Traites actuellement (necessaires) :
// 1(Annotation), aussi 4(pour maillage). 5(ParamUV) traite par AutoCorrect
// Currently handled (necessary) :
// 1(Annotation), also 4(for meshing). 5(ParamUV) handled by AutoCorrect
Standard_Integer CN;
Standard_Integer i; // svv Jan11 2000 : porting on DEC
for (i = 1; i <= nb; i++)
{
// Subordinate (sur directs en propre seulement)
// Subordinate (on direct descendants only)
Handle(IGESData_IGESEntity) ent = themodel->Entity(i);
Standard_Integer igt = ent->TypeNumber();
Handle(Interface_GeneralModule) gmodule;
@@ -241,7 +241,7 @@ void IGESData_BasicEditor::ComputeStatus()
Interface_EntityIterator sh = G.Sharings(ent); // Maillage ...
if (sh.NbEntities() > 0)
G.GetFromEntity(ent, Standard_True, 4);
// UV : voir AutoCorrect des classes concernees (Boundary et CurveOnSurface)
// UV : see AutoCorrect of concerned classes (Boundary and CurveOnSurface)
/*
} else if (ent->IsKind(STANDARD_TYPE(IGESGeom_CurveOnSurface))) {
DeclareAndCast(IGESGeom_CurveOnSurface,cos,ent); // Curve UV
@@ -258,8 +258,8 @@ void IGESData_BasicEditor::ComputeStatus()
}
}
// A present, on va appliquer tout cela "de force"
// Seule exception : des UseFlags non nuls deja en place sont laisses
// Now, we will apply all this "by force"
// Only exception: non-zero UseFlags already in place are left
for (i = 1; i <= nb; i++)
{
@@ -289,9 +289,9 @@ Standard_Boolean IGESData_BasicEditor::AutoCorrect(const Handle(IGESData_IGESEnt
Standard_Boolean done = Standard_False;
if (ent.IsNull())
return done;
// Corrections dans l entete (entites presentes)
// On ne verifie pas les items "Shared", presents de toute facon
// Entete : traite par DirChecker pour les cas standard
// Corrections in the header (present entities)
// We don't check "Shared" items, present anyway
// Header : handled by DirChecker for standard cases
/*
linefont = ent->LineFont();
if (!linefont.IsNull() && themodel->Number(linefont) == 0) {
@@ -331,7 +331,7 @@ Standard_Boolean IGESData_BasicEditor::AutoCorrect(const Handle(IGESData_IGESEnt
}
*/
// Corrections dans les Assocs (les Props restent attachees a l Entite)
// Corrections in Assocs (Props remain attached to the Entity)
Interface_EntityIterator iter = ent->Associativities();
for (iter.Start(); iter.More(); iter.Next())
{

2
src/DataExchange/TKDEIGES/IGESData/IGESData_ColorEntity.cxx
View File

@@ -16,4 +16,4 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_ColorEntity, IGESData_IGESEntity)
// ColorEntity ne sert qu'au controle de type (entite Color du directory part)
// ColorEntity is only used for type control (Color entity of the directory part)

6
src/DataExchange/TKDEIGES/IGESData/IGESData_DefSwitch.cxx
View File

@@ -13,9 +13,9 @@
#include <IGESData_DefSwitch.hxx>
// DefSwitch : represente une definition, soit vide (-> valeur = 0),
// soit comme rang dans une table (-> valeur > 0 ce rang),
// soit comme reference (-> valeur < 0), la reference elle-meme est ailleurs
// DefSwitch : represents a definition, either empty (-> value = 0),
// or as rank in a table (-> value > 0 this rank),
// or as reference (-> value < 0), the reference itself is elsewhere
//=================================================================================================

10
src/DataExchange/TKDEIGES/IGESData/IGESData_DefaultGeneral.cxx
View File

@@ -58,14 +58,14 @@ IGESData_DirChecker IGESData_DefaultGeneral::DirChecker(const Standard_Integer,
{
IGESData_DirChecker dc;
return dc;
} // aucun critere specifique
} // no specific criteria
void IGESData_DefaultGeneral::OwnCheckCase(const Standard_Integer,
const Handle(IGESData_IGESEntity)&,
const Interface_ShareTool&,
Handle(Interface_Check)&) const
{
} // aucun critere specifique
} // no specific criteria
Standard_Boolean IGESData_DefaultGeneral::NewVoid(const Standard_Integer CN,
Handle(Standard_Transient)& entto) const
@@ -89,12 +89,12 @@ void IGESData_DefaultGeneral::OwnCopyCase(const Standard_Integer CN,
return;
DeclareAndCast(IGESData_UndefinedEntity, enfr, entfrom);
DeclareAndCast(IGESData_UndefinedEntity, ento, entto);
// ShallowCopy aura passe DirStatus
// transmettre les contenus des UndefinedContents
// ShallowCopy will have passed DirStatus
// transmit the contents of UndefinedContents
Handle(Interface_UndefinedContent) cont = new Interface_UndefinedContent;
cont->GetFromAnother(enfr->UndefinedContent(), TC);
ento->SetNewContent(cont);
// FreeFormat, encore des choses
// FreeFormat, more things
if (enfr->IsKind(STANDARD_TYPE(IGESData_FreeFormatEntity)))
{
DeclareAndCast(IGESData_FreeFormatEntity, enf, entfrom);

32
src/DataExchange/TKDEIGES/IGESData/IGESData_DirChecker.cxx
View File

@@ -23,17 +23,17 @@
#include <stdio.h>
// Pour Correct :
// For Correct :
// MGE 23/07/98
// Chaque critere est par defaut inhibe
// Each criterion is inhibited by default
//=================================================================================================
IGESData_DirChecker::IGESData_DirChecker()
{
thetype = theform1 = theform2 = 0;
thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
thegraphier = -100; // ne pas tester GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // ne pas tester
thegraphier = -100; // do not test GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // do not test
}
//=================================================================================================
@@ -42,10 +42,10 @@ IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype)
{
thetype = atype;
theform1 = 0;
theform2 = -1; // test de forme inhibe
theform2 = -1; // form test inhibited
thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
thegraphier = -100; // ne pas tester GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // ne pas tester
thegraphier = -100; // do not test GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // do not test
}
//=================================================================================================
@@ -53,10 +53,10 @@ IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype)
IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype, const Standard_Integer aform)
{
thetype = atype;
theform1 = theform2 = aform; // forme : valeur requise
theform1 = theform2 = aform; // form : required value
thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
thegraphier = -100; // ne pas tester GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // ne pas tester
thegraphier = -100; // do not test GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // do not test
}
//=================================================================================================
@@ -67,10 +67,10 @@ IGESData_DirChecker::IGESData_DirChecker(const Standard_Integer atype,
{
thetype = atype;
theform1 = aform1;
theform2 = aform2; // forme : [...]
theform2 = aform2; // form : [...]
thestructure = thelinefont = thelineweig = thecolor = IGESData_ErrorRef;
thegraphier = -100; // ne pas tester GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // ne pas tester
thegraphier = -100; // do not test GraphicsIgnored
theblankst = thesubordst = theuseflag = thehierst = -100; // do not test
}
//=================================================================================================
@@ -85,7 +85,7 @@ Standard_Boolean IGESData_DirChecker::IsSet() const
void IGESData_DirChecker::SetDefault()
{
Structure(IGESData_DefVoid);
} // Option par defaut
} // Default option
//=================================================================================================
@@ -377,14 +377,14 @@ Standard_Boolean IGESData_DirChecker::Correct(const Handle(IGESData_IGESEntity)&
}
}
Handle(IGESData_IGESEntity) structure; // par defaut Nulle
Handle(IGESData_IGESEntity) structure; // by default Null
if (thestructure != IGESData_DefVoid)
structure = ent->Structure();
Handle(IGESData_ViewKindEntity) nulview;
Handle(IGESData_LineFontEntity) nulfont;
Handle(IGESData_LevelListEntity) nulevel;
Handle(IGESData_ColorEntity) nulcolor;
Handle(IGESData_LabelDisplayEntity) label; // par defaut Nulle
Handle(IGESData_LabelDisplayEntity) label; // by default Null
if (thegraphier != -1)
label = ent->LabelDisplay();
Standard_Integer linew = 0;

2
src/DataExchange/TKDEIGES/IGESData/IGESData_DirPart.cxx
View File

@@ -69,7 +69,7 @@ void IGESData_DirPart::Init(const Standard_Integer i1,
thesubs[8] = '\0';
}
// CString : on modifie leur CONTENU, pas le POINTEUR LUI-MEME
// CString : we modify their CONTENT, not the POINTER ITSELF
//=================================================================================================

6
src/DataExchange/TKDEIGES/IGESData/IGESData_FreeFormatEntity.cxx
View File

@@ -21,8 +21,8 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_FreeFormatEntity, IGESData_UndefinedEntity)
// Donne un acces simple a la constitution d une UndefinedEntity :
// Methodes de UndefinedContent, + Type & Form, + AddEntities (little gadget)
// Provides simple access to the constitution of an UndefinedEntity :
// Methods of UndefinedContent, + Type & Form, + AddEntities (little gadget)
IGESData_FreeFormatEntity::IGESData_FreeFormatEntity() {}
void IGESData_FreeFormatEntity::SetTypeNumber(const Standard_Integer typenum)
@@ -140,7 +140,7 @@ void IGESData_FreeFormatEntity::ClearNegativePointers()
void IGESData_FreeFormatEntity::WriteOwnParams(IGESData_IGESWriter& IW) const
{
// Redefini de UndefinedEntity pour : NegativePointers
// Redefined from UndefinedEntity for : NegativePointers
Standard_Integer neg = 0;
Standard_Integer fneg = 0;
if (!thenegptrs.IsNull())

6
src/DataExchange/TKDEIGES/IGESData/IGESData_GeneralModule.cxx
View File

@@ -74,7 +74,7 @@ void IGESData_GeneralModule::OwnImpliedCase(const Standard_Integer,
const Handle(IGESData_IGESEntity)&,
Interface_EntityIterator&) const
{
} // par defaut, rien (redefinissable)
} // by default, nothing (redefinable)
void IGESData_GeneralModule::CheckCase(const Standard_Integer CN,
const Handle(Standard_Transient)& ent,
@@ -103,7 +103,7 @@ void IGESData_GeneralModule::CopyCase(const Standard_Integer CN,
DeclareAndCast(IGESData_IGESEntity, enfr, entfrom);
//// ento->Clear();
// ... Reprendre entete ...
// ... Resume header ...
//? ento->InitTypeAndForm (enfr->TypeNumber(), enfr->FormNumber());ShallowCopy
if (enfr->DefLineFont() == IGESData_DefReference)
@@ -206,7 +206,7 @@ void IGESData_GeneralModule::WhenDeleteCase(const Standard_Integer CN
void IGESData_GeneralModule::OwnDeleteCase(const Standard_Integer,
const Handle(IGESData_IGESEntity)&) const
{
} // par defaut, rien (redefinissable)
} // by default, nothing (redefinable)
Handle(TCollection_HAsciiString) IGESData_GeneralModule::Name(const Standard_Integer,
const Handle(Standard_Transient)& ent,

16
src/DataExchange/TKDEIGES/IGESData/IGESData_GlobalSection.cxx
View File

@@ -30,13 +30,13 @@
#include <stdio.h>
// Routines locales copiant une string [l`ideal serait : astr = astr->Copy()]
// et transformant un CString (Hollerith ou non) en HAsciiString non Holl.
// et l inverse
// Local routines copying a string [the ideal would be : astr = astr->Copy()]
// and transforming a CString (Hollerith or not) to non-Hollerith HAsciiString.
// and the reverse
static void CopyString(Handle(TCollection_HAsciiString)& astr)
{
if (astr.IsNull())
return; // ne rien faire si String pas definie !
return; // do nothing if String not defined !
Handle(TCollection_HAsciiString) S = new TCollection_HAsciiString("");
S->AssignCat(astr);
astr = S;
@@ -66,7 +66,7 @@ static void MakeHollerith(const Handle(TCollection_HAsciiString)& astr,
IGESData_GlobalSection::IGESData_GlobalSection()
: theSeparator(','),
theEndMark(';'),
theIntegerBits(32), // simple = entier = 32b, double = 64
theIntegerBits(32), // simple = integer = 32b, double = 64
theMaxPower10Single(38),
theMaxDigitsSingle(6),
theMaxPower10Double(308),
@@ -127,7 +127,7 @@ void IGESData_GlobalSection::Init(const Handle(Interface_ParamSet)& params,
theFileName.Nullify();
theSystemId.Nullify();
theInterfaceVersion.Nullify();
theIntegerBits = 32; // par defaut, simple = entier = 32b, double = 64
theIntegerBits = 32; // by default, simple = integer = 32b, double = 64
theMaxPower10Single = 38;
theMaxDigitsSingle = 6;
theMaxPower10Double = 308;
@@ -149,8 +149,8 @@ void IGESData_GlobalSection::Init(const Handle(Interface_ParamSet)& params,
// clang-format on
theDraftingStandard = 0;
theCascadeUnit = UnitsMethods::GetCasCadeLengthUnit();
theLastChangeDate.Nullify(); // nouveaute 5.1 (peut etre absente)
theAppliProtocol.Nullify(); // nouveaute 5.3 (peut etre absente)
theLastChangeDate.Nullify(); // new in 5.1 (may be absent)
theAppliProtocol.Nullify(); // new in 5.3 (may be absent)
Standard_Integer nbp = params->NbParams();

4
src/DataExchange/TKDEIGES/IGESData/IGESData_IGESDumper.cxx
View File

@@ -38,7 +38,7 @@ IGESData_IGESDumper::IGESData_IGESDumper(const Handle(IGESData_IGESModel)& model
void IGESData_IGESDumper::PrintDNum(const Handle(IGESData_IGESEntity)& ent,
Standard_OStream& S) const
{
// Affichage garanti sur 12 caracteres 12345/D24689
// Display guaranteed on 12 characters 12345/D24689
Standard_Integer num = 0;
if (!ent.IsNull())
{
@@ -239,7 +239,7 @@ void IGESData_IGESDumper::Dump(const Handle(IGESData_IGESEntity)& ent,
}
}
// Donnees attachees : Properties, Associativities, et Sharings
// Attached data : Properties, Associativities, and Sharings
if (att < 0)
return;
Interface_EntityIterator iter = ent->Properties();

8
src/DataExchange/TKDEIGES/IGESData/IGESData_IGESEntity.cxx
View File

@@ -66,7 +66,7 @@ IGESData_IGESEntity::IGESData_IGESEntity()
void IGESData_IGESEntity::Clear()
{
// Handle et DefSwitch
// Handle and DefSwitch
theStructure.Nullify();
theDefLineFont.SetVoid();
theLineFont.Nullify();
@@ -222,8 +222,8 @@ Handle(IGESData_LabelDisplayEntity) IGESData_IGESEntity::LabelDisplay() const
return GetCasted(IGESData_LabelDisplayEntity, theLabDisplay);
}
// Status : un Integer pour BlankStatus,SubrodinateStatus,USeFlag,HierarchySt.
// Decoupage : 4 bits chacun (BlankStatus tout a droite, etc)
// Status : an Integer for BlankStatus,SubordinateStatus,UseFlag,HierarchySt.
// Division : 4 bits each (BlankStatus on the right, etc)
Standard_Integer IGESData_IGESEntity::BlankStatus() const
{
@@ -446,7 +446,7 @@ gp_GTrsf IGESData_IGESEntity::VectorLocation() const
{
if (!HasTransf())
return gp_GTrsf(); // Identite
// Prendre Location et anuler TranslationPart
// Take Location and cancel TranslationPart
gp_GTrsf loca = Transf()->Value(); // c-a-d Compoound
loca.SetTranslationPart(gp_XYZ(0., 0., 0.));
return loca;

8
src/DataExchange/TKDEIGES/IGESData/IGESData_IGESModel.cxx
View File

@@ -32,7 +32,7 @@ IMPLEMENT_STANDARD_RTTIEXT(IGESData_IGESModel, Interface_InterfaceModel)
static Standard_CString voidline = "";
// Routine interne utilisee pour VerifyCheck
// Internal routine used for VerifyCheck
void IGESData_VerifyDate(const Handle(TCollection_HAsciiString)& str,
Handle(Interface_Check)& ach,
const Standard_CString mess);
@@ -396,7 +396,7 @@ void IGESData_IGESModel::VerifyCheck(Handle(Interface_Check)& ach) const
ach->SendFail(Msg48);
}
// .. verifie-t-on UnitName en accord avec UnitFlag ?
// .. should we verify UnitName in accordance with UnitFlag ?
if (theheader.UnitName().IsNull())
{
// Sending of message : Unit Name parameter is undefined.
@@ -465,7 +465,7 @@ void IGESData_IGESModel::VerifyCheck(Handle(Interface_Check)& ach) const
Message_Msg Msg52("XSTEP_52");
ach->SendFail(Msg52);
}
// .. comment verifier les coordonnees max ?
// .. how to verify the max coordinates ?
// Sending of message : Version Flag parameter is incorrect.
if (theheader.IGESVersion() < 1
@@ -506,7 +506,7 @@ void IGESData_VerifyDate(const Handle(TCollection_HAsciiString)& str,
Message_Msg Msg57("XSTEP_57");
// =====================================
// Attention c est du Hollerith
// Warning this is Hollerith format
if (str.IsNull())
{
ach->SendFail(Msg57);

20
src/DataExchange/TKDEIGES/IGESData/IGESData_IGESReaderData.cxx
View File

@@ -108,7 +108,7 @@ void IGESData_IGESReaderData::SetDirPart(const Standard_Integer num,
res2,
label,
subs);
//// thedirs(num) = DP; // verifier si utile
//// thedirs(num) = DP; // check if useful
// InitParams(num); gka optimization memory
}
@@ -181,18 +181,18 @@ Standard_Integer IGESData_IGESReaderData::FindNextRecord(const Standard_Integer
return (num + 1);
}
// Reference a d'autres entites : c'est a la fois tres simple et problematique
// Tres simple : une reference a une entite est un numero (dans directory list)
// qui vaut (2*N-1) si N est le rang vrai de l'entite
// Problematique : ce numero est un Entier ... rien ne le distingue d'un autre
// D'ou critere : tout entier impair inferieur a 2*NbRecords PEUT etre une
// reference ... C'est a chaque entite de faire ensuite son tri ...
// Attention, une reference peut etre donnee en "Pointeur Negatif"
// N.B.: DirPart non concernes (lecture specifique assuree par IGESEntity)
// Reference to other entities: this is both very simple and problematic
// Very simple: a reference to an entity is a number (in directory list)
// which equals (2*N-1) if N is the true rank of the entity
// Problematic: this number is an Integer... nothing distinguishes it from another
// Hence criterion: any odd integer less than 2*NbRecords CAN be a
// reference... It's up to each entity to sort it out afterwards...
// Attention, a reference can be given as "Negative Pointer"
// N.B.: DirPart not concerned (specific reading ensured by IGESEntity)
void IGESData_IGESReaderData::SetEntityNumbers()
{
// On essaie de se baser uniquement sur calcul de IGESRead
// We try to rely solely on IGESRead calculation
/*
Standard_Integer nbd = thedirs.Upper();
for (Standard_Integer i = 1; i <= nbd; i ++) {

36
src/DataExchange/TKDEIGES/IGESData/IGESData_IGESReaderTool.cxx
View File

@@ -82,9 +82,9 @@ Standard_Boolean IGESData_IGESReaderTool::Recognize(const Standard_Integer
}
// ###########################################################################
// ######## LECTURE (Controle General) ########
// ######## READING (General Control) ########
// (Elements enchaines par la classe de base Interface_FileReaderTool)
// (Elements chained by the base class Interface_FileReaderTool)
void IGESData_IGESReaderTool::BeginRead(const Handle(Interface_InterfaceModel)& amodel)
{
@@ -106,7 +106,7 @@ void IGESData_IGESReaderTool::BeginRead(const Handle(Interface_InterfaceModel)&
thedefweight = igesdat->DefaultLineWeight();
}
// Manquent les procedures de reprise sur erreur en cours de route ...
// Missing error recovery procedures during the process ...
Standard_Boolean IGESData_IGESReaderTool::AnalyseRecord(const Standard_Integer num,
const Handle(Standard_Transient)& anent,
Handle(Interface_Check)& ach)
@@ -117,29 +117,29 @@ Standard_Boolean IGESData_IGESReaderTool::AnalyseRecord(const Standard_Integer
DeclareAndCast(IGESData_IGESEntity, ent, anent);
DeclareAndCast(IGESData_IGESReaderData, igesdat, Data());
// Demarrage de la lecture : Faire Clear
// Start of reading : Do Clear
ent->Clear();
// UndefinedEntity : une pre-analyse est faite
// UndefinedEntity : a pre-analysis is done
DeclareAndCast(IGESData_UndefinedEntity, undent, ent);
if (!undent.IsNull())
{
IGESData_DirPart DP = igesdat->DirPart(num); // qui le copie ...
undent->ReadDir(igesdat, DP, ach); // DP a pu etre modifie
ReadDir(ent, igesdat, DP, ach); // Lecture avec ce DP
IGESData_DirPart DP = igesdat->DirPart(num); // which copies it ...
undent->ReadDir(igesdat, DP, ach); // DP may have been modified
ReadDir(ent, igesdat, DP, ach); // Reading with this DP
}
else
ReadDir(ent, igesdat, igesdat->DirPart(num), ach);
thestep = IGESData_ReadDir;
// Liste de Parametres : controle de son entete
// Parameter List : control of its header
// Handle(Interface_ParamList) list = Data()->Params(num);
Standard_Integer nbpar = Data()->NbParams(num);
Standard_Integer n0par = (num == 1 ? 1 : (Data()->ParamFirstRank(num - 1) + 1));
if (nbpar < 1)
{
// Liste vide non admise, sauf si Undefined (par exemple type nul)
// Empty list not allowed, except if Undefined (for example null type)
if (!undent.IsNull())
return Standard_True;
// Sending of message : DE : no parameter
@@ -196,7 +196,7 @@ void IGESData_IGESReaderTool::EndRead(const Handle(Interface_InterfaceModel)& /*
}
// ###########################################################################
// ######## UNE ENTITE ########
// ######## ONE ENTITY ########
// ######## Directory Part ########
@@ -354,10 +354,10 @@ void IGESData_IGESReaderTool::ReadDir(const Handle(IGESData_IGESEntity)& ent
ent->InitMisc(Structure, Lbd, LWeightNum);
ent->InitDirFieldEntity(8, fieldlab);
// ignores : 1(type),2(ptrPsect),13(type),16(lignesPsect),17(form)
// type et forme sont lus directement du DirPart; autres infos recalculees
// ignores : 1(type),2(ptrPsect),13(type),16(linesPsect),17(form)
// type and form are read directly from DirPart; other info recalculated
// Restent a analyser nom (short label) et snum (subscript number)
// Remaining to analyze name (short label) and snum (subscript number)
Handle(TCollection_HAsciiString) ShortLabel;
Standard_Integer SubScriptN = -1;
Standard_Integer iacar = 0;
@@ -381,7 +381,7 @@ void IGESData_IGESReaderTool::ReadDir(const Handle(IGESData_IGESEntity)& ent
SubScriptN = atoi(snum);
ent->SetLabel(ShortLabel, SubScriptN);
// Enfin, SetLineWeight, tenant compte du defaut
// Finally, SetLineWeight, taking into account the default
ent->SetLineWeight(IR->DefaultLineWeight(), themaxweight, thegradweight);
}
@@ -395,7 +395,7 @@ void IGESData_IGESReaderTool::ReadOwnParams(const Handle(IGESData_IGESEntity)&
Handle(Interface_ReaderModule) imodule;
Standard_Integer CN;
// Les Modules font tout
// The Modules do everything
if (therlib.Select(ent, imodule, CN))
{
Handle(IGESData_ReadWriteModule) module = Handle(IGESData_ReadWriteModule)::DownCast(imodule);
@@ -408,13 +408,13 @@ void IGESData_IGESReaderTool::ReadOwnParams(const Handle(IGESData_IGESEntity)&
Message_Msg Msg35("XSTEP_35");
Msg35.Arg(thecnum);
ach->SendFail(Msg35);
// Cas de UndefinedEntity
// Case of UndefinedEntity
}
else if (ent->IsKind(STANDARD_TYPE(IGESData_UndefinedEntity)))
{
DeclareAndCast(IGESData_UndefinedEntity, undent, ent);
undent->ReadOwnParams(IR, PR);
// IGESEntity creee puis non reconnue ... (bizarre, non ?)
// IGESEntity created then not recognized ... (strange, isn't it ?)
}
else
{

68
src/DataExchange/TKDEIGES/IGESData/IGESData_IGESWriter.cxx
View File

@@ -40,7 +40,7 @@
// #define PATIENCELOG
// Constructeur complet : taille OK, et se remplit depuis le modele en direct
// Complete constructor: size OK, and fills from the model directly
IGESData_IGESWriter::IGESData_IGESWriter(const Handle(IGESData_IGESModel)& amodel)
: thedirs(0, amodel->NbEntities()),
@@ -54,10 +54,10 @@ IGESData_IGESWriter::IGESData_IGESWriter(const Handle(IGESData_IGESModel)& amode
thesep = ',';
theendm = ';';
thepars = new TColStd_HSequenceOfHAsciiString();
thepnum.SetValue(1, 1); // debut des parametres de la 1re entite
thepnum.SetValue(1, 1); // start of parameters for the 1st entity
thesect = 0;
thepnum.Init(0);
// Format flottant : cf FloatWriter
// Floating format : see FloatWriter
}
IGESData_IGESWriter::IGESData_IGESWriter()
@@ -76,7 +76,7 @@ IGESData_IGESWriter::IGESData_IGESWriter(const IGESData_IGESWriter&)
{
}
// .... Controle d Envoi des Flottants ....
// .... Float Sending Control ....
Interface_FloatWriter& IGESData_IGESWriter::FloatWriter()
{
@@ -109,7 +109,7 @@ void IGESData_IGESWriter::SendStartLine(const Standard_CString startline)
thestar->Append(new TCollection_HAsciiString(startline));
return;
}
// Trop longue : on passe par bouts
// Too long: we go piece by piece
char startchar = startline[MaxcarsG];
pstartline[MaxcarsG] = '\0';
SendStartLine(startline);
@@ -141,7 +141,7 @@ void IGESData_IGESWriter::SendModel(const Handle(IGESData_Protocol)& protocol)
if (i % 1000 == 1)
std::cout << "*" << std::flush;
#endif
// Attention aux cas d erreur : contenu redefini
// Watch out for error cases : redefined content
if (themodel->IsRedefinedContent(i))
{
sout << " -- IGESWriter : Erroneous Entity N0." << i << " --" << std::endl;
@@ -153,12 +153,12 @@ void IGESData_IGESWriter::SendModel(const Handle(IGESData_Protocol)& protocol)
}
DirPart(cnt);
OwnParams(ent); // preparation : porte sur le vrai <ent> ...
OwnParams(ent); // preparation: applies to the real <ent> ...
// Envoi proprement dit des Parametres proprement definis
// Actual sending of properly defined Parameters
Handle(IGESData_ReadWriteModule) module;
Standard_Integer CN;
// Differents cas
// Different cases
if (lib.Select(cnt, module, CN))
module->WriteOwnParams(CN, cnt, *this);
else if (cnt->IsKind(STANDARD_TYPE(IGESData_UndefinedEntity)))
@@ -175,7 +175,7 @@ void IGESData_IGESWriter::SendModel(const Handle(IGESData_Protocol)& protocol)
EndEntity();
}
#ifdef PATIENCELOG
std::cout << " Envoi des Entites Termine" << std::endl;
std::cout << " Entity Sending Finished" << std::endl;
#endif
SectionT();
}
@@ -195,8 +195,8 @@ void IGESData_IGESWriter::SectionG(const IGESData_GlobalSection& header)
thesep = header.Separator();
theendm = header.EndMark();
thecurr.SetMax(MaxcarsG);
// Important : les Parametres sont sortis sous leur forme definitive
// (c-a-d Hollerith pour les Textes ...)
// Important : Parameters are output in their final form
// (i.e. Hollerith for Texts ...)
Handle(Interface_ParamSet) gl = header.Params();
Standard_Integer nb = gl->NbParams();
for (Standard_Integer i = 1; i <= nb; i++)
@@ -239,9 +239,9 @@ void IGESData_IGESWriter::DirPart(const Handle(IGESData_IGESEntity)& anent)
if (nument == 0)
return;
IGESData_DirPart& DP = thedirs.ChangeValue(nument);
// Remplissage du DirPart
// Filling the DirPart
v[0] = anent->TypeNumber();
v[1] = 0; // numero en section P : calcule ulterieurement
v[1] = 0; // number in section P: calculated later
if (anent->HasStructure())
v[2] = -themodel->DNum(anent->DirFieldEntity(3));
else
@@ -294,7 +294,7 @@ void IGESData_IGESWriter::DirPart(const Handle(IGESData_IGESEntity)& anent)
else
v[14] = 0;
v[15] = 0; // nb lignes section P : calcule plus tard
v[15] = 0; // number of lines in section P: calculated later
v[16] = anent->FormNumber();
anent->CResValues(res1, res2);
@@ -378,7 +378,7 @@ void IGESData_IGESWriter::Associativities(const Handle(IGESData_IGESEntity)& ane
throw Interface_InterfaceError("IGESWriter : Associativities");
thestep = IGESData_ReadAssocs;
if (!anent->ArePresentAssociativities() && !anent->ArePresentProperties())
return; // Properties suivent : ne pas les omettre !
return; // Properties follow : do not omit them !
Send(anent->NbAssociativities());
for (Interface_EntityIterator iter = anent->Associativities(); iter.More(); iter.Next())
{
@@ -398,7 +398,7 @@ void IGESData_IGESWriter::EndEntity()
thestep = IGESData_ReadEnd;
}
// .... Alimentation des parametres ....
// .... Parameter feeding ....
void IGESData_IGESWriter::AddString(const Handle(TCollection_HAsciiString)& val,
const Standard_Integer more)
@@ -417,7 +417,7 @@ void IGESData_IGESWriter::AddString(const Standard_CString val,
lnstr = (Standard_Integer)strlen(val);
if (!thecurr.CanGet(lnstr + more + 1))
{
// + 1 (18-SEP-1996) pour etre sur que le separateur n est pas en tete de ligne
// + 1 (18-SEP-1996) to be sure that the separator n is not at the head of line
if (thesect < 3)
thehead->Append(thecurr.Moved());
else
@@ -425,7 +425,7 @@ void IGESData_IGESWriter::AddString(const Standard_CString val,
}
Standard_Integer maxcars = (thesect == 3 ? MaxcarsP : MaxcarsG);
Standard_Integer n2 = 0;
// .. pb de taille limite (30-DEC-1996)
// .. size limit issue (30-DEC-1996)
while (lnstr > maxcars)
{
thecurr.Add(&val[n2], lnstr);
@@ -441,7 +441,7 @@ void IGESData_IGESWriter::AddString(const Standard_CString val,
void IGESData_IGESWriter::AddChar(const Standard_Character val, const Standard_Integer more)
{
// 1 seul caractere : cas particulier simplifie
// 1 single character : simplified special case
char text[2];
text[0] = val;
text[1] = '\0';
@@ -479,7 +479,7 @@ void IGESData_IGESWriter::SendBoolean(const Standard_Boolean val)
void IGESData_IGESWriter::Send(const Standard_Real val)
{
// Valeur flottante, expurgee de "0000" qui trainent et de "E+00"
// Floating value, purged of trailing "0000" and "E+00"
char lval[24];
AddChar(thesep);
Standard_Integer lng = thefloatw.Write(val, lval);
@@ -508,7 +508,7 @@ void IGESData_IGESWriter::Send(const Handle(IGESData_IGESEntity)& val,
num = themodel->DNum(val);
if (negative)
num = -num;
Send(num); // qui faut tout, une fois Entity convertie en Integer
Send(num); // which handles everything, once Entity converted to Integer
}
void IGESData_IGESWriter::Send(const gp_XY& val)
@@ -527,7 +527,7 @@ void IGESData_IGESWriter::Send(const gp_XYZ& val)
void IGESData_IGESWriter::SendString(const Handle(TCollection_HAsciiString)& val)
{
AddChar(thesep);
AddString(val); // envoi en l etat
AddString(val); // send as is
}
// .... Envoi final ....
@@ -559,12 +559,12 @@ static void writefnes(Standard_OStream& S, const Standard_CString ligne)
Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
{
// ATTENTION MODEFNES : si themodew = 10 ... alors on ecrit du FNES
// quesaco ? fnes = iges + xor sur les caracteres (150,151,152,153,150...)
// avec en plus une ligne qcq en tete ...
// donc tous les 4 car.s, on fait un tour de modulo. ainsi a 64 et a 72 ...
// On a une mini-routine qui ecrit un morceau de texte "en fnes", et les
// blancs qui sont optimises (quand meme ...)
// WARNING MODEFNES : if themodew = 10 ... then we write FNES
// what is it? fnes = iges + xor on characters (150,151,152,153,150...)
// with additionally some line at the head ...
// so every 4 chars, we do a modulo round. thus at 64 and at 72 ...
// We have a mini-routine that writes a piece of text "in fnes", and the
// blanks that are optimized (anyway ...)
Standard_Boolean isGood = (S.good());
Standard_Boolean fnes = (themodew >= 10);
@@ -587,7 +587,7 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
if (thesect != 4)
throw Interface_InterfaceError("IGESWriter not ready for Print");
// Start Section (assez simple, somme toute). Attention si commentaires
// Start Section (quite simple, all in all). Watch out for comments
Handle(TCollection_HAsciiString) line;
Standard_Integer nbs = 1;
if (thestar.IsNull())
@@ -629,7 +629,7 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
std::cout << "Global Section : " << std::flush;
#endif
isGood = S.good();
// Global Section : convertie dans <thehead>
// Global Section : converted in <thehead>
Standard_Integer nbg = thehead->Length();
for (i = 1; i <= nbg && isGood; i++)
{
@@ -686,8 +686,8 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
res2,
lab,
num);
v[1] = thepnum.Value(i); // debut en P
v[15] = thepnum.Value(i + 1) - thepnum.Value(i); // nb de lignes en P
v[1] = thepnum.Value(i); // start in P
v[15] = thepnum.Value(i + 1) - thepnum.Value(i); // nb of lines in P
sprintf(ligne,
"%8d%8d%8d%8d%8d%8d%8d%8d%2.2d%2.2d%2.2d%2.2dD%7.7d",
v[0],
@@ -747,7 +747,7 @@ Standard_Boolean IGESData_IGESWriter::Print(Standard_OStream& S) const
char finlin[32];
sprintf(finlin, " %7.7dP%7.7d", 2 * i - 1, j);
line = thepars->Value(j);
// line->LeftJustify(MaxcarsP,' '); remplace par plus economique ! :
// line->LeftJustify(MaxcarsP,' '); replaced by more economical ! :
if (fnes)
writefnes(S, line->ToCString());

2
src/DataExchange/TKDEIGES/IGESData/IGESData_LabelDisplayEntity.cxx
View File

@@ -16,4 +16,4 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_LabelDisplayEntity, IGESData_IGESEntity)
// LabelDisplayEntity ne sert qu'au controle de type (pour le directory part)
// LabelDisplayEntity is only used for type control (for the directory part)

2
src/DataExchange/TKDEIGES/IGESData/IGESData_LevelListEntity.cxx
View File

@@ -17,7 +17,7 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_LevelListEntity, IGESData_IGESEntity)
// LevelListEntity ne sert qu'au controle de type (pour le directory part)
// LevelListEntity is only used for type control (for the directory part)
Standard_Boolean IGESData_LevelListEntity::HasLevelNumber(const Standard_Integer level) const
{
Standard_Integer nb = NbLevelNumbers();

2
src/DataExchange/TKDEIGES/IGESData/IGESData_LineFontEntity.cxx
View File

@@ -16,4 +16,4 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_LineFontEntity, IGESData_IGESEntity)
// LineTypeEntity ne sert qu'au controle de type (pour le directory part)
// LineTypeEntity is only used for type control (for the directory part)

2
src/DataExchange/TKDEIGES/IGESData/IGESData_NameEntity.cxx
View File

@@ -17,4 +17,4 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_NameEntity, IGESData_IGESEntity)
// NameEntity sert a decrire des entites "propriete nom" (Value a definir)
// NameEntity is used to describe entities "name property" (Value to be defined)

2
src/DataExchange/TKDEIGES/IGESData/IGESData_ParamCursor.cxx
View File

@@ -69,5 +69,5 @@ void IGESData_ParamCursor::SetAdvance(const Standard_Boolean advance)
theadv = advance;
}
// LA SUITE : inline , cf lxx
// THE REST : inline , see lxx
// (Start,Limit,Count,ItemSize,TermSize,Offset,Advance)

90
src/DataExchange/TKDEIGES/IGESData/IGESData_ParamReader.cxx
View File

@@ -31,7 +31,7 @@
#include <stdio.h>
// MGE 03/08/98
static Standard_Integer testconv = -1; // cf parametre de session
static Standard_Integer testconv = -1; // see session parameter
// .... Gestion generale (etat, courant ...) ....
@@ -107,7 +107,7 @@ void IGESData_ParamReader::EndAll()
thestage = IGESData_ReadEnd;
}
// .... Acces de base aux parametres ....
// .... Basic parameter access ....
//=================================================================================================
@@ -165,19 +165,19 @@ Handle(IGESData_IGESEntity) IGESData_ParamReader::ParamEntity(
return GetCasted(IGESData_IGESEntity, IR->BoundEntity(n));
}
// .... Assistance a la lecture ....
// .... Reading assistance ....
// Les fonctions Read* offrent les services suivants :
// Gestion des erreurs : le Check est alimente, par Fail ou Corrected selon
// Si Fail, retour de fonction False (peut etre utile), sinon True
// En outre, un Status est gere (de type enum DataState)
// (peut etre interroge suite a appel Read* si retour True/False trop court)
// The Read* functions offer the following services :
// Error management : the Check is fed, by Fail or Corrected accordingly
// If Fail, function returns False (may be useful), otherwise True
// Furthermore, a Status is managed (of type enum DataState)
// (can be queried following Read* call if True/False return too short)
//
// Gestion du pointeur courant (sur option, nais elle est mise par defaut) :
// Les parametres sont designes via un ParmCursor, qui peut etre fabrique par
// les methodes ad hoc Current et CurrentList, et qui peut demander a avancer
// le pointeur courant une fois la lecture faite
// En outre, pour un HArray1, on peut preciser index de depart
// Current pointer management (optional, but set by default) :
// Parameters are designated via a ParmCursor, which can be manufactured by
// the ad hoc methods Current and CurrentList, and which can request to advance
// the current pointer once reading is done
// Furthermore, for an HArray1, you can specify starting index
//=================================================================================================
@@ -271,17 +271,17 @@ Standard_Boolean IGESData_ParamReader::PrepareRead(const IGESData_ParamCursor& P
return Standard_True;
}
// theindex donne le debut de la lecture; tjrs cale sur debut d item
// thenbterm donne debut a lire dans l item
// Ainsi, l indice vrai est theindex + thenbterm
// thenbterm avance par +nb. Quand il a depasse thetermsz, item suivant
// theindex est lui-meme limite (critere d arret) a themaxind
// theindex gives the start of reading; always aligned on item start
// thenbterm gives start to read in the item
// Thus, the true index is theindex + thenbterm
// thenbterm advances by +nb. When it has exceeded thetermsz, next item
// theindex is itself limited (stop criterion) to themaxind
//=================================================================================================
Standard_Integer IGESData_ParamReader::FirstRead(const Standard_Integer nb)
{
theindex += theoffset; // On se cale d office sur le debut du terme a lire
theindex += theoffset; // We automatically align on the start of the term to read
Standard_Integer res = theindex;
thenbterm = nb;
if (thenbterm >= thetermsz)
@@ -299,7 +299,7 @@ Standard_Integer IGESData_ParamReader::NextRead(const Standard_Integer nb)
Standard_Integer res = theindex;
if (theindex >= themaxind)
res = 0;
thenbterm += nb; // Par Item : en lire thetermsz, puis item suivant
thenbterm += nb; // Per Item: read thetermsz, then next item
if (thenbterm >= thetermsz)
{
theindex += theitemsz;
@@ -389,8 +389,8 @@ Standard_Boolean IGESData_ParamReader::ReadBoolean(const IGESData_ParamCursor& P
return Standard_False;
}
// Un Booleen, c est 0/1. Mais on peut tolerer d autres valeurs
// On peut toujours consulter LastReadStatus apres la lecture pour etre sur
// A Boolean is 0/1. But we can tolerate other values
// One can always consult LastReadStatus after reading to be sure
Standard_Integer flag = atoi(FP.CValue());
if (flag != 0 && flag != 1)
{
@@ -430,8 +430,8 @@ Standard_Boolean IGESData_ParamReader::ReadBoolean(const IGESData_ParamCursor& P
return Standard_False;
}
// Un Booleen, c est 0/1. Mais on peut tolerer d autres valeurs
// On peut toujours consulter LastReadStatus apres la lecture pour etre sur
// A Boolean is 0/1. But we can tolerate other values
// One can always consult LastReadStatus after reading to be sure
Standard_Integer flag = atoi(FP.CValue());
if (flag != 0 && flag != 1)
{
@@ -668,11 +668,11 @@ Standard_Boolean IGESData_ParamReader::ReadEntity(const Handle(IGESData_IGESRead
val = GetCasted(IGESData_IGESEntity, IR->BoundEntity(nval));
if (val.IsNull())
return canbenul;
// Cas du "Nul IGES"
// Case of "Null IGES"
if (val->TypeNumber() == 0)
{ // Null ou pas encore rempli ...
{ // Null or not yet filled ...
if (IR->DirType(nval).Type() == 0)
{ // le vrai critere (un peu cher)
{ // the real criterion (a bit expensive)
val.Nullify();
if (!canbenul)
{
@@ -718,11 +718,11 @@ Standard_Boolean IGESData_ParamReader::ReadEntity(const Handle(IGESData_IGESRead
val = GetCasted(IGESData_IGESEntity, IR->BoundEntity(nval));
if (val.IsNull())
return canbenul;
// Cas du "Nul IGES"
// Case of "Null IGES"
if (val->TypeNumber() == 0)
{ // Null ou pas encore rempli ...
{ // Null or not yet filled ...
if (IR->DirType(nval).Type() == 0)
{ // le vrai critere (un peu cher)
{ // the real criterion (a bit expensive)
val.Nullify();
if (!canbenul)
{
@@ -1061,12 +1061,12 @@ Standard_Boolean IGESData_ParamReader::ReadEnts(const Handle(IGESData_IGESReader
}
if (ind == indmax + 1)
{
} // tableau complet
} // complete array
else if (ind == index)
val.Nullify(); // tableau vide
val.Nullify(); // empty array
else
{
// Trous : ils ont ete elimines, mais le tableau est a retailler
// Gaps: they have been eliminated, but the array needs to be resized
Handle(IGESData_HArray1OfIGESEntity) tab = new IGESData_HArray1OfIGESEntity(index, ind - 1);
for (i = index; i < ind; i++)
tab->SetValue(i, val->Value(i));
@@ -1120,12 +1120,12 @@ Standard_Boolean IGESData_ParamReader::ReadEnts(const Handle(IGESData_IGESReader
}
if (ind == indmax + 1)
{
} // tableau complet
} // complete array
else if (ind == index)
val.Nullify(); // tableau vide
val.Nullify(); // empty array
else
{
// Trous : ils ont ete elimines, mais le tableau est a retailler
// Gaps: they have been eliminated, but the array needs to be resized
Handle(IGESData_HArray1OfIGESEntity) tab = new IGESData_HArray1OfIGESEntity(index, ind - 1);
for (i = index; i < ind; i++)
tab->SetValue(i, val->Value(i));
@@ -1283,10 +1283,10 @@ Standard_Boolean IGESData_ParamReader::ReadingReal(const Standard_Integer num, S
// AddWarning (mess,ssem,"Real with no decimal point (added), 1st rank=%d");
}
}
// Par convention (pas d enum explicite dans IGES), signifie
// "reconnu comme flottant mais pas blanc-bleu" c-a-d sans point decimal
// mais avec exposant (sinon ce serait un entier)
// -> un message avertissement + on ajoute le point puis on convertit
// By convention (no explicit enum in IGES), means
// "recognized as floating but not clean" i.e. without decimal point
// but with exponent (otherwise it would be an integer)
// -> a warning message + we add the point then convert
val = Atof(text);
}
@@ -1361,10 +1361,10 @@ Standard_Boolean IGESData_ParamReader::ReadingReal(const Standard_Integer num,
AddWarning(mess, ssem, "Real with no decimal point (added), 1st rank=%d");
}
}
// Par convention (pas d enum explicite dans IGES), signifie
// "reconnu comme flottant mais pas blanc-bleu" c-a-d sans point decimal
// mais avec exposant (sinon ce serait un entier)
// -> un message avertissement + on ajoute le point puis on convertit
// By convention (no explicit enum in IGES), means
// "recognized as floating but not clean" i.e. without decimal point
// but with exponent (otherwise it would be an integer)
// -> a warning message + we add the point then convert
val = Atof(text);
}
@@ -1450,7 +1450,7 @@ void IGESData_ParamReader::SendWarning(const Message_Msg& amsg)
thelast = Standard_False;
}
// .... Gestion courante du statut de lecture ....
// .... Current reading status management ....
//=================================================================================================

2
src/DataExchange/TKDEIGES/IGESData/IGESData_Protocol.cxx
View File

@@ -35,7 +35,7 @@ Handle(Interface_Protocol) IGESData_Protocol::Resource(const Standard_Integer /*
return nulpro;
}
// TypeNumber : Ici, on reconnait UndefinedEntity (faut bien quelqu un)
// TypeNumber : Here, we recognize UndefinedEntity (someone has to)
Standard_Integer IGESData_Protocol::TypeNumber(const Handle(Standard_Type)& atype) const
{

2
src/DataExchange/TKDEIGES/IGESData/IGESData_ReadWriteModule.cxx
View File

@@ -41,4 +41,4 @@ void IGESData_ReadWriteModule::Read(const Standard_Integer,
#endif
}
// IGESReaderTool fait tout
// IGESReaderTool does everything

4
src/DataExchange/TKDEIGES/IGESData/IGESData_SingleParentEntity.cxx
View File

@@ -17,5 +17,5 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_SingleParentEntity, IGESData_IGESEntity)
// SingleParentEntity sert a decrire des entites "associativite parent"
// (methode Parent a definir)
// SingleParentEntity is used to describe "parent associativity" entities
// (Parent method to be defined)

2
src/DataExchange/TKDEIGES/IGESData/IGESData_SpecificModule.cxx
View File

@@ -21,4 +21,4 @@ Standard_Boolean IGESData_SpecificModule::OwnCorrect(const Standard_Integer,
const Handle(IGESData_IGESEntity)&) const
{
return Standard_False;
} // par defaut, ne fait rien
} // by default, does nothing

42
src/DataExchange/TKDEIGES/IGESData/IGESData_ToolLocation.cxx
View File

@@ -49,15 +49,15 @@ IGESData_ToolLocation::IGESData_ToolLocation(const Handle(IGESData_IGESModel)& a
void IGESData_ToolLocation::Load()
{
// Pour chaque Entite, sauf Transf et Assoc (sauf SingleParent), on considere
// ses "OwnShared" comme etant dependents
// For each Entity, except Transf and Assoc (except SingleParent), we consider
// its "OwnShared" as being dependents
Standard_Integer nb = themodel->NbEntities();
for (Standard_Integer i = 1; i <= nb; i++)
{
Handle(IGESData_IGESEntity) ent = themodel->Entity(i);
if (ent->IsKind(STANDARD_TYPE(IGESData_TransfEntity)))
continue;
// Cas de SingleParentEntity
// Case of SingleParentEntity
if (ent->IsKind(STANDARD_TYPE(IGESData_SingleParentEntity)))
{
DeclareAndCast(IGESData_SingleParentEntity, assoc, ent);
@@ -68,9 +68,9 @@ void IGESData_ToolLocation::Load()
continue;
}
if (ent->TypeNumber() == TYPEFORASSOC)
continue; // Assoc sauf SingleParent
// Cas courant
SetOwnAsDependent(ent); // qui opere
continue; // Assoc except SingleParent
// Current case
SetOwnAsDependent(ent); // which operates
}
}
@@ -121,9 +121,9 @@ void IGESData_ToolLocation::SetOwnAsDependent(const Handle(IGESData_IGESEntity)&
Handle(IGESData_GeneralModule) module = Handle(IGESData_GeneralModule)::DownCast(gmodule);
Interface_EntityIterator list;
module->OwnSharedCase(CN, ent, list);
// Remarque : en toute rigueur, il faudrait ignorer les entites referencees
// dont le SubordinateStatus vaut 0 ou 2 ...
// Question : ce Status est-il toujours bien comme il faut ?
// Remark : strictly speaking, we should ignore the referenced entities
// whose SubordinateStatus is 0 or 2 ...
// Question : is this Status always correct as it should be ?
for (list.Start(); list.More(); list.Next())
SetReference(ent, GetCasted(IGESData_IGESEntity, list.Value()));
}
@@ -213,7 +213,7 @@ Standard_Boolean IGESData_ToolLocation::HasParentByAssociativity(
gp_GTrsf IGESData_ToolLocation::ParentLocation(const Handle(IGESData_IGESEntity)& ent) const
{
gp_GTrsf locat; // par defaut, identite
gp_GTrsf locat; // by default, identity
Handle(IGESData_IGESEntity) parent = Parent(ent);
// Definition recursive
if (!parent.IsNull())
@@ -224,8 +224,8 @@ gp_GTrsf IGESData_ToolLocation::ParentLocation(const Handle(IGESData_IGESEntity)
gp_GTrsf IGESData_ToolLocation::EffectiveLocation(const Handle(IGESData_IGESEntity)& ent) const
{
gp_GTrsf locat = ent->Location();
// Combiner Transf et ParentLocation
locat.PreMultiply(ParentLocation(ent)); // ne pas se tromper de sens !
// Combine Transf and ParentLocation
locat.PreMultiply(ParentLocation(ent)); // don't confuse the direction !
return locat;
}
@@ -240,19 +240,19 @@ Standard_Boolean IGESData_ToolLocation::ConvertLocation(const Standard_Real prec
const Standard_Real unit)
{
if (result.Form() != gp_Identity)
result = gp_Trsf(); // Identite forcee au depart
// On prend le contenu de <loc>. Attention a l adressage
result = gp_Trsf(); // Identity forced at start
// We take the content of <loc>. Be careful with addressing
gp_XYZ v1(loc.Value(1, 1), loc.Value(1, 2), loc.Value(1, 3));
gp_XYZ v2(loc.Value(2, 1), loc.Value(2, 2), loc.Value(2, 3));
gp_XYZ v3(loc.Value(3, 1), loc.Value(3, 2), loc.Value(3, 3));
// A-t-on affaire a une similitude ?
// Are we dealing with a similarity ?
Standard_Real m1 = v1.Modulus();
Standard_Real m2 = v2.Modulus();
Standard_Real m3 = v3.Modulus();
// D abord est-elle singuliere cette matrice ?
// First is this matrix singular ?
if (m1 < prec || m2 < prec || m3 < prec)
return Standard_False;
Standard_Real mm = (m1 + m2 + m3) / 3.; // voici la Norme moyenne, cf Scale
Standard_Real mm = (m1 + m2 + m3) / 3.; // here is the average Norm, see Scale
if (Abs(m1 - mm) > prec * mm || Abs(m2 - mm) > prec * mm || Abs(m3 - mm) > prec * mm)
return Standard_False;
v1.Divide(m1);
@@ -260,8 +260,8 @@ Standard_Boolean IGESData_ToolLocation::ConvertLocation(const Standard_Real prec
v3.Divide(m3);
if (Abs(v1.Dot(v2)) > prec || Abs(v2.Dot(v3)) > prec || Abs(v3.Dot(v1)) > prec)
return Standard_False;
// Ici, Orthogonale et memes normes. En plus on l a Normee
// Restent les autres caracteristiques :
// Here, Orthogonal and same norms. Plus we normalized it
// Remain the other characteristics :
if (Abs(mm - 1.) > prec)
result.SetScale(gp_Pnt(0, 0, 0), mm);
gp_XYZ tp = loc.TranslationPart();
@@ -269,11 +269,11 @@ Standard_Boolean IGESData_ToolLocation::ConvertLocation(const Standard_Real prec
tp.Multiply(unit);
if (tp.X() != 0. || tp.Y() != 0. || tp.Z() != 0.)
result.SetTranslationPart(tp);
// On isole le cas de l Identite (tellement facile et avantageux)
// We isolate the case of Identity (so easy and advantageous)
if (v1.X() != 1. || v1.Y() != 0. || v1.Z() != 0. || v2.X() != 0. || v2.Y() != 1. || v2.Z() != 0.
|| v3.X() != 0. || v3.Y() != 0. || v3.Z() != 1.)
{
// Pas Identite : vraie construction depuis un Ax3
// Not Identity : real construction from an Ax3
gp_Dir d1(v1);
gp_Dir d2(v2);
gp_Dir d3(v3);

4
src/DataExchange/TKDEIGES/IGESData/IGESData_TransfEntity.cxx
View File

@@ -17,5 +17,5 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_TransfEntity, IGESData_IGESEntity)
// TransfEntity ne sert que pour controle de Type, et fourniture par Value
// de la GTrsf correspondante
// TransfEntity is only used for Type control, and providing by Value
// the corresponding GTrsf

14
src/DataExchange/TKDEIGES/IGESData/IGESData_UndefinedEntity.cxx
View File

@@ -145,8 +145,8 @@ Standard_Boolean IGESData_UndefinedEntity::HasSubScriptNumber() const
return Standard_False;
}
// ReadDir verifie les donnees, s il y a des erreurs les note (status),
// genere un nouveau DirPart sans ces erreurs, et appelle ReadDir de base
// ReadDir verifies the data, if there are errors notes them (status),
// generates a new DirPart without these errors, and calls base ReadDir
//=================================================================================================
@@ -167,7 +167,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
Standard_Integer v[17];
Standard_Character res1[9], res2[9], lab[9], subs[9];
Standard_Integer max = 2 * IR->NbRecords(); // valeur maxi pour DSectNum
Standard_Integer max = 2 * IR->NbRecords(); // max value for DSectNum
thedstat = 0;
Handle(IGESData_IGESEntity) anent;
@@ -315,7 +315,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
for (i = 0; i < 8; i++)
{
if (subs[i] == '\0')
break; // fin de ligne
break; // end of line
if (subs[i] != ' ' && (subs[i] < 48 || subs[i] > 57))
iapb = Standard_True;
}
@@ -330,7 +330,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
subs[i] = ' ';
}
// ... Fin de cette analyse : si necessaire on reconstruit DP ...
// ... End of this analysis : if necessary we rebuild DP ...
if (thedstat == 0)
return Standard_True;
else
@@ -360,7 +360,7 @@ Standard_Boolean IGESData_UndefinedEntity::ReadDir(const Handle(IGESData_IGESRea
}
}
// Parametres indifferencies : assocs et props ignores
// Undifferentiated parameters : assocs and props ignored
//=================================================================================================
@@ -378,7 +378,7 @@ void IGESData_UndefinedEntity::ReadOwnParams(const Handle(IGESData_IGESReaderDat
}
else thecont->AddLiteral (ptyp,new TCollection_HAsciiString(PR.ParamValue(i)));
*/
// On est TOUJOURS en mode litteral, c est bien plus clair !
// We are ALWAYS in literal mode, it's much clearer !
thecont->AddLiteral(ptyp, new TCollection_HAsciiString(PR.ParamValue(i)));
}
PR.SetCurrentNumber(nb + 1);

6
src/DataExchange/TKDEIGES/IGESData/IGESData_ViewKindEntity.cxx
View File

@@ -17,6 +17,6 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESData_ViewKindEntity, IGESData_IGESEntity)
// ViewKindEntity ne sert qu'au controle de type (entite View du directory part
// qui peut etre une Vue Simple ou une Liste de Vue
// Vue Simple doit implementer IsSingle a Standard_True, Liste de Vue a Standard_False
// ViewKindEntity is only used for type control (View entity in directory part
// which can be a Simple View or a View List
// Simple View must implement IsSingle as Standard_True, View List as Standard_False

8
src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_AttributeTable.cxx
View File

@@ -31,9 +31,9 @@
IMPLEMENT_STANDARD_RTTIEXT(IGESDefs_AttributeTable, IGESData_IGESEntity)
// ATTENTION ATTENTION : L Appellation "ROW" n est pas reconduite en l etat
// Le Numero d Attribut est donne en 1er (donc, en colonne du HArray2 et non
// en ligne), le numero de Colonne en 2e (donc, comme un numero de Ligne)
// WARNING WARNING : The "ROW" designation is not continued as is
// The Attribute Number is given first (therefore, in column of HArray2 and not
// in row), the Column number second (therefore, as a Row number)
IGESDefs_AttributeTable::IGESDefs_AttributeTable() {}
void IGESDefs_AttributeTable::Init(const Handle(TColStd_HArray2OfTransient)& attributes)
@@ -124,5 +124,5 @@ Standard_Boolean IGESDefs_AttributeTable::AttributeAsLogical(const Standard_Inte
const Standard_Integer Rownum,
const Standard_Integer Valuenum) const
{
return (AttributeAsInteger(Atnum, Rownum, Valuenum) != 0); // raccourci
return (AttributeAsInteger(Atnum, Rownum, Valuenum) != 0); // shortcut
}

2
src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_TabularData.cxx
View File

@@ -59,7 +59,7 @@ Standard_Integer IGESDefs_TabularData::NbPropertyValues() const
Standard_Integer IGESDefs_TabularData::ComputedNbPropertyValues() const
{
return theNbPropertyValues; // pas malin ... a ameliorer
return theNbPropertyValues; // not smart ... to improve
}
Standard_Boolean IGESDefs_TabularData::OwnCorrect()

4
src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_ToolAttributeDef.cxx
View File

@@ -146,8 +146,8 @@ void IGESDefs_ToolAttributeDef::ReadOwnParams(const Handle(IGESDefs_AttributeDef
switch (attrValueDataType)
{
case 0: {
PR.SetCurrentNumber(PR.CurrentNumber() + 1); // passer
//// attrValue->SetValue(j, NULL); par defaut
PR.SetCurrentNumber(PR.CurrentNumber() + 1); // skip
//// attrValue->SetValue(j, NULL); by default
break;
}
case 1: {

4
src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_ToolAttributeTable.cxx
View File

@@ -231,7 +231,7 @@ void IGESDefs_ToolAttributeTable::OwnCopy(const Handle(IGESDefs_AttributeTable)&
Standard_Integer atype = ab->AttributeValueDataType(i);
switch (atype)
{
case 0: //// list2->SetValue(i,k,NULL); par defaut
case 0: //// list2->SetValue(i,k,NULL); by default
break;
case 1: {
DeclareAndCast(TColStd_HArray1OfInteger, otherInt, another->AttributeList(i, k));
@@ -267,7 +267,7 @@ void IGESDefs_ToolAttributeTable::OwnCopy(const Handle(IGESDefs_AttributeTable)&
GetCasted(IGESData_IGESEntity, TC.Transferred(otherEnt->Value(j))));
}
break;
case 5: ///// list2->SetValue(i,k,NULL); par defaut
case 5: ///// list2->SetValue(i,k,NULL); by default
break;
case 6: { // Here item takes value 0 or 1
DeclareAndCast(TColStd_HArray1OfInteger, otherInt, another->AttributeList(i, k));

8
src/DataExchange/TKDEIGES/IGESDefs/IGESDefs_ToolTabularData.cxx
View File

@@ -99,9 +99,9 @@ void IGESDefs_ToolTabularData::ReadOwnParams(const Handle(IGESDefs_TabularData)&
valuesInd->SetValue(i, tarr);
}
// ?? for (i=1; i<=nbDeps; i++) { }
// Dependents : definition pas limpide, on accumule tout sur un seul
// HArray1OfReal, mis en 1re position du HArray1OfHArray1OfReal
// On y met tous les flottants qui restent
// Dependents : definition not clear, we accumulate everything on a single
// HArray1OfReal, put in 1st position of the HArray1OfHArray1OfReal
// We put all the remaining floats there
Standard_Integer curnum = PR.CurrentNumber();
Standard_Integer nbpars = PR.NbParams();
Standard_Integer nbd = 0;
@@ -135,7 +135,7 @@ void IGESDefs_ToolTabularData::ReadOwnParams(const Handle(IGESDefs_TabularData)&
PR.SetCurrentNumber (curnum+1);
} */
PR.AddWarning("Don't know exactly how to read dependent values ...");
// ?? a eclaircir
// ?? to clarify
DirChecker(ent).CheckTypeAndForm(PR.CCheck(), ent);
ent->Init(nbProps, propType, typesInd, nbValuesInd, valuesInd, valuesDep);
}

2
src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_GeneralSymbol.cxx
View File

@@ -40,7 +40,7 @@ void IGESDimen_GeneralSymbol::Init(const Handle(IGESDimen_GeneralNote)&
theGeoms = allGeoms;
theLeaders = allLeaders;
InitTypeAndForm(228, FormNumber());
// FormNumber precises the Nature of the Symbol, cf G.14 (0-3 or > 5000)
// FormNumber specifies the Nature of the Symbol, see G.14 (0-3 or > 5000)
}
void IGESDimen_GeneralSymbol::SetFormNumber(const Standard_Integer form)

2
src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_RadiusDimension.cxx
View File

@@ -39,7 +39,7 @@ void IGESDimen_RadiusDimension::Init(const Handle(IGESDimen_GeneralNote)& aNote,
theCenter = arcCenter;
theLeader2 = anotherArrow;
if (!anotherArrow.IsNull())
InitTypeAndForm(222, 1); // 1 admet aussi Null
InitTypeAndForm(222, 1); // 1 also admits Null
else
InitTypeAndForm(222, FormNumber());
}

4
src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolCenterLine.cxx
View File

@@ -121,10 +121,10 @@ Standard_Boolean IGESDimen_ToolCenterLine::OwnCorrect(const Handle(IGESDimen_Cen
}
if (ent->Datatype() == 1)
return res;
// Forcer DataType = 1 -> reconstruire
// Force DataType = 1 -> reconstruct
Standard_Integer nb = ent->NbPoints();
if (nb == 0)
return res; // rien pu faire (est-ce possible ?)
return res; // nothing could be done (is this possible?)
Handle(TColgp_HArray1OfXY) pts = new TColgp_HArray1OfXY(1, nb);
for (Standard_Integer i = 1; i <= nb; i++)
pts->SetValue(i, gp_XY(ent->Point(i).X(), ent->Point(i).Y()));

2
src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolDimensionedGeometry.cxx
View File

@@ -112,7 +112,7 @@ Standard_Boolean IGESDimen_ToolDimensionedGeometry::OwnCorrect(
{
if (ent->NbDimensions() == 1)
return Standard_False;
// forcer NbDimensions a 1 -> reconstruire
// force NbDimensions to 1 -> reconstruct
Standard_Integer nb = ent->NbGeometryEntities();
Handle(IGESData_HArray1OfIGESEntity) EntArray = new IGESData_HArray1OfIGESEntity(1, nb);
for (Standard_Integer i = 1; i <= nb; i++)

2
src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolNewDimensionedGeometry.cxx
View File

@@ -177,7 +177,7 @@ Standard_Boolean IGESDimen_ToolNewDimensionedGeometry::OwnCorrect(
}
if (ent->NbDimensions() == 1)
return res;
// Forcer NbDimensions = 1 -> reconstruire
// Force NbDimensions = 1 -> reconstruct
Standard_Integer nb = ent->NbGeometries();
Handle(IGESData_HArray1OfIGESEntity) tempGeomEnts = new IGESData_HArray1OfIGESEntity(1, nb);
Handle(TColStd_HArray1OfInteger) tempDimLocFlags = new TColStd_HArray1OfInteger(1, nb);

4
src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolSection.cxx
View File

@@ -121,10 +121,10 @@ Standard_Boolean IGESDimen_ToolSection::OwnCorrect(const Handle(IGESDimen_Sectio
}
if (ent->Datatype() == 1)
return res;
// Forcer DataType = 1 -> reconstruire
// Force DataType = 1 -> reconstruct
Standard_Integer nb = ent->NbPoints();
if (nb == 0)
return Standard_False; // rien pu faire (est-ce possible ?)
return Standard_False; // nothing could be done (is this possible?)
Handle(TColgp_HArray1OfXY) pts = new TColgp_HArray1OfXY(1, nb);
for (Standard_Integer i = 1; i <= nb; i++)
pts->SetValue(i, gp_XY(ent->Point(i).X(), ent->Point(i).Y()));

4
src/DataExchange/TKDEIGES/IGESDimen/IGESDimen_ToolWitnessLine.cxx
View File

@@ -121,10 +121,10 @@ Standard_Boolean IGESDimen_ToolWitnessLine::OwnCorrect(
}
if (ent->Datatype() == 1)
return res;
// Forcer DataType = 1 -> reconstruire
// Force DataType = 1 -> reconstruct
Standard_Integer nb = ent->NbPoints();
if (nb == 0)
return Standard_False; // rien pu faire (est-ce possible ?)
return Standard_False; // nothing could be done (is this possible?)
Handle(TColgp_HArray1OfXY) pts = new TColgp_HArray1OfXY(1, nb);
for (Standard_Integer i = 1; i <= nb; i++)
pts->SetValue(i, gp_XY(ent->Point(i).X(), ent->Point(i).Y()));

4
src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolDrawing.cxx
View File

@@ -186,7 +186,7 @@ void IGESDraw_ToolDrawing::OwnCopy(const Handle(IGESDraw_Drawing)& another,
Standard_Boolean IGESDraw_ToolDrawing::OwnCorrect(const Handle(IGESDraw_Drawing)& ent) const
{
// Vues vides : les supprimer
// Empty views: remove them
Standard_Integer i, nb = ent->NbViews();
Standard_Integer nbtrue = nb;
for (i = 1; i <= nb; i++)
@@ -219,7 +219,7 @@ Standard_Boolean IGESDraw_ToolDrawing::OwnCorrect(const Handle(IGESDraw_Drawing)
viewOrigins->SetValue(nbtrue, ent->ViewOrigin(i).XY());
}
// Ne pas oublier les annotations ...
// Don't forget the annotations ...
Standard_Integer nbanot = ent->NbAnnotations();
Handle(IGESData_HArray1OfIGESEntity) annotations = new IGESData_HArray1OfIGESEntity(1, nbanot);
for (i = 1; i <= nbanot; i++)

4
src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolSegmentedViewsVisible.cxx
View File

@@ -244,7 +244,7 @@ void IGESDraw_ToolSegmentedViewsVisible::OwnCopy(
else
{
colorValues->SetValue(i, another->ColorValue(i));
//// colorDefinitions->SetValue( i, NULL ); par defaut
//// colorDefinitions->SetValue( i, NULL ); by default
}
if (another->IsFontDefinition(i))
@@ -256,7 +256,7 @@ void IGESDraw_ToolSegmentedViewsVisible::OwnCopy(
else
{
lineFontValues->SetValue(i, another->LineFontValue(i));
//// lineFontDefinitions->SetValue( i, NULL ); par defaut
//// lineFontDefinitions->SetValue( i, NULL ); by default
}
lineWeights->SetValue(i, another->LineWeightItem(i));

4
src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolViewsVisible.cxx
View File

@@ -159,7 +159,7 @@ void IGESDraw_ToolViewsVisible::OwnCopy(const Handle(IGESDraw_ViewsVisible)& ano
DeclareAndCast(IGESData_ViewKindEntity, tempView, TC.Transferred(another->ViewItem(I)));
tempViewEntities->SetValue(I, tempView);
}
// Displayed -> Implied : mettre une liste vide par defaut
// Displayed -> Implied : set an empty list by default
Handle(IGESData_HArray1OfIGESEntity) tempDisplayEntities;
ent->Init(tempViewEntities, tempDisplayEntities);
}
@@ -253,7 +253,7 @@ void IGESDraw_ToolViewsVisible::OwnDump(const Handle(IGESDraw_ViewsVisible)& ent
Standard_Boolean IGESDraw_ToolViewsVisible::OwnCorrect(
const Handle(IGESDraw_ViewsVisible)& ent) const
{
// Les entites affichees doivent referencer <ent>. Elles ont priorite.
// The displayed entities must reference <ent>. They have priority.
Standard_Boolean res = Standard_False;
Standard_Integer nb = ent->NbDisplayedEntities();
const Handle(IGESData_ViewKindEntity)& entcomp = ent;

4
src/DataExchange/TKDEIGES/IGESDraw/IGESDraw_ToolViewsVisibleWithAttr.cxx
View File

@@ -279,7 +279,7 @@ void IGESDraw_ToolViewsVisibleWithAttr::OwnCopy(
Standard_Integer tempLineWeight = another->LineWeightItem(I);
tempLineWeights->SetValue(I, tempLineWeight);
}
// Displayed -> Implied : mettre une liste vide par defaut
// Displayed -> Implied : set an empty list by default
Handle(IGESData_HArray1OfIGESEntity) tempDisplayEntities;
ent->Init(tempViewEntities,
tempLineFonts,
@@ -425,7 +425,7 @@ void IGESDraw_ToolViewsVisibleWithAttr::OwnDump(const Handle(IGESDraw_ViewsVisib
Standard_Boolean IGESDraw_ToolViewsVisibleWithAttr::OwnCorrect(
const Handle(IGESDraw_ViewsVisibleWithAttr)& ent) const
{
// Les entites affichees doivent referencer <ent>. Elles ont priorite.
// The displayed entities must reference <ent>. They have priority.
Standard_Boolean res = Standard_False;
Standard_Integer nb = ent->NbDisplayedEntities();
const Handle(IGESData_ViewKindEntity)& entcomp = ent;

40
src/DataExchange/TKDEIGES/IGESFile/IGESFile_Read.cxx
View File

@@ -14,17 +14,17 @@
// dce 21.01.99 : move of general message to IGESToBRep_Reader
#include <stdio.h>
// declarations des programmes C de base :
// declarations of basic C programs:
#include <IGESData_IGESReaderData.hxx>
#include <IGESData_IGESReaderTool.hxx>
#include <IGESData_GeneralModule.hxx>
#include <Interface_Check.hxx>
// Pour traiter les exceptions :
// To handle exceptions:
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
// definition de base, a inclure pour utiliser
// basic definition, to include for use
#include <IGESFile_Read.hxx>
#include "igesread.h"
@@ -35,8 +35,8 @@
// To use Msg class
#include <Message_Msg.hxx>
// decoupage interne pour faciliter les recuperations d erreurs
static Standard_Integer recupne, recupnp; // pour affichage en cas de pepin
// internal breakdown to facilitate error recovery
static Standard_Integer recupne, recupnp; // for display in case of problem
static Handle(Interface_Check)& checkread()
{
@@ -50,10 +50,10 @@ void IGESFile_Check(int mode, Message_Msg& amsg);
// void IGESFile_Check2 (int mode,char * code, int num, char * str);
// void IGESFile_Check3 (int mode,char * code);
// Correspondance entre types igesread et types Interface_ParamFile ...
// Correspondence between igesread types and Interface_ParamFile types ...
static Interface_ParamType LesTypes[10];
// Nouvelle maniere : Protocol suffit
// New way: Protocol is sufficient
Standard_Integer IGESFile_Read(char* nomfic,
const Handle(IGESData_IGESModel)& amodel,
@@ -71,7 +71,7 @@ Standard_Integer IGESFile_ReadFNES(char* nomfic,
return IGESFile_Read(nomfic, amodel, protocol, nulreco, Standard_True);
}
// Ancienne maniere : avec Recognizer
// Old way: with Recognizer
Standard_Integer IGESFile_Read(char* nomfic,
const Handle(IGESData_IGESModel)& amodel,
@@ -96,7 +96,7 @@ Standard_Integer IGESFile_Read(char* nomfic,
if (result != 0)
return result;
// Chargement des resultats dans un IGESReader
// Loading results into an IGESReader
LesTypes[ArgVide] = Interface_ParamVoid;
LesTypes[ArgQuid] = Interface_ParamMisc;
@@ -104,12 +104,12 @@ Standard_Integer IGESFile_Read(char* nomfic,
LesTypes[ArgInt] = Interface_ParamInteger;
LesTypes[ArgSign] = Interface_ParamInteger;
LesTypes[ArgReal] = Interface_ParamReal;
LesTypes[ArgExp] = Interface_ParamMisc; // exposant pas termine
LesTypes[ArgRexp] = Interface_ParamReal; // exposant complet
LesTypes[ArgMexp] = Interface_ParamEnum; // exposant mais pas de point
LesTypes[ArgExp] = Interface_ParamMisc; // exponent not finished
LesTypes[ArgRexp] = Interface_ParamReal; // complete exponent
LesTypes[ArgMexp] = Interface_ParamEnum; // exponent but no decimal point
int nbparts, nbparams;
iges_stats(&nbparts, &nbparams); // et fait les Initialisations necessaires
iges_stats(&nbparts, &nbparams); // and performs necessary initializations
Handle(IGESData_IGESReaderData) IR =
// new IGESData_IGESReaderData (nbparts, nbparams);
new IGESData_IGESReaderData((lesect[3] + 1) / 2, nbparams);
@@ -119,7 +119,7 @@ Standard_Integer IGESFile_Read(char* nomfic,
{
OCC_CATCH_SIGNALS
IGESFile_ReadHeader(IR);
} // fin essai 1 (global)
} // end attempt 1 (global)
catch (Standard_Failure const&)
{
// Sending of message : Internal error during the header reading
@@ -136,7 +136,7 @@ Standard_Integer IGESFile_Read(char* nomfic,
IGESFile_ReadContent(IR);
// Sending of message : Loaded data
} // fin essai 2 (entites)
} // end attempt 2 (entities)
catch (Standard_Failure const&)
{
// Sending of message : Internal error during the content reading
@@ -172,7 +172,7 @@ Standard_Integer IGESFile_Read(char* nomfic,
amodel->SetProtocol(protocol);
iges_finfile(2);
// A present, le check
// Now, the check
// Nb warning in global section.
Standard_Integer nbWarn = checkread()->NbWarnings(), nbFail = checkread()->NbFails();
const Handle(Interface_Check)& oldglob = amodel->GlobalCheck();
@@ -187,14 +187,14 @@ Standard_Integer IGESFile_Read(char* nomfic,
return 0;
}
// Decoupage interne
// Internal breakdown
void IGESFile_ReadHeader(const Handle(IGESData_IGESReaderData)& IR)
{
Standard_Integer l = 0; // szv#4:S4163:12Mar99 i,j,k not needed
char* parval;
int typarg;
// d abord les start lines (commentaires)
// first the start lines (comments)
// szv#4:S4163:12Mar99 optimized
/*
while ( (j = iges_lirparam(&typarg,&parval)) != 0) {
@@ -206,7 +206,7 @@ void IGESFile_ReadHeader(const Handle(IGESData_IGESReaderData)& IR)
if (k >= 0 || l > 0) IR->AddStartLine (parval);
l ++;
}
// puis la Global Section
// then the Global Section
iges_setglobal();
while ( (i = iges_lirparam(&typarg,&parval)) != 0) {
IR->AddGlobal(LesTypes[typarg],parval);
@@ -223,7 +223,7 @@ void IGESFile_ReadHeader(const Handle(IGESData_IGESReaderData)& IR)
IR->AddStartLine(parval);
l++;
}
// puis la Global Section
// then the Global Section
iges_setglobal();
while (iges_lirparam(&typarg, &parval) != 0)
IR->AddGlobal(LesTypes[typarg], parval);

2
src/DataExchange/TKDEIGES/IGESFile/IGESFile_Read.hxx
View File

@@ -11,7 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
// Include a utiliser pour appeler IGESFile_Read
// Include to use for calling IGESFile_Read
#ifndef IGESFile_Read_HeaderFile
#define IGESFile_Read_HeaderFile

150
src/DataExchange/TKDEIGES/IGESFile/analiges.c
View File

@@ -24,38 +24,38 @@ void iges_addparam(int longval, char* parval);
#define ArgVide 0
#define ArgQuid 1
#define ArgChar 2
#define ArgInt 3 /* Entier non signe : peut evoluer vers Real ou Char */
#define ArgSign 4 /* Entier signe : peut evoluer vers Real */
#define ArgInt 3 /* Unsigned integer: can evolve to Real or Char */
#define ArgSign 4 /* Signed integer: can evolve to Real */
#define ArgReal 5
#define ArgExp 6 /* Real + lettre E : attendre confirmation */
#define ArgRexp 7 /* Real + Exposant : se ramene a Real */
#define ArgMexp 8 /* Real + Exposant INCOMPLET (pas de point decimal) */
#define ArgExp 6 /* Real + letter E: wait for confirmation */
#define ArgRexp 7 /* Real + Exponent: reduces to Real */
#define ArgMexp 8 /* Real + INCOMPLETE Exponent (no decimal point) */
/* les structures de travail de structiges sont connues :
a savoir declarations + curp */
/* the working structures of structiges are known:
namely declarations + curp */
/* #define VERIFPRINT */
/* Lecture section D
Chaque entite tient sur deux lignes
/* Reading section D
Each entity spans two lines
Dstat demarre a zero "on lit une nouvelle entite"
et bascule avec un "deuxieme ligne de l'entite"
Dstat starts at zero "we read a new entity"
and switches with a "second line of the entity"
*/
static int bases[] =
{ 1,10,100,1000,10000,100000,1000000, 10000000,100000000,1000000000 };
/* DECODAGE : parce que scanf ne fait pas vraiment ce qu'il faut */
/* Utilitaire decodant un nombre en format fixe dans une ligne
Il part de "depuis" inclus (debut ligne = 0) et prend "tant" caracteres
Valeur lue en retour de fonction */
static int IGES_decode (char* ligne, int depuis, int tant)
/* DECODING: because scanf doesn't really do what's needed */
/* Utility decoding a number in fixed format in a line
It starts from "depuis" included (line start = 0) and takes "tant" characters
Value read as function return */
static int IGES_decode (char* line, int depuis, int tant)
{
int val = 0; int i;
int depart = depuis+tant-1;
for (i = 0; i < tant; i ++) {
char uncar = ligne[depart-i];
char uncar = line[depart-i];
if (uncar == ' ') break;
else if (uncar == '+') continue;
else if (uncar == '-') val = -val;
@@ -64,90 +64,90 @@ static int IGES_decode (char* ligne, int depuis, int tant)
return val;
}
/* Recopie d'une chaine de caracteres de longueur fixe (close par \0) */
void IGES_copstr(char *ligne, int depuis, int tant, char* dans)
/* Copy of a fixed-length character string (closed by \0) */
void IGES_copstr(char *line, int depuis, int tant, char* dans)
{
int i;
for (i = 0; i < tant; i ++) { dans[i] = ligne[depuis+i]; }
for (i = 0; i < tant; i ++) { dans[i] = line[depuis+i]; }
dans[tant] = '\0';
}
/* Analyse section D */
void iges_Dsect (int *Dstat, int numsec, char* ligne)
/* Analysis section D */
void iges_Dsect (int *Dstat, int numsec, char* line)
{
struct dirpart *curp;
if (*Dstat == 0) {
iges_newpart(numsec);
curp = iges_get_curp();
curp->typ = IGES_decode(ligne, 0,8);
curp->poi = IGES_decode(ligne, 8,8);
curp->pdef = IGES_decode(ligne,16,8);
curp->tra = IGES_decode(ligne,24,8);
curp->niv = IGES_decode(ligne,32,8);
curp->vue = IGES_decode(ligne,40,8);
curp->trf = IGES_decode(ligne,48,8);
curp->aff = IGES_decode(ligne,56,8);
curp->blk = IGES_decode(ligne,64,2);
curp->sub = IGES_decode(ligne,66,2);
curp->use = IGES_decode(ligne,68,2);
curp->her = IGES_decode(ligne,70,2);
curp->typ = IGES_decode(line, 0,8);
curp->poi = IGES_decode(line, 8,8);
curp->pdef = IGES_decode(line,16,8);
curp->tra = IGES_decode(line,24,8);
curp->niv = IGES_decode(line,32,8);
curp->vue = IGES_decode(line,40,8);
curp->trf = IGES_decode(line,48,8);
curp->aff = IGES_decode(line,56,8);
curp->blk = IGES_decode(line,64,2);
curp->sub = IGES_decode(line,66,2);
curp->use = IGES_decode(line,68,2);
curp->her = IGES_decode(line,70,2);
#ifdef VERIFPRINT
printf("Entite %d : type %d ->P %d\n",numsec,typ,poi);
printf("Entity %d : type %d ->P %d\n",numsec,typ,poi);
#endif
*Dstat = 1;
} else if (*Dstat == 1) {
curp = iges_get_curp();
curp->typ2 = IGES_decode(ligne, 0,8);
curp->epa = IGES_decode(ligne, 8,8);
curp->col = IGES_decode(ligne,16,8);
curp->nbl = IGES_decode(ligne,24,8);
curp->form = IGES_decode(ligne,32,8);
IGES_copstr (ligne,40,8,curp->res1);
IGES_copstr (ligne,48,8,curp->res2);
IGES_copstr (ligne,56,8,curp->nom);
IGES_copstr (ligne,64,8,curp->num);
curp->typ2 = IGES_decode(line, 0,8);
curp->epa = IGES_decode(line, 8,8);
curp->col = IGES_decode(line,16,8);
curp->nbl = IGES_decode(line,24,8);
curp->form = IGES_decode(line,32,8);
IGES_copstr (line,40,8,curp->res1);
IGES_copstr (line,48,8,curp->res2);
IGES_copstr (line,56,8,curp->nom);
IGES_copstr (line,64,8,curp->num);
#ifdef VERIFPRINT
printf("Entite %d : type %d (redite) form %d\n",numsec,typ2,form);
printf("Entity %d : type %d (redite) form %d\n",numsec,typ2,form);
#endif
*Dstat = 0;
}
}
/* Lecture section P : preanalyse
Extraction du numero D et troncature a 64 caracteres */
/* Reading section P: pre-analysis
Extraction of D number and truncation to 64 characters */
void iges_Psect (int numsec, char ligne[80])
void iges_Psect (int numsec, char line[80])
{
int dnum;
dnum = atoi(&ligne[65]);
ligne[64] = '\0';
dnum = atoi(&line[65]);
line[64] = '\0';
iges_curpart(dnum);
#ifdef VERIFPRINT
printf("Entite P:%d ->D:%d,soit %s\n",numsec,dnum,ligne);
printf("Entity P:%d ->D:%d,soit %s\n",numsec,dnum,line);
#else
(void)numsec; // just to avoid warning
#endif
}
/* Depiautage ligne section P (ou G)
Fractionnement en parametres
Separes par Separateur courant (c_separ), de fin (c_fin), plus
traitement des caracteres sous forme Hollerith ... (nnnH...)
/* Parsing line section P (or G)
Parameter breakdown
Separated by current Separator (c_separ), end (c_fin), plus
character processing in Hollerith form ... (nnnH...)
Pstat entree : 0 debut entite, 1 debut ligne, 2 courant, 3 pas fini(H)
Pstat retour : 0 fin entite, 1 fin ligne, 2 courant (en voila un), 3
pas fini (un nnnH... pas termine)
Pstat input : 0 entity start, 1 line start, 2 current, 3 not finished(H)
Pstat return : 0 entity end, 1 line end, 2 current (here's one), 3
not finished (a nnnH... not finished)
*/
static int nbcarH = 0; static int numcar = 0; static int reste = 0;
/* reste : 0 cas normal; 1 completer parametre; -1 le sauter */
/* reste: 0 normal case; 1 complete parameter; -1 skip it */
static int typarg;
/* + definitions des types de parametres en tete */
/* + parameter type definitions at head */
void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
void iges_param (int *Pstat, char *line, char c_separ, char c_fin, int lonlin)
{
int i,i0,j; char param[80]; char unpar;
if (*Pstat == 0) reste = 0;
@@ -156,17 +156,17 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
else {
numcar = nbcarH;
if (numcar > lonlin) {
iges_addparam(lonlin,ligne);
iges_addparam(lonlin,line);
nbcarH -= lonlin; /* ??? enregistrer ... ??? */
return;
} else {
iges_addparam(nbcarH,ligne);
iges_addparam(nbcarH,line);
nbcarH = 0;
}
}
i0 = 0; /* debut param utile (apres blancs eventuels), par defaut a 0 */
i0 = 0; /* useful param start (after possible blanks), default to 0 */
typarg = ArgVide;
for (i = 0; (unpar = ligne[numcar+i]) != '\0'; i ++) {
for (i = 0; (unpar = line[numcar+i]) != '\0'; i ++) {
if (unpar == c_separ) {
*Pstat = 2; param[i] = '\0';
#ifdef VERIFPRINT
@@ -175,7 +175,7 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
if (reste == 0) iges_newparam(typarg,i-i0+1,&param[i0]);
else if (reste > 0) iges_addparam(i-i0+1,&param[i0]);
reste = 0;
for (j = i+1; (unpar = ligne[numcar+j]) != '\0'; j++) {
for (j = i+1; (unpar = line[numcar+j]) != '\0'; j++) {
if (unpar != ' ') { numcar += i+1; return; }
}
*Pstat = 1; return;
@@ -192,7 +192,7 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
}
param[i] = unpar;
/* Type du parametre ? */
/* Parameter type ? */
if (unpar > 47 && unpar < 58) {
if (typarg == ArgInt) continue;
@@ -225,8 +225,8 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
if (param[j] > 47 && param[j] < 58) nbcarH = nbcarH*10 + (param[j]-48);
else { nbcarH = 0; break; }
}
if (numcar+i+nbcarH >= lonlin) { /* texte a cheval sur +ieurs lignes */
for (j = 1; j < lonlin-numcar-i; j++) param[i+j] = ligne[numcar+i+j];
if (numcar+i+nbcarH >= lonlin) { /* text spanning multiple lines */
for (j = 1; j < lonlin-numcar-i; j++) param[i+j] = line[numcar+i+j];
param[lonlin-numcar] = '\0';
nbcarH = (numcar+i +nbcarH+1 -lonlin);
*Pstat =3;
@@ -237,28 +237,28 @@ void iges_param (int *Pstat, char *ligne, char c_separ, char c_fin, int lonlin)
reste = 1;
return;
} else {
for (j = 1; j <= nbcarH; j++) param[i+j] = ligne[numcar+i+j];
for (j = 1; j <= nbcarH; j++) param[i+j] = line[numcar+i+j];
i += nbcarH;
}
}
/* blanc : leading (facile) ou trailing (chercher la suite), sinon mauvais */
/* blank : leading (easy) or trailing (look for continuation), otherwise bad */
else if (unpar == ' ') {
if (typarg == ArgVide) i0 = i+1;
else {
for (j = i+1; (unpar = ligne[numcar+j]) != '\0' ; j ++) {
for (j = i+1; (unpar = line[numcar+j]) != '\0' ; j ++) {
if (unpar == c_separ || unpar == c_fin) break;
if (unpar != ' ') { typarg = ArgQuid; break; }
}
}
}
else typarg = ArgQuid; /* caractere non reconnu */
else typarg = ArgQuid; /* unrecognized character */
}
/* Ici, fin de ligne sans separateur : noter parametre en cours ! */
/* Here, end of line without separator : note current parameter ! */
*Pstat = 1; param[i] = '\0'; reste = -1;
#ifdef VERIFPRINT
printf ("Fin de ligne sans separateur, numcar,i : %d %d\n",numcar,i);
printf ("End of line without separator, numcar,i : %d %d\n",numcar,i);
if (i > i0) printf("numcar = %d type %d param: %s ",numcar,typarg,&param[i0]);
#endif
if (i > i0) iges_newparam(typarg,i-i0+1,&param[i0]);

20
src/DataExchange/TKDEIGES/IGESFile/igesread.c
View File

@@ -13,7 +13,7 @@
commercial license or contractual agreement.
*/
/* Regroupement des sources "C" pour compilation */
/* Grouping of "C" sources for compilation */
#include <stdio.h>
#include "igesread.h"
#include <OSD_OpenFile.hxx>
@@ -24,7 +24,7 @@ void IGESFile_Check21 (int mode,char * code, int num, char * str);
void IGESFile_Check3 (int mode,char * code);
void IGESFile_Check2 (int mode,char * code, int num, char * str);
/* #include "structiges.c" ... fait par analiges qui en a l'usage ... */
/* #include "structiges.c" ... done by analiges which uses it ... */
void iges_initfile();
int iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes);
void iges_newparam(int typarg,int longval, char *parval);
@@ -34,12 +34,12 @@ void iges_Psect(int numsec,char ligne[80]);
/* Routine de lecture generale d'un fichier IGES
Assure l'enchainement des appels necessaires
Il en resulte un ensemble de donnees (struct C) interrogeables par
routines ad hoc (cf igesread.h qui les recapitule pour appel par C++)
/* General reading routine for an IGES file
Ensures the chaining of necessary calls
Results in a set of data (struct C) queryable by
ad hoc routines (see igesread.h which summarizes them for C++ call)
Retourne : 0 si OK, 1 si fichier pas pu etre ouvert
Returns: 0 if OK, 1 if file could not be opened
*/
@@ -64,7 +64,7 @@ int igesread (char* nomfic, int lesect[6], int modefnes)
lefic = stdin; i0 = numsec = 0; numl = 0;
if (nomfic[0] != '\0')
lefic = OSD_OpenFile(nomfic,"r");
if (lefic == NULL) return -1; /* fichier pas pu etre ouvert */
if (lefic == NULL) return -1; /* file could not be opened */
for (i = 1; i < 6; i++) lesect[i] = 0;
for (j = 0; j < 100; j++) ligne[j] = 0;
for(;;) {
@@ -102,7 +102,7 @@ int igesread (char* nomfic, int lesect[6], int modefnes)
if (i == 2) { /* Header (Global sect) */
iges_setglobal();
for (;;) {
if (lesect[i] == 1) { /* Separation specifique */
if (lesect[i] == 1) { /* Specific separation */
int n0 = 0;
if (ligne[0] != ',') { c_separ = ligne[2]; n0 = 3; }
if (ligne[n0+1] != c_separ) { c_fin = ligne[n0+3]; }
@@ -112,7 +112,7 @@ int igesread (char* nomfic, int lesect[6], int modefnes)
}
}
if (i == 3) iges_Dsect(&Dstat,numsec,ligne); /* Directory (Dsect) */
if (i == 4) { /* Parametres (Psect) */
if (i == 4) { /* Parameters (Psect) */
iges_Psect(numsec,ligne);
for (;;) {
iges_param(&Pstat,ligne,c_separ,c_fin,64);

28
src/DataExchange/TKDEIGES/IGESFile/igesread.h
View File

@@ -13,7 +13,7 @@
commercial license or contractual agreement.
*/
/* Appel externe aux routines de lecture (en C) */
/* External call to reading routines (in C) */
#include <stdio.h>
/* structiges : */
@@ -25,10 +25,10 @@ struct parlist
struct dirpart
{
int typ, poi, pdef, tra, niv, vue, trf, aff, blk, sub, use, her; /* ligne 1 */
int typ2, epa, col, nbl, form; /* ligne 2 */
int typ, poi, pdef, tra, niv, vue, trf, aff, blk, sub, use, her; /* line 1 */
int typ2, epa, col, nbl, form; /* line 2 */
char res1[10], res2[10], nom[10], num[10];
struct parlist list; /* liste Psect */
struct parlist list; /* Psect list */
int numpart; /* n0 en Dsect */
};
@@ -49,11 +49,11 @@ extern "C"
struct dirpart* iges_get_curp(void);
void iges_initfile();
int iges_lire(FILE* lefic, int* numsec, char ligne[100], int modefnes);
int iges_lire(FILE* lefic, int* numsec, char line[100], int modefnes);
void iges_newparam(int typarg, int longval, char* parval);
void iges_param(int* Pstat, char* ligne, char c_separ, char c_fin, int lonlin);
void iges_Dsect(int* Dstat, int numsec, char* ligne);
void iges_Psect(int numsec, char ligne[80]);
void iges_param(int* Pstat, char* line, char c_separ, char c_fin, int lonlin);
void iges_Dsect(int* Dstat, int numsec, char* line);
void iges_Psect(int numsec, char line[80]);
/* MGE 20/07/98 */
void IGESFile_Check2(int mode, char* code, int num, char* str);
@@ -63,13 +63,13 @@ extern "C"
}
#endif
/* Definition des types de parametres de l'analyseur de base IGES */
/* Definition of parameter types for the basic IGES analyzer */
#define ArgVide 0
#define ArgQuid 1
#define ArgChar 2
#define ArgInt 3 /* Entier non signe : peut evoluer vers Real ou Char */
#define ArgSign 4 /* Entier signe : peut evoluer vers Real */
#define ArgInt 3 /* Unsigned integer: can evolve to Real or Char */
#define ArgSign 4 /* Signed integer: can evolve to Real */
#define ArgReal 5
#define ArgExp 6 /* Real + lettre E : attendre confirmation */
#define ArgRexp 7 /* Real + Exposant : se ramene a Real */
#define ArgMexp 8 /* Real + Exposant INCOMPLET (pas de point decimal) */
#define ArgExp 6 /* Real + letter E: wait for confirmation */
#define ArgRexp 7 /* Real + Exponent: reduces to Real */
#define ArgMexp 8 /* Real + INCOMPLETE Exponent (no decimal point) */

126
src/DataExchange/TKDEIGES/IGESFile/liriges.c
View File

@@ -15,74 +15,74 @@
#include "igesread.h"
#include <string.h>
/* Routine de base de lecture d'un fichier IGES
/* Basic routine for reading an IGES file
Cette routine lit une ligne, sauf si le statut "relire sur place" est mis
(utilise pour changement de section) : il est reannule ensuite
This routine reads a line, except if the "re-read in place" status is set
(used for section change): it is reset afterwards
Cette routine retourne :
- statut (retour fonction) : no de section : S,G,D,P,T (car 73) ou
0 (EOF) ou -1 (tacher de sauter) ou -2 (car. 73 faux)
- un numero de ligne dans la section (car. 74 a 80)
- la ligne tronquee a 72 caracteres (0 binaire dans le 73ieme)
Il faut lui fournir (buffer) une ligne reservee a 81 caracteres
This routine returns:
- status (function return): section no: S,G,D,P,T (char 73) or
0 (EOF) or -1 (try to skip) or -2 (char 73 false)
- a line number in the section (char 74 to 80)
- the line truncated to 72 characters (binary 0 in the 73rd)
Must provide it (buffer) a line reserved for 81 characters
Cas d erreur : ligne fausse des le debut -> abandon. Sinon tacher d enjamber
Error case: false line from the start -> abort. Otherwise try to step over
*/
static int iges_fautrelire = 0;
int iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
/*int iges_lire (lefic,numsec,ligne,modefnes)*/
/*FILE* lefic; int *numsec; char ligne[100]; int modefnes;*/
int iges_lire (FILE* lefic, int *numsec, char line[100], int modefnes)
/*int iges_lire (lefic,numsec,line,modefnes)*/
/*FILE* lefic; int *numsec; char line[100]; int modefnes;*/
{
int i,result; char typesec;
/* int length;*/
if (iges_fautrelire == 0)
{
if (*numsec == 0)
ligne[72] = ligne[79] = ' ';
line[72] = line[79] = ' ';
ligne[0] = '\0';
line[0] = '\0';
if(modefnes)
{
if (fgets(ligne,99,lefic) == NULL) /*for kept compatibility with fnes*/
if (fgets(line,99,lefic) == NULL) /*for kept compatibility with fnes*/
return 0;
}
else
{
/* PTV: 21.03.2002 it is necessary for files that have only `\r` but no `\n`
example file is 919-001-T02-04-CP-VL.iges */
while ( fgets ( ligne, 2, lefic ) && ( ligne[0] == '\r' || ligne[0] == '\n' ) )
while ( fgets ( line, 2, lefic ) && ( line[0] == '\r' || line[0] == '\n' ) )
{
}
if (fgets(&ligne[1],80,lefic) == NULL)
if (fgets(&line[1],80,lefic) == NULL)
return 0;
}
if (*numsec == 0 && ligne[72] != 'S' && ligne[79] == ' ')
{/* ON A DU FNES : Sauter la 1re ligne */
ligne[0] = '\0';
if (*numsec == 0 && line[72] != 'S' && line[79] == ' ')
{/* WE HAVE FNES: Skip the 1st line */
line[0] = '\0';
if(modefnes)
{
if (fgets(ligne,99,lefic) == NULL) /*for kept compatibility with fnes*/
if (fgets(line,99,lefic) == NULL) /*for kept compatibility with fnes*/
return 0;
}
else
{
while ( fgets ( ligne, 2, lefic ) && ( ligne[0] == '\r' || ligne[0] == '\n' ) )
while ( fgets ( line, 2, lefic ) && ( line[0] == '\r' || line[0] == '\n' ) )
{
}
if (fgets(&ligne[1],80,lefic) == NULL)
if (fgets(&line[1],80,lefic) == NULL)
return 0;
}
}
if ((ligne[0] & 128) && modefnes)
if ((line[0] & 128) && modefnes)
{
for (i = 0; i < 80; i ++)
ligne[i] = (char)(ligne[i] ^ (150 + (i & 3)));
line[i] = (char)(line[i] ^ (150 + (i & 3)));
}
}
@@ -90,7 +90,7 @@ int iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
return 0;
{//0x1A is END_OF_FILE for OS DOS and WINDOWS. For other OS we set this rule forcefully.
char *fc = strchr(ligne, 0x1A);
char *fc = strchr(line, 0x1A);
if(fc != 0)
{
fc[0] = '\0';
@@ -99,38 +99,38 @@ int iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
}
iges_fautrelire = 0;
if (ligne[0] == '\0' || ligne[0] == '\n' || ligne[0] == '\r')
return iges_lire(lefic,numsec,ligne,modefnes); /* 0 */
if (line[0] == '\0' || line[0] == '\n' || line[0] == '\r')
return iges_lire(lefic,numsec,line,modefnes); /* 0 */
if (sscanf(&ligne[73],"%d",&result) != 0) {
if (sscanf(&line[73],"%d",&result) != 0) {
*numsec = result;
typesec = ligne[72];
typesec = line[72];
switch (typesec) {
case 'S' : ligne[72] = '\0'; return (1);
case 'G' : ligne[72] = '\0'; return (2);
case 'D' : ligne[72] = '\0'; return (3);
case 'P' : ligne[72] = '\0'; return (4);
case 'T' : ligne[72] = '\0'; return (5);
case 'S' : line[72] = '\0'; return (1);
case 'G' : line[72] = '\0'; return (2);
case 'D' : line[72] = '\0'; return (3);
case 'P' : line[72] = '\0'; return (4);
case 'T' : line[72] = '\0'; return (5);
default :;
}
/* the column 72 is empty, try to check the neighbour*/
if(strlen(ligne)==80
&& (ligne[79]=='\n' || ligne[79]=='\r') && (ligne[0]<='9' && ligne[0]>='0')) {
if(strlen(line)==80
&& (line[79]=='\n' || line[79]=='\r') && (line[0]<='9' && line[0]>='0')) {
/*check in case of loss.*/
int index;
for(index = 1; ligne[index]<='9' && ligne[index]>='0'; index++);
if (ligne[index]=='D' || ligne[index]=='d') {
for(index = 1; line[index]<='9' && line[index]>='0'; index++);
if (line[index]=='D' || line[index]=='d') {
for(index = 79; index > 0; index--)
ligne[index] = ligne[index-1];
ligne[0]='.';
line[index] = line[index-1];
line[0]='.';
}
typesec = ligne[72];
typesec = line[72];
switch (typesec) {
case 'S' : ligne[72] = '\0'; return (1);
case 'G' : ligne[72] = '\0'; return (2);
case 'D' : ligne[72] = '\0'; return (3);
case 'P' : ligne[72] = '\0'; return (4);
case 'T' : ligne[72] = '\0'; return (5);
case 'S' : line[72] = '\0'; return (1);
case 'G' : line[72] = '\0'; return (2);
case 'D' : line[72] = '\0'; return (3);
case 'P' : line[72] = '\0'; return (4);
case 'T' : line[72] = '\0'; return (5);
default :;
}
}
@@ -138,33 +138,33 @@ int iges_lire (FILE* lefic, int *numsec, char ligne[100], int modefnes)
// the line is not conform to standard, try to read it (if there are some missing spaces)
// find the number end
i = (int)strlen(ligne);
while ((ligne[i] == '\0' || ligne[i] == '\n' || ligne[i] == '\r' || ligne[i] == ' ') && i > 0)
i = (int)strlen(line);
while ((line[i] == '\0' || line[i] == '\n' || line[i] == '\r' || line[i] == ' ') && i > 0)
i--;
if (i != (int)strlen(ligne))
ligne[i + 1] = '\0';
if (i != (int)strlen(line))
line[i + 1] = '\0';
// find the number start
while (ligne[i] >= '0' && ligne[i] <= '9' && i > 0)
while (line[i] >= '0' && line[i] <= '9' && i > 0)
i--;
if (sscanf(&ligne[i + 1],"%d",&result) == 0)
if (sscanf(&line[i + 1],"%d",&result) == 0)
return -1;
*numsec = result;
// find type of line
while (ligne[i] == ' ' && i > 0)
while (line[i] == ' ' && i > 0)
i--;
typesec = ligne[i];
typesec = line[i];
switch (typesec) {
case 'S' : ligne[i] = '\0'; return (1);
case 'G' : ligne[i] = '\0'; return (2);
case 'D' : ligne[i] = '\0'; return (3);
case 'P' : ligne[i] = '\0'; return (4);
case 'T' : ligne[i] = '\0'; return (5);
default :; /* printf("Ligne incorrecte, ignoree n0.%d :\n%s\n",*numl,ligne); */
case 'S' : line[i] = '\0'; return (1);
case 'G' : line[i] = '\0'; return (2);
case 'D' : line[i] = '\0'; return (3);
case 'P' : line[i] = '\0'; return (4);
case 'T' : line[i] = '\0'; return (5);
default :; /* printf("Incorrect line, ignored n0.%d :\n%s\n",*numl,line); */
}
return -1;
}
/* Pour commander la relecture sur place */
/* To control re-reading in place */
void iges_arelire()
{ iges_fautrelire = 1; }

92
src/DataExchange/TKDEIGES/IGESFile/structiges.c
View File

@@ -18,19 +18,19 @@
#include "igesread.h"
/* Structures temporaires IGES (enregistrement des entites et parametres)
Comprennent : les declarations, et la gestion de l'entite en cours */
/* Temporary IGES structures (recording entities and parameters)
Include: declarations, and management of the current entity */
static int nbparts;
static int nbparams;
/* Liste de parametres IGES (header ou current part) */
/* IGES parameter list (header or current part) */
static struct parlist *curlist;
static struct parlist *starts; /* Start Section du fichier IGES */
static struct parlist *header; /* Entete du fichier IGES */
static struct parlist *starts; /* Start Section of IGES file */
static struct parlist *header; /* Header of IGES file */
/* Declaration d'une portion de Directory IGES */
/* Declaration of a portion of IGES Directory */
static struct dirpart *curp;
struct dirpart *iges_get_curp (void)
@@ -38,7 +38,7 @@ struct dirpart *iges_get_curp (void)
return curp;
}
/* Declaration d'un parametre IGES (Psect) */
/* Declaration of an IGES parameter (Psect) */
static struct oneparam {
struct oneparam *next;
int typarg;
@@ -53,7 +53,7 @@ static struct dirpage {
} *firstpage = NULL;
#define Maxpar 20000
static struct parpage { /* une page de parametres ; cf AddParam */
static struct parpage { /* a page of parameters; see AddParam */
struct parpage* next;
int used;
struct oneparam params[Maxpar+1];
@@ -64,28 +64,28 @@ static int curnumpart = 0;
static struct dirpage *curpage;
/* ROUTINES UTILITAIRES de traitement des textes (char*) */
/* UTILITY ROUTINES for text processing (char*) */
/* Gestion du texte courant : c'est un texte alloue dynamiquement
iges_newchar en alloue un (jete le precedent alloue si pas lu)
rec_gettext lit le texte en cours, qui ne sera pas desalloue ensuite
rec_settext en force un autre en jetant le precedent (idem rec_newtext)
tandis que rec_newtext alloue un texte, sans lien avec le courant
/* Current text management: it's a dynamically allocated text
iges_newchar allocates one (discards the previous allocated if not read)
rec_gettext reads the current text, which will not be deallocated afterwards
rec_settext forces another by discarding the previous (same as rec_newtext)
while rec_newtext allocates a text, without link to the current one
*/
#define Maxcar 10000
static struct carpage {
struct carpage* next; /* chainage des pages de caracteres */
int used; /* place deja prise */
char cars[Maxcar+1]; /* page de caracteres */
struct carpage* next; /* chaining of character pages */
int used; /* space already taken */
char cars[Maxcar+1]; /* character page */
} *onecarpage;
static char* restext = NULL ; /* texte courant (allocation dynamique) */
/* static int resalloc = 0 ; */ /* alloue (memoire a liberer) ou non */
static char* restext = NULL ; /* current text (dynamic allocation) */
/* static int resalloc = 0 ; */ /* allocated (memory to free) or not */
/* Utilitaire : Reservation de caracteres
Remplace suite de mini-malloc par gestion de page */
/* Utility: Character reservation
Replaces series of mini-malloc with page management */
static char* iges_newchar (int lentext)
{
@@ -107,9 +107,9 @@ static char* iges_newchar (int lentext)
}
/* FICHIER IGES Proprement Dit */
/* IGES FILE Properly Speaking */
/* Initialisation de l'enregistrement d'un fichier */
/* Initialization of file recording */
void iges_initfile()
{
onecarpage = (struct carpage*) malloc ( sizeof(struct carpage) );
@@ -122,19 +122,19 @@ void iges_initfile()
header = (struct parlist*) malloc ( sizeof(struct parlist) );
header->first = header->last = NULL; header->nbparam = 0;
curlist = starts; /* On commence a enregistrer la start section */
curlist = starts; /* We start recording the start section */
nbparts = nbparams = 0;
firstpage = (struct dirpage*) malloc ( sizeof(struct dirpage) );
firstpage->next = NULL; firstpage->used = 0;
curpage = firstpage;
}
/* Passage au Header (Global Section), lecture comme ecriture */
/* Switch to Header (Global Section), reading as writing */
void iges_setglobal()
{ if (curlist == header) return; curlist = header; curparam = curlist->first; }
/* Definition et Selection d'un nouveau dirpart */
/* Definition and Selection of a new dirpart */
void iges_newpart(int numsec)
{
@@ -153,7 +153,7 @@ void iges_newpart(int numsec)
}
/* Selection du dirpart dnum, correspond a numsec en Psect */
/* Selection of dirpart dnum, corresponds to numsec in Psect */
void iges_curpart (int dnum)
{
@@ -181,20 +181,20 @@ void iges_curpart (int dnum)
}
curpage = curpage->next;
}
curp = NULL; /* pas trouve */
curp = NULL; /* not found */
}
/* Definition d'un nouveau parametre */
/* (manque la gestion d'un Hollerith sur plusieurs lignes) */
/* Definition of a new parameter */
/* (missing management of Hollerith over multiple lines) */
/* longval : longueur de parval, incluant le zero final */
/* longval: length of parval, including the final zero */
void iges_newparam (int typarg, int longval, char *parval)
{
char *newval;
int i;
if (curlist == NULL) return; /* non defini : abandon */
if (curlist == NULL) return; /* not defined: abort */
newval = iges_newchar(longval);
for (i = 0; i < longval; i++) newval[i] = parval[i];
@@ -218,7 +218,7 @@ void iges_newparam (int typarg, int longval, char *parval)
nbparams ++;
}
/* Complement du parametre courant (cf Hollerith sur +ieurs lignes) */
/* Complement of current parameter (see Hollerith over multiple lines) */
void iges_addparam (int longval, char* parval)
{
char *newval, *oldval;
@@ -235,9 +235,9 @@ void iges_addparam (int longval, char* parval)
}
/* Relecture : Initialiation */
/* entites relues par suite de lirpart + {lirparam}
lirparam initiaux : pour relire le demarrage (start section) */
/* Re-reading: Initialization */
/* entities re-read following lirpart + {lirparam}
initial lirparam: to re-read the startup (start section) */
void iges_stats (int* nbpart, int* nbparam)
{
curpage = firstpage; curnumpart = 0;
@@ -247,9 +247,9 @@ void iges_stats (int* nbpart, int* nbparam)
*nbparam = nbparams;
}
/* Lecture d'une part : retour = n0 section, 0 si fin */
/* \par tabval tableau recepteur des entiers (reserver 17 valeurs) */
/* \par res1 res2 nom num char : transmis a part */
/* Reading a part: return = section n0, 0 if end */
/* \par tabval integer receiver array (reserve 17 values) */
/* \par res1 res2 nom num char: transmitted to part */
int iges_lirpart (int* *tabval, char* *res1, char* *res2, char* *nom, char* *num, int *nbparam)
{
if (curpage == NULL) return 0;
@@ -257,24 +257,24 @@ int iges_lirpart (int* *tabval, char* *res1, char* *res2, char* *nom, char* *num
curlist = &(curp->list);
*nbparam = curlist->nbparam;
curparam = curlist->first;
*tabval = &(curp->typ); /* adresse de curp = adresse du tableau */
*tabval = &(curp->typ); /* address of curp = address of array */
*res1 = curp->res1; *res2 = curp->res2;
*nom = curp->nom; *num = curp->num;
return curp->numpart;
}
/* Passage au suivant (une fois lus les parametres) */
/* Move to next (once parameters are read) */
void iges_nextpart()
{
curnumpart ++;
if (curnumpart >= curpage->used) { /* attention, adressage de 0 a used-1 */
if (curnumpart >= curpage->used) { /* caution, addressing from 0 to used-1 */
curpage = curpage->next;
curnumpart = 0;
}
}
/* Lecture parametre + passage au suivant */
int iges_lirparam (int *typarg, char* *parval) /* renvoie 0 si fin de liste, 1 sinon */
/* Read parameter + move to next */
int iges_lirparam (int *typarg, char* *parval) /* returns 0 if end of list, 1 otherwise */
{
if (curparam == NULL) return 0;
*typarg = curparam->typarg;
@@ -283,8 +283,8 @@ int iges_lirparam (int *typarg, char* *parval) /* renvoie 0 si fin de liste,
return 1;
}
/* Fin pour ce fichier : liberer la place */
/* mode = 0 : tout; 1 : parametres; 2 : caracteres */
/* End for this file: free the space */
/* mode = 0: all; 1: parameters; 2: characters */
void iges_finfile (int mode)
{
struct dirpage* oldpage;

10
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ConicArc.cxx
View File

@@ -238,7 +238,7 @@ void IGESGeom_ConicArc::ComputedDefinition(Standard_Real& Xcen,
if (IsFromParabola())
{
Rmin = Rmax = -1.; // rayons : yena pas
Rmin = Rmax = -1.; // radii : there are none
if ((Abs(a) <= eps) && (Abs(b) <= eps))
{
Xcen = (f * c - e * e) / c / d / 2.;
@@ -274,11 +274,11 @@ void IGESGeom_ConicArc::ComputedDefinition(Standard_Real& Xcen,
else
{
// -> Conique a centre, cas general
// On utilise les Determinants des matrices :
// -> Centered conic, general case
// We use the matrix Determinants :
// | a b d |
// gdet (3x3) = | b c e | et pdet (2X2) = | a b |
// | d e f | | b c |
// gdet (3x3) = | b c e | and pdet (2X2) = | a b |
// | d e f | | b c |
Standard_Real gdet = a * c * f + 2 * b * d * e - c * d * d - a * e * e - b * b * f;
Standard_Real pdet = a * c - b * b;

2
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_CopiousData.cxx
View File

@@ -59,7 +59,7 @@ void IGESGeom_CopiousData::SetPolyline(const Standard_Boolean F)
void IGESGeom_CopiousData::SetClosedPath2D()
{
InitTypeAndForm(106, 63); // et verifier DataType !
InitTypeAndForm(106, 63); // and verify DataType !
}
Standard_Boolean IGESGeom_CopiousData::IsPointSet() const

2
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolBSplineCurve.cxx
View File

@@ -348,7 +348,7 @@ void IGESGeom_ToolBSplineCurve::OwnCheck(const Handle(IGESGeom_BSplineCurve)& en
// Message_Msg Msg109("XSTEP_109");
//========================================
Standard_Real eps = 1.E-04; // Tolerance des tests ??
Standard_Real eps = 1.E-04; // Test tolerance ??
// Standard_Real norm = ent->Normal().SquareModulus();
// modified by rln 17/12/97 check of flag PROP2 according to IGES Standard

2
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolBSplineSurface.cxx
View File

@@ -204,7 +204,7 @@ void IGESGeom_ToolBSplineSurface::ReadOwnParams(const Handle(IGESGeom_BSplineSur
st = PR.ReadReal(PR.Current(), "Starting Value For V Direction", aVmin);
st = PR.ReadReal(PR.Current(), "Ending Value For U Direction", aVmax);
*/
// PROTECTION contre ANSYS 5.3 qui ecrit 3 flottants en plus ...
// PROTECTION against ANSYS 5.3 which writes 3 additional floats ...
Standard_Integer icur = PR.CurrentNumber(), imax = PR.NbParams();
Standard_Real bid;
Standard_Integer pbfin = 0;

14
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolBoundary.cxx
View File

@@ -320,12 +320,12 @@ Standard_Boolean IGESGeom_ToolBoundary::OwnCorrect(const Handle(IGESGeom_Boundar
if (ent->BoundaryType() != 0)
return res; // OK
// Reste Boundary Type : s ilya des ParameterCurves, il doit valoir 1
// On reconstruit donc la Boundary a l identique, mais avec BoundaryType = 1
// Remaining Boundary Type : if there are ParameterCurves, it must be valued 1
// We therefore reconstruct the Boundary identically, but with BoundaryType = 1
// si type = 0, annuller tous les ParameterCurves
// -> On reconstruit, avec ParameterCurves Nulles
// En plus, les ParameterCurves doivent avoir leur UseFlag a 5
// if type = 0, nullify all ParameterCurves
// -> We reconstruct, with Null ParameterCurves
// In addition, the ParameterCurves must have their UseFlag at 5
Handle(IGESBasic_HArray1OfHArray1OfIGESEntity) cv2d =
new IGESBasic_HArray1OfHArray1OfIGESEntity(1, nb);
@@ -383,8 +383,8 @@ void IGESGeom_ToolBoundary::OwnCheck(const Handle(IGESGeom_Boundary)& ent,
ach->SendFail(Msg123);
}
// il faudrait aussi tester que, pour BoundaryType = 1, la Surface est bien
// Parametrique ... (au moins un cas ne passe pas : c est Plane 108)
// we should also test that, for BoundaryType = 1, the Surface is indeed
// Parametric ... (at least one case fails : it is Plane 108)
if (ent->BoundaryType() == 1)
{
if (ent->Surface()->TypeNumber() == 108)

2
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolCircularArc.cxx
View File

@@ -120,7 +120,7 @@ void IGESGeom_ToolCircularArc::OwnCheck(const Handle(IGESGeom_CircularArc)& /*en
Handle(Interface_Check)& /*ach*/) const
{
/*
//Standard_Real eps = 1.E-04; // Tolerance des tests ?? //szv#4:S4163:12Mar99 not needed
//Standard_Real eps = 1.E-04; // Test tolerance ?? //szv#4:S4163:12Mar99 not needed
Standard_Real Rad1 = Sqrt(Square(ent->StartPoint().X() - ent->Center().X()) +
Square(ent->StartPoint().Y() - ent->Center().Y()));

2
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolCurveOnSurface.cxx
View File

@@ -225,7 +225,7 @@ void IGESGeom_ToolCurveOnSurface::OwnCheck(const Handle(IGESGeom_CurveOnSurface)
// Standard_Integer pref = ent->PreferenceMode();
// if (pref < 0 || pref > 3)
// ach.SendFail("Incorrect value for the Preference Mode");
// tolerance a la norme
// tolerance to the standard
// if (pref == 1 && ent->CurveUV().IsNull())
// ach.AddWarning("Preference Mode asks UV and Curve UV not defined");
// if (pref == 2 && ent->Curve3D().IsNull())

2
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolOffsetCurve.cxx
View File

@@ -287,7 +287,7 @@ Standard_Boolean IGESGeom_ToolOffsetCurve::OwnCorrect(const Handle(IGESGeom_Offs
Handle(IGESData_IGESEntity) func = ent->Function();
if (func.IsNull())
return Standard_False;
// OffsetType != 3 : reconstruire avec Offset Function Nulle
// OffsetType != 3 : reconstruct with Null Offset Function
func.Nullify();
ent->Init(ent->BaseCurve(),
ent->OffsetType(),

6
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolPlane.cxx
View File

@@ -99,7 +99,7 @@ void IGESGeom_ToolPlane::ReadOwnParams(const Handle(IGESGeom_Plane)& en
}
} // szv#4:S4163:12Mar99 `st=` not needed
// st = PR.ReadEntity(IR, PR.Current(), "Bounding Curve", aCurve,Standard_True);
// en principe exige si FormNumber != 0 ... cf OwnCheck (Load accepte)
// in principle required if FormNumber != 0 ... see OwnCheck (Load accepts)
if (PR.IsParamDefined(PR.CurrentNumber()))
{
@@ -219,11 +219,11 @@ void IGESGeom_ToolPlane::OwnCheck(const Handle(IGESGeom_Plane)& ent,
ach->SendFail(Msg137);
}
// These messages are transferred in the translation procedure
// if ( (A*A + B*B + C*C) < eps) // pas nul !
// if ( (A*A + B*B + C*C) < eps) // not null !
// ach.SendFail("Incorrect Coefficients for the Plane");
if (!ent->HasBoundingCurve())
return;
// Symbol : verifie si Size defini > 0 (sinon, n a pas de signification)
// Symbol : check if Size defined > 0 (otherwise, has no meaning)
/* Standard_Real ec = 0.;
if (ent->SymbolSize() > 0.) ec = A*ent->SymbolAttach().X() + B*ent->SymbolAttach().Y() +
C * ent->SymbolAttach().Z() - D;

4
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolSplineSurface.cxx
View File

@@ -164,8 +164,8 @@ void IGESGeom_ToolSplineSurface::ReadOwnParams(const Handle(IGESGeom_SplineSurfa
}
else
{
// Si fin manquante ... On refait temp !
// Les valeurs n ont pas ete lues ... il faut d abord les relire !
// If end missing ... We redo temp !
// The values were not read ... we must first re-read them !
Temp = new TColStd_HArray1OfReal(1, 16);
Temp->Init(0.);
for (k = 1; k <= 16; k++)

2
src/DataExchange/TKDEIGES/IGESGeom/IGESGeom_ToolTransformationMatrix.cxx
View File

@@ -164,7 +164,7 @@ void IGESGeom_ToolTransformationMatrix::OwnCheck(const Handle(IGESGeom_Transform
}
// These messages are transferred in the translation procedure
/*
if (form > 1) return; // ce qui suit : matrice orthogonale
if (form > 1) return; // what follows : orthogonal matrix
if (form == 0 && ent->Value().IsNegative())
ach.AddFail("For Form 0, Determinant is not Positive");
else if (form == 1 && !ent->Value().IsNegative())

2
src/DataExchange/TKDEIGES/IGESGraph/IGESGraph_ToolColor.cxx
View File

@@ -62,7 +62,7 @@ void IGESGraph_ToolColor::WriteOwnParams(const Handle(IGESGraph_Color)& ent,
IW.Send(Red);
IW.Send(Green);
IW.Send(Blue);
// ATTENTION place a reserver (Null) silya des pointeurs additionnels
// WARNING place to reserve (Null) if there are additional pointers
if (ent->HasColorName())
IW.Send(ent->ColorName());
else

6
src/DataExchange/TKDEIGES/IGESGraph/IGESGraph_ToolDrawingUnits.cxx
View File

@@ -113,7 +113,7 @@ Standard_Boolean IGESGraph_ToolDrawingUnits::OwnCorrect(
}
break;
case 3:
break; // nom libre
break; // free name
case 4:
if (strcmp(unm, "FT") == 0)
{
@@ -163,7 +163,7 @@ Standard_Boolean IGESGraph_ToolDrawingUnits::OwnCorrect(
}
break;
default:
break; // on ne peut rien faire ... ?
break; // we can't do anything ... ?
}
res |= (!name.IsNull());
@@ -215,7 +215,7 @@ void IGESGraph_ToolDrawingUnits::OwnCheck(const Handle(IGESGraph_DrawingUnits)&
break;
case 3:
unok = Standard_True;
break; // nom libre
break; // free name
case 4:
unok = !strcmp(unm, "FT");
break;

2
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect.cxx
View File

@@ -49,7 +49,7 @@ Standard_Integer IGESSelect::WhatIges(const Handle(IGESData_IGESEntity)& ent,
if (igesent.IsNull() || model.IsNull())
return 0;
// Plane : de View ? de SingleParent ? sinon cf TrimmedSurface & cie
// Plane : from View? from SingleParent? otherwise see TrimmedSurface & co
return 0;
}

67
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_Activator.cxx
View File

@@ -114,7 +114,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
switch (number)
{
case 5: // **** ListViews (sans tri complementaire)
case 5: // **** ListViews (without additional sorting)
case 6: // **** ListDrawings
case 7: { // **** ListS(ingle)Views
Standard_Integer listmode = 0;
@@ -122,12 +122,11 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
argc = -1;
if (argc < 2)
{
std::cout << "Ajouter un argument pour avoir :\n"
<< " l : liste resumee"
<< " c : liste complete par item (mais pas pour remaining)\n"
<< " r : idem + liste complete remaining\n"
<< " sur tout le modele. Ajouter nom selection pour lister sur une partie"
<< std::endl;
std::cout << "Add an argument to have :\n"
<< " l : summary list"
<< " c : complete list per item (but not for remaining)\n"
<< " r : same + complete remaining list\n"
<< " on entire model. Add selection name to list on a part" << std::endl;
return (argc >= 0 ? IFSelect_RetError : IFSelect_RetVoid);
}
if (arg1[0] == 'l')
@@ -138,12 +137,12 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
else if (arg1[0] == 'c')
{
listmode = 1;
std::cout << "Liste complete par item (pas pour Remaining)" << std::endl;
std::cout << "Complete list per item (not for Remaining)" << std::endl;
}
else if (arg1[0] == 'r')
{
listmode = 2;
std::cout << "Liste complete par item et pour Remaining" << std::endl;
std::cout << "Complete list per item and for Remaining" << std::endl;
}
else
{
@@ -207,8 +206,8 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
case 10: { // **** IGESType (form Type/Form)
if (argc < 2)
{
std::cout << "Donner le n0 de type desire, + en option la forme\n"
<< " Si pas de forme, prend toutes les formes du type demande" << std::endl;
std::cout << "Give the desired type number, + optionally the form\n"
<< " If no form, takes all forms of the requested type" << std::endl;
return IFSelect_RetError;
}
char signature[20];
@@ -228,7 +227,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
case 12: { // **** IGES Name
if (argc < 2)
{
std::cout << "Donner un Nom de TextParam pour IGESName" << std::endl;
std::cout << "Give a TextParam Name for IGESName" << std::endl;
return IFSelect_RetError;
}
Handle(IGESSelect_SelectName) sel = new IGESSelect_SelectName;
@@ -243,13 +242,13 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
case 14: { // **** IGES LevelNumber
if (argc < 2)
{
std::cout << "Donner nom IntParam pour Level" << std::endl;
std::cout << "Give IntParam name for Level" << std::endl;
return IFSelect_RetError;
}
DeclareAndCast(IFSelect_IntParam, lev, WS->NamedItem(arg1));
if (lev.IsNull())
{
std::cout << arg1 << " : pas un IntParam (pour Level)" << std::endl;
std::cout << arg1 << " : not an IntParam (for Level)" << std::endl;
return IFSelect_RetError;
}
Handle(IGESSelect_SelectLevelNumber) sel = new IGESSelect_SelectLevelNumber;
@@ -283,7 +282,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
prem = '?';
else if (argc == 5)
{
std::cout << "floatformat tout court donne les formes admises" << std::endl;
std::cout << "floatformat alone gives the accepted forms" << std::endl;
return IFSelect_RetError;
}
else
@@ -298,13 +297,13 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
digits = atoi(arg1);
else
{
std::cout << "floatformat digits, digits=nb de chiffres signifiants, ou\n"
std::cout << "floatformat digits, digits=nb of significant digits, or\n"
<< "floatformat NZ %mainformat [%rangeformat [Rmin Rmax]]\n"
<< " NZ : N ou n pour Non-zero-suppress, Z ou z pour zero-suppress\n"
<< " %mainformat : format principal type printf, ex,: %E\n"
<< " + optionnel : format secondaire (flottants autour de 1.) :\n"
<< " %rangeformat Rmin Rmax : format type printf entre Rmin et Rmax\n"
<< " %rangeformat tout seul : format type printf entre 0.1 et 1000.\n"
<< " NZ : N or n for Non-zero-suppress, Z or z for zero-suppress\n"
<< " %mainformat : main format printf type, ex,: %E\n"
<< " + optional : secondary format (floats around 1.) :\n"
<< " %rangeformat Rmin Rmax : printf type format between Rmin and Rmax\n"
<< " %rangeformat alone : printf type format between 0.1 and 1000.\n"
<< std::flush;
return (prem == '?' ? IFSelect_RetVoid : IFSelect_RetError);
}
@@ -339,7 +338,7 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
case 41: { // **** SetGlobalParameter
if (argc < 3)
{
std::cout << "Donner entier=n0 param a changer + nom TextParam pour la valeur" << std::endl;
std::cout << "Give integer=n0 param to change + TextParam name for the value" << std::endl;
return IFSelect_RetError;
}
Standard_Integer numpar = atoi(arg1);
@@ -391,8 +390,8 @@ IFSelect_ReturnStatus IGESSelect_Activator::Do(const Standard_Integer
case 60: { // **** Spline To BSpline
if (argc < 2)
{
std::cout << "Pour SplineToBSpline, donner mode :\n"
<< " n pour normal, t pour tryC2" << std::endl;
std::cout << "For SplineToBSpline, give mode :\n"
<< " n for normal, t for tryC2" << std::endl;
return IFSelect_RetError;
}
Standard_Boolean tryC2;
@@ -452,11 +451,11 @@ Standard_CString IGESSelect_Activator::Help(const Standard_Integer number) const
switch (number)
{
case 5:
return "Liste Vues (tous types). Nom selection sinon tout modele";
return "List Views (all types). Selection name otherwise entire model";
case 6:
return "Liste Drawings. Nom selection sinon tout modele";
return "List Drawings. Selection name otherwise entire model";
case 7:
return "Liste Vues SIMPLES. Nom selection sinon tout modele";
return "List SIMPLE Views. Selection name otherwise entire model";
case 10:
return "type:integer [form:integer] : cree Select IGESType";
@@ -472,21 +471,21 @@ Standard_CString IGESSelect_Activator::Help(const Standard_Integer number) const
case 21:
return "cree Select From Drawing";
case 22:
return "cree Select From Single View";
return "create Select From Single View";
case 23:
return "cree Select Drawing From, drawing(s) pour une liste d entites";
return "create Select Drawing From, drawing(s) for an entity list";
case 24:
return "cree Select View From, views pour une liste d entites";
return "create Select View From, views for an entity list";
case 31:
return "cree Dispatch Per Drawing";
return "create Dispatch Per Drawing";
case 32:
return "cree Dispatch Per SingleView";
return "create Dispatch Per SingleView";
case 40:
return "options... : cree FloatFormat ... floatformat tout court->help";
return "options... : create FloatFormat ... floatformat alone->help";
case 41:
return "numpar:integer value:TextParam : cree Set Global Param";
return "numpar:integer value:TextParam : create Set Global Param";
case 42:
return "cree Set Version -> 5.1";
case 43:

10
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_RebuildGroups.cxx
View File

@@ -37,14 +37,14 @@ void IGESSelect_RebuildGroups::Performing(IFSelect_ContextModif& ctx,
const Handle(IGESData_IGESModel)& target,
Interface_CopyTool& TC) const
{
// On reconstruit les groupes qui peuvent l etre
// Pour chaque groupe de l original, on regarde les composants transferes
// (evt filtres par <ctx>)
// Ensuite, silyena plus d une, on refait un nouveau groupe
// We rebuild the groups that can be
// For each group of the original, we look at the transferred components
// (possibly filtered by <ctx>)
// Then, if there are more than one, we create a new group
DeclareAndCast(IGESData_IGESModel, original, ctx.OriginalModel());
Standard_Integer nbo = original->NbEntities();
// Entites a prendre en compte pour la reconstruction
// Entities to consider for reconstruction
// NB : Les groupes deja transferes ne sont bien sur pas reconstruits !
TColStd_Array1OfInteger pris(0, nbo);
pris.Init(0);

2
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_SelectBypassGroup.cxx
View File

@@ -34,7 +34,7 @@ Standard_Boolean IGESSelect_SelectBypassGroup::Explore(const Standard_Integer /*
const Interface_Graph& /*G*/,
Interface_EntityIterator& explored) const
{
DeclareAndCast(IGESBasic_Group, gr, ent); // Group les regroupe tous
DeclareAndCast(IGESBasic_Group, gr, ent); // Group groups them all
if (gr.IsNull())
return Standard_True;

2
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_SelectBypassSubfigure.cxx
View File

@@ -89,7 +89,7 @@ Standard_Boolean IGESSelect_SelectBypassSubfigure::Explore(const Standard_Intege
explored.AddItem(subf->BaseEntity());
}
// Si c est pas tout ca, c est un objet de base et on le prend tel quel
// If it's not all that, it's a base object and we take it as is
return Standard_True;
}

2
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_SignStatus.cxx
View File

@@ -116,5 +116,5 @@ Standard_Boolean IGESSelect_SignStatus::Matches(const Handle(Standard_Transient)
return Standard_False;
}
}
return exact; // un brin de reflexion pour arriver
return exact; // a bit of reflection to arrive
}

8
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_ViewSorter.cxx
View File

@@ -76,7 +76,7 @@ Standard_Boolean IGESSelect_ViewSorter::AddEntity(const Handle(IGESData_IGESEnti
if (themap.FindIndex(igesent))
return Standard_False;
themap.Add(igesent);
// Recuperation de la vue (attention au cas du Drawing)
// View recovery (watch out for Drawing case)
Handle(IGESData_IGESEntity) view;
if (igesent->TypeNumber() == PourDrawing)
view = igesent; // DRAWING
@@ -131,10 +131,10 @@ Standard_Integer IGESSelect_ViewSorter::NbEntities() const
void IGESSelect_ViewSorter::SortSingleViews(const Standard_Boolean alsoframes)
{
// Du tas initial, on ecarte : les vues nulles, et selon alsoframe les drawings
// Vues nulles : cf theremain (remain initial reconduit)
// From the initial pile, we exclude : null views, and according to alsoframe the drawings
// Null views : see theremain (initial remain carried forward)
// Remarque : le filtre IsSingle a ete applique par Add
// Note : the IsSingle filter has been applied by Add
thefinals.Clear();
Standard_Integer nb = theinditem.Length();
// Standard_Integer numit = 0; //szv#4:S4163:12Mar99 not needed

2
src/DataExchange/TKDEIGES/IGESSelect/IGESSelect_WorkLibrary.cxx
View File

@@ -185,7 +185,7 @@ void IGESSelect_WorkLibrary::DumpEntity(const Handle(Interface_InterfaceModel)&
return;
}
// On attaque le dump : d abord cas de l Erreur
// We start the dump : first the Error case
if (iserr)
{
S << " ERRONEOUS, Content, Type cdl : ";

4
src/DataExchange/TKDEIGES/IGESSolid/IGESSolid_Loop.cxx
View File

@@ -102,13 +102,13 @@ Standard_Boolean IGESSolid_Loop::IsIsoparametric(const Standard_Integer EdgeInde
if (!theIsoparametricFlags->Value(EdgeIndex).IsNull())
return (theIsoparametricFlags->Value(EdgeIndex)->Value(CurveIndex) != 0);
else
return Standard_False; // faut bien dire qq chose
return Standard_False; // must say something
}
Handle(IGESData_IGESEntity) IGESSolid_Loop::ParametricCurve(const Standard_Integer EdgeIndex,
const Standard_Integer CurveIndex) const
{
Handle(IGESData_IGESEntity) acurve; // par defaut sera nulle
Handle(IGESData_IGESEntity) acurve; // by default will be null
if (!theCurves->Value(EdgeIndex).IsNull())
acurve = theCurves->Value(EdgeIndex)->Value(CurveIndex);
return acurve;

2
src/DataExchange/TKDEIGES/IGESSolid/IGESSolid_ToolConicalSurface.cxx
View File

@@ -78,7 +78,7 @@ void IGESSolid_ToolConicalSurface::WriteOwnParams(const Handle(IGESSolid_Conical
IW.Send(ent->Radius());
IW.Send(ent->SemiAngle());
if (ent->IsParametrised())
IW.Send(ent->ReferenceDir()); // cf FormNumber
IW.Send(ent->ReferenceDir()); // see FormNumber
}
void IGESSolid_ToolConicalSurface::OwnShared(const Handle(IGESSolid_ConicalSurface)& ent,

2
src/DataExchange/TKDEIGES/IGESSolid/IGESSolid_TopoBuilder.cxx
View File

@@ -186,7 +186,7 @@ void IGESSolid_TopoBuilder::AddCurveUV(const Handle(IGESData_IGESEntity)& curve,
void IGESSolid_TopoBuilder::EndEdge()
{
// transformer thecuruv,theiso en array et le mettre dans theeuv
// transform thecuruv,theiso to array and put it in theeuv
Handle(IGESData_HArray1OfIGESEntity) curuv;
Handle(TColStd_HArray1OfInteger) iso;
if (!thecuruv->IsEmpty())

Some files were not shown because too many files have changed in this diff Show More