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 - Method guard iterative update (#674)

Browse Source 
- Standardizes comment formatting by replacing detailed comment blocks with a uniform "//=================================================================================================" separator
- Removes redundant "function:" and "purpose:" fields that often contained minimal or no useful information
- Maintains code functionality while improving visual consistency across the codebase
This commit is contained in:
Pasukhin Dmitry
2025-08-15 17:14:53 +01:00
committed by GitHub
parent 02f6fa7be2
commit ae4de70f98
365 changed files with 3229 additions and 9377 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/ApplicationFramework/TKBin/BinMNaming/BinMNaming_NamedShapeDriver.lxx
View File

@@ -13,10 +13,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : SetWithTriangles
// purpose :
//=======================================================================
//=================================================================================================
inline void BinMNaming_NamedShapeDriver::SetWithTriangles(const Standard_Boolean isWithTriangles)
{
@@ -25,10 +22,7 @@ inline void BinMNaming_NamedShapeDriver::SetWithTriangles(const Standard_Boolean
myShapeSet->SetWithTriangles(isWithTriangles);
}
//=======================================================================
// function : SetWithNormals
// purpose :
//=======================================================================
//=================================================================================================
inline void BinMNaming_NamedShapeDriver::SetWithNormals(const Standard_Boolean isWithNormals)
{

5
src/ApplicationFramework/TKBinL/BinMDF/BinMDF_ADriver.lxx
View File

@@ -15,10 +15,7 @@
#include <TDF_Attribute.hxx>
//=======================================================================
// function : TypeName
// purpose :
//=======================================================================
//=================================================================================================
inline const TCollection_AsciiString& BinMDF_ADriver::TypeName() const
{

10
src/ApplicationFramework/TKBinL/BinObjMgt/BinObjMgt_Persistent.lxx
View File

@@ -203,20 +203,14 @@ inline Standard_Boolean BinObjMgt_Persistent::noMoreData(const Standard_Integer
return myIsError;
}
//=======================================================================
// function : PutBoolean
// purpose :
//=======================================================================
//=================================================================================================
inline BinObjMgt_Persistent& BinObjMgt_Persistent::PutBoolean(const Standard_Boolean theValue)
{
return PutInteger((Standard_Integer)theValue);
}
//=======================================================================
// function : GetBoolean
// purpose :
//=======================================================================
//=================================================================================================
inline const BinObjMgt_Persistent& BinObjMgt_Persistent::GetBoolean(
Standard_Boolean& theValue) const

50
src/ApplicationFramework/TKCAF/TDataXtd/TDataXtd_PatternStd.lxx
View File

@@ -13,100 +13,70 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Signature
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer TDataXtd_PatternStd::Signature() const
{
return mySignature;
}
//=======================================================================
// function : Axis1
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TNaming_NamedShape) TDataXtd_PatternStd::Axis1() const
{
return myAxis1;
}
//=======================================================================
// function : Axis2
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TNaming_NamedShape) TDataXtd_PatternStd::Axis2() const
{
return myAxis2;
}
//=======================================================================
// function : Axis1Reversed
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TDataXtd_PatternStd::Axis1Reversed() const
{
return myAxis1Reversed;
}
//=======================================================================
// function : Axis2Reversed
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TDataXtd_PatternStd::Axis2Reversed() const
{
return myAxis2Reversed;
}
//=======================================================================
// function : Value1
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TDataStd_Real) TDataXtd_PatternStd::Value1() const
{
return myValue1;
}
//=======================================================================
// function : Value2
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TDataStd_Real) TDataXtd_PatternStd::Value2() const
{
return myValue2;
}
//=======================================================================
// function : NbInstances1
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TDataStd_Integer) TDataXtd_PatternStd::NbInstances1() const
{
return myNb1;
}
//=======================================================================
// function : NbInstances2
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TDataStd_Integer) TDataXtd_PatternStd::NbInstances2() const
{
return myNb2;
}
//=======================================================================
// function : Mirror
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TNaming_NamedShape) TDataXtd_PatternStd::Mirror() const
{

6
src/ApplicationFramework/TKCAF/TDataXtd/TDataXtd_Presentation.cxx
View File

@@ -261,10 +261,8 @@ Standard_Integer TDataXtd_Presentation::getOldColorNameFromNewEnum(Quantity_Name
return anOld;
}
//=======================================================================
// function : TDataXtd_Presentation
// purpose : Default constructor.
//=======================================================================
//=================================================================================================
TDataXtd_Presentation::TDataXtd_Presentation()
: myDriverGUID("00000000-0000-0000-0000-000000000000"),
myColor(Quantity_NOC_WHITE),

5
src/ApplicationFramework/TKCAF/TNaming/TNaming_CopyShape.cxx
View File

@@ -157,10 +157,7 @@ static Handle(TopLoc_Datum3D) TranslateDatum3D(const Handle(TopLoc_Datum3D)&
return TD;
}
//=======================================================================
// function : Translates
// purpose : Topological Location
//=======================================================================
//=================================================================================================
TopLoc_Location TNaming_CopyShape::Translate(const TopLoc_Location& L,
TColStd_IndexedDataMapOfTransientTransient& aMap)

30
src/ApplicationFramework/TKCAF/TNaming/TNaming_IteratorOnShapesSet.lxx
View File

@@ -16,57 +16,39 @@
#include <TNaming_ShapesSet.hxx>
//=======================================================================
// function :
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_IteratorOnShapesSet::TNaming_IteratorOnShapesSet() {}
//=======================================================================
// function :
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_IteratorOnShapesSet::TNaming_IteratorOnShapesSet(const TNaming_ShapesSet& S)
{
Init(S);
}
//=======================================================================
// function : Init
// purpose :
//=======================================================================
//=================================================================================================
inline void TNaming_IteratorOnShapesSet::Init(const TNaming_ShapesSet& S)
{
myIt.Initialize(S.Map());
}
//=======================================================================
// function : More
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_IteratorOnShapesSet::More() const
{
return (myIt.More());
}
//=======================================================================
// function : Next
// purpose :
//=======================================================================
//=================================================================================================
inline void TNaming_IteratorOnShapesSet::Next()
{
myIt.Next();
}
//=======================================================================
// function : Value
// purpose :
//=======================================================================
//=================================================================================================
inline const TopoDS_Shape& TNaming_IteratorOnShapesSet::Value() const
{

20
src/ApplicationFramework/TKCAF/TNaming/TNaming_NamedShape.lxx
View File

@@ -14,40 +14,28 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : ID
// purpose :
//=======================================================================
//=================================================================================================
inline const Standard_GUID& TNaming_NamedShape::ID() const
{
return GetID();
}
//=======================================================================
// function :
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_Evolution TNaming_NamedShape::Evolution() const
{
return myEvolution;
}
//=======================================================================
// function :
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer TNaming_NamedShape::Version() const
{
return myVersion;
}
//=======================================================================
// function :
// purpose :
//=======================================================================
//=================================================================================================
inline void TNaming_NamedShape::SetVersion(const Standard_Integer v)
{

5
src/ApplicationFramework/TKCAF/TNaming/TNaming_NewShapeIterator.lxx
View File

@@ -14,10 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : More
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_NewShapeIterator::More() const
{

5
src/ApplicationFramework/TKCAF/TNaming/TNaming_OldShapeIterator.lxx
View File

@@ -14,10 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : More
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_OldShapeIterator::More() const
{

30
src/ApplicationFramework/TKCAF/TNaming/TNaming_RefShape.lxx
View File

@@ -14,20 +14,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : TNaming_RefShape
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_RefShape::TNaming_RefShape()
: myFirstUse(0)
{
}
//=======================================================================
// function : TNaming_RefShape
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_RefShape::TNaming_RefShape(const TopoDS_Shape& S)
: myShape(S),
@@ -35,40 +29,28 @@ inline TNaming_RefShape::TNaming_RefShape(const TopoDS_Shape& S)
{
}
//=======================================================================
// function : FirstUse
// purpose :
//=======================================================================
//=================================================================================================
inline void TNaming_RefShape::FirstUse(const TNaming_PtrNode& pdn)
{
myFirstUse = pdn;
}
//=======================================================================
// function : Shape
// purpose :
//=======================================================================
//=================================================================================================
inline void TNaming_RefShape::Shape(const TopoDS_Shape& S)
{
myShape = S;
}
//=======================================================================
// function : FirstUse
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_PtrNode TNaming_RefShape::FirstUse() const
{
return myFirstUse;
}
//=======================================================================
// function : Shape
// purpose :
//=======================================================================
//=================================================================================================
inline const TopoDS_Shape& TNaming_RefShape::Shape() const
{

5
src/ApplicationFramework/TKCAF/TNaming/TNaming_SameShapeIterator.lxx
View File

@@ -14,10 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : More
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_SameShapeIterator::More() const
{

45
src/ApplicationFramework/TKCAF/TNaming/TNaming_ShapesSet.lxx
View File

@@ -16,87 +16,60 @@
#include <TopTools_MapOfShape.hxx>
//=======================================================================
// function : TNaming_ShapesSet
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_ShapesSet::TNaming_ShapesSet() {}
//=======================================================================
// function : Clear
// purpose :
//=======================================================================
//=================================================================================================
inline void TNaming_ShapesSet::Clear()
{
myMap.Clear();
}
//=======================================================================
// function : Add
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::Add(const TopoDS_Shape& S)
{
return myMap.Add(S);
}
//=======================================================================
// function : Standard_Boolean
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::Contains(const TopoDS_Shape& S) const
{
return myMap.Contains(S);
}
//=======================================================================
// function : Standard_Boolean
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::Remove(const TopoDS_Shape& S)
{
return myMap.Remove(S);
}
//=======================================================================
// function : IsEmpty
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TNaming_ShapesSet::IsEmpty() const
{
return myMap.IsEmpty();
}
//=======================================================================
// function : NbShapes
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer TNaming_ShapesSet::NbShapes() const
{
return myMap.Extent();
}
//=======================================================================
// function : ChangeMap
// purpose :
//=======================================================================
//=================================================================================================
inline TopTools_MapOfShape& TNaming_ShapesSet::ChangeMap()
{
return myMap;
}
//=======================================================================
// function : Map
// purpose :
//=======================================================================
//=================================================================================================
inline const TopTools_MapOfShape& TNaming_ShapesSet::Map() const
{

10
src/ApplicationFramework/TKCAF/TNaming/TNaming_UsedShapes.lxx
View File

@@ -14,20 +14,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Map
// purpose :
//=======================================================================
//=================================================================================================
inline TNaming_DataMapOfShapePtrRefShape& TNaming_UsedShapes::Map()
{
return myMap;
}
//=======================================================================
// function : ID
// purpose :
//=======================================================================
//=================================================================================================
inline const Standard_GUID& TNaming_UsedShapes::ID() const
{

5
src/ApplicationFramework/TKCDF/PCDM/PCDM_Reader.lxx
View File

@@ -13,10 +13,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : GetStatus
// purpose :
//=======================================================================
//=================================================================================================
inline PCDM_ReaderStatus PCDM_Reader::GetStatus() const
{

5
src/ApplicationFramework/TKLCAF/TDF/TDF_Attribute.cxx
View File

@@ -44,10 +44,7 @@ IMPLEMENT_STANDARD_RTTIEXT(TDF_Attribute, Standard_Transient)
#define TDF_DATA_COMMIT_OPTIMIZED
//=======================================================================
// function : TDF_Attribute
// purpose : Initializes fields.
//=======================================================================
//=================================================================================================
TDF_Attribute::TDF_Attribute()
: myLabelNode(NULL),

5
src/ApplicationFramework/TKLCAF/TDF/TDF_CopyLabel.lxx
View File

@@ -14,10 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : IsDone
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TDF_CopyLabel::IsDone() const
{

5
src/ApplicationFramework/TKLCAF/TDF/TDF_IDFilter.cxx
View File

@@ -51,10 +51,7 @@ void TDF_IDFilter::Keep(const Standard_GUID& anID)
myIDMap.Remove(anID);
}
//=======================================================================
// function : Keep
// purpose : Keeps a list of ID.
//=======================================================================
//=================================================================================================
void TDF_IDFilter::Keep(const TDF_IDList& anIDList)
{

20
src/ApplicationFramework/TKLCAF/TDataStd/TDataStd_TreeNode.cxx
View File

@@ -91,10 +91,7 @@ const Standard_GUID& TDataStd_TreeNode::ID() const
return myTreeID;
}
//=======================================================================
// TreeNode : TDataStd_TreeNode
// purpose : Constructor
//=======================================================================
//=================================================================================================
TDataStd_TreeNode::TDataStd_TreeNode()
: myFather(NULL),
@@ -408,10 +405,7 @@ Handle(TDataStd_TreeNode) TDataStd_TreeNode::Previous() const
return O;
}
//=======================================================================
// TreeNode : First
// purpose : Returns first child
//=======================================================================
//=================================================================================================
Handle(TDataStd_TreeNode) TDataStd_TreeNode::First() const
{
@@ -598,10 +592,7 @@ Standard_Boolean TDataStd_TreeNode::AfterUndo(const Handle(TDF_AttributeDelta)&
return Standard_True;
}
//=======================================================================
// TreeNode : Restore
// purpose :
//=======================================================================
//=================================================================================================
void TDataStd_TreeNode::Restore(const Handle(TDF_Attribute)& other)
{
@@ -675,10 +666,7 @@ void TDataStd_TreeNode::References(const Handle(TDF_DataSet)& aDataSet) const
}
}
//=======================================================================
// TreeNode : Dump
// purpose : Dump of the TreeNode
//=======================================================================
//=================================================================================================
Standard_OStream& TDataStd_TreeNode::Dump(Standard_OStream& anOS) const
{

15
src/ApplicationFramework/TKLCAF/TDocStd/TDocStd_ApplicationDelta.lxx
View File

@@ -13,30 +13,21 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : GetDocuments
// purpose :
//=======================================================================
//=================================================================================================
inline TDocStd_SequenceOfDocument& TDocStd_ApplicationDelta::GetDocuments()
{
return myDocuments;
}
//=======================================================================
// function : GetName
// purpose :
//=======================================================================
//=================================================================================================
inline const TCollection_ExtendedString& TDocStd_ApplicationDelta::GetName() const
{
return myName;
}
//=======================================================================
// function : SetName
// purpose :
//=======================================================================
//=================================================================================================
inline void TDocStd_ApplicationDelta::SetName(const TCollection_ExtendedString& theName)
{

30
src/ApplicationFramework/TKLCAF/TDocStd/TDocStd_MultiTransactionManager.lxx
View File

@@ -13,20 +13,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : GetUndoLimit
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer TDocStd_MultiTransactionManager::GetUndoLimit() const
{
return myUndoLimit;
}
//=======================================================================
// function : GetAvailableUndos
// purpose :
//=======================================================================
//=================================================================================================
inline const TDocStd_SequenceOfApplicationDelta& TDocStd_MultiTransactionManager::
GetAvailableUndos() const
@@ -34,10 +28,7 @@ inline const TDocStd_SequenceOfApplicationDelta& TDocStd_MultiTransactionManager
return myUndos;
}
//=======================================================================
// function : GetAvailableRedos
// purpose :
//=======================================================================
//=================================================================================================
inline const TDocStd_SequenceOfApplicationDelta& TDocStd_MultiTransactionManager::
GetAvailableRedos() const
@@ -45,30 +36,21 @@ inline const TDocStd_SequenceOfApplicationDelta& TDocStd_MultiTransactionManager
return myRedos;
}
//=======================================================================
// function : Documents
// purpose :
//=======================================================================
//=================================================================================================
inline const TDocStd_SequenceOfDocument& TDocStd_MultiTransactionManager::Documents() const
{
return myDocuments;
}
//=======================================================================
// function : IsNestedTransactionMode
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TDocStd_MultiTransactionManager::IsNestedTransactionMode() const
{
return myIsNestedTransactionMode;
}
//=======================================================================
// function : HasOpenCommand
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TDocStd_MultiTransactionManager::HasOpenCommand() const
{

5
src/ApplicationFramework/TKLCAF/TFunction/TFunction_DriverTable.cxx
View File

@@ -152,10 +152,7 @@ Standard_Boolean TFunction_DriverTable::RemoveDriver(const Standard_GUID& guid
return Standard_False;
}
//=======================================================================
// function : Clear
// purpose : Removes all drivers
//=======================================================================
//=================================================================================================
void TFunction_DriverTable::Clear()
{

5
src/ApplicationFramework/TKLCAF/TFunction/TFunction_Function.cxx
View File

@@ -165,10 +165,7 @@ Handle(TDF_Attribute) TFunction_Function::NewEmpty() const
void TFunction_Function::References(const Handle(TDF_DataSet)& /*aDataSet*/) const {}
//=======================================================================
// function : Dump
// purpose : Dump of the function
//=======================================================================
//=================================================================================================
Standard_OStream& TFunction_Function::Dump(Standard_OStream& anOS) const
{

5
src/ApplicationFramework/TKLCAF/TFunction/TFunction_IFunction.cxx
View File

@@ -380,10 +380,7 @@ const TFunction_DoubleMapOfIntegerLabel& TFunction_IFunction::GetAllFunctions()
return TFunction_Scope::Set(myLabel)->GetFunctions();
}
//=======================================================================
// function : GetLogbook
// purpose : Returns the Logbook.
//=======================================================================
//=================================================================================================
Handle(TFunction_Logbook) TFunction_IFunction::GetLogbook() const
{

15
src/ApplicationFramework/TKLCAF/TFunction/TFunction_Scope.cxx
View File

@@ -145,30 +145,21 @@ Standard_Boolean TFunction_Scope::HasFunction(const TDF_Label& L) const
return myFunctions.IsBound2(L);
}
//=======================================================================
// function : GetFunction
// purpose : Returns a function.
//=======================================================================
//=================================================================================================
Standard_Integer TFunction_Scope::GetFunction(const TDF_Label& L) const
{
return myFunctions.Find2(L);
}
//=======================================================================
// function : GetFunction
// purpose : Returns a function.
//=======================================================================
//=================================================================================================
const TDF_Label& TFunction_Scope::GetFunction(const Standard_Integer ID) const
{
return myFunctions.Find1(ID);
}
//=======================================================================
// function : GetLogbook
// purpose : Returns the Logbook.
//=======================================================================
//=================================================================================================
Handle(TFunction_Logbook) TFunction_Scope::GetLogbook() const
{

10
src/ApplicationFramework/TKTObj/TObj/TObj_Object.cxx
View File

@@ -488,10 +488,7 @@ Standard_Boolean TObj_Object::Detach(const TObj_DeletingMode theMode)
return Standard_True;
}
//=======================================================================
// function : Detach
// purpose : public static method
//=======================================================================
//=================================================================================================
Standard_Boolean TObj_Object::Detach(const TDF_Label& theLabel, const TObj_DeletingMode theMode)
{
@@ -573,10 +570,7 @@ void TObj_Object::AfterRetrieval()
aModel->RegisterName(GetName(), GetLabel(), GetDictionary());
}
//=======================================================================
// function : BeforeStoring
// purpose : base implementation
//=======================================================================
//=================================================================================================
void TObj_Object::BeforeStoring() {}

5
src/ApplicationFramework/TKTObj/TObj/TObj_Persistence.cxx
View File

@@ -40,10 +40,7 @@ TObj_Persistence::TObj_Persistence(const Standard_CString theType)
getMapOfTypes().Bind(theType, this);
}
//=======================================================================
// function : Destructor
// purpose : Unregister the type
//=======================================================================
//=================================================================================================
TObj_Persistence::~TObj_Persistence()
{

5
src/ApplicationFramework/TKTObj/TObj/TObj_TReference.cxx
View File

@@ -82,10 +82,7 @@ void TObj_TReference::Set(const Handle(TObj_Object)& theElem, const TDF_Label& t
myMasterLabel = theMasterLabel;
}
//=======================================================================
// function : Set
// purpose : for persistent only.
//=======================================================================
//=================================================================================================
void TObj_TReference::Set(const TDF_Label& theLabel, const TDF_Label& theMasterLabel)
{

6
src/ApplicationFramework/TKVCAF/TPrsStd/TPrsStd_AISPresentation.cxx
View File

@@ -631,10 +631,8 @@ void TPrsStd_AISPresentation::BeforeForget()
}
}
//=======================================================================
// function : AfterResume
// purpose : display if displayed
//=======================================================================
//=================================================================================================
void TPrsStd_AISPresentation::AfterResume()
{
if (IsDisplayed())

5
src/ApplicationFramework/TKVCAF/TPrsStd/TPrsStd_DriverTable.cxx
View File

@@ -120,10 +120,7 @@ Standard_Boolean TPrsStd_DriverTable::RemoveDriver(const Standard_GUID& guid)
return myDrivers.UnBind(guid);
}
//=======================================================================
// function : Clear
// purpose : Removes all drivers
//=======================================================================
//=================================================================================================
void TPrsStd_DriverTable::Clear()
{

5
src/ApplicationFramework/TKXml/XmlMNaming/XmlMNaming_NamedShapeDriver.cxx
View File

@@ -276,10 +276,7 @@ static TNaming_Evolution EvolutionEnum(const XmlObjMgt_DOMString& theString)
return aResult;
}
//=======================================================================
// function : doTranslate
// purpose : shape storage to XML
//=======================================================================
//=================================================================================================
static void doTranslate(const TopoDS_Shape& theShape,
XmlMNaming_Shape1& theResult,

6
src/ApplicationFramework/TKXml/XmlMNaming/XmlMNaming_NamedShapeDriver.lxx
View File

@@ -13,10 +13,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : GetShapesLocations
// purpose :
//=======================================================================
//=================================================================================================
inline TopTools_LocationSet& XmlMNaming_NamedShapeDriver::GetShapesLocations()
{
return myShapeSet.ChangeLocations();

20
src/ApplicationFramework/TKXmlL/XmlObjMgt/XmlObjMgt_Array1.lxx
View File

@@ -13,40 +13,28 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Element
// purpose :
//=======================================================================
//=================================================================================================
inline const XmlObjMgt_Element& XmlObjMgt_Array1::Element() const
{
return myElement;
}
//=======================================================================
// function : Length
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer XmlObjMgt_Array1::Length() const
{
return myLast - myFirst + 1;
}
//=======================================================================
// function : Lower
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer XmlObjMgt_Array1::Lower() const
{
return myFirst;
}
//=======================================================================
// function : Upper
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer XmlObjMgt_Array1::Upper() const
{

28
src/ApplicationFramework/TKXmlL/XmlObjMgt/XmlObjMgt_Persistent.lxx
View File

@@ -13,48 +13,36 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Element
// purpose :
//=======================================================================
//=================================================================================================
inline const XmlObjMgt_Element& XmlObjMgt_Persistent::Element() const
{
return myElement;
}
//=======================================================================
// function : Element
// purpose :
//=======================================================================
//=================================================================================================
inline XmlObjMgt_Element& XmlObjMgt_Persistent::Element()
{
return myElement;
}
//=======================================================================
// function : operator XmlObjMgt_Element
// purpose :
//=======================================================================
//=================================================================================================
inline XmlObjMgt_Persistent::operator const XmlObjMgt_Element&() const
{
return myElement;
}
//=======================================================================
// function : operator XmlObjMgt_Element
// purpose :
//=======================================================================
//=================================================================================================
inline XmlObjMgt_Persistent::operator XmlObjMgt_Element&()
{
return myElement;
}
//=======================================================================
// function : Id
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer XmlObjMgt_Persistent::Id() const
{
return myID;

6
src/DataExchange/TKDEIGES/IGESCAFControl/IGESCAFControl_Reader.cxx
View File

@@ -143,10 +143,8 @@ static void AddCompositeShape(const Handle(XCAFDoc_ShapeTool)& theSTool,
return;
}
//=======================================================================
// function : Transfer
// purpose : basic working method
//=======================================================================
//=================================================================================================
Standard_Boolean IGESCAFControl_Reader::Transfer(const Handle(TDocStd_Document)& doc,
const Message_ProgressRange& theProgress)
{

10
src/DataExchange/TKDEIGES/IGESControl/IGESControl_Reader.lxx
View File

@@ -11,20 +11,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : SetReadVisible
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESControl_Reader::SetReadVisible(const Standard_Boolean ReadRoot)
{
theReadOnlyVisible = ReadRoot;
}
//=======================================================================
// function : GetReadVisible
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean IGESControl_Reader::GetReadVisible() const
{

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

@@ -16,10 +16,9 @@
// 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
//=======================================================================
// function : IGESData_DefSwitch
// purpose : Default constructor.
//=======================================================================
//=================================================================================================
IGESData_DefSwitch::IGESData_DefSwitch()
: theval(0)
{

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

@@ -48,10 +48,8 @@ static const Standard_Integer IGESShiftUse = 8;
static const Standard_Integer IGESShiftHier = 12;
} // namespace
//=======================================================================
// function : IGESData_IGESEntity
// purpose : Default constructor.
//=======================================================================
//=================================================================================================
IGESData_IGESEntity::IGESData_IGESEntity()
: theType(0),
theForm(0),

10
src/DataExchange/TKDEIGES/IGESToBRep/IGESToBRep_AlgoContainer.lxx
View File

@@ -15,20 +15,14 @@
#include <IGESToBRep_AlgoContainer.hxx>
//=======================================================================
// function : SetToolContainer
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_AlgoContainer::SetToolContainer(const Handle(IGESToBRep_ToolContainer)& TC)
{
myTC = TC;
}
//=======================================================================
// function : ToolContainer
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(IGESToBRep_ToolContainer) IGESToBRep_AlgoContainer::ToolContainer() const
{

130
src/DataExchange/TKDEIGES/IGESToBRep/IGESToBRep_CurveAndSurface.lxx
View File

@@ -16,220 +16,154 @@
#include <Transfer_TransientProcess.hxx>
#include <IGESData_IGESEntity.hxx>
//=======================================================================
// function : SetEpsilon
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetEpsilon(const Standard_Real eps)
{
myEps = eps;
}
//=======================================================================
// function : GetEpsilon
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetEpsilon() const
{
return myEps;
}
//=======================================================================
// function : SetEpsCoeff
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetEpsCoeff(const Standard_Real eps)
{
myEpsCoeff = eps;
}
//=======================================================================
// function : GetEpsCoeff
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetEpsCoeff() const
{
return myEpsCoeff;
}
//=======================================================================
// function : GetEpsGeom
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetEpsGeom() const
{
return myEpsGeom;
}
//=======================================================================
// function : SetMinTol
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetMinTol(const Standard_Real mintol)
{
myMinTol = mintol;
}
//=======================================================================
// function : SetMaxTol
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetMaxTol(const Standard_Real maxtol)
{
myMaxTol = maxtol;
}
//=======================================================================
// function : GetMinTol
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetMinTol() const
{
return myMinTol;
}
//=======================================================================
// function : GetMaxTol
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetMaxTol() const
{
return myMaxTol;
}
//=======================================================================
// function : SetModeApprox
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetModeApprox(const Standard_Boolean mode)
{
myModeApprox = mode;
}
//=======================================================================
// function : GetModeApprox
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean IGESToBRep_CurveAndSurface::GetModeApprox() const
{
return myModeApprox;
}
//=======================================================================
// function : SetModeTransfer
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetModeTransfer(const Standard_Boolean mode)
{
myModeIsTopo = mode;
}
//=======================================================================
// function : GetModeTransfer
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean IGESToBRep_CurveAndSurface::GetModeTransfer() const
{
return myModeIsTopo;
}
//=======================================================================
// function : SetOptimized
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetOptimized(const Standard_Boolean optimized)
{
myContIsOpti = optimized;
}
//=======================================================================
// function : GetOptimized
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean IGESToBRep_CurveAndSurface::GetOptimized() const
{
return myContIsOpti;
}
//=======================================================================
// function : GetUnitFactor
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real IGESToBRep_CurveAndSurface::GetUnitFactor() const
{
return myUnitFactor;
}
//=======================================================================
// function : SetSurfaceCurve
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetSurfaceCurve(const Standard_Integer ival)
{
mySurfaceCurve = ival;
}
//=======================================================================
// function : GetSurfaceCurve
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer IGESToBRep_CurveAndSurface::GetSurfaceCurve() const
{
return mySurfaceCurve;
}
//=======================================================================
// function : GetModel
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(IGESData_IGESModel) IGESToBRep_CurveAndSurface::GetModel() const
{
return myModel;
}
//=======================================================================
// function : SetContinuity
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetContinuity(const Standard_Integer continuity)
{
myContinuity = continuity;
}
//=======================================================================
// function : GetContinuity
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer IGESToBRep_CurveAndSurface::GetContinuity() const
{
return myContinuity;
}
//=======================================================================
// function : SetTransferProcess
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SetTransferProcess(
const Handle(Transfer_TransientProcess)& TP)
@@ -237,20 +171,14 @@ inline void IGESToBRep_CurveAndSurface::SetTransferProcess(
myTP = TP;
}
//=======================================================================
// function : GetTransferProcess
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(Transfer_TransientProcess) IGESToBRep_CurveAndSurface::GetTransferProcess() const
{
return myTP;
}
//=======================================================================
// function : SendFail
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SendFail(const Handle(IGESData_IGESEntity)& start,
const Message_Msg& amsg)
@@ -258,10 +186,7 @@ inline void IGESToBRep_CurveAndSurface::SendFail(const Handle(IGESData_IGESEntit
GetTransferProcess()->SendFail(start, amsg);
}
//=======================================================================
// function : SendWarning
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SendWarning(const Handle(IGESData_IGESEntity)& start,
const Message_Msg& amsg)
@@ -269,10 +194,7 @@ inline void IGESToBRep_CurveAndSurface::SendWarning(const Handle(IGESData_IGESEn
GetTransferProcess()->SendWarning(start, amsg);
}
//=======================================================================
// function : SendMsg
// purpose :
//=======================================================================
//=================================================================================================
inline void IGESToBRep_CurveAndSurface::SendMsg(const Handle(IGESData_IGESEntity)& start,
const Message_Msg& amsg)

72
src/DataExchange/TKDESTEP/STEPCAFControl/STEPCAFControl_ExternFile.lxx
View File

@@ -13,100 +13,70 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : SetWS
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPCAFControl_ExternFile::SetWS(const Handle(XSControl_WorkSession)& WS)
{
myWS = WS;
}
//=======================================================================
// function : GetWS
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(XSControl_WorkSession) STEPCAFControl_ExternFile::GetWS() const
{
return myWS;
}
//=======================================================================
// function : SetLoadStatus
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPCAFControl_ExternFile::SetLoadStatus(const IFSelect_ReturnStatus stat)
{
myLoadStatus = stat;
}
//=======================================================================
// function : GetLoadStatus
// purpose :
//=======================================================================
//=================================================================================================
inline IFSelect_ReturnStatus STEPCAFControl_ExternFile::GetLoadStatus() const
{
return myLoadStatus;
}
//=======================================================================
// function : SetTransferStatus
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPCAFControl_ExternFile::SetTransferStatus(const Standard_Boolean isok)
{
myTransferStatus = isok;
}
//=======================================================================
// function : GetTransferStatus
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean STEPCAFControl_ExternFile::GetTransferStatus() const
{
return myTransferStatus;
}
//=======================================================================
// function : SetWriteStatus
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPCAFControl_ExternFile::SetWriteStatus(const IFSelect_ReturnStatus stat)
{
myWriteStatus = stat;
}
//=======================================================================
// function : GetWriteStatus
// purpose :
//=======================================================================
//=================================================================================================
inline IFSelect_ReturnStatus STEPCAFControl_ExternFile::GetWriteStatus() const
{
return myWriteStatus;
}
//=======================================================================
// function : SetName
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPCAFControl_ExternFile::SetName(const Handle(TCollection_HAsciiString)& name)
{
myName = name;
}
//=======================================================================
// function : GetName
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(TCollection_HAsciiString) STEPCAFControl_ExternFile::GetName() const
{
@@ -114,20 +84,16 @@ inline Handle(TCollection_HAsciiString) STEPCAFControl_ExternFile::GetName() con
}
/*
//=======================================================================
//function : SetShape
//purpose :
//=======================================================================
//=================================================================================================
inline void STEPCAFControl_ExternFile::SetShape (const TopoDS_Shape &Shape)
{
myShape = Shape;
}
//=======================================================================
//function : GetShape
//purpose :
//=======================================================================
//=================================================================================================
inline TopoDS_Shape STEPCAFControl_ExternFile::GetShape () const
{
@@ -135,20 +101,14 @@ inline TopoDS_Shape STEPCAFControl_ExternFile::GetShape () const
}
*/
//=======================================================================
// function : SetLabel
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPCAFControl_ExternFile::SetLabel(const TDF_Label& Label)
{
myLabel = Label;
}
//=======================================================================
// function : GetLabel
// purpose :
//=======================================================================
//=================================================================================================
inline TDF_Label STEPCAFControl_ExternFile::GetLabel() const
{

5
src/DataExchange/TKDESTEP/STEPCAFControl/STEPCAFControl_Reader.cxx
View File

@@ -523,10 +523,7 @@ void STEPCAFControl_Reader::prepareUnits(const Handle(StepData_StepModel)& theMo
theModel->SetLocalLengthUnit(aScaleFactorMM);
}
//=======================================================================
// function : Transfer
// purpose : basic working method
//=======================================================================
//=================================================================================================
Standard_Boolean STEPCAFControl_Reader::Transfer(STEPControl_Reader& reader,
const Standard_Integer nroot,

5
src/DataExchange/TKDESTEP/STEPConstruct/STEPConstruct_ExternRefs.cxx
View File

@@ -840,10 +840,7 @@ Standard_Integer STEPConstruct_ExternRefs::WriteExternRefs(const Standard_Intege
return myAEIAs.Length();
}
//=======================================================================
// function : addAP214ExterRef
// purpose : PTV 30.01.2003 TRJ11
//=======================================================================
//=================================================================================================
Standard_Boolean STEPConstruct_ExternRefs::addAP214ExterRef(
const Handle(StepAP214_AppliedDocumentReference)& ADR,

25
src/DataExchange/TKDESTEP/STEPConstruct/STEPConstruct_Tool.lxx
View File

@@ -20,30 +20,21 @@
#include <Transfer_FinderProcess.hxx>
#include <XSControl_WorkSession.hxx>
//=======================================================================
// function : WS
// purpose :
//=======================================================================
//=================================================================================================
inline const Handle(XSControl_WorkSession)& STEPConstruct_Tool::WS() const
{
return myWS;
}
//=======================================================================
// function : Model
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(Interface_InterfaceModel) STEPConstruct_Tool::Model() const
{
return myWS->Model();
}
//=======================================================================
// function : Graph
// purpose :
//=======================================================================
//=================================================================================================
inline const Interface_Graph& STEPConstruct_Tool::Graph(const Standard_Boolean recompute) const
{
@@ -51,20 +42,14 @@ inline const Interface_Graph& STEPConstruct_Tool::Graph(const Standard_Boolean r
return recompute ? myWS->Graph() : myHGraph->Graph();
}
//=======================================================================
// function : TransientProcess
// purpose :
//=======================================================================
//=================================================================================================
inline const Handle(Transfer_TransientProcess)& STEPConstruct_Tool::TransientProcess() const
{
return myTransientProcess;
}
//=======================================================================
// function : FinderProcess
// purpose :
//=======================================================================
//=================================================================================================
inline const Handle(Transfer_FinderProcess)& STEPConstruct_Tool::FinderProcess() const
{

15
src/DataExchange/TKDESTEP/STEPSelections/STEPSelections_AssemblyComponent.lxx
View File

@@ -14,10 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : GetSDR
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(StepShape_ShapeDefinitionRepresentation) STEPSelections_AssemblyComponent::GetSDR()
const
@@ -25,10 +22,7 @@ inline Handle(StepShape_ShapeDefinitionRepresentation) STEPSelections_AssemblyCo
return mySDR;
}
//=======================================================================
// function : GetList
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(STEPSelections_HSequenceOfAssemblyLink) STEPSelections_AssemblyComponent::GetList()
const
@@ -36,10 +30,7 @@ inline Handle(STEPSelections_HSequenceOfAssemblyLink) STEPSelections_AssemblyCom
return myList;
}
//=======================================================================
// function : SetSDR
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPSelections_AssemblyComponent::SetSDR(
const Handle(StepShape_ShapeDefinitionRepresentation)& sdr)

10
src/DataExchange/TKDESTEP/STEPSelections/STEPSelections_AssemblyExplorer.lxx
View File

@@ -14,20 +14,14 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : NbAssemblies
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer STEPSelections_AssemblyExplorer::NbAssemblies() const
{
return myRoots.Length();
}
//=======================================================================
// function : Root
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(STEPSelections_AssemblyComponent) STEPSelections_AssemblyExplorer::Root(
const Standard_Integer rank) const

30
src/DataExchange/TKDESTEP/STEPSelections/STEPSelections_AssemblyLink.lxx
View File

@@ -14,40 +14,28 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : GetNAUO
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(StepRepr_NextAssemblyUsageOccurrence) STEPSelections_AssemblyLink::GetNAUO() const
{
return myNAUO;
}
//=======================================================================
// function : GetSDSR
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(Standard_Transient) STEPSelections_AssemblyLink::GetItem() const
{
return myItem;
}
//=======================================================================
// function : GetComponent
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(STEPSelections_AssemblyComponent) STEPSelections_AssemblyLink::GetComponent() const
{
return myComponent;
}
//=======================================================================
// function : SetNAUO
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPSelections_AssemblyLink::SetNAUO(
const Handle(StepRepr_NextAssemblyUsageOccurrence)& nauo)
@@ -55,20 +43,14 @@ inline void STEPSelections_AssemblyLink::SetNAUO(
myNAUO = nauo;
}
//=======================================================================
// function : SetCDSR
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPSelections_AssemblyLink::SetItem(const Handle(Standard_Transient)& item)
{
myItem = item;
}
//=======================================================================
// function : SetComponent
// purpose :
//=======================================================================
//=================================================================================================
inline void STEPSelections_AssemblyLink::SetComponent(
const Handle(STEPSelections_AssemblyComponent)& part)

5
src/DataExchange/TKDESTEP/StepToTopoDS/StepToTopoDS_NMTool.cxx
View File

@@ -18,10 +18,7 @@
#include <TopExp_Explorer.hxx>
#include <TopoDS_Shape.hxx>
// ============================================================================
// Method : StepToTopoDS_NMTool
// Purpose : Default constructor
// ============================================================================
//=================================================================================================
StepToTopoDS_NMTool::StepToTopoDS_NMTool()
{

25
src/DataExchange/TKDESTEP/StepToTopoDS/StepToTopoDS_Root.lxx
View File

@@ -16,50 +16,35 @@
#include <StepToTopoDS_Root.hxx>
//=======================================================================
// function : IsDone
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean StepToTopoDS_Root::IsDone() const
{
return done;
}
//=======================================================================
// function : Precision
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real StepToTopoDS_Root::Precision() const
{
return myPrecision;
}
//=======================================================================
// function : SetPrecision
// purpose :
//=======================================================================
//=================================================================================================
inline void StepToTopoDS_Root::SetPrecision(const Standard_Real preci)
{
myPrecision = preci;
}
//=======================================================================
// function : MaxTol
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real StepToTopoDS_Root::MaxTol() const
{
return myMaxTol;
}
//=======================================================================
// function : SetMaxTol
// purpose :
//=======================================================================
//=================================================================================================
inline void StepToTopoDS_Root::SetMaxTol(const Standard_Real maxpreci)
{

5
src/DataExchange/TKDESTEP/StepToTopoDS/StepToTopoDS_TranslateCompositeCurve.lxx
View File

@@ -15,10 +15,7 @@
#include <StepToTopoDS_TranslateCompositeCurve.hxx>
//=======================================================================
// function : IsInfiniteSegment
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean StepToTopoDS_TranslateCompositeCurve::IsInfiniteSegment() const
{

6
src/DataExchange/TKXCAF/XCAFPrs/XCAFPrs_DocumentIdIterator.hxx
View File

@@ -48,10 +48,8 @@ private:
Standard_Integer myPosition; //!< last processed new-line symbol
};
// =======================================================================
// function : Next
// purpose :
// =======================================================================
//=================================================================================================
inline void XCAFPrs_DocumentIdIterator::Next()
{
for (Standard_Integer aCharIndex = myPosition + 1; aCharIndex <= myPath.Length(); ++aCharIndex)

60
src/DataExchange/TKXSBase/MoniTool/MoniTool_Timer.lxx
View File

@@ -11,10 +11,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : MoniTool_Timer
// purpose :
//=======================================================================
//=================================================================================================
inline MoniTool_Timer::MoniTool_Timer()
: myCount(0),
@@ -23,30 +20,21 @@ inline MoniTool_Timer::MoniTool_Timer()
{
}
//=======================================================================
// function : Timer
// purpose :
//=======================================================================
//=================================================================================================
inline OSD_Timer& MoniTool_Timer::Timer()
{
return myTimer;
}
//=======================================================================
// function : Timer
// purpose :
//=======================================================================
//=================================================================================================
inline const OSD_Timer& MoniTool_Timer::Timer() const
{
return myTimer;
}
//=======================================================================
// function : Start
// purpose :
//=======================================================================
//=================================================================================================
inline void MoniTool_Timer::Start()
{
@@ -57,10 +45,7 @@ inline void MoniTool_Timer::Start()
myNesting++;
}
//=======================================================================
// function : Stop
// purpose :
//=======================================================================
//=================================================================================================
inline void MoniTool_Timer::Stop()
{
@@ -70,10 +55,7 @@ inline void MoniTool_Timer::Stop()
// AmendStop();
}
//=======================================================================
// function : Reset
// purpose :
//=======================================================================
//=================================================================================================
inline void MoniTool_Timer::Reset()
{
@@ -82,40 +64,28 @@ inline void MoniTool_Timer::Reset()
myAmend = 0;
}
//=======================================================================
// function : Count
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer MoniTool_Timer::Count() const
{
return myCount;
}
//=======================================================================
// function : IsRunning
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer MoniTool_Timer::IsRunning() const
{
return myNesting;
}
//=======================================================================
// function : Amend
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real MoniTool_Timer::Amend() const
{
return myAmend;
}
//=======================================================================
// function : CPU
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Real MoniTool_Timer::CPU()
{
@@ -125,20 +95,14 @@ inline Standard_Real MoniTool_Timer::CPU()
return cpu - myAmend;
}
//=======================================================================
// function : Start
// purpose :
//=======================================================================
//=================================================================================================
inline void MoniTool_Timer::Start(const Standard_CString name)
{
Timer(name)->Start();
}
//=======================================================================
// function : Stop
// purpose :
//=======================================================================
//=================================================================================================
inline void MoniTool_Timer::Stop(const Standard_CString name)
{

20
src/DataExchange/TKXSBase/MoniTool/MoniTool_TimerSentry.lxx
View File

@@ -13,10 +13,7 @@
#include <MoniTool_Timer.hxx>
//=======================================================================
// function : MoniTool_TimerSentry
// purpose :
//=======================================================================
//=================================================================================================
inline MoniTool_TimerSentry::MoniTool_TimerSentry(const Standard_CString cname)
: myTimer(MoniTool_Timer::Timer(cname))
@@ -24,10 +21,7 @@ inline MoniTool_TimerSentry::MoniTool_TimerSentry(const Standard_CString cname)
myTimer->Start();
}
//=======================================================================
// function : MoniTool_TimerSentry
// purpose :
//=======================================================================
//=================================================================================================
inline MoniTool_TimerSentry::MoniTool_TimerSentry(const Handle(MoniTool_Timer)& timer)
{
@@ -46,20 +40,14 @@ inline MoniTool_TimerSentry::~MoniTool_TimerSentry()
myTimer->Stop();
}
//=======================================================================
// function : Timer
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(MoniTool_Timer) MoniTool_TimerSentry::Timer() const
{
return myTimer;
}
//=======================================================================
// function : Stop
// purpose :
//=======================================================================
//=================================================================================================
inline void MoniTool_TimerSentry::Stop()
{

40
src/DataExchange/TKXSBase/TransferBRep/TransferBRep_TransferResultInfo.lxx
View File

@@ -14,80 +14,56 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Result
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::Result()
{
return myR;
}
//=======================================================================
// function : ResultWarning
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::ResultWarning()
{
return myRW;
}
//=======================================================================
// function : ResultFail
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::ResultFail()
{
return myRF;
}
//=======================================================================
// function : ResultWarningFail
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::ResultWarningFail()
{
return myRWF;
}
//=======================================================================
// function : NoResult
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResult()
{
return myNR;
}
//=======================================================================
// function : NoResultWarning
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResultWarning()
{
return myNRW;
}
//=======================================================================
// function : NoResultFail
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResultFail()
{
return myNRF;
}
//=======================================================================
// function : NoResultWarningFail
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer& TransferBRep_TransferResultInfo::NoResultWarningFail()
{

6
src/DataExchange/TKXmlXCAF/XmlMXCAFDoc/XmlMXCAFDoc_LocationDriver.lxx
View File

@@ -13,10 +13,8 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : SetSharedLocations
// purpose :
//=======================================================================
//=================================================================================================
inline void XmlMXCAFDoc_LocationDriver::SetSharedLocations(
const TopTools_LocationSetPtr& theLocations)
{

5
src/Draw/TKDCAF/DDF/DDF.cxx
View File

@@ -70,10 +70,7 @@ Standard_Boolean DDF::GetDF(Standard_CString& Name,
return Standard_False;
}
//=======================================================================
// function : Find
// purpose : Finds an attribute.
//=======================================================================
//=================================================================================================
Standard_Boolean DDF::Find(const Handle(TDF_Data)& DF,
const Standard_CString Entry,

10
src/Draw/TKDCAF/DDF/DDF_TransactionCommands.cxx
View File

@@ -35,10 +35,7 @@ static Handle(TDF_Delta) DDF_LastDelta;
// Transaction commands
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//=======================================================================
// function : OpenTran
// purpose : Opens a transaction
//=======================================================================
//=================================================================================================
static Standard_Integer OpenTran(Draw_Interpretor& di, Standard_Integer n, const char** a)
{
@@ -55,10 +52,7 @@ static Standard_Integer OpenTran(Draw_Interpretor& di, Standard_Integer n, const
return 0;
}
//=======================================================================
// function : AbortTran
// purpose : Aborts a transaction
//=======================================================================
//=================================================================================================
static Standard_Integer AbortTran(Draw_Interpretor& di, Standard_Integer n, const char** a)
{

5
src/Draw/TKDCAF/DDataStd/DDataStd_DrawPresentation.cxx
View File

@@ -208,10 +208,7 @@ void DDataStd_DrawPresentation::BeforeForget()
DrawErase(Label(), this);
}
//=======================================================================
// function : AfterResume
// purpose : display if displayed
//=======================================================================
//=================================================================================================
void DDataStd_DrawPresentation::AfterResume()
{

20
src/Draw/TKDCAF/DDataStd/DDataStd_TreeCommands.cxx
View File

@@ -502,10 +502,7 @@ static Standard_Integer DDataStd_InitChildNodeIterator(Draw_Interpretor& di,
return 1;
}
//=======================================================================
// TreeNode : ChildNodeMore
// purpose : ChildNodeMore
//=======================================================================
//=================================================================================================
static Standard_Integer DDataStd_ChildNodeMore(Draw_Interpretor& di,
Standard_Integer /*n*/,
@@ -522,10 +519,7 @@ static Standard_Integer DDataStd_ChildNodeMore(Draw_Interpretor& di,
return 0;
}
//=======================================================================
// TreeNode : ChildNodeNext
// purpose : ChildNodeNext
//=======================================================================
//=================================================================================================
static Standard_Integer DDataStd_ChildNodeNext(Draw_Interpretor& /*di*/,
Standard_Integer /*n*/,
@@ -548,10 +542,7 @@ static Standard_Integer DDataStd_ChildNodeNextBrother(Draw_Interpretor& /*di*/,
return 0;
}
//=======================================================================
// TreeNode : ChildNodeValue
// purpose : ChildNodeValue
//=======================================================================
//=================================================================================================
static Standard_Integer DDataStd_ChildNodeValue(Draw_Interpretor& di,
Standard_Integer /*n*/,
@@ -563,10 +554,7 @@ static Standard_Integer DDataStd_ChildNodeValue(Draw_Interpretor& di,
return 0;
}
//=======================================================================
// TreeNode : TreeCommands
// purpose :
//=======================================================================
//=================================================================================================
void DDataStd::TreeCommands(Draw_Interpretor& theCommands)
{

6
src/Draw/TKDCAF/DNaming/DNaming_Line3DDriver.cxx
View File

@@ -62,10 +62,8 @@ Standard_Boolean DNaming_Line3DDriver::MustExecute(const Handle(TFunction_Logboo
return Standard_True;
}
//=======================================================================
// function : Execute
// purpose : Execute the function
//=======================================================================
//=================================================================================================
Standard_Integer DNaming_Line3DDriver::Execute(Handle(TFunction_Logbook)& theLog) const
{
Handle(TFunction_Function) aFunction;

20
src/Draw/TKDraw/DBRep/DBRep_Edge.lxx
View File

@@ -14,40 +14,28 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Edge
// purpose :
//=======================================================================
//=================================================================================================
inline const TopoDS_Edge& DBRep_Edge::Edge() const
{
return myEdge;
}
//=======================================================================
// function : Edge
// purpose :
//=======================================================================
//=================================================================================================
inline void DBRep_Edge::Edge(const TopoDS_Edge& E)
{
myEdge = E;
}
//=======================================================================
// function : Color
// purpose :
//=======================================================================
//=================================================================================================
inline const Draw_Color& DBRep_Edge::Color() const
{
return myColor;
}
//=======================================================================
// function : Color
// purpose :
//=======================================================================
//=================================================================================================
inline void DBRep_Edge::Color(const Draw_Color& C)
{

35
src/Draw/TKDraw/DBRep/DBRep_Face.lxx
View File

@@ -14,40 +14,28 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Face
// purpose :
//=======================================================================
//=================================================================================================
inline const TopoDS_Face& DBRep_Face::Face() const
{
return myFace;
}
//=======================================================================
// function : Face
// purpose :
//=======================================================================
//=================================================================================================
inline void DBRep_Face::Face(const TopoDS_Face& F)
{
myFace = F;
}
//=======================================================================
// function : NbIsos
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer DBRep_Face::NbIsos() const
{
return myTypes.Upper();
}
//=======================================================================
// function : Iso
// purpose :
//=======================================================================
//=================================================================================================
inline void DBRep_Face::Iso(const Standard_Integer I,
const GeomAbs_IsoType T,
@@ -61,10 +49,7 @@ inline void DBRep_Face::Iso(const Standard_Integer I,
myParams(3 * I) = T2;
}
//=======================================================================
// function : GetIso
// purpose :
//=======================================================================
//=================================================================================================
inline void DBRep_Face::GetIso(const Standard_Integer I,
GeomAbs_IsoType& T,
@@ -81,20 +66,14 @@ inline void DBRep_Face::GetIso(const Standard_Integer I,
T2 = myParams(3 * I);
}
//=======================================================================
// function : Color
// purpose :
//=======================================================================
//=================================================================================================
inline const Draw_Color& DBRep_Face::Color() const
{
return myColor;
}
//=======================================================================
// function : Color
// purpose :
//=======================================================================
//=================================================================================================
inline void DBRep_Face::Color(const Draw_Color& C)
{

5
src/Draw/TKDraw/Draw/Draw_GraphicCommands.cxx
View File

@@ -873,10 +873,7 @@ static Standard_Integer hcolor(Draw_Interpretor& di, Standard_Integer n, const c
return 0;
}
//=======================================================================
// function : xwd
// purpose : xwd file from a view
//=======================================================================
//=================================================================================================
extern void Draw_RepaintNowIfNecessary();

138
src/Draw/TKDraw/Draw/Draw_Window_1.mm
View File

@@ -117,10 +117,8 @@ Standard_Real Draw_RGBColorsArray[MAXCOLOR][3] = {{1.0, 1.0, 1.0},
{0.94, 0.9, 0.55},
{1.0, 0.5, 0.31}};
//=======================================================================
//function : Draw_Window
//purpose :
//=======================================================================
//=================================================================================================
Draw_Window::Draw_Window (const char* theTitle,
const NCollection_Vec2<int>& theXY,
const NCollection_Vec2<int>& theSize,
@@ -166,10 +164,8 @@ Draw_Window::~Draw_Window()
}
}
//=======================================================================
//function : init
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::init (const NCollection_Vec2<int>& theXY,
const NCollection_Vec2<int>& theSize)
{
@@ -213,19 +209,15 @@ void Draw_Window::init (const NCollection_Vec2<int>& theXY,
[myWindow setReleasedWhenClosed: NO];
}
//=======================================================================
//function : InitBuffer
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::InitBuffer()
{
//
}
//=======================================================================
//function : SetPosition
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::SetPosition (Standard_Integer theNewXpos,
Standard_Integer theNewYpos)
{
@@ -233,10 +225,8 @@ void Draw_Window::SetPosition (Standard_Integer theNewXpos,
[myWindow setFrameTopLeftPoint: aNewPosition];
}
//=======================================================================
//function : SetDimension
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::SetDimension (Standard_Integer theNewWidth,
Standard_Integer theNewHeight)
{
@@ -247,10 +237,8 @@ void Draw_Window::SetDimension (Standard_Integer theNewWidth,
[myWindow setFrame: aNewContentRect display: YES];
}
//=======================================================================
//function : GetPosition
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::GetPosition (Standard_Integer &thePosX,
Standard_Integer &thePosY)
{
@@ -259,30 +247,24 @@ void Draw_Window::GetPosition (Standard_Integer &thePosX,
thePosY = getScreenBottom() - aWindowRect.origin.y - aWindowRect.size.height;
}
//=======================================================================
//function : HeightWin
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer Draw_Window::HeightWin() const
{
NSRect aViewBounds = [myView bounds];
return aViewBounds.size.height;
}
//=======================================================================
//function : WidthWin
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer Draw_Window::WidthWin() const
{
NSRect aViewBounds = [myView bounds];
return aViewBounds.size.width;
}
//=======================================================================
//function : SetTitle
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::SetTitle (const TCollection_AsciiString& theTitle)
{
NSString* aTitleNs = [[NSString alloc] initWithUTF8String: theTitle.ToCString()];
@@ -290,29 +272,23 @@ void Draw_Window::SetTitle (const TCollection_AsciiString& theTitle)
[aTitleNs release];
}
//=======================================================================
//function : GetTitle
//purpose :
//=======================================================================
//=================================================================================================
TCollection_AsciiString Draw_Window::GetTitle() const
{
Standard_CString aTitle = [[myWindow title] UTF8String];
return TCollection_AsciiString (aTitle);
}
//=======================================================================
//function :DefineColor
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean Draw_Window::DefineColor (const Standard_Integer , Standard_CString )
{
return Standard_True; // unused
}
//=======================================================================
//function : IsMapped
//purpose :
//=======================================================================
//=================================================================================================
bool Draw_Window::IsMapped() const
{
if (Draw_VirtualWindows
@@ -324,10 +300,8 @@ bool Draw_Window::IsMapped() const
return [myWindow isVisible];
}
//=======================================================================
//function : DisplayWindow
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::DisplayWindow()
{
if (Draw_VirtualWindows)
@@ -341,10 +315,8 @@ void Draw_Window::DisplayWindow()
}
}
//=======================================================================
//function : Hide
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::Hide()
{
if (myWindow != NULL)
@@ -353,10 +325,8 @@ void Draw_Window::Hide()
}
}
//=======================================================================
//function : Destroy
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::Destroy()
{
if (myWindow != NULL)
@@ -378,10 +348,8 @@ void Draw_Window::Destroy()
}
}
//=======================================================================
//function : Clear
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::Clear()
{
[myImageBuffer lockFocus];
@@ -396,19 +364,15 @@ void Draw_Window::Clear()
}
}
//=======================================================================
//function : Flush
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::Flush()
{
//
}
//=======================================================================
//function : DrawString
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::DrawString (Standard_Integer theXLeft, Standard_Integer theYTop,
const char* theText)
{
@@ -431,10 +395,8 @@ void Draw_Window::DrawString (Standard_Integer theXLeft, Standard_Integer theYTo
}
}
//=======================================================================
//function : DrawSegments
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::DrawSegments (const Draw_XSegment* theSegments,
Standard_Integer theNumberOfElements)
{
@@ -484,10 +446,8 @@ void Draw_Window::DrawSegments (const Draw_XSegment* theSegments,
Draw_IsInZoomingMode = Standard_False;
}
//=======================================================================
//function : Redraw
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::Redraw()
{
if (myUseBuffer)
@@ -496,29 +456,23 @@ void Draw_Window::Redraw()
}
}
//=======================================================================
//function : SetColor
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::SetColor (Standard_Integer theColor)
{
myCurrentColor = theColor;
}
//=======================================================================
//function : SetMode
//purpose :
//=======================================================================
//=================================================================================================
void Draw_Window::SetMode (Standard_Integer theMode)
{
// unsupported
(void )theMode;
}
//=======================================================================
//function : Save
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean Draw_Window::Save (Standard_CString theFileName) const
{
Cocoa_LocalPool aLocalPool;

18
src/Draw/TKIVtkDraw/IVtkDraw/IVtkDraw.cxx
View File

@@ -1271,10 +1271,8 @@ static Standard_Integer VtkSelect(Draw_Interpretor&,
return 0;
}
//===================================================================
// Fubction : VtkViewProj
// Purpose :
//===================================================================
//=================================================================================================
static Standard_Integer VtkViewProj(Draw_Interpretor&,
Standard_Integer theNbArgs,
const char** theArgVec)
@@ -1507,10 +1505,8 @@ static int VtkCamera(Draw_Interpretor& theDI, Standard_Integer theArgsNb, const
return 0;
}
//===================================================================
// Fubction : VtkDump
// Purpose :
//===================================================================
//=================================================================================================
static Standard_Integer VtkDump(Draw_Interpretor&, Standard_Integer theArgNum, const char** theArgs)
{
if (!GetInteractor() || !GetInteractor()->IsEnabled())
@@ -1654,10 +1650,8 @@ static Standard_Integer VtkDump(Draw_Interpretor&, Standard_Integer theArgNum, c
return 0;
}
//===================================================================
// Fubction : VtkBackgroundColor
// Purpose :
//===================================================================
//=================================================================================================
static Standard_Integer VtkBackgroundColor(Draw_Interpretor&,
Standard_Integer theArgNum,
const char** theArgs)

5
src/Draw/TKQADraw/QADNaming/QADNaming_SelectionCommands.cxx
View File

@@ -272,10 +272,7 @@ static void CollectAttachment(const TDF_Label& root,
}
}
//=======================================================================
// function : Attachment
// purpose : Attachment DF entry
//=======================================================================
//=================================================================================================
static Standard_Integer QADNaming_Attachment(Draw_Interpretor& di,
Standard_Integer n,

6
src/Draw/TKTopTest/BOPTest/BOPTest_CheckCommands.cxx
View File

@@ -93,10 +93,8 @@ void BOPTest::CheckCommands(Draw_Interpretor& theCommands)
g);
}
//=======================================================================
// class : BOPTest_Interf
// purpose : Auxiliary class
//=======================================================================
//=================================================================================================
class BOPTest_Interf
{
public:

50
src/Draw/TKTopTest/HLRTest/HLRTest_DrawablePolyEdgeTool.lxx
View File

@@ -14,100 +14,70 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : Show
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::Show()
{
myHideMode = Standard_False;
}
//=======================================================================
// function : Hide
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::Hide()
{
myHideMode = Standard_True;
}
//=======================================================================
// function : DisplayRg1Line
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::DisplayRg1Line(const Standard_Boolean B)
{
myDispRg1 = B;
}
//=======================================================================
// function : DisplayRg1Line
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::DisplayRg1Line() const
{
return myDispRg1;
}
//=======================================================================
// function : DisplayRgNLine
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::DisplayRgNLine(const Standard_Boolean B)
{
myDispRgN = B;
}
//=======================================================================
// function : DisplayRgNLine
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::DisplayRgNLine() const
{
return myDispRgN;
}
//=======================================================================
// function : DisplayHidden
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::DisplayHidden(const Standard_Boolean B)
{
myDispHid = B;
}
//=======================================================================
// function : DisplayHidden
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::DisplayHidden() const
{
return myDispHid;
}
//=======================================================================
// function : Debug
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_DrawablePolyEdgeTool::Debug(const Standard_Boolean B)
{
myDebug = B;
}
//=======================================================================
// function : Debug
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean HLRTest_DrawablePolyEdgeTool::Debug() const
{

5
src/Draw/TKTopTest/HLRTest/HLRTest_OutLiner.lxx
View File

@@ -14,10 +14,7 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : OutLiner
// purpose :
//=======================================================================
//=================================================================================================
inline Handle(HLRTopoBRep_OutLiner) HLRTest_OutLiner::OutLiner() const
{

60
src/Draw/TKTopTest/HLRTest/HLRTest_ShapeData.lxx
View File

@@ -14,120 +14,84 @@
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
//=======================================================================
// function : VisibleColor
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_ShapeData::VisibleColor(const Draw_Color& CVis)
{
myVColor = CVis;
}
//=======================================================================
// function : VisibleOutLineColor
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_ShapeData::VisibleOutLineColor(const Draw_Color& COVis)
{
myVOColor = COVis;
}
//=======================================================================
// function : VisibleIsoColor
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_ShapeData::VisibleIsoColor(const Draw_Color& CIVis)
{
myVIColor = CIVis;
}
//=======================================================================
// function : HiddenColor
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_ShapeData::HiddenColor(const Draw_Color& CHid)
{
myHColor = CHid;
}
//=======================================================================
// function : HiddenOutLineColor
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_ShapeData::HiddenOutLineColor(const Draw_Color& COHid)
{
myHOColor = COHid;
}
//=======================================================================
// function : HiddenIsoColor
// purpose :
//=======================================================================
//=================================================================================================
inline void HLRTest_ShapeData::HiddenIsoColor(const Draw_Color& CIHid)
{
myHIColor = CIHid;
}
//=======================================================================
// function : VisibleColor
// purpose :
//=======================================================================
//=================================================================================================
inline Draw_Color HLRTest_ShapeData::VisibleColor() const
{
return myVColor;
}
//=======================================================================
// function : VisibleOutLineColor
// purpose :
//=======================================================================
//=================================================================================================
inline Draw_Color HLRTest_ShapeData::VisibleOutLineColor() const
{
return myVOColor;
}
//=======================================================================
// function : VisibleIsoColor
// purpose :
//=======================================================================
//=================================================================================================
inline Draw_Color HLRTest_ShapeData::VisibleIsoColor() const
{
return myVIColor;
}
//=======================================================================
// function : HiddenColor
// purpose :
//=======================================================================
//=================================================================================================
inline Draw_Color HLRTest_ShapeData::HiddenColor() const
{
return myHColor;
}
//=======================================================================
// function : HiddenOutLineColor
// purpose :
//=======================================================================
//=================================================================================================
inline Draw_Color HLRTest_ShapeData::HiddenOutLineColor() const
{
return myHOColor;
}
//=======================================================================
// function : HiddenIsoColor
// purpose :
//=======================================================================
//=================================================================================================
inline Draw_Color HLRTest_ShapeData::HiddenIsoColor() const
{

102
src/Draw/TKViewerTest/ViewerTest/ViewerTest_ViewerCommands_1.mm
View File

@@ -46,10 +46,8 @@ extern void ActivateView (const TCollection_AsciiString& theViewName,
extern NCollection_DoubleMap <TCollection_AsciiString, Handle(V3d_View)> ViewerTest_myViews;
// =======================================================================
// function : GetCocoaScreenResolution
// purpose :
// =======================================================================
//=================================================================================================
void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& theHeight)
{
NSRect aRect = [[NSScreen mainScreen] visibleFrame];
@@ -57,10 +55,8 @@ void GetCocoaScreenResolution (Standard_Integer& theWidth, Standard_Integer& the
theHeight = (Standard_Integer )aRect.size.height;
}
// =======================================================================
// function : FindViewId
// purpose :
// =======================================================================
//=================================================================================================
TCollection_AsciiString FindViewId (const NSWindow* theWindow)
{
TCollection_AsciiString aViewId = "";
@@ -100,20 +96,16 @@ TCollection_AsciiString FindViewId (const NSWindow* theWindow)
@end
// =======================================================================
// function : ViewerMainLoop
// purpose :
// =======================================================================
//=================================================================================================
int ViewerMainLoop (Standard_Integer, const char** )
{
// unused
return 0;
}
// =======================================================================
// function : ViewerTest_SetCocoaEventManagerView
// purpose :
// =======================================================================
//=================================================================================================
void ViewerTest_SetCocoaEventManagerView (const Handle(Cocoa_Window)& theWindow)
{
if (theWindow.IsNull())
@@ -180,20 +172,16 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
@implementation ViewerTest_CocoaEventManagerView
// =======================================================================
// function : setFrameSize
// purpose :
// =======================================================================
//=================================================================================================
- (void )setFrameSize: (NSSize )theNewSize
{
[super setFrameSize: theNewSize];
ViewerTest::CurrentEventManager()->ProcessConfigure();
}
// =======================================================================
// function : drawRect
// purpose :
// =======================================================================
//=================================================================================================
- (void )drawRect: (NSRect )theDirtyRect
{
(void )theDirtyRect;
@@ -203,10 +191,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
}
}
// =======================================================================
// function : mouseMoved
// purpose :
// =======================================================================
//=================================================================================================
- (void )mouseMoved: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -216,19 +202,15 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : acceptsFirstResponder
// purpose :
// =======================================================================
//=================================================================================================
- (BOOL )acceptsFirstResponder
{
return YES;
}
// =======================================================================
// function : mouseDown
// purpose :
// =======================================================================
//=================================================================================================
- (void )mouseDown: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -237,10 +219,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : mouseUp
// purpose :
// =======================================================================
//=================================================================================================
- (void )mouseUp: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -249,10 +229,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : mouseDragged
// purpose :
// =======================================================================
//=================================================================================================
- (void )mouseDragged: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -262,10 +240,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : rightMouseDown
// purpose :
// =======================================================================
//=================================================================================================
- (void )rightMouseDown: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -274,10 +250,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : rightMouseUp
// purpose :
// =======================================================================
//=================================================================================================
- (void )rightMouseUp: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -286,10 +260,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : rightMouseDragged
// purpose :
// =======================================================================
//=================================================================================================
- (void )rightMouseDragged: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -299,10 +271,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : scrollWheel
// purpose :
// =======================================================================
//=================================================================================================
- (void )scrollWheel: (NSEvent* )theEvent
{
const Graphic3d_Vec2i aPos = getMouseCoords (self, theEvent);
@@ -319,10 +289,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
ViewerTest::CurrentEventManager()->FlushViewEvents (ViewerTest::GetAISContext(), ViewerTest::CurrentView(), true);
}
// =======================================================================
// function : keyDown
// purpose :
// =======================================================================
//=================================================================================================
- (void )keyDown: (NSEvent* )theEvent
{
unsigned int aKeyCode = [theEvent keyCode];
@@ -341,10 +309,8 @@ static Aspect_VKeyFlags getMouseKeyFlags (NSEvent* theEvent)
//}
}
// =======================================================================
// function : keyUp
// purpose :
// =======================================================================
//=================================================================================================
- (void )keyUp: (NSEvent* )theEvent
{
unsigned int aKeyCode = [theEvent keyCode];

12
src/Draw/TKXDEDRAW/XDEDRAW/XDEDRAW_Notes.cxx
View File

@@ -1093,10 +1093,8 @@ static Standard_Integer noteGetNotes(Draw_Interpretor& di, Standard_Integer argc
return 0;
}
//=======================================================================
// function : noteUsername
// purpose : gets a note username
//=======================================================================
//=================================================================================================
static const cmd XNoteUsername = {"XNoteUsername", 3, "XNoteUsername Doc note"};
static Standard_Integer noteUsername(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
@@ -1189,10 +1187,8 @@ static Standard_Integer noteTimestamp(Draw_Interpretor& di,
return 0;
}
//=======================================================================
// function : noteDump
// purpose : dump a note contents
//=======================================================================
//=================================================================================================
static const cmd XNoteDump = {"XNoteDump", 3, "XNoteDump Doc note"};
static Standard_Integer noteDump(Draw_Interpretor& di, Standard_Integer argc, const char** argv)

65
src/FoundationClasses/TKMath/BSplCLib/BSplCLib.lxx
View File

@@ -18,40 +18,28 @@
#include <TColgp_Array1OfPnt.hxx>
#include <TColgp_Array1OfPnt2d.hxx>
//=======================================================================
// function : MaxDegree
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer BSplCLib::MaxDegree()
{
return 25;
}
//=======================================================================
// function : NoWeights
// purpose :
//=======================================================================
//=================================================================================================
inline TColStd_Array1OfReal* BSplCLib::NoWeights()
{
return NULL;
}
//=======================================================================
// function : NoMults
// purpose :
//=======================================================================
//=================================================================================================
inline TColStd_Array1OfInteger* BSplCLib::NoMults()
{
return NULL;
}
//=======================================================================
// function : CoefsD0
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD0(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
@@ -61,10 +49,7 @@ inline void BSplCLib::CoefsD0(const Standard_Real U,
BSplCLib::CacheD0(U, Poles.Length() - 1, 0., 1., Poles, Weights, P);
}
//=======================================================================
// function : CoefsD0
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD0(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
@@ -74,10 +59,7 @@ inline void BSplCLib::CoefsD0(const Standard_Real U,
BSplCLib::CacheD0(U, Poles.Length() - 1, 0., 1., Poles, Weights, P);
}
//=======================================================================
// function : CoefsD1
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD1(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
@@ -88,10 +70,7 @@ inline void BSplCLib::CoefsD1(const Standard_Real U,
BSplCLib::CacheD1(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec);
}
//=======================================================================
// function : CoefsD1
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD1(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
@@ -102,10 +81,7 @@ inline void BSplCLib::CoefsD1(const Standard_Real U,
BSplCLib::CacheD1(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec);
}
//=======================================================================
// function : CoefsD2
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD2(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
@@ -117,10 +93,7 @@ inline void BSplCLib::CoefsD2(const Standard_Real U,
BSplCLib::CacheD2(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2);
}
//=======================================================================
// function : CoefsD2
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD2(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
@@ -132,10 +105,7 @@ inline void BSplCLib::CoefsD2(const Standard_Real U,
BSplCLib::CacheD2(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2);
}
//=======================================================================
// function : CoefsD3
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD3(const Standard_Real U,
const TColgp_Array1OfPnt& Poles,
@@ -148,10 +118,7 @@ inline void BSplCLib::CoefsD3(const Standard_Real U,
BSplCLib::CacheD3(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2, Vec3);
}
//=======================================================================
// function : CoefsD3
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::CoefsD3(const Standard_Real U,
const TColgp_Array1OfPnt2d& Poles,
@@ -164,10 +131,7 @@ inline void BSplCLib::CoefsD3(const Standard_Real U,
BSplCLib::CacheD3(U, Poles.Length() - 1, 0., 1., Poles, Weights, P, Vec1, Vec2, Vec3);
}
//=======================================================================
// function : PolesCoefficients
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::PolesCoefficients(const TColgp_Array1OfPnt& Poles,
TColgp_Array1OfPnt& CachePoles)
@@ -175,10 +139,7 @@ inline void BSplCLib::PolesCoefficients(const TColgp_Array1OfPnt& Poles,
BSplCLib::PolesCoefficients(Poles, PLib::NoWeights(), CachePoles, PLib::NoWeights());
}
//=======================================================================
// function : PolesCoefficients
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplCLib::PolesCoefficients(const TColgp_Array1OfPnt2d& Poles,
TColgp_Array1OfPnt2d& CachePoles)

114
src/FoundationClasses/TKMath/BSplCLib/BSplCLib_CurveComputation.gxx
View File

@@ -46,10 +46,8 @@ struct BSplCLib_DataContainer
Standard_Real ders[Dimension_gen*4];
};
//=======================================================================
//function : Reverse
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::Reverse(Array1OfPoints& Poles,
const Standard_Integer L)
@@ -73,10 +71,8 @@ void BSplCLib::Reverse(Array1OfPoints& Poles,
// CURVES MODIFICATIONS
//
//=======================================================================
//function : RemoveKnot
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean BSplCLib::RemoveKnot
(const Standard_Integer Index,
@@ -152,10 +148,8 @@ void BSplCLib::InsertKnots
else PLib::GetPoles(newpoles,NewPoles);
}
//=======================================================================
//function : InsertKnot
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::InsertKnot(const Standard_Integer ,
const Standard_Real U,
@@ -179,10 +173,8 @@ void BSplCLib::InsertKnot(const Standard_Integer ,
k,&m,NewPoles,NewWeights,nk,nm,Epsilon(U));
}
//=======================================================================
//function : RaiseMultiplicity
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::RaiseMultiplicity(const Standard_Integer KnotIndex,
const Standard_Integer Mult,
@@ -205,10 +197,8 @@ void BSplCLib::RaiseMultiplicity(const Standard_Integer KnotIndex,
k,&m,NewPoles,NewWeights,nk,nm,Epsilon(k(1)));
}
//=======================================================================
//function : IncreaseDegree
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::IncreaseDegree
(const Standard_Integer Degree,
@@ -241,10 +231,8 @@ void BSplCLib::IncreaseDegree
else PLib::GetPoles(newpoles,NewPoles);
}
//=======================================================================
//function : Unperiodize
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::Unperiodize
(const Standard_Integer Degree,
@@ -275,10 +263,8 @@ void BSplCLib::Unperiodize
else PLib::GetPoles(newpoles,NewPoles);
}
//=======================================================================
//function : Trimming
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::Trimming(const Standard_Integer Degree,
const Standard_Boolean Periodic,
@@ -408,10 +394,8 @@ static void PrepareEval
}
}
//=======================================================================
//function : D0
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::D0
(const Standard_Real U,
@@ -440,10 +424,8 @@ void BSplCLib::D0
CoordsToPoint (P, dc.poles, );
}
//=======================================================================
//function : D1
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::D1
(const Standard_Real U,
@@ -473,10 +455,8 @@ void BSplCLib::D1
CoordsToPoint (V, result + Dimension_gen, );
}
//=======================================================================
//function : D2
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::D2
(const Standard_Real U,
@@ -511,10 +491,8 @@ void BSplCLib::D2
CoordsToPoint (V2, result + 2 * Dimension_gen, );
}
//=======================================================================
//function : D3
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::D3
(const Standard_Real U,
@@ -554,10 +532,8 @@ void BSplCLib::D3
CoordsToPoint (V3, result + 3 * Dimension_gen, );
}
//=======================================================================
//function : DN
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::DN
(const Standard_Real U,
@@ -593,10 +569,8 @@ void BSplCLib::DN
}
}
//=======================================================================
//function : Solves a LU factored Matrix
//purpose :
//=======================================================================
//=================================================================================================
Standard_Integer
BSplCLib::SolveBandedSystem(const math_Matrix& Matrix,
@@ -1154,10 +1128,8 @@ void BSplCLib::BuildCache(const Standard_Real theParameter,
theCacheArray.SetValue(theCacheArray.LowerRow(), theCacheArray.LowerCol() + aCacheShift - 1, 1.0);
}
//=======================================================================
//function : Interpolate
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::Interpolate(const Standard_Integer Degree,
const TColStd_Array1OfReal& FlatKnots,
@@ -1180,10 +1152,8 @@ void BSplCLib::Interpolate(const Standard_Integer Degree,
InversionProblem) ;
}
//=======================================================================
//function : Interpolate
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::Interpolate(const Standard_Integer Degree,
const TColStd_Array1OfReal& FlatKnots,
@@ -1334,10 +1304,8 @@ void BSplCLib::MovePoint (const Standard_Real U,
// given u as parameter) to reach a new position
//=======================================================================
//=======================================================================
//function : MovePointAndTangent
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::MovePointAndTangent (const Standard_Real U,
const Vector& Delta,
@@ -1383,10 +1351,8 @@ void BSplCLib::MovePointAndTangent (const Standard_Real U,
ErrorStatus) ;
}
//=======================================================================
//function : Resolution
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::Resolution(const Array1OfPoints& Poles,
const TColStd_Array1OfReal* Weights,
@@ -1408,10 +1374,8 @@ void BSplCLib::Resolution(const Array1OfPoints& Poles,
UTolerance) ;
}
//=======================================================================
//function : FunctionMultiply
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::FunctionMultiply
(const BSplCLib_EvaluatorFunction & FunctionPtr,
@@ -1447,10 +1411,8 @@ void BSplCLib::FunctionMultiply
theStatus);
}
//=======================================================================
//function : FunctionReparameterise
//purpose :
//=======================================================================
//=================================================================================================
void BSplCLib::FunctionReparameterise
(const BSplCLib_EvaluatorFunction & FunctionPtr,

25
src/FoundationClasses/TKMath/BSplSLib/BSplSLib.lxx
View File

@@ -18,10 +18,7 @@
#include <TColgp_Array2OfPnt.hxx>
#include <TColStd_Array2OfReal.hxx>
//=======================================================================
// function : CoefsD0
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplSLib::CoefsD0(const Standard_Real U,
const Standard_Real V,
@@ -42,10 +39,7 @@ inline void BSplSLib::CoefsD0(const Standard_Real U,
Point);
}
//=======================================================================
// function : CoefsD1
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplSLib::CoefsD1(const Standard_Real U,
const Standard_Real V,
@@ -70,10 +64,7 @@ inline void BSplSLib::CoefsD1(const Standard_Real U,
VecV);
}
//=======================================================================
// function : CoefsD2
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplSLib::CoefsD2(const Standard_Real U,
const Standard_Real V,
@@ -104,10 +95,7 @@ inline void BSplSLib::CoefsD2(const Standard_Real U,
VecVV);
}
//=======================================================================
// function : PolesCoefficients
// purpose :
//=======================================================================
//=================================================================================================
inline void BSplSLib::PolesCoefficients(const TColgp_Array2OfPnt& Poles,
TColgp_Array2OfPnt& CachePoles)
@@ -115,10 +103,7 @@ inline void BSplSLib::PolesCoefficients(const TColgp_Array2OfPnt& Poles,
BSplSLib::PolesCoefficients(Poles, BSplSLib::NoWeights(), CachePoles, BSplSLib::NoWeights());
}
//=======================================================================
// function : NoWeights
// purpose :
//=======================================================================
//=================================================================================================
inline TColStd_Array2OfReal* BSplSLib::NoWeights()
{

12
src/FoundationClasses/TKMath/BVH/BVH_BinaryTree.hxx
View File

@@ -196,10 +196,8 @@ void EstimateSAH(const BVH_Tree<T, N, BVH_BinaryTree>* theTree,
}
} // namespace BVH
// =======================================================================
// function : EstimateSAH
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
T BVH_Tree<T, N, BVH_BinaryTree>::EstimateSAH() const
{
@@ -208,10 +206,8 @@ T BVH_Tree<T, N, BVH_BinaryTree>::EstimateSAH() const
return aSAH;
}
// =======================================================================
// function : CollapseToQuadTree
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
BVH_Tree<T, N, BVH_QuadTree>* BVH_Tree<T, N, BVH_BinaryTree>::CollapseToQuadTree() const
{

12
src/FoundationClasses/TKMath/BVH/BVH_BinnedBuilder.hxx
View File

@@ -98,10 +98,8 @@ private:
// clang-format on
};
// =======================================================================
// function : getSubVolumes
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N, int Bins>
void BVH_BinnedBuilder<T, N, Bins>::getSubVolumes(BVH_Set<T, N>* theSet,
BVH_Tree<T, N>* theBVH,
@@ -210,10 +208,8 @@ struct BVH_AxisSelector<T, 2>
};
} // namespace BVH
// =======================================================================
// function : buildNode
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N, int Bins>
typename BVH_QueueBuilder<T, N>::BVH_ChildNodes BVH_BinnedBuilder<T, N, Bins>::buildNode(
BVH_Set<T, N>* theSet,

18
src/FoundationClasses/TKMath/BVH/BVH_Box.hxx
View File

@@ -517,10 +517,8 @@ struct BoxMinMax<T, 2>
};
} // namespace BVH
// =======================================================================
// function : Combine
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
void BVH_Box<T, N>::Combine(const BVH_Box& theBox)
{
@@ -540,10 +538,8 @@ void BVH_Box<T, N>::Combine(const BVH_Box& theBox)
}
}
// =======================================================================
// function : Area
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
T BVH_Box<T, N>::Area() const
{
@@ -551,10 +547,8 @@ T BVH_Box<T, N>::Area() const
: BVH::SurfaceCalculator<T, N>::Area(myMaxPoint - myMinPoint);
}
// =======================================================================
// function : Center
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
T BVH_Box<T, N>::Center(const Standard_Integer theAxis) const
{

6
src/FoundationClasses/TKMath/BVH/BVH_DistanceField.lxx
View File

@@ -17,10 +17,8 @@
#include <OSD_Parallel.hxx>
#include <BVH_Distance.hxx>
// =======================================================================
// function : BVH_DistanceField
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
BVH_DistanceField<T, N>::BVH_DistanceField(const Standard_Integer theMaximumSize,
const Standard_Boolean theComputeSign)

12
src/FoundationClasses/TKMath/BVH/BVH_LinearBuilder.hxx
View File

@@ -67,10 +67,8 @@ protected:
Standard_Integer theDigit) const;
};
// =======================================================================
// function : BVH_LinearBuilder
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
BVH_LinearBuilder<T, N>::BVH_LinearBuilder(const Standard_Integer theLeafNodeSize,
const Standard_Integer theMaxTreeDepth)
@@ -306,10 +304,8 @@ private:
};
} // namespace BVH
// =======================================================================
// function : Build
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
void BVH_LinearBuilder<T, N>::Build(BVH_Set<T, N>* theSet,
BVH_Tree<T, N>* theBVH,

12
src/FoundationClasses/TKMath/BVH/BVH_Properties.hxx
View File

@@ -161,10 +161,8 @@ struct UnitVector<T, 4>
};
} // namespace BVH
// =======================================================================
// function : SetTransform
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
void BVH_Transform<T, N>::SetTransform(const BVH_MatNt& theTransform)
{
@@ -172,10 +170,8 @@ void BVH_Transform<T, N>::SetTransform(const BVH_MatNt& theTransform)
BVH::MatrixOp<T, N>::Inverse(myTransform, myTransformInversed);
}
// =======================================================================
// function : Apply
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
BVH_Box<T, N> BVH_Transform<T, N>::Apply(const BVH_Box<T, N>& theBox) const
{

6
src/FoundationClasses/TKMath/BVH/BVH_QueueBuilder.hxx
View File

@@ -160,10 +160,8 @@ protected:
Standard_Integer myNumOfThreads; //!< Number of threads used to build BVH
};
// =======================================================================
// function : addChildren
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
void BVH_QueueBuilder<T, N>::addChildren(
BVH_Tree<T, N>* theBVH,

6
src/FoundationClasses/TKMath/BVH/BVH_RadixSorter.hxx
View File

@@ -178,10 +178,8 @@ protected:
};
} // namespace BVH
// =======================================================================
// function : Perform
// purpose :
// =======================================================================
//=================================================================================================
template <class T, int N>
void BVH_RadixSorter<T, N>::Perform(BVH_Set<T, N>* theSet,
const Standard_Integer theStart,

12
src/FoundationClasses/TKMath/BVH/BVH_Traverse.lxx
View File

@@ -32,10 +32,8 @@ struct BVH_NodeInStack
};
} // namespace
// =======================================================================
// function : BVH_Traverse::Select
// purpose :
// =======================================================================
//=================================================================================================
template <class NumType, int Dimension, class BVHSetType, class MetricType>
Standard_Integer BVH_Traverse<NumType, Dimension, BVHSetType, MetricType>::Select(
const opencascade::handle<BVH_Tree<NumType, Dimension>>& theBVH)
@@ -167,10 +165,8 @@ struct BVH_PairNodesInStack
};
} // namespace
// =======================================================================
// function : BVH_PairTraverse::Select
// purpose :
// =======================================================================
//=================================================================================================
template <class NumType, int Dimension, class BVHSetType, class MetricType>
Standard_Integer BVH_PairTraverse<NumType, Dimension, BVHSetType, MetricType>::Select(
const opencascade::handle<BVH_Tree<NumType, Dimension>>& theBVH1,

6
src/FoundationClasses/TKMath/Bnd/Bnd_B2x.gxx
View File

@@ -106,10 +106,8 @@ Standard_Boolean Bnd_B2x::Limit (const Bnd_B2x& theBox)
return aResult;
}
//=======================================================================
//function : Transformed
//purpose :
//=======================================================================
//=================================================================================================
Bnd_B2x Bnd_B2x::Transformed (const gp_Trsf2d& theTrsf) const
{

18
src/FoundationClasses/TKMath/Bnd/Bnd_B3x.gxx
View File

@@ -134,10 +134,8 @@ Standard_Boolean Bnd_B3x::Limit (const Bnd_B3x& theBox)
return aResult;
}
//=======================================================================
//function : Transformed
//purpose :
//=======================================================================
//=================================================================================================
Bnd_B3x Bnd_B3x::Transformed (const gp_Trsf& theTrsf) const
{
@@ -319,10 +317,8 @@ Standard_Boolean Bnd_B3x::IsOut (const Bnd_B3x& theBox,
return aResult;
}
//=======================================================================
//function : IsOut
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean Bnd_B3x::IsOut (const gp_Ax3& thePlane) const
{
@@ -343,10 +339,8 @@ Standard_Boolean Bnd_B3x::IsOut (const gp_Ax3& thePlane) const
return ((aDist0 + aDist1) * (aDist0 - aDist1) > 0.);
}
//=======================================================================
//function : IsOut
//purpose :
//=======================================================================
//=================================================================================================
Standard_Boolean Bnd_B3x::IsOut (const gp_Ax1& theLine,
const Standard_Boolean isRay,

12
src/FoundationClasses/TKMath/Poly/Poly_ArrayOfNodes.hxx
View File

@@ -112,10 +112,8 @@ public:
gp_Pnt operator[](Standard_Integer theIndex) const { return Value(theIndex); }
};
// =======================================================================
// function : Value
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Pnt Poly_ArrayOfNodes::Value(Standard_Integer theIndex) const
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt))
@@ -129,10 +127,8 @@ inline gp_Pnt Poly_ArrayOfNodes::Value(Standard_Integer theIndex) const
}
}
// =======================================================================
// function : SetValue
// purpose :
// =======================================================================
//=================================================================================================
inline void Poly_ArrayOfNodes::SetValue(Standard_Integer theIndex, const gp_Pnt& theValue)
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt))

12
src/FoundationClasses/TKMath/Poly/Poly_ArrayOfUVNodes.hxx
View File

@@ -112,10 +112,8 @@ public:
gp_Pnt2d operator[](Standard_Integer theIndex) const { return Value(theIndex); }
};
// =======================================================================
// function : Value
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Pnt2d Poly_ArrayOfUVNodes::Value(Standard_Integer theIndex) const
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt2d))
@@ -129,10 +127,8 @@ inline gp_Pnt2d Poly_ArrayOfUVNodes::Value(Standard_Integer theIndex) const
}
}
// =======================================================================
// function : SetValue
// purpose :
// =======================================================================
//=================================================================================================
inline void Poly_ArrayOfUVNodes::SetValue(Standard_Integer theIndex, const gp_Pnt2d& theValue)
{
if (myStride == (Standard_Integer)sizeof(gp_Pnt2d))

5
src/FoundationClasses/TKMath/TopLoc/TopLoc_Location.cxx
View File

@@ -22,10 +22,7 @@
#include <TopLoc_Location.hxx>
#include <TopLoc_SListOfItemLocation.hxx>
//=======================================================================
// function : TopLoc_Location
// purpose : constructor Identity
//=======================================================================
//=================================================================================================
TopLoc_Location::TopLoc_Location() {}

37
src/FoundationClasses/TKMath/TopLoc/TopLoc_Location.lxx
View File

@@ -19,60 +19,43 @@
#include <TopLoc_Datum3D.hxx>
#include <TopLoc_ItemLocation.hxx>
//=======================================================================
// function : IsIdentity
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Boolean TopLoc_Location::IsIdentity() const
{
return myItems.IsEmpty();
}
//=======================================================================
// function : Identity
// purpose :
//=======================================================================
//=================================================================================================
inline void TopLoc_Location::Identity()
{
myItems.Clear();
}
//=======================================================================
// function : FirstDatum
// purpose :
//=======================================================================
//=================================================================================================
inline const Handle(TopLoc_Datum3D)& TopLoc_Location::FirstDatum() const
{
return myItems.Value().myDatum;
}
//=======================================================================
// function : FirstPower
// purpose :
//=======================================================================
//=================================================================================================
inline Standard_Integer TopLoc_Location::FirstPower() const
{
return myItems.Value().myPower;
}
//=======================================================================
// function : NextLocation
// purpose :
//=======================================================================
//=================================================================================================
inline const TopLoc_Location& TopLoc_Location::NextLocation() const
{
return (*(TopLoc_Location*)&(myItems.Tail()));
}
//=======================================================================
// function : HashCode
// purpose :
//=======================================================================
//=================================================================================================
inline size_t TopLoc_Location::HashCode() const
{
// Hashing base on IsEqual function
@@ -94,10 +77,8 @@ inline size_t TopLoc_Location::HashCode() const
return aHash;
}
//=======================================================================
// function : ShallowDump
// purpose :
//=======================================================================
//=================================================================================================
inline void ShallowDump(const TopLoc_Location& me, Standard_OStream& S)
{
me.ShallowDump(S);

24
src/FoundationClasses/TKMath/gp/gp_Ax2.hxx
View File

@@ -370,10 +370,8 @@ private:
gp_Dir vxdir;
};
// =======================================================================
// function : SetAxis
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax2::SetAxis(const gp_Ax1& theA1)
{
Standard_Real a = theA1.Direction() * vxdir;
@@ -399,10 +397,8 @@ inline void gp_Ax2::SetAxis(const gp_Ax1& theA1)
}
}
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax2::SetDirection(const gp_Dir& theV)
{
Standard_Real a = theV * vxdir;
@@ -428,10 +424,8 @@ inline void gp_Ax2::SetDirection(const gp_Dir& theV)
}
}
// =======================================================================
// function : IsCoplanar
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Ax2::IsCoplanar(const gp_Ax2& theOther,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const
@@ -448,10 +442,8 @@ inline Standard_Boolean gp_Ax2::IsCoplanar(const gp_Ax2& theOther,
return D1 <= theLinearTolerance && axis.IsParallel(theOther.axis, theAngularTolerance);
}
// =======================================================================
// function : IsCoplanar
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Ax2::IsCoplanar(const gp_Ax1& theA,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const

42
src/FoundationClasses/TKMath/gp/gp_Ax22d.hxx
View File

@@ -262,10 +262,8 @@ private:
gp_Dir2d vxdir;
};
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax22d::SetXAxis(const gp_Ax2d& theA1)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
@@ -281,10 +279,8 @@ inline void gp_Ax22d::SetXAxis(const gp_Ax2d& theA1)
}
}
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax22d::SetYAxis(const gp_Ax2d& theA1)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
@@ -300,10 +296,8 @@ inline void gp_Ax22d::SetYAxis(const gp_Ax2d& theA1)
}
}
// =======================================================================
// function : SetXDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax22d::SetXDirection(const gp_Dir2d& theVx)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
@@ -318,10 +312,8 @@ inline void gp_Ax22d::SetXDirection(const gp_Dir2d& theVx)
}
}
// =======================================================================
// function : SetYDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax22d::SetYDirection(const gp_Dir2d& theVy)
{
Standard_Boolean isSign = (vxdir.Crossed(vydir)) >= 0.0;
@@ -336,10 +328,8 @@ inline void gp_Ax22d::SetYDirection(const gp_Dir2d& theVy)
}
}
// =======================================================================
// function : Rotate
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax22d::Rotate(const gp_Pnt2d& theP, const Standard_Real theAng)
{
gp_Pnt2d aTemp = point;
@@ -349,10 +339,8 @@ inline void gp_Ax22d::Rotate(const gp_Pnt2d& theP, const Standard_Real theAng)
vydir.Rotate(theAng);
}
// =======================================================================
// function : Scale
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax22d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
gp_Pnt2d aTemp = point;
@@ -365,10 +353,8 @@ inline void gp_Ax22d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
}
}
// =======================================================================
// function : Transform
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax22d::Transform(const gp_Trsf2d& theT)
{
gp_Pnt2d aTemp = point;

48
src/FoundationClasses/TKMath/gp/gp_Ax3.hxx
View File

@@ -327,10 +327,8 @@ private:
gp_Dir vxdir;
};
// =======================================================================
// function : gp_Ax3
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Ax3::gp_Ax3(const gp_Ax2& theA)
: axis(theA.Axis()),
vydir(theA.YDirection()),
@@ -338,10 +336,8 @@ inline gp_Ax3::gp_Ax3(const gp_Ax2& theA)
{
}
// =======================================================================
// function : Ax2
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Ax2 gp_Ax3::Ax2() const
{
gp_Dir aZz = axis.Direction();
@@ -352,20 +348,16 @@ inline gp_Ax2 gp_Ax3::Ax2() const
return gp_Ax2(axis.Location(), aZz, vxdir);
}
// =======================================================================
// function : SetAxis
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax3::SetAxis(const gp_Ax1& theA1)
{
axis.SetLocation(theA1.Location());
SetDirection(theA1.Direction());
}
// =======================================================================
// function : SetDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax3::SetDirection(const gp_Dir& theV)
{
Standard_Real aDot = theV.Dot(vxdir);
@@ -398,10 +390,8 @@ inline void gp_Ax3::SetDirection(const gp_Dir& theV)
}
}
// =======================================================================
// function : SetXDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax3::SetXDirection(const gp_Dir& theVx)
{
Standard_Real aDot = theVx.Dot(axis.Direction());
@@ -433,10 +423,8 @@ inline void gp_Ax3::SetXDirection(const gp_Dir& theVx)
}
}
// =======================================================================
// function : SetYDirection
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Ax3::SetYDirection(const gp_Dir& theVy)
{
Standard_Real aDot = theVy.Dot(axis.Direction());
@@ -465,10 +453,8 @@ inline void gp_Ax3::SetYDirection(const gp_Dir& theVy)
}
}
// =======================================================================
// function : IsCoplanar
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Ax3::IsCoplanar(const gp_Ax3& theOther,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const
@@ -488,10 +474,8 @@ inline Standard_Boolean gp_Ax3::IsCoplanar(const gp_Ax3& theOther,
&& axis.IsParallel(theOther.axis, theAngularTolerance));
}
// =======================================================================
// function : IsCoplanar
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Ax3::IsCoplanar(const gp_Ax1& theA1,
const Standard_Real theLinearTolerance,
const Standard_Real theAngularTolerance) const

24
src/FoundationClasses/TKMath/gp/gp_Circ.hxx
View File

@@ -222,10 +222,8 @@ private:
Standard_Real radius;
};
// =======================================================================
// function : Scale
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Circ::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
radius *= theS;
@@ -236,10 +234,8 @@ inline void gp_Circ::Scale(const gp_Pnt& theP, const Standard_Real theS)
pos.Scale(theP, theS);
}
// =======================================================================
// function : Scaled
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Circ gp_Circ::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Circ aC = *this;
@@ -252,10 +248,8 @@ inline gp_Circ gp_Circ::Scaled(const gp_Pnt& theP, const Standard_Real theS) con
return aC;
}
// =======================================================================
// function : Transform
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Circ::Transform(const gp_Trsf& theT)
{
radius *= theT.ScaleFactor();
@@ -266,10 +260,8 @@ inline void gp_Circ::Transform(const gp_Trsf& theT)
pos.Transform(theT);
}
// =======================================================================
// function : Transformed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Circ gp_Circ::Transformed(const gp_Trsf& theT) const
{
gp_Circ aC = *this;

48
src/FoundationClasses/TKMath/gp/gp_Circ2d.hxx
View File

@@ -245,10 +245,8 @@ private:
Standard_Real radius;
};
// =======================================================================
// function : Coefficients
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Circ2d::Coefficients(Standard_Real& theA,
Standard_Real& theB,
Standard_Real& theC,
@@ -266,10 +264,8 @@ inline void gp_Circ2d::Coefficients(Standard_Real& theA,
theF = aXc * aXc + anYc * anYc - radius * radius;
}
// =======================================================================
// function : Distance
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Real gp_Circ2d::Distance(const gp_Pnt2d& theP) const
{
gp_XY aCoord = theP.XY();
@@ -282,10 +278,8 @@ inline Standard_Real gp_Circ2d::Distance(const gp_Pnt2d& theP) const
return aD;
}
// =======================================================================
// function : Reversed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Circ2d gp_Circ2d::Reversed() const
{
gp_Circ2d aCirc = *this;
@@ -295,10 +289,8 @@ inline gp_Circ2d gp_Circ2d::Reversed() const
return aCirc;
}
// =======================================================================
// function : SquareDistance
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Real gp_Circ2d::SquareDistance(const gp_Pnt2d& theP) const
{
gp_XY aCoord = theP.XY();
@@ -307,10 +299,8 @@ inline Standard_Real gp_Circ2d::SquareDistance(const gp_Pnt2d& theP) const
return aD * aD;
}
// =======================================================================
// function : Scale
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Circ2d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
{
radius *= theS;
@@ -321,10 +311,8 @@ inline void gp_Circ2d::Scale(const gp_Pnt2d& theP, const Standard_Real theS)
pos.Scale(theP, theS);
}
// =======================================================================
// function : Scaled
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Circ2d gp_Circ2d::Scaled(const gp_Pnt2d& theP, const Standard_Real theS) const
{
gp_Circ2d aCirc = *this;
@@ -337,10 +325,8 @@ inline gp_Circ2d gp_Circ2d::Scaled(const gp_Pnt2d& theP, const Standard_Real the
return aCirc;
}
// =======================================================================
// function : Transform
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Circ2d::Transform(const gp_Trsf2d& theT)
{
radius *= theT.ScaleFactor();
@@ -351,10 +337,8 @@ inline void gp_Circ2d::Transform(const gp_Trsf2d& theT)
pos.Transform(theT);
}
// =======================================================================
// function : Transformed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Circ2d gp_Circ2d::Transformed(const gp_Trsf2d& theT) const
{
gp_Circ2d aCirc = *this;

36
src/FoundationClasses/TKMath/gp/gp_Cone.hxx
View File

@@ -231,10 +231,8 @@ private:
Standard_Real semiAngle;
};
// =======================================================================
// function : gp_Cone
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Cone::gp_Cone(const gp_Ax3& theA3,
const Standard_Real theAng,
const Standard_Real theRadius)
@@ -252,10 +250,8 @@ inline gp_Cone::gp_Cone(const gp_Ax3& theA3,
"gp_Cone() - invalid construction parameters");
}
// =======================================================================
// function : SetSemiAngle
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Cone::SetSemiAngle(const Standard_Real theAng)
{
Standard_Real aVal = theAng;
@@ -269,10 +265,8 @@ inline void gp_Cone::SetSemiAngle(const Standard_Real theAng)
semiAngle = theAng;
}
// =======================================================================
// function : Scale
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Cone::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
pos.Scale(theP, theS);
@@ -283,10 +277,8 @@ inline void gp_Cone::Scale(const gp_Pnt& theP, const Standard_Real theS)
}
}
// =======================================================================
// function : Scaled
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Cone gp_Cone::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Cone aC = *this;
@@ -299,10 +291,8 @@ inline gp_Cone gp_Cone::Scaled(const gp_Pnt& theP, const Standard_Real theS) con
return aC;
}
// =======================================================================
// function : Transform
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Cone::Transform(const gp_Trsf& theT)
{
pos.Transform(theT);
@@ -313,10 +303,8 @@ inline void gp_Cone::Transform(const gp_Trsf& theT)
}
}
// =======================================================================
// function : Transformed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Cone gp_Cone::Transformed(const gp_Trsf& theT) const
{
gp_Cone aC = *this;

24
src/FoundationClasses/TKMath/gp/gp_Cylinder.hxx
View File

@@ -191,10 +191,8 @@ private:
Standard_Real radius;
};
// =======================================================================
// function : Scale
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Cylinder::Scale(const gp_Pnt& theP, const Standard_Real theS)
{
pos.Scale(theP, theS);
@@ -205,10 +203,8 @@ inline void gp_Cylinder::Scale(const gp_Pnt& theP, const Standard_Real theS)
}
}
// =======================================================================
// function : Scaled
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Cylinder gp_Cylinder::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Cylinder aCyl = *this;
@@ -221,10 +217,8 @@ inline gp_Cylinder gp_Cylinder::Scaled(const gp_Pnt& theP, const Standard_Real t
return aCyl;
}
// =======================================================================
// function : Transform
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Cylinder::Transform(const gp_Trsf& theT)
{
pos.Transform(theT);
@@ -235,10 +229,8 @@ inline void gp_Cylinder::Transform(const gp_Trsf& theT)
}
}
// =======================================================================
// function : Transformed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Cylinder gp_Cylinder::Transformed(const gp_Trsf& theT) const
{
gp_Cylinder aCyl = *this;

84
src/FoundationClasses/TKMath/gp/gp_Dir.hxx
View File

@@ -288,10 +288,8 @@ private:
#include <gp_Trsf.hxx>
// =======================================================================
// function : gp_Dir
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir::gp_Dir(const gp_Vec& theV)
{
const gp_XYZ& aXYZ = theV.XYZ();
@@ -306,10 +304,8 @@ inline gp_Dir::gp_Dir(const gp_Vec& theV)
coord.SetZ(aZ / aD);
}
// =======================================================================
// function : gp_Dir
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir::gp_Dir(const gp_XYZ& theXYZ)
{
Standard_Real aX = theXYZ.X();
@@ -323,10 +319,8 @@ inline gp_Dir::gp_Dir(const gp_XYZ& theXYZ)
coord.SetZ(aZ / aD);
}
// =======================================================================
// function : gp_Dir
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir::gp_Dir(const Standard_Real theXv,
const Standard_Real theYv,
const Standard_Real theZv)
@@ -339,10 +333,8 @@ inline gp_Dir::gp_Dir(const Standard_Real theXv,
coord.SetZ(theZv / aD);
}
// =======================================================================
// function : SetCoord
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::SetCoord(const Standard_Integer theIndex, const Standard_Real theXi)
{
Standard_Real aX = coord.X();
@@ -370,10 +362,8 @@ inline void gp_Dir::SetCoord(const Standard_Integer theIndex, const Standard_Rea
coord.SetZ(aZ / aD);
}
// =======================================================================
// function : SetCoord
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::SetCoord(const Standard_Real theXv,
const Standard_Real theYv,
const Standard_Real theZv)
@@ -386,10 +376,8 @@ inline void gp_Dir::SetCoord(const Standard_Real theXv,
coord.SetZ(theZv / aD);
}
// =======================================================================
// function : SetX
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::SetX(const Standard_Real theX)
{
Standard_Real anY = coord.Y();
@@ -402,10 +390,8 @@ inline void gp_Dir::SetX(const Standard_Real theX)
coord.SetZ(aZ / aD);
}
// =======================================================================
// function : SetY
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::SetY(const Standard_Real theY)
{
Standard_Real aZ = coord.Z();
@@ -418,10 +404,8 @@ inline void gp_Dir::SetY(const Standard_Real theY)
coord.SetZ(aZ / aD);
}
// =======================================================================
// function : SetZ
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::SetZ(const Standard_Real theZ)
{
Standard_Real aX = coord.X();
@@ -434,10 +418,8 @@ inline void gp_Dir::SetZ(const Standard_Real theZ)
coord.SetZ(theZ / aD);
}
// =======================================================================
// function : SetXYZ
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::SetXYZ(const gp_XYZ& theXYZ)
{
Standard_Real aX = theXYZ.X();
@@ -451,10 +433,8 @@ inline void gp_Dir::SetXYZ(const gp_XYZ& theXYZ)
coord.SetZ(aZ / aD);
}
// =======================================================================
// function : Cross
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::Cross(const gp_Dir& theRight)
{
coord.Cross(theRight.coord);
@@ -464,10 +444,8 @@ inline void gp_Dir::Cross(const gp_Dir& theRight)
coord.Divide(aD);
}
// =======================================================================
// function : Crossed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir gp_Dir::Crossed(const gp_Dir& theRight) const
{
gp_Dir aV = *this;
@@ -479,10 +457,8 @@ inline gp_Dir gp_Dir::Crossed(const gp_Dir& theRight) const
return aV;
}
// =======================================================================
// function : CrossCross
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::CrossCross(const gp_Dir& theV1, const gp_Dir& theV2)
{
coord.CrossCross(theV1.coord, theV2.coord);
@@ -492,10 +468,8 @@ inline void gp_Dir::CrossCross(const gp_Dir& theV1, const gp_Dir& theV2)
coord.Divide(aD);
}
// =======================================================================
// function : CrossCrossed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir gp_Dir::CrossCrossed(const gp_Dir& theV1, const gp_Dir& theV2) const
{
gp_Dir aV = *this;
@@ -507,10 +481,8 @@ inline gp_Dir gp_Dir::CrossCrossed(const gp_Dir& theV1, const gp_Dir& theV2) con
return aV;
}
// =======================================================================
// function : Rotate
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir::Rotate(const gp_Ax1& theA1, const Standard_Real theAng)
{
gp_Trsf aT;

78
src/FoundationClasses/TKMath/gp/gp_Dir2d.hxx
View File

@@ -257,10 +257,8 @@ private:
#include <gp_Ax2d.hxx>
#include <gp_Trsf2d.hxx>
// =======================================================================
// function : gp_Dir2d
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir2d::gp_Dir2d(const gp_Vec2d& theV)
{
const gp_XY& aXY = theV.XY();
@@ -273,10 +271,8 @@ inline gp_Dir2d::gp_Dir2d(const gp_Vec2d& theV)
coord.SetY(anY / aD);
}
// =======================================================================
// function : gp_Dir2d
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir2d::gp_Dir2d(const gp_XY& theXY)
{
Standard_Real aX = theXY.X();
@@ -288,10 +284,8 @@ inline gp_Dir2d::gp_Dir2d(const gp_XY& theXY)
coord.SetY(anY / aD);
}
// =======================================================================
// function : gp_Dir2d
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Dir2d::gp_Dir2d(const Standard_Real theXv, const Standard_Real theYv)
{
Standard_Real aD = sqrt(theXv * theXv + theYv * theYv);
@@ -301,10 +295,8 @@ inline gp_Dir2d::gp_Dir2d(const Standard_Real theXv, const Standard_Real theYv)
coord.SetY(theYv / aD);
}
// =======================================================================
// function : SetCoord
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir2d::SetCoord(const Standard_Integer theIndex, const Standard_Real theXi)
{
Standard_Real aX = coord.X();
@@ -326,10 +318,8 @@ inline void gp_Dir2d::SetCoord(const Standard_Integer theIndex, const Standard_R
coord.SetY(anY / aD);
}
// =======================================================================
// function : SetCoord
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir2d::SetCoord(const Standard_Real theXv, const Standard_Real theYv)
{
Standard_Real aD = sqrt(theXv * theXv + theYv * theYv);
@@ -339,10 +329,8 @@ inline void gp_Dir2d::SetCoord(const Standard_Real theXv, const Standard_Real th
coord.SetY(theYv / aD);
}
// =======================================================================
// function : SetX
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir2d::SetX(const Standard_Real theX)
{
Standard_Real anY = coord.Y();
@@ -353,10 +341,8 @@ inline void gp_Dir2d::SetX(const Standard_Real theX)
coord.SetY(anY / aD);
}
// =======================================================================
// function : SetY
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir2d::SetY(const Standard_Real theY)
{
Standard_Real aX = coord.X();
@@ -367,10 +353,8 @@ inline void gp_Dir2d::SetY(const Standard_Real theY)
coord.SetY(theY / aD);
}
// =======================================================================
// function : SetXY
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir2d::SetXY(const gp_XY& theXY)
{
Standard_Real aX = theXY.X();
@@ -382,10 +366,8 @@ inline void gp_Dir2d::SetXY(const gp_XY& theXY)
coord.SetY(anY / aD);
}
// =======================================================================
// function : IsEqual
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Dir2d::IsEqual(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
@@ -397,10 +379,8 @@ inline Standard_Boolean gp_Dir2d::IsEqual(const gp_Dir2d& theOther,
return anAng <= theAngularTolerance;
}
// =======================================================================
// function : IsNormal
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Dir2d::IsNormal(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
@@ -417,10 +397,8 @@ inline Standard_Boolean gp_Dir2d::IsNormal(const gp_Dir2d& theOther,
return anAng <= theAngularTolerance;
}
// =======================================================================
// function : IsOpposite
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Dir2d::IsOpposite(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
@@ -432,10 +410,8 @@ inline Standard_Boolean gp_Dir2d::IsOpposite(const gp_Dir2d& theOther,
return M_PI - anAng <= theAngularTolerance;
}
// =======================================================================
// function : IsParallel
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Boolean gp_Dir2d::IsParallel(const gp_Dir2d& theOther,
const Standard_Real theAngularTolerance) const
{
@@ -447,10 +423,8 @@ inline Standard_Boolean gp_Dir2d::IsParallel(const gp_Dir2d& theOther,
return anAng <= theAngularTolerance || M_PI - anAng <= theAngularTolerance;
}
// =======================================================================
// function : Rotate
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Dir2d::Rotate(const Standard_Real theAng)
{
gp_Trsf2d aT;

60
src/FoundationClasses/TKMath/gp/gp_Elips.hxx
View File

@@ -263,10 +263,8 @@ private:
Standard_Real minorRadius;
};
// =======================================================================
// function : Directrix1
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Ax1 gp_Elips::Directrix1() const
{
Standard_Real anE = Eccentricity();
@@ -278,10 +276,8 @@ inline gp_Ax1 gp_Elips::Directrix1() const
return gp_Ax1(gp_Pnt(anOrig), pos.YDirection());
}
// =======================================================================
// function : Directrix2
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Ax1 gp_Elips::Directrix2() const
{
Standard_Real anE = Eccentricity();
@@ -293,10 +289,8 @@ inline gp_Ax1 gp_Elips::Directrix2() const
return gp_Ax1(gp_Pnt(anOrig), pos.YDirection());
}
// =======================================================================
// function : Eccentricity
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Real gp_Elips::Eccentricity() const
{
if (majorRadius == 0.0)
@@ -309,10 +303,8 @@ inline Standard_Real gp_Elips::Eccentricity() const
}
}
// =======================================================================
// function : Focus1
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Pnt gp_Elips::Focus1() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius - minorRadius * minorRadius);
@@ -321,10 +313,8 @@ inline gp_Pnt gp_Elips::Focus1() const
return gp_Pnt(aPP.X() + aC * aDD.X(), aPP.Y() + aC * aDD.Y(), aPP.Z() + aC * aDD.Z());
}
// =======================================================================
// function : Focus2
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Pnt gp_Elips::Focus2() const
{
Standard_Real aC = sqrt(majorRadius * majorRadius - minorRadius * minorRadius);
@@ -333,10 +323,8 @@ inline gp_Pnt gp_Elips::Focus2() const
return gp_Pnt(aPP.X() - aC * aDD.X(), aPP.Y() - aC * aDD.Y(), aPP.Z() - aC * aDD.Z());
}
// =======================================================================
// function : Parameter
// purpose :
// =======================================================================
//=================================================================================================
inline Standard_Real gp_Elips::Parameter() const
{
if (majorRadius == 0.0)
@@ -349,10 +337,8 @@ inline Standard_Real gp_Elips::Parameter() const
}
}
// =======================================================================
// function : Scale
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Elips::Scale(const gp_Pnt& theP, const Standard_Real theS)
// Modified by skv - Fri Apr 8 10:28:10 2005 OCC8559 Begin
// { pos.Scale(P, S); }
@@ -372,10 +358,8 @@ inline void gp_Elips::Scale(const gp_Pnt& theP, const Standard_Real theS)
// Modified by skv - Fri Apr 8 10:28:10 2005 OCC8559 End
// =======================================================================
// function : Scaled
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Elips gp_Elips::Scaled(const gp_Pnt& theP, const Standard_Real theS) const
{
gp_Elips anE = *this;
@@ -393,10 +377,8 @@ inline gp_Elips gp_Elips::Scaled(const gp_Pnt& theP, const Standard_Real theS) c
return anE;
}
// =======================================================================
// function : Transform
// purpose :
// =======================================================================
//=================================================================================================
inline void gp_Elips::Transform(const gp_Trsf& theT)
{
majorRadius *= theT.ScaleFactor();
@@ -412,10 +394,8 @@ inline void gp_Elips::Transform(const gp_Trsf& theT)
pos.Transform(theT);
}
// =======================================================================
// function : Transformed
// purpose :
// =======================================================================
//=================================================================================================
inline gp_Elips gp_Elips::Transformed(const gp_Trsf& theT) const
{
gp_Elips anE = *this;

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