- Removed verbose function header comments (name, purpose) across multiple C++ source files.
- Introduced a single-line separator comment before each function for consistent formatting.
- Applied the change in visualization, modeling, algorithms, foundation, and application framework modules.
static Standard_GUID BinStorageDriver("03a56835-8269-11d5-aab2-0050044b1af1");
static Standard_GUID BinRetrievalDriver("03a56836-8269-11d5-aab2-0050044b1af1");
-//=======================================================================
-// function : Factory
-// purpose : PLUGIN FACTORY
-//=======================================================================
+//=================================================================================================
+
const Handle(Standard_Transient)& BinDrivers::Factory(const Standard_GUID& theGUID)
{
if (theGUID == BinStorageDriver)
static Standard_GUID BinLStorageDriver("13a56835-8269-11d5-aab2-0050044b1af1");
static Standard_GUID BinLRetrievalDriver("13a56836-8269-11d5-aab2-0050044b1af1");
-//=======================================================================
-// function : Factory
-// purpose : PLUGIN FACTORY
-//=======================================================================
+//=================================================================================================
+
const Handle(Standard_Transient)& BinLDrivers::Factory(const Standard_GUID& theGUID)
{
if (theGUID == BinLStorageDriver)
#include <TDocStd_FormatVersion.hxx>
#include <BinMDataStd.hxx>
-//=======================================================================
-// function : BinLDrivers_DocumentSection
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
BinLDrivers_DocumentSection::BinLDrivers_DocumentSection()
: myIsPostRead(Standard_False)
if (aBufSize < aLen)
aBufSize += sizeof(Standard_Integer);
- // Write the buffer: size + string
+ // Write the buffer: size + string
#ifdef DO_INVERSE
aBufSz[0] = InverseInt((Standard_Integer)aBufSize);
#else
unsigned char Data4[8]; // 8-bytes long on all OS
} BinObjMgt_UUID;
-//=======================================================================
-// function : BinObjMgt_Persistent
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
BinObjMgt_Persistent::BinObjMgt_Persistent()
: myIndex(1),
return s;
}
-//=======================================================================
-// function : Print
-// purpose : Prints UsedShapes.
-//=======================================================================
+//=================================================================================================
Standard_OStream& TNaming::Print(const TDF_Label& ACCESS, Standard_OStream& s)
{
return myName;
}
-//=======================================================================
-// function : Regenerate
-// purpose : idem designer
-//=======================================================================
+//=================================================================================================
Standard_Boolean TNaming_Naming::Regenerate(TDF_LabelMap& MDF)
// myTriangleMode(aTriMode)
//{
//}
-//=======================================================================
-// function : Add
-// purpose : Adds S2 in S1
-//=======================================================================
+//=================================================================================================
+
void TNaming_TranslateTool::Add(TopoDS_Shape& S1, const TopoDS_Shape& S2) const
{
BRep_Builder B;
}
}
-//=======================================================================
-// function : LDOMBasicString
-// purpose : Copy constructor
-//=======================================================================
+//=================================================================================================
LDOMBasicString::LDOMBasicString(const LDOMBasicString& anOther)
: myType(anOther.Type())
return aNullAttribute;
}
-//=======================================================================
-// function : GetFirstAttribute
-// purpose : private method
-//=======================================================================
+//=================================================================================================
const LDOM_BasicAttribute* LDOM_BasicElement::GetFirstAttribute(
const LDOM_BasicNode*& theLastCh,
return *this;
}
-//=======================================================================
-// function : setData
-// purpose : replace the data
-//=======================================================================
+//=================================================================================================
void LDOM_CharacterData::setData(const LDOMString& theValue)
{
mySeq->Append(&aNode);
}
-//=======================================================================
-// function : LDOM_NodeList
-// purpose : Copy constructor
-//=======================================================================
+//=================================================================================================
LDOM_NodeList::LDOM_NodeList(const LDOM_NodeList& theOther)
{
return c;
}
-//=======================================================================
-// function : underflow
-// purpose : redefined virtual
-//=======================================================================
+//=================================================================================================
int LDOM_SBuffer::underflow()
{
}
}
-//=======================================================================
-// function : Write
-// purpose : Stream out a char
-//=======================================================================
+//=================================================================================================
+
void LDOM_XmlWriter::Write(Standard_OStream& theOStream, const char theChar)
{
theOStream.write(&theChar, sizeof(char));
aDelta->AddAttributeDelta(DELTACREATION); \
}
-//=======================================================================
-// function : TDF_Data
-// purpose : empty constructor
-//=======================================================================
+//=================================================================================================
TDF_Data::TDF_Data()
: myTransaction(0),
IMPLEMENT_STANDARD_RTTIEXT(TDF_DataSet, Standard_Transient)
-//=======================================================================
-// function : TDF_DataSet
-// purpose : Creates a DataSet.
-//=======================================================================
+//=================================================================================================
+
TDF_DataSet::TDF_DataSet() {}
//=================================================================================================
}
}
-//=======================================================================
-// function : Ignore
-// purpose : Ignores an ID.
-//=======================================================================
+//=================================================================================================
void TDF_IDFilter::Ignore(const Standard_GUID& anID)
{
return childLabelNode;
}
-//=======================================================================
-// function : InternalDump
-// purpose : Private method.
-//=======================================================================
+//=================================================================================================
void TDF_Label::InternalDump(Standard_OStream& anOS,
const TDF_IDFilter& aFilter,
return A;
}
-//=======================================================================
-// function : TDF_Reference
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
TDF_Reference::TDF_Reference() {}
}
}
-//=======================================================================
-// function : DeepDump
-// purpose : Deep dump of a DF.
-//=======================================================================
+//=================================================================================================
void TDF_Tool::DeepDump(Standard_OStream& anOS, const Handle(TDF_Data)& aDF)
{
anOS << " dumped between " << --i << std::endl;
}
-//=======================================================================
-// function : ExtendedDeepDump
-// purpose : Internal method.
-//=======================================================================
+//=================================================================================================
static void TDF_Tool_ExtendedDeepDump(Standard_OStream& anOS,
const TDF_Label& aLabel,
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
+
void TDataStd_AsciiString::SetID()
{
Backup();
return A;
}
-//=======================================================================
-// function : TDataStd_BooleanArray
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_BooleanArray::TDataStd_BooleanArray()
: myID(GetID())
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
+
void TDataStd_BooleanArray::SetID()
{
Backup();
return A;
}
-//=======================================================================
-// function : TDataStd_BooleanList
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_BooleanList::TDataStd_BooleanList()
: myID(GetID())
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_BooleanList::SetID()
{
return TDataStd_ByteArrayID;
}
-//=======================================================================
-// function : TDataStd_ByteArray
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_ByteArray::TDataStd_ByteArray()
: myIsDelta(Standard_False),
myID(GetID())
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_ByteArray::SetID()
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_Comment::SetID()
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_ExtStringArray::SetID()
{
return A;
}
-//=======================================================================
-// function : TDataStd_ExtStringList
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_ExtStringList::TDataStd_ExtStringList()
: myID(GetID())
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_ExtStringList::SetID()
{
return SetAttr(L, V, theGuid);
}
-//=======================================================================
-// function : TDataStd_Integer
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
TDataStd_Integer::TDataStd_Integer()
: myValue(-1),
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
+
void TDataStd_Integer::SetID()
{
Backup();
return A;
}
-//=======================================================================
-// function : TDataStd_IntegerArray
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
TDataStd_IntegerArray::TDataStd_IntegerArray()
: myIsDelta(Standard_False),
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_IntegerArray::SetID()
{
return A;
}
-//=======================================================================
-// function : TDataStd_IntegerList
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_IntegerList::TDataStd_IntegerList()
: myID(GetID())
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_IntegerList::SetID()
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_Name::SetID()
{
return TDataStd_NamedDataID;
}
-//=======================================================================
-// function : TDataStd_NamedData
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_NamedData::TDataStd_NamedData() {}
//=================================================================================================
return SetAttr(L, V, theGuid);
}
-//=======================================================================
-// function : TDataStd_Real
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
TDataStd_Real::TDataStd_Real()
: myValue(RealFirst()),
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
+
void TDataStd_Real::SetID()
{
Backup();
return A;
}
-//=======================================================================
-// function : TDataStd_RealArray
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
TDataStd_RealArray::TDataStd_RealArray()
: myIsDelta(Standard_False),
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_RealArray::SetID()
{
return A;
}
-//=======================================================================
-// function : TDataStd_RealList
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_RealList::TDataStd_RealList()
: myID(GetID())
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
+
void TDataStd_RealList::SetID()
{
Backup();
return A;
}
-//=======================================================================
-// function : TDataStd_ReferenceArray
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_ReferenceArray::TDataStd_ReferenceArray()
: myID(GetID())
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
void TDataStd_ReferenceArray::SetID()
{
return A;
}
-//=======================================================================
-// function : TDataStd_ReferenceList
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
+
TDataStd_ReferenceList::TDataStd_ReferenceList()
: myID(GetID())
{
myID = theGuid;
}
-//=======================================================================
-// function : SetID
-// purpose : sets default ID
-//=======================================================================
+//=================================================================================================
+
void TDataStd_ReferenceList::SetID()
{
Backup();
AbortTransaction();
}
-//=======================================================================
-// function : CommitTransaction
-// purpose : Private method.
-//=======================================================================
+//=================================================================================================
Standard_Boolean TDocStd_Document::CommitTransaction()
{
return isDone;
}
-//=======================================================================
-// function : AbortTransaction
-// purpose : Private method.
-//=======================================================================
+//=================================================================================================
void TDocStd_Document::AbortTransaction()
{
}
}
-//=======================================================================
-// function :OpenTransaction
-// purpose : Private method.
-//=======================================================================
+//=================================================================================================
void TDocStd_Document::OpenTransaction()
{
{
}
-//=======================================================================
-// function : Set
-// purpose : Class method.
-//=======================================================================
+//=================================================================================================
Handle(TDocStd_XLink) TDocStd_XLink::Set(const TDF_Label& atLabel)
{
return myID;
}
-//=======================================================================
-// function : Set
-// purpose : CLASS method.
-//=======================================================================
+//=================================================================================================
Handle(TDocStd_XLinkRoot) TDocStd_XLinkRoot::Set(const Handle(TDF_Data)& aDF)
{
TFunction_Driver::TFunction_Driver() {}
-//=======================================================================
-// function : Init
-// purpose : Initialization
-//=======================================================================
+//=================================================================================================
void TFunction_Driver::Init(const TDF_Label& L)
{
return GetID();
}
-//=======================================================================
-// function : TFunction_Logbook
-// purpose : A Logbook creation
-//=======================================================================
+//=================================================================================================
+
TFunction_Logbook::TFunction_Logbook()
: isDone(Standard_False)
{
#include <ShapePersistent_Geom_Surface.hxx>
#include <ShapePersistent_BRep.hxx>
-//=======================================================================
-// function : BindTypes
-// purpose : Register types
-//=======================================================================
+//=================================================================================================
+
void ShapePersistent::BindTypes(StdObjMgt_MapOfInstantiators& theMap)
{
theMap.Bind<StdLPersistent_HArray1::Persistent>("PTopoDS_HArray1OfHShape");
0);
}
-//=======================================================================
-// function : BindTypes
-// purpose : Register types
-//=======================================================================
+//=================================================================================================
+
void StdDrivers::BindTypes(StdObjMgt_MapOfInstantiators& theMap)
{
StdLPersistent ::BindTypes(theMap);
IMPLEMENT_STANDARD_RTTIEXT(StdDrivers_DocumentRetrievalDriver, StdLDrivers_DocumentRetrievalDriver)
-//=======================================================================
-// function : bindTypes
-// purpose : Register types
-//=======================================================================
+//=================================================================================================
+
void StdDrivers_DocumentRetrievalDriver::bindTypes(StdObjMgt_MapOfInstantiators& theMap)
{
StdDrivers::BindTypes(theMap);
#include <StdPersistent_DataXtd_PatternStd.hxx>
#include <StdPersistent_PPrsStd.hxx>
-//=======================================================================
-// function : BindTypes
-// purpose : Register types
-//=======================================================================
+//=================================================================================================
+
void StdPersistent::BindTypes(StdObjMgt_MapOfInstantiators& theMap)
{
// Non-attribute data
0);
}
-//=======================================================================
-// function : BindTypes
-// purpose : Register types
-//=======================================================================
+//=================================================================================================
+
void StdLDrivers::BindTypes(StdObjMgt_MapOfInstantiators& theMap)
{
StdLPersistent::BindTypes(theMap);
return aReadData.PersistentObject(aRootData.Roots()->First()->Reference());
}
-//=======================================================================
-// function : Read
-// purpose : not implemented
-//=======================================================================
+//=================================================================================================
void StdLDrivers_DocumentRetrievalDriver::Read(Standard_IStream& /*theIStream*/,
const Handle(Storage_Data)& /*theStorageData*/,
}
}
-//=======================================================================
-// function : bindTypes
-// purpose : Register types
-//=======================================================================
+//=================================================================================================
+
void StdLDrivers_DocumentRetrievalDriver::bindTypes(StdObjMgt_MapOfInstantiators& theMap)
{
StdLDrivers::BindTypes(theMap);
#include <StdLPersistent_TreeNode.hxx>
#include <StdLPersistent_NamedData.hxx>
-//=======================================================================
-// function : BindTypes
-// purpose : Register types
-//=======================================================================
+//=================================================================================================
+
void StdLPersistent::BindTypes(StdObjMgt_MapOfInstantiators& theMap)
{
// Non-attribute data
Close();
}
-//=======================================================================
-// function : CloseDocument
-// purpose : free OCAF document
-//=======================================================================
+//=================================================================================================
void TObj_Model::CloseDocument(const Handle(TDocStd_Document)& theDoc)
{
IMPLEMENT_STANDARD_RTTIEXT(TObj_TIntSparseArray, TDF_Attribute)
-//=======================================================================
-// function : TObj_TIntSparseArray
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
TObj_TIntSparseArray::TObj_TIntSparseArray()
: myVector(100),
anInto->myAIS.Nullify();
}
-//=======================================================================
-// function : AfterAddition
-// purpose : erase if displayed
-//=======================================================================
+//=================================================================================================
+
void TPrsStd_AISPresentation::AfterAddition()
{
AfterResume();
}
-//=======================================================================
-// function : BeforeRemoval
-// purpose : erase if displayed
-//=======================================================================
+//=================================================================================================
+
void TPrsStd_AISPresentation::BeforeRemoval()
{
BeforeForget();
}
-//=======================================================================
-// function : BeforeForget
-// purpose : erase if displayed
-//=======================================================================
+//=================================================================================================
+
void TPrsStd_AISPresentation::BeforeForget()
{
if (!myAIS.IsNull())
static Standard_GUID XmlStorageDriver("03a56820-8269-11d5-aab2-0050044b1af1");
static Standard_GUID XmlRetrievalDriver("03a56822-8269-11d5-aab2-0050044b1af1");
-//=======================================================================
-// function : Factory
-// purpose : PLUGIN FACTORY
-//=======================================================================
+//=================================================================================================
+
const Handle(Standard_Transient)& XmlDrivers::Factory(const Standard_GUID& theGUID)
{
if (theGUID == XmlStorageDriver)
static Standard_GUID XmlLStorageDriver("13a56820-8269-11d5-aab2-0050044b1af1");
static Standard_GUID XmlLRetrievalDriver("13a56822-8269-11d5-aab2-0050044b1af1");
-//=======================================================================
-// function : Factory
-// purpose : PLUGIN FACTORY
-//=======================================================================
+//=================================================================================================
+
const Handle(Standard_Transient)& XmlLDrivers::Factory(const Standard_GUID& theGUID)
{
if (theGUID == XmlLStorageDriver)
#define SLENGTH 80
-//=======================================================================
-// function : CreationDate
-// purpose : mm/dd/yy
-//=======================================================================
+//=================================================================================================
+
TCollection_AsciiString XmlLDrivers::CreationDate()
{
Standard_Character nowstr[SLENGTH];
#include <XmlLDrivers_NamespaceDef.hxx>
-//=======================================================================
-// function : XmlLDrivers_NamespaceDef
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
+
XmlLDrivers_NamespaceDef::XmlLDrivers_NamespaceDef() {}
//=================================================================================================
#include <XmlObjMgt_Document.hxx>
#include <XmlObjMgt_Persistent.hxx>
-//=======================================================================
-// function : XmlObjMgt_Persistent
-// purpose : empty constructor
-//=======================================================================
+//=================================================================================================
+
XmlObjMgt_Persistent::XmlObjMgt_Persistent()
: myID(0)
{
return Standard_True;
}
-//=======================================================================
-// function : ReadStep
-// purpose : Reading of a file
-//=======================================================================
+//=================================================================================================
void RWStepAP214_ReadWriteModule::ReadStep(const Standard_Integer CN,
const Handle(StepData_StepReaderData)& data,
return;
}
-//=======================================================================
-// function : WriteStep
-// purpose : Writing of a file
-//=======================================================================
+//=================================================================================================
void RWStepAP214_ReadWriteModule::WriteStep(const Standard_Integer CN,
StepData_StepWriter& SW,
return 1.;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::SiUnitNameFactor
-// Purpose :
-// ==========================================================================
+//=================================================================================================
Standard_Boolean STEPConstruct_UnitContext::SiUnitNameFactor(
const Handle(StepBasic_SiUnit)& aSiUnit,
}
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::ComputeFactors
-// Purpose :
-// ==========================================================================
+//=================================================================================================
Standard_Integer STEPConstruct_UnitContext::ComputeFactors(
const Handle(StepRepr_GlobalUnitAssignedContext)& aContext,
return status;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::ComputeTolerance
-// Purpose :
-// ==========================================================================
+//=================================================================================================
Standard_Integer STEPConstruct_UnitContext::ComputeTolerance(
const Handle(StepRepr_GlobalUncertaintyAssignedContext)& aContext)
return status;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::LengthFactor
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Real STEPConstruct_UnitContext::LengthFactor() const
{
return lengthFactor;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::PlaneAngleFactor
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Real STEPConstruct_UnitContext::PlaneAngleFactor() const
{
return planeAngleFactor;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::SolidAngleFactor
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Real STEPConstruct_UnitContext::SolidAngleFactor() const
{
return solidAngleFactor;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::Uncertainty
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Real STEPConstruct_UnitContext::Uncertainty() const
{
return theUncertainty;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::HasUncertainty
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Boolean STEPConstruct_UnitContext::HasUncertainty() const
{
return hasUncertainty;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::LengthDone
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Boolean STEPConstruct_UnitContext::LengthDone() const
{
return lengthDone;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::PlaneAngleDone
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Boolean STEPConstruct_UnitContext::PlaneAngleDone() const
{
return planeAngleDone;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::SolidAngleDone
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_Boolean STEPConstruct_UnitContext::SolidAngleDone() const
{
return solidAngleDone;
}
-// ==========================================================================
-// Method : STEPConstruct_UnitContext::StatusMessage
-// Purpose :
-// ==========================================================================
+//=================================================================================================
+
Standard_CString STEPConstruct_UnitContext::StatusMessage(const Standard_Integer status) const
{
switch (status)
}
}
-//=======================================================================
-// Method : SetModel
-// Purpose :
-//=======================================================================
+//=================================================================================================
+
void STEPControl_ActorRead::SetModel(const Handle(Interface_InterfaceModel)& theModel)
{
myModel = theModel;
#include <StepData_Factors.hxx>
-// ============================================================================
-// Method : Constructor
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
StepData_Factors::StepData_Factors()
: myLengthFactor(1.),
myPlaneAngleFactor(1.),
{
}
-// ============================================================================
-// Method : InitializeFactors
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
void StepData_Factors::InitializeFactors(const Standard_Real theLengthFactor,
const Standard_Real thePlaneAngleFactor,
const Standard_Real theSolidAngleFactor)
myFactDR = thePlaneAngleFactor;
}
-// ============================================================================
-// Method : LengthFactor
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Standard_Real StepData_Factors::LengthFactor() const
{
return myLengthFactor;
}
-// ============================================================================
-// Method : PlaneAngleFactor
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Standard_Real StepData_Factors::PlaneAngleFactor() const
{
return myPlaneAngleFactor;
}
-// ============================================================================
-// Method : SolidAngleFactor
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Standard_Real StepData_Factors::SolidAngleFactor() const
{
return mySolidAngleFactor;
}
-// ============================================================================
-// Method : FactorRadianDegree
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Standard_Real StepData_Factors::FactorRadianDegree() const
{
return myFactRD;
}
-// ============================================================================
-// Method : FactorDegreeRadian
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Standard_Real StepData_Factors::FactorDegreeRadian() const
{
return myFactDR;
}
-// ============================================================================
-// Method : SetCascadeUnit
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
void StepData_Factors::SetCascadeUnit(const Standard_Real theUnit)
{
myCascadeUnit = theUnit;
}
-// ============================================================================
-// Method : CascadeUnit
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Standard_Real StepData_Factors::CascadeUnit() const
{
return myCascadeUnit;
}
}
-// ============================================================================
-// Method : StepToTopoDS_Builder
-// Purpose : Empty constructor
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_Builder::StepToTopoDS_Builder()
: myError(StepToTopoDS_BuilderOther)
{
#include <Transfer_TransientProcess.hxx>
#include <TransferBRep.hxx>
-// ============================================================================
-// Method : StepToTopoDS_Tool::StepToTopoDS_Tool
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_Tool::StepToTopoDS_Tool()
: myComputePC(Standard_False),
myNbC0Surf(0),
Init(Map, TP);
}
-// ============================================================================
-// Method : Init
-// Purpose : Init with a Map
-// ============================================================================
+//=================================================================================================
void StepToTopoDS_Tool::Init(const StepToTopoDS_DataMapOfTRI& Map,
const Handle(Transfer_TransientProcess)& TP)
return myDataMap.Find(TRI);
}
-// ============================================================================
-// Method : StepToTopoDS_Tool::ClearEdgeMap
-// Purpose :
-// ============================================================================
+//=================================================================================================
void StepToTopoDS_Tool::ClearEdgeMap()
{
myEdgeMap.Clear();
}
-// ============================================================================
-// Method : StepToTopoDS_Tool::IsEdgeBound
-// Purpose :
-// ============================================================================
+//=================================================================================================
Standard_Boolean StepToTopoDS_Tool::IsEdgeBound(const StepToTopoDS_PointPair& PP)
{
return myEdgeMap.IsBound(PP);
}
-// ============================================================================
-// Method : StepToTopoDS_Tool_BindEdge
-// Purpose :
-// ============================================================================
+//=================================================================================================
void StepToTopoDS_Tool::BindEdge(const StepToTopoDS_PointPair& PP, const TopoDS_Edge& E)
{
myEdgeMap.Bind(PP, E);
}
-// ============================================================================
-// Method : StepToTopoDS_Tool::FindEdge
-// Purpose :
-// ============================================================================
+//=================================================================================================
const TopoDS_Edge& StepToTopoDS_Tool::FindEdge(const StepToTopoDS_PointPair& PP)
{
return myEdgeMap.Find(PP);
}
-// ============================================================================
-// Method : StepToTopoDS_Tool::ClearVertexMap
-// Purpose :
-// ============================================================================
+//=================================================================================================
void StepToTopoDS_Tool::ClearVertexMap()
{
myVertexMap.Clear();
}
-// ============================================================================
-// Method : StepToTopoDS_Tool::IsVertexBound
-// Purpose :
-// ============================================================================
+//=================================================================================================
Standard_Boolean StepToTopoDS_Tool::IsVertexBound(const Handle(StepGeom_CartesianPoint)& PG)
{
return myVertexMap.IsBound(PG);
}
-// ============================================================================
-// Method : StepToTopoDS_Tool::BindVertex
-// Purpose :
-// ============================================================================
+//=================================================================================================
void StepToTopoDS_Tool::BindVertex(const Handle(StepGeom_CartesianPoint)& P, const TopoDS_Vertex& V)
{
#endif
}
-// ============================================================================
-// Method : StepToTopoDS_Tool::FindVertex
-// Purpose :
-// ============================================================================
+//=================================================================================================
const TopoDS_Vertex& StepToTopoDS_Tool::FindVertex(const Handle(StepGeom_CartesianPoint)& P)
{
return myVertexMap.Find(P);
}
-// ============================================================================
-// Method : ComputePCurve
-// Purpose :
-// ============================================================================
+//=================================================================================================
void StepToTopoDS_Tool::ComputePCurve(const Standard_Boolean B)
{
myComputePC = B;
}
-// ============================================================================
-// Method : ComputePCurve
-// Purpose :
-// ============================================================================
+//=================================================================================================
Standard_Boolean StepToTopoDS_Tool::ComputePCurve() const
{
//: d8
// Used in I-DEAS-like STP processing (ssv; 15.11.2010)
// #define DEBUG
-// ============================================================================
-// Method : DecodeMakeEdgeError
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
static void DecodeMakeEdgeError(const BRepLib_MakeEdge& ME,
const Handle(Standard_Transient)& orig,
const Handle(Geom_Curve)& myCurve,
#endif
}
-// ============================================================================
-// Method : StepToTopoDS_TranslateEdge::StepToTopoDS_TranslateEdge
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
static Handle(Geom_Curve) MakeCurve(const Handle(StepGeom_Curve)& C1,
const Handle(Transfer_TransientProcess)& TP,
#include <XSAlgo.hxx>
#include <XSAlgo_ShapeProcessor.hxx>
-// ============================================================================
-// Method : RemoveSinglePCurve
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
static void RemoveSinglePCurve(const TopoDS_Edge& aEdge, const TopoDS_Face& aFace)
{
ShapeBuild_Edge().RemovePCurve(aEdge, aFace);
}
-// ============================================================================
-// Method : RemovePCurves
-// Purpose :
-// ============================================================================
+//=================================================================================================
static void RemovePCurves(const TopoDS_Wire& aWire, const TopoDS_Face& aFace)
{
}
}
-// ============================================================================
-// Method : StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
StepToTopoDS_TranslateEdgeLoop::StepToTopoDS_TranslateEdgeLoop()
: myError(StepToTopoDS_TranslateEdgeLoopOther)
}
} // namespace
-// ============================================================================
-// Method : StepToTopoDS_TranslateFace
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_TranslateFace::StepToTopoDS_TranslateFace()
: myError(StepToTopoDS_TranslateFaceOther)
{
#include <Transfer_TransientProcess.hxx>
// #include <BRepAPI.hxx>
-// ============================================================================
-// Method :
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_TranslatePolyLoop::StepToTopoDS_TranslatePolyLoop()
: myError(StepToTopoDS_TranslatePolyLoopOther)
{
done = Standard_False;
}
-// ============================================================================
-// Method :
-// Purpose :
-// ============================================================================
+//=================================================================================================
StepToTopoDS_TranslatePolyLoop::StepToTopoDS_TranslatePolyLoop(
const Handle(StepShape_PolyLoop)& PL,
Init(PL, T, S, F, theLocalFactors);
}
-// ============================================================================
-// Method :
-// Purpose :
-// ============================================================================
+//=================================================================================================
void StepToTopoDS_TranslatePolyLoop::Init(const Handle(StepShape_PolyLoop)& PL,
StepToTopoDS_Tool& aTool,
}
}
-// ============================================================================
-// Method :
-// Purpose :
-// ============================================================================
+//=================================================================================================
const TopoDS_Shape& StepToTopoDS_TranslatePolyLoop::Value() const
{
return myResult;
}
-// ============================================================================
-// Method :
-// Purpose :
-// ============================================================================
+//=================================================================================================
StepToTopoDS_TranslatePolyLoopError StepToTopoDS_TranslatePolyLoop::Error() const
{
#include <Transfer_TransientProcess.hxx>
#include <TransferBRep_ShapeBinder.hxx>
-// ============================================================================
-// Method : StepToTopoDS_TranslateShell::StepToTopoDS_TranslateShell
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_TranslateShell::StepToTopoDS_TranslateShell()
: myError(StepToTopoDS_TranslateShellOther)
{
#include <Transfer_TransientProcess.hxx>
#include <TransferBRep_ShapeBinder.hxx>
-// ============================================================================
-// Method : StepToTopoDS_TranslateSolid::StepToTopoDS_TranslateSolid
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_TranslateSolid::StepToTopoDS_TranslateSolid()
: myError(StepToTopoDS_TranslateSolidOther)
{
// #include <BRepAPI.hxx>
// For I-DEAS-like processing (ssv; 15.11.2010)
-// ============================================================================
-// Method : StepToTopoDS_TranslateVertex::StepToTopoDS_TranslateVertex
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_TranslateVertex::StepToTopoDS_TranslateVertex()
: myError(StepToTopoDS_TranslateVertexOther)
{
#include <Transfer_TransientProcess.hxx>
// #include <BRepAPI.hxx>
-// ============================================================================
-// Method : StepToTopoDS_TranslateVertexLoop::StepToTopoDS_TranslateVertexLoop
-// Purpose : Empty Constructor
-// ============================================================================
+//=================================================================================================
+
StepToTopoDS_TranslateVertexLoop::StepToTopoDS_TranslateVertexLoop()
: myError(StepToTopoDS_TranslateVertexLoopOther)
{
#include <TopoDSToStep_Tool.hxx>
#include <Transfer_FinderProcess.hxx>
-// ============================================================================
-// Method : TopoDSToStep_Builder
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
TopoDSToStep_Builder::TopoDSToStep_Builder()
: myError(TopoDSToStep_BuilderOther)
{
done = Standard_False;
}
-// ============================================================================
-// Method : TopoDSToStep_Builder
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
TopoDSToStep_Builder::TopoDSToStep_Builder(const TopoDS_Shape& aShape,
TopoDSToStep_Tool& aTool,
const Handle(Transfer_FinderProcess)& FP,
Init(aShape, aTool, FP, theTessellatedGeomParam, theLocalFactors, theProgress);
}
-// ============================================================================
-// Method : Init
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
void TopoDSToStep_Builder::Init(const TopoDS_Shape& aShape,
TopoDSToStep_Tool& myTool,
const Handle(Transfer_FinderProcess)& FP,
#include <TopoDS_Shape.hxx>
#include <TopoDSToStep_FacetedTool.hxx>
-// ============================================================================
-// Method :
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
TopoDSToStep_FacetedError TopoDSToStep_FacetedTool::CheckTopoDSShape(const TopoDS_Shape& aShape)
{
TopExp_Explorer FaceExp, EdgeExp;
#include <TopoDSToStep_WireframeBuilder.hxx>
#include <Transfer_FinderProcess.hxx>
-// ============================================================================
-// Method : TopoDSToStep_Builder::TopoDSToStep_Builder
-// Purpose :
-// ============================================================================
+//=================================================================================================
+
TopoDSToStep_WireframeBuilder::TopoDSToStep_WireframeBuilder()
: myError(TopoDSToStep_BuilderOther)
{
done = Standard_False;
}
-// ============================================================================
-// Method : TopoDSToStep_Builder::TopoDSToStep_Builder
-// Purpose :
-// ============================================================================
+//=================================================================================================
TopoDSToStep_WireframeBuilder::TopoDSToStep_WireframeBuilder(
const TopoDS_Shape& aShape,
myResult = itemList;
}
-// ============================================================================
-// Method : TopoDSToStep_Builder::Error
-// Purpose :
-// ============================================================================
+//=================================================================================================
TopoDSToStep_BuilderError TopoDSToStep_WireframeBuilder::Error() const
{
return myError;
}
-// ============================================================================
-// Method : TopoDSToStep_Builder::Value
-// Purpose :
-// ============================================================================
+//=================================================================================================
const Handle(TColStd_HSequenceOfTransient)& TopoDSToStep_WireframeBuilder::Value() const
{
static VrmlData_Scene MyDefaultScene;
-//=======================================================================
-// function : IsEqual
-// purpose : Global method
-//=======================================================================
+//=================================================================================================
Standard_Boolean IsEqual(const Handle(VrmlData_Node)& theOne, const Handle(VrmlData_Node)& theTwo)
{
return GetChildren(theNode1).Contains(theNode2);
}
-// =======================================================================
-// function : GetNodeType
-// purpose : Returns node type
-// =======================================================================
+//=================================================================================================
XCAFDoc_AssemblyGraph::NodeType XCAFDoc_AssemblyGraph::GetNodeType(
const Standard_Integer theNode) const
}
}
-//=======================================================================
-// function : UnSetFatherlink
-// purpose : Remove link finily
-//=======================================================================
+//=================================================================================================
void XCAFDoc_GraphNode::UnSetFatherlink(const Handle(XCAFDoc_GraphNode)& F)
{
}
}
-//=======================================================================
-// function : UnSetChildlink
-// purpose : Remove link finily
-//=======================================================================
+//=================================================================================================
void XCAFDoc_GraphNode::UnSetChildlink(const Handle(XCAFDoc_GraphNode)& Ch)
{
return myAdaptorWrite->Recognize(new Transfer_TransientMapper(obj));
}
-//=======================================================================
-// function : TransferFinder
-// purpose : internal function
-//=======================================================================
+//=================================================================================================
static IFSelect_ReturnStatus TransferFinder(const Handle(Transfer_ActorOfFinderProcess)& theActor,
const Handle(Transfer_Finder)& theMapper,
Handle(DDataStd_DrawPresentation)::DownCast(Into)->SetDrawable(myDrawable);
}
-//=======================================================================
-// function : AfterAddition
-// purpose : erase if displayed
-//=======================================================================
+//=================================================================================================
void DDataStd_DrawPresentation::AfterAddition()
{
// if (isDisplayed) DrawDisplay ();
}
-//=======================================================================
-// function : BeforeRemoval
-// purpose : erase if displayed
-//=======================================================================
+//=================================================================================================
void DDataStd_DrawPresentation::BeforeRemoval()
{
// if (isDisplayed) DrawErase ();
}
-//=======================================================================
-// function : BeforeForget
-// purpose : erase if displayed
-//=======================================================================
+//=================================================================================================
void DDataStd_DrawPresentation::BeforeForget()
{
return aLastFun;
}
-//=======================================================================
-// function : GetObjectFromFunction
-// purpose : Returns Object
-//=======================================================================
+//=================================================================================================
+
Handle(TDataStd_UAttribute) DNaming::GetObjectFromFunction(
const Handle(TFunction_Function)& theFunction)
{
static Standard_Real HatcherConfusion2d = 1.e-8;
static Standard_Real HatcherConfusion3d = 1.e-8;
-//=======================================================================
-// Function : DBRep_IsoBuilder
-// Purpose : Constructeur.
-//=======================================================================
+//=================================================================================================
DBRep_IsoBuilder::DBRep_IsoBuilder(const TopoDS_Face& TopologicalFace,
const Standard_Real Infinite,
myIsActive = myStepX > MinimumStep && myStepY > MinimumStep && myStepZ > MinimumStep;
}
-//=======================================================================
-// Function : DrawOn
-// Purpose : Displays the grid.
-//=======================================================================
+//=================================================================================================
void Draw_Grid::DrawOn(Draw_Display& Out) const
{
return true;
}
-//=======================================================================
-// function : Set
-// purpose : set a TCL var
-//=======================================================================
+//=================================================================================================
+
void Draw::Set(const Standard_CString Name, const Standard_CString val)
{
Standard_PCharacter pName, pVal;
Draw::Set(theName, aDrawPoint);
}
-//=======================================================================
-// function : Set
-// purpose : Geometry from Geom
-//=======================================================================
+//=================================================================================================
+
void DrawTrSurf::Set(const Standard_CString theName,
const Handle(Geom_Geometry)& theGeometry,
const Standard_Boolean isSenseMarker)
Draw::Set(theName, aDrawable);
}
-//=======================================================================
-// function : Set
-// purpose : Curve from Geom2d
-//=======================================================================
+//=================================================================================================
+
void DrawTrSurf::Set(const Standard_CString theName,
const Handle(Geom2d_Curve)& theCurve,
const Standard_Boolean isSenseMarker)
{
}
-//=======================================================================
-// function : DrawCurve2dOn
-// purpose : draw a 2D curve
-//=======================================================================
+//=================================================================================================
void DrawTrSurf_Drawable::DrawCurve2dOn(Adaptor2d_Curve2d& C, Draw_Display& aDisplay) const
{
}
}
-//=======================================================================
-// function : DrawCurveOn
-// purpose : draw a 3D curve
-//=======================================================================
+//=================================================================================================
void DrawTrSurf_Drawable::DrawCurveOn(Adaptor3d_Curve& C, Draw_Display& aDisplay) const
{
#include <BRepPrimAPI_MakeSphere.hxx>
#include <BRepAlgoAPI_Section.hxx>
-//=======================================================================
-// function : OCCN2
-// purpose : BOOLEAN OPERATION
-//=======================================================================
+//=================================================================================================
+
static Standard_Integer OCCN2(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
{
if (argc > 2)
}
}
-//=======================================================================
-// function : checkshape
-// purpose : Checks a shape
-//=======================================================================
+//=================================================================================================
+
static Standard_Integer checkshape(Draw_Interpretor& theCommands,
Standard_Integer narg,
const char** a)
return 0;
}
-//=======================================================================
-// function : GLU
-// purpose : Commande glue
-//=======================================================================
+//=================================================================================================
static Standard_Integer GLU(Draw_Interpretor&, Standard_Integer narg, const char** a)
{
return 0.5 * Abs((theP3 - theP1).Crossed(theP2 - theP1));
}
-//=======================================================================
-// function : Perform
-// purpose : Performs checking
-//=======================================================================
+//=================================================================================================
void MeshTest_CheckTopology::Perform(Draw_Interpretor& di)
{
}
//---------------gka
-//=======================================================================
-// function : offset2dcurve
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
+
static Standard_Integer offset2dcurve(Draw_Interpretor& di,
Standard_Integer argc,
const char** argv)
return 0;
}
-//=======================================================================
-// function : offsetcurve
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
+
static Standard_Integer offsetcurve(Draw_Interpretor& di, Standard_Integer argc, const char** argv)
{
if (argc < 5)
return 0;
}
-//=======================================================================
-// function : VFont
-// purpose : Font management
-//=======================================================================
+//=================================================================================================
+
struct FontComparator
{
bool operator()(const Handle(Font_SystemFont)& theFontA, const Handle(Font_SystemFont)& theFontB)
return 0;
}
-//==============================================================================
-// function : VRotate
-// purpose : Camera Rotating
-//==============================================================================
+//=================================================================================================
static int VRotate(Draw_Interpretor& /*theDi*/, Standard_Integer theArgNb, const char** theArgVec)
{
return 0;
}
-//=======================================================================
-// function : noteDeleteAll
-// purpose : deletes all notes
-//=======================================================================
+//=================================================================================================
+
static const cmd XNoteDeleteAll = {"XNoteDeleteAll", 2, "XNoteDeleteAll Doc"};
static Standard_Integer noteDeleteAll(Draw_Interpretor& di,
return Standard_True;
}
-//=============================================================================
-// function : ReadGltf
-// purpose : Reads glTF file
-//=============================================================================
+//=================================================================================================
+
static Standard_Integer ReadGltf(Draw_Interpretor& theDI,
Standard_Integer theNbArgs,
const char** theArgVec)
return 0;
}
-//=============================================================================
-// function : WriteGltf
-// purpose : Writes glTF file
-//=============================================================================
+//=================================================================================================
+
static Standard_Integer WriteGltf(Draw_Interpretor& theDI,
Standard_Integer theNbArgs,
const char** theArgVec)
return Standard_True;
}
-//=============================================================================
-// function : ReadObj
-// purpose : Reads OBJ file
-//=============================================================================
+//=================================================================================================
+
static Standard_Integer ReadObj(Draw_Interpretor& theDI,
Standard_Integer theNbArgs,
const char** theArgVec)
return 0;
}
-///=============================================================================
-// function : WriteObj
-// purpose : Writes OBJ file
-//=============================================================================
+///=================================================================================================
+
static Standard_Integer WriteObj(Draw_Interpretor& theDI,
Standard_Integer theNbArgs,
const char** theArgVec)
#include <XSControl_WorkSession.hxx>
#include <XSDRAW.hxx>
-//=======================================================================
-// function : writeply
-// purpose : write PLY file
-//=======================================================================
+//=================================================================================================
+
static Standard_Integer WritePly(Draw_Interpretor& theDI,
Standard_Integer theNbArgs,
const char** theArgVec)
return 0;
}
-//=============================================================================
-// function : readstl
-// purpose : Reads stl file
-//=============================================================================
+//=================================================================================================
+
static Standard_Integer readstl(Draw_Interpretor& theDI,
Standard_Integer theArgc,
const char** theArgv)
IMPLEMENT_STANDARD_RTTIEXT(Poly_CoherentTriangulation, Standard_Transient)
-//=======================================================================
-// function : Poly_CoherentTriangulation
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
Poly_CoherentTriangulation::Poly_CoherentTriangulation(
const Handle(NCollection_BaseAllocator)& theAlloc)
TopLoc_Location::TopLoc_Location() {}
-//=======================================================================
-// function : TopLoc_Location
-// purpose : constructor Datum
-//=======================================================================
+//=================================================================================================
TopLoc_Location::TopLoc_Location(const Handle(TopLoc_Datum3D)& D)
{
return Transformation();
}
-//=======================================================================
-// function : Inverted
-// purpose : return the inverse
-//=======================================================================
+//=================================================================================================
TopLoc_Location TopLoc_Location::Inverted() const
{
return Other.Inverted().Multiplied(*this);
}
-//=======================================================================
-// function : Powered
-// purpose : power elevation
-//=======================================================================
+//=================================================================================================
TopLoc_Location TopLoc_Location::Powered(const Standard_Integer pwr) const
{
return Inverted().Powered(-pwr);
}
-//=======================================================================
-// function : IsEqual
-// purpose : operator ==
-//=======================================================================
+//=================================================================================================
// two locations are Equal if the Items have the same LocalValues and Powers
// this is a recursive function to test it
static const Standard_Real CGOLD = 0.3819660; // 0.5*(3 - sqrt(5));
-//=======================================================================
-// function : SHFT
-// purpose : Shifts arguments
-//=======================================================================
+//=================================================================================================
+
inline void SHFT(Standard_Real& theA, Standard_Real& theB, Standard_Real& theC, Standard_Real& theD)
{
theA = theB;
}
}
-//=======================================================================
-// function : ReadCompleteInfo
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
+
void FSD_File::ReadCompleteInfo(Standard_IStream& /*theIStream*/, Handle(Storage_Data)& /*theData*/)
{
}
return Handle(TColStd_HSequenceOfHExtendedString)::DownCast(myReportStrings->Value(aFlagIndex));
}
-//=======================================================================
-// function : PrepareReport
-// purpose : static method
-//=======================================================================
+//=================================================================================================
TCollection_ExtendedString Message_Algorithm::PrepareReport(
const Handle(TColStd_HPackedMapOfInteger)& theMapError,
return aNewReport;
}
-//=======================================================================
-// function : PrepareReport
-// purpose : static method
-//=======================================================================
+//=================================================================================================
TCollection_ExtendedString Message_Algorithm::PrepareReport(
const TColStd_SequenceOfHExtendedString& theReportSeq,
}
}
-//=======================================================================
-// function : Allocate
-// purpose : Allocate a memory
-//=======================================================================
+//=================================================================================================
+
void* NCollection_AccAllocator::Allocate(const size_t theSize)
{
const AlignedSize aSize(theSize);
//
}
-//=======================================================================
-// function : Allocate
-// purpose : allocate a memory
-//=======================================================================
+//=================================================================================================
+
void* NCollection_AlignedAllocator::Allocate(const size_t theSize)
{
return Standard::AllocateAligned(theSize, myAlignment);
return Standard::Allocate(theSize);
}
-//=======================================================================
-// function : AllocateOptimal
-// purpose : Optimal allocation
-//=======================================================================
+//=================================================================================================
+
void* NCollection_BaseAllocator::AllocateOptimal(const size_t theSize)
{
return Standard::AllocateOptimal(theSize);
}
}
-//=======================================================================
-// function : PReverse
-// purpose : reverse the list
-//=======================================================================
+//=================================================================================================
void NCollection_BaseList::PReverse()
{
delete myMutex;
}
-//=======================================================================
-// function : AllocateOptimal
-// purpose : allocate a memory
-//=======================================================================
+//=================================================================================================
+
void* NCollection_IncAllocator::AllocateOptimal(const size_t theSize)
{
Standard_Mutex::Sentry aLock(myMutex);
return aRes;
}
-//=======================================================================
-// function : Allocate
-// purpose : Allocate a memory
-//=======================================================================
+//=================================================================================================
+
void* NCollection_IncAllocator::Allocate(const size_t theSize)
{
return AllocateOptimal(theSize);
#include <windows.h>
#endif
-//=======================================================================
-// function : NCollection_WinHeapAllocator
-// purpose : Main constructor
-//=======================================================================
+//=================================================================================================
+
NCollection_WinHeapAllocator::NCollection_WinHeapAllocator(const size_t theInitSizeBytes)
: NCollection_BaseAllocator(),
#if (defined(_WIN32) || defined(__WIN32__))
static BOOL __fastcall _get_file_time(const wchar_t*, LPSYSTEMTIME, BOOL);
static void __fastcall _test_raise(TCollection_AsciiString, Standard_CString);
-//=======================================================================
-// function : OSD_FileNode
-// purpose : Empty Constructor
-//=======================================================================
+//=================================================================================================
OSD_FileNode::OSD_FileNode() {}
SetDraft();
}
-//=======================================================================
-// function :SetOptions
-// purpose : Defines the style
-//======================================================================
+//=================================================================================================
+
void BRepFill_Draft::SetOptions(const BRepFill_TransitionStyle Style,
const Standard_Real Min,
const Standard_Real Max)
return myIsDone;
}
-//=======================================================================
-// function : Face
-// purpose : returns the result
-//======================================================================
+//=================================================================================================
+
TopoDS_Face BRepFill_Filling::Face() const
{
return myFace;
IMPLEMENT_STANDARD_RTTIEXT(BRepFill_LocationLaw, Standard_Transient)
-//=======================================================================
-// function : Norm
-// purpose : Norm of a Matrix
-//=======================================================================
+//=================================================================================================
+
static Standard_Real Norm(const gp_Mat& M)
{
Standard_Real R, Norme;
myForceApproxC1 = ForceApproxC1;
}
-//=======================================================================
-// function : Add
-// purpose : Add a Section
-//=======================================================================
+//=================================================================================================
+
void BRepFill_PipeShell::Add(const TopoDS_Shape& Profile,
const Standard_Boolean WithContact,
const Standard_Boolean WithCorrection)
ResetLoc();
}
-//=======================================================================
-// function : Add
-// purpose : Add a Section
-//=======================================================================
+//=================================================================================================
+
void BRepFill_PipeShell::Add(const TopoDS_Shape& Profile,
const TopoDS_Vertex& Location,
const Standard_Boolean WithContact,
ResetLoc();
}
-//=======================================================================
-// function : Delete
-// purpose : Delete a section
-//=======================================================================
+//=================================================================================================
+
void BRepFill_PipeShell::DeleteProfile(const TopoDS_Shape& Profile)
{
Standard_Boolean Trouve = Standard_False;
return B;
}
-//=======================================================================
-// function : Shape
-// purpose : Return the result
-//=======================================================================
+//=================================================================================================
+
const TopoDS_Shape& BRepFill_PipeShell::Shape() const
{
return myShape;
myDone = Standard_True;
}
-//=======================================================================
-// function : Create
-// purpose : Evolutive Wire
-//=======================================================================
+//=================================================================================================
BRepFill_ShapeLaw::BRepFill_ShapeLaw(const TopoDS_Wire& W,
const Handle(Law_Function)& L,
BuildSection(Shape, CylSurf.Shape());
}
-//=======================================================================
-// function : BRepProj_Projection
-// purpose : Conical projection
-//=======================================================================
+//=================================================================================================
BRepProj_Projection::BRepProj_Projection(const TopoDS_Shape& Wire,
const TopoDS_Shape& Shape,
myMapShapeStatus.Clear();
}
-//=======================================================================
-// function : ChkIntg
-// purpose : Check Integrity
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean CheckEdgeParameter(const Handle(TopOpeBRepDS_HDataStructure)& myHDS);
Standard_Boolean TopOpeBRepDS_Check::ChkIntg()
}
}
-//=======================================================================
-// function : ChkIntg
-// purpose : Check Integrity
-//=======================================================================
+//=================================================================================================
+
void TopOpeBRepDS_HDataStructure::ChkIntg()
{
// Check the integrity of the DS
}
}
-//=======================================================================
-// function : Perform
-// purpose : feature of Height
-//=======================================================================
+//=================================================================================================
void BRepFeat_MakeDPrism::Perform(const Standard_Real Height)
{
}
}
-//=======================================================================
-// function : Perform
-// purpose : till shape Until
-//=======================================================================
+//=================================================================================================
void BRepFeat_MakePipe::Perform(const TopoDS_Shape& Until)
{
}
}
-//=======================================================================
-// function : Add
-// purpose : static function
-//=======================================================================
+//=================================================================================================
static void Add(const Standard_Integer ind,
TColStd_MapOfInteger& mapI,
}
}
-//=======================================================================
-// function : Propagate
-// purpose : static function
-//=======================================================================
+//=================================================================================================
static void Propagate(const TopoDS_Shape& F,
TopoDS_Shape& Sh,
}
}
-//=======================================================================
-// function : IsInside
-// purpose : static function
-//=======================================================================
+//=================================================================================================
static Standard_Boolean IsInside(const TopoDS_Shape& S1, const TopoDS_Shape& S2)
{
}
}
-//=======================================================================
-// function : Recadre1
-// purpose : Contact lost on 1
-//=======================================================================
+//=================================================================================================
Standard_Boolean BRepBlend_RstRstLineBuilder::Recadre1(Blend_RstRstFunction& Func,
Blend_SurfCurvFuncInv& Finv,
return tg2d;
}
-//=======================================================================
-// function : DerFguide
-// purpose : dF/dw
-//=======================================================================
+//=================================================================================================
void BlendFunc_Corde::DerFguide(const math_Vector& Sol, gp_Vec2d& DerF)
{
return ChoixConge;
}
-//=======================================================================
-// function : NextSide
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
Standard_Integer ChFi3d::NextSide(TopAbs_Orientation& Or1,
TopAbs_Orientation& Or2,
return ChoixConge;
}
-//=======================================================================
-// function : NextSide
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
void ChFi3d::NextSide(TopAbs_Orientation& Or,
const TopAbs_Orientation OrSave,
}
}
-//=======================================================================
-// function : SameSide
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
Standard_Boolean ChFi3d::SameSide(const TopAbs_Orientation Or,
const TopAbs_Orientation OrSave1,
return SC1;
}
-//=======================================================================
-// function : TrsfTrans
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
+
TopAbs_Orientation ChFi3d_TrsfTrans(const IntSurf_TypeTrans T1)
{
switch (T1)
}
}
#endif
-//=======================================================================
-// function : SearchIndex
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
+
static Standard_Integer SearchIndex(const Standard_Real Value, Handle(BRepBlend_Line)& Lin)
{
Standard_Integer NbPnt = Lin->NbPoints(), Ind;
return Ind;
}
-//=======================================================================
-// function : IsObst
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
+
static Standard_Integer nbedconnex(const TopTools_ListOfShape& L)
{
Standard_Integer nb = 0, i = 0;
return !IsVois(E, Vref, VEMap, DONE, 0, prof);
}
-//=======================================================================
-// function : CompParam
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
static void CompParam(const Geom2dAdaptor_Curve& Carc,
Handle(Geom2d_Curve) Ctg,
#include <Precision.hxx>
#include <TopOpeBRepDS_DataStructure.hxx>
-//=======================================================================
-// function : MakeFillet
-// Purpose : cas plan/plan.
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean ChFiKPart_MakeFillet(TopOpeBRepDS_DataStructure& DStr,
const Handle(ChFiDS_SurfData)& Data,
const gp_Pln& Pl1,
#include <Precision.hxx>
#include <TopOpeBRepDS_DataStructure.hxx>
-//=======================================================================
-// function : MakeRotule
-// Purpose : cas plan/plan.
-//=======================================================================
+//=================================================================================================
+
Standard_Boolean ChFiKPart_MakeRotule(TopOpeBRepDS_DataStructure& DStr,
const Handle(ChFiDS_SurfData)& Data,
const gp_Pln& pl,
#include <Geom2dAdaptor_Curve.hxx>
-//=======================================================================
-// Function : Geom2dHatch_Element
-// Purpose : Empty Constructor.
-//=======================================================================
+//=================================================================================================
Geom2dHatch_Element::Geom2dHatch_Element() {}
//=======================================================================
//=======================================================================
-//=======================================================================
-// Function : Dump
-// Purpose : Dumps the hatcher.
-//=======================================================================
+//=================================================================================================
void Geom2dHatch_Hatcher::Dump() const
{
return Standard_True;
}
-//=======================================================================
-// function : SetSameDistribution
-// purpose : Internal Use Only
-//=======================================================================
+//=================================================================================================
static Standard_Integer SetSameDistribution(Handle(Geom_BSplineCurve)& C1,
Handle(Geom_BSplineCurve)& C2)
} // for_ii
}
-//==================================================================
-// Function: GetCurve
-// Purpose : return the path
-//==================================================================
+//=================================================================================================
+
const Handle(Adaptor3d_Curve)& GeomFill_LocationDraft::GetCurve() const
{
return myCurve;
myLaw = L;
}
-//===============================================================
-// Function : Perform
-// Purpose : Le plus simple
-//===============================================================
+//=================================================================================================
+
void GeomFill_SectionPlacement::Perform(const Standard_Real Tol)
{
Handle(Adaptor3d_Curve) Path;
return (myParam - Point.myParam > Confusion);
}
-//=======================================================================
-// Function : Dump
-// Purpose : Dump of the point.
-//=======================================================================
+//=================================================================================================
void HatchGen_PointOnHatching::Dump(const Standard_Integer Index) const
{
static const int Pourcent3[9] = {0, 1, 2, 0, 1, 2, 0, 1, 2};
-//=======================================================================
-// function : IntPatch_InterferencePolyhedron
-// purpose : Empty constructor.
-//=======================================================================
+//=================================================================================================
IntPatch_InterferencePolyhedron::IntPatch_InterferencePolyhedron()
: Intf_Interference(Standard_False),
static const Standard_Real PRCANG = Precision::Angular();
}
-//=======================================================================
-// function : Intf_InterferencePolygon2d
-// purpose : constructor empty
-//=======================================================================
+//=================================================================================================
Intf_InterferencePolygon2d::Intf_InterferencePolygon2d()
: Intf_Interference(Standard_False),
}
}
-//=======================================================================
-// function : CheckCurveData
-// purpose : Internal use only
-//=======================================================================
+//=================================================================================================
static void CheckCurveData(const TColStd_Array1OfReal& CPoles,
const TColStd_Array1OfReal& CKnots,
throw Standard_ConstructionError();
}
-//=======================================================================
-// function : KnotAnalysis
-// purpose : Internal use only
-//=======================================================================
+//=================================================================================================
static void KnotAnalysis(const Standard_Integer Degree,
const Standard_Boolean Periodic,
#define SAME 0
#define LOWER -1
-//=======================================================================
-// function : TopTrans_CurveTransition
-// purpose : Empty Constructor.
-//=======================================================================
+//=================================================================================================
TopTrans_CurveTransition::TopTrans_CurveTransition()
: myCurv(0.0),
return OneBefore;
}
-//=======================================================================
-// function : Compare
-// purpose : Compare two angles
-//=======================================================================
+//=================================================================================================
Standard_Integer TopTrans_CurveTransition::Compare(const Standard_Real Ang1,
const Standard_Real Ang2,
return bMicro;
}
-//=======================================================================
-// function : UpdateOrigins
-// purpose : Updating origins
-//=======================================================================
+//=================================================================================================
+
static void UpdateOrigins(const TopTools_ListOfShape& theLA,
TopTools_DataMapOfShapeListOfShape& theOrigins,
BOPAlgo_Builder& theGF)
return newPCurve;
}
-//=======================================================================
-// function : Glue
-// purpose : glue two edges.
-//=======================================================================
+//=================================================================================================
static TopoDS_Edge Glue(const TopoDS_Edge& E1,
const TopoDS_Edge& E2,
return myPipe.LastShape();
}
-//=======================================================================
-// function : Generated
-// purpose : standard method
-//=======================================================================
+//=================================================================================================
+
const TopTools_ListOfShape& BRepOffsetAPI_MakePipe::Generated(const TopoDS_Shape& S)
{
myPipe.Generated(S, myGenerated);
S.Closed(Standard_True);
}
-//=======================================================================
-// function : MakeFace
-// purpose : Make a Planar Face
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::MakeFace(TopoDS_Face& F, const gp_Pln& P) const
{
myBuilder.MakeFace(F, new Geom_Plane(P), Precision::Confusion());
}
-//=======================================================================
-// function : MakeWire
-// purpose : Make an empty Wire
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::MakeWire(TopoDS_Wire& W) const
{
myBuilder.Degenerated(E, Standard_True);
}
-//=======================================================================
-// function : MakeEdge
-// purpose : Make a linear Edge
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::MakeEdge(TopoDS_Edge& E, const gp_Lin& L) const
{
myBuilder.UpdateEdge(E, new Geom2d_Circle(C), F, Precision::Confusion());
}
-//=======================================================================
-// function : MakeVertex
-// purpose : Make a Vertex
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::MakeVertex(TopoDS_Vertex& V, const gp_Pnt& P) const
{
myBuilder.MakeVertex(V, P, Precision::Confusion());
}
-//=======================================================================
-// function : ReverseFace
-// purpose : Reverse a Face
-//=======================================================================
+//=================================================================================================
void BRepPrim_Builder::ReverseFace(TopoDS_Face& F) const
{
BRepPrim_Wedge_Init(ShellBuilt, VerticesBuilt, EdgesBuilt, WiresBuilt, FacesBuilt);
}
-//=======================================================================
-// function : BRepPrim_GWedge
-// purpose : build a STEP wedge
-//=======================================================================
+//=================================================================================================
BRepPrim_GWedge::BRepPrim_GWedge(const BRepPrim_Builder& B,
const gp_Ax2& Axes,
IMPLEMENT_STANDARD_RTTIEXT(ShapeAnalysis_FreeBoundData, Standard_Transient)
-//=======================================================================
-// function : ShapeAnalysis_FreeBoundData
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
+
ShapeAnalysis_FreeBoundData::ShapeAnalysis_FreeBoundData()
{
myNotches = new TopTools_HSequenceOfShape();
#include <TopTools_MapOfShape.hxx>
// ied_modif_for_compil_Nov-19-1998
-//=======================================================================
-// function : ShapeAnalysis_FreeBounds
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
+
ShapeAnalysis_FreeBounds::ShapeAnalysis_FreeBounds() {}
//=================================================================================================
countourLength = length;
}
-//=======================================================================
-// function : ShapeAnalysis_FreeBoundsProperties
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
ShapeAnalysis_FreeBoundsProperties::ShapeAnalysis_FreeBoundsProperties()
{
return Standard_True;
}
-//=======================================================================
-// method : IsDegenerated
-// purpose:
-//=======================================================================
+//=================================================================================================
Standard_Boolean ShapeAnalysis_Surface::IsDegenerated(const gp_Pnt2d& p2d1,
const gp_Pnt2d& p2d2,
return Standard_True;
}
-//=======================================================================
-// function : CheckLacking
-// purpose :
-//
-//=======================================================================
+//=================================================================================================
Standard_Boolean ShapeAnalysis_Wire::CheckLacking(const Standard_Integer num,
const Standard_Real Tolerance)
aFace.SetEdge(theIDCurvOnFace, anEdge.myID);
}
-//=======================================================================
-// function : CreateNewEdge
-// purpose : Creates FS_Edge
-//=======================================================================
+//=================================================================================================
+
void BRepBuilderAPI_FastSewing::CreateNewEdge(const Standard_Integer theIDPrevVertex,
const Standard_Integer theIDCurrVertex,
const Standard_Integer theFaceID,
}*/
}
-//=======================================================================
-// function : IsMergedClosed
-// purpose : internal use
-//=======================================================================
+//=================================================================================================
Standard_Boolean BRepBuilderAPI_Sewing::IsMergedClosed(const TopoDS_Edge& Edge1,
const TopoDS_Edge& Edge2,
}
}
-//=======================================================================
-// function : IsDegeneratedWire
-// purpose : internal use
-//=======================================================================
+//=================================================================================================
static Standard_Boolean IsDegeneratedWire(const TopoDS_Shape& wire)
{
return Standard_False;
}
-//=======================================================================
-// function : Closed2d
-// purpose : for periodic faces
-//=======================================================================
+//=================================================================================================
+
BRepCheck_Status BRepCheck_Wire::Closed2d(const TopoDS_Face& theFace, const Standard_Boolean Update)
{
Handle(BRepCheck_HListOfStatus) aHList;
return Standard_True;
}
-//=======================================================================
-// function : initNodes
-// purpose : Initializes nodes
-//=======================================================================
+//=================================================================================================
+
void BRepExtrema_TriangleSet::initNodes(const TColgp_Array1OfPnt& theNodes,
const gp_Trsf& theTrsf,
const Standard_Integer theIndex)
{
}
-//=======================================================================
-// function : Inertia::Reset
-// purpose : Zeroes all values.
-//=======================================================================
+//=================================================================================================
+
void BRepGProp_Gauss::Inertia::Reset()
{
memset(reinterpret_cast<void*>(this), 0, sizeof(BRepGProp_Gauss::Inertia));
static void CutSketch(MAT2d_SequenceOfSequenceOfGeometry& Figure,
MAT2d_DataMapOfBiIntInteger& NbSect);
-//=============================================================================
-// function : BRepMAT2d_BisectingLocus
-// purpose : Constructeur vide.
-//=============================================================================
+//=================================================================================================
+
BRepMAT2d_BisectingLocus::BRepMAT2d_BisectingLocus()
: isDone(Standard_False),
nbContours(0)
// Modified by Sergey KHROMOV - Wed Mar 6 17:40:14 2002 End
//
-//=======================================================================
-// function : GetCurveType
-// purpose : Get curve type.
-//=======================================================================
+//=================================================================================================
GeomAbs_CurveType GetCurveType(const Handle(Geom2d_Curve)& theC2d)
{
bisector2 = B2;
}
-//=============================================================================
-// function : Value
-// purpose :
-///=============================================================================
+//=================================================================================================
+
Standard_Boolean Bisector_FunctionInter::Value(const Standard_Real X, Standard_Real& F)
{
gp_Pnt2d PC = curve->Value(X);
IMPLEMENT_STANDARD_RTTIEXT(Geom2d_BSplineCurve, Geom2d_BoundedCurve)
-//=======================================================================
-// function : CheckCurveData
-// purpose : Internal use only
-//=======================================================================
+//=================================================================================================
+
static void CheckCurveData(const TColgp_Array1OfPnt2d& CPoles,
const TColStd_Array1OfReal& CKnots,
const TColStd_Array1OfInteger& CMults,
Init(npoles, nweights);
}
-//=======================================================================
-// function : Increase
-// purpose : increase degree
-//=======================================================================
+//=================================================================================================
void Geom2d_BezierCurve::Increase(const Standard_Integer Deg)
{
}
}
-//=======================================================================
-// function :LocatePart_RevExt
-// purpose : processes Knots
-//=======================================================================
+//=================================================================================================
Standard_Boolean Adaptor3d_CurveOnSurface::LocatePart_RevExt(const gp_Pnt2d& UV,
const gp_Vec2d& DUV,
return Ok;
}
-//=======================================================================
-// function :LocatePart
-// purpose : for BSplineSurface
-//=======================================================================
+//=================================================================================================
void Adaptor3d_CurveOnSurface::LocatePart(const gp_Pnt2d& UV,
const gp_Vec2d& DUV,
IMPLEMENT_STANDARD_RTTIEXT(Geom_BSplineCurve, Geom_BoundedCurve)
-//=======================================================================
-// function : CheckCurveData
-// purpose : Internal use only
-//=======================================================================
+//=================================================================================================
+
static void CheckCurveData(const TColgp_Array1OfPnt& CPoles,
const TColStd_Array1OfReal& CKnots,
const TColStd_Array1OfInteger& CMults,
IMPLEMENT_STANDARD_RTTIEXT(Geom_BSplineSurface, Geom_BoundedSurface)
-//=======================================================================
-// function : CheckSurfaceData
-// purpose : Internal use only.
-//=======================================================================
+//=================================================================================================
+
static void CheckSurfaceData(const TColgp_Array2OfPnt& SPoles,
const TColStd_Array1OfReal& SUKnots,
const TColStd_Array1OfReal& SVKnots,
throw Standard_ConstructionError("Geom_BSplineSurface: # V Poles and degree mismatch");
}
-//=======================================================================
-// function : Rational
-// purpose : Internal use only.
-//=======================================================================
+//=================================================================================================
static void Rational(const TColStd_Array2OfReal& Weights,
Standard_Boolean& Urational,
Init(npoles, nweights);
}
-//=======================================================================
-// function : Increase
-// purpose : increase degree
-//=======================================================================
+//=================================================================================================
void Geom_BezierCurve::Increase(const Standard_Integer Deg)
{
}
}
-//=======================================================================
-// function : AddPoleCol
-// purpose : Internal use only.
-//=======================================================================
+//=================================================================================================
static void AddPoleCol(const TColgp_Array2OfPnt& Poles,
const TColgp_Array1OfPnt& PoleCol,
}
}
-//=======================================================================
-// function : AddRatPoleCol
-// purpose : Internal use only.
-//=======================================================================
+//=================================================================================================
static void AddRatPoleCol(const TColgp_Array2OfPnt& Poles,
const TColStd_Array2OfReal& Weights,
}
}
-//=======================================================================
-// function : AddPoleRow
-// purpose : Internal use only.
-//=======================================================================
+//=================================================================================================
static void AddPoleRow(const TColgp_Array2OfPnt& Poles,
const TColgp_Array1OfPnt& PoleRow,
return CPnts_AbscissaPoint::Length(C, C.FirstParameter(), C.LastParameter());
}
-//=======================================================================
-// function : Length
-// purpose : 3d with tolerance
-//=======================================================================
+//=================================================================================================
Standard_Real CPnts_AbscissaPoint::Length(const Adaptor3d_Curve& C, const Standard_Real Tol)
{
return CPnts_AbscissaPoint::Length(C, C.FirstParameter(), C.LastParameter(), Tol);
}
-//=======================================================================
-// function : Length
-// purpose : 2d with tolerance
-//=======================================================================
+//=================================================================================================
Standard_Real CPnts_AbscissaPoint::Length(const Adaptor2d_Curve2d& C, const Standard_Real Tol)
{
return CPnts_AbscissaPoint::Length(C, C.FirstParameter(), C.LastParameter(), Tol);
}
-//=======================================================================
-// function : Length
-// purpose : 3d with parameters
-//=======================================================================
+//=================================================================================================
Standard_Real CPnts_AbscissaPoint::Length(const Adaptor3d_Curve& C,
const Standard_Real U1,
return Abs(TheLength.Value());
}
-//=======================================================================
-// function : Length
-// purpose : 2d with parameters
-//=======================================================================
+//=================================================================================================
Standard_Real CPnts_AbscissaPoint::Length(const Adaptor2d_Curve2d& C,
const Standard_Real U1,
throw Standard_NotImplemented();
}
-//=======================================================================
-// function : Extrema_ExtElCS
-// purpose : Circle/Sphere
-//=======================================================================
+//=================================================================================================
+
Extrema_ExtElCS::Extrema_ExtElCS(const gp_Circ& C, const gp_Sphere& S)
{
Perform(C, S);
}
-//=======================================================================
-// function : Perform
-// purpose : Circle/Sphere
-//=======================================================================
+//=================================================================================================
+
void Extrema_ExtElCS::Perform(const gp_Circ& C, const gp_Sphere& S)
{
myDone = Standard_False;
#include <gp_Pnt2d.hxx>
#include <gp_Trsf2d.hxx>
-// ============================================================================
-// Method : RadianToDegree
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Handle(Geom2d_Curve) GeomConvert_Units::RadianToDegree(const Handle(Geom2d_Curve)& theCurve2d,
const Handle(Geom_Surface)& theSurf,
const Standard_Real theLengthFactor,
return aPcurve;
}
-// ============================================================================
-// Method : MirrorPCurve
-// Purpose:
-// ============================================================================
+//=================================================================================================
+
Handle(Geom2d_Curve) GeomConvert_Units::MirrorPCurve(const Handle(Geom2d_Curve)& theCurve)
{
Handle(Geom2d_Curve) theMirrored = Handle(Geom2d_Curve)::DownCast(theCurve->Copy());
return aDist;
}
-//=======================================================================
-// function : IntAna_QuadQuadGeo
-// purpose : Empty constructor
-//=======================================================================
+//=================================================================================================
+
IntAna_QuadQuadGeo::IntAna_QuadQuadGeo(void)
: done(Standard_False),
nbint(0),
}
}
-//=======================================================================
-// function : Point
-// purpose : Returns a Point
-//=======================================================================
+//=================================================================================================
+
gp_Pnt IntAna_QuadQuadGeo::Point(const Standard_Integer n) const
{
if (!done)
return gp_Pnt(0, 0, 0);
}
-//=======================================================================
-// function : Line
-// purpose : Returns a Line
-//=======================================================================
+//=================================================================================================
+
gp_Lin IntAna_QuadQuadGeo::Line(const Standard_Integer n) const
{
if (!done)
}
}
-//=======================================================================
-// function : Circle
-// purpose : Returns a Circle
-//=======================================================================
+//=================================================================================================
+
gp_Circ IntAna_QuadQuadGeo::Circle(const Standard_Integer n) const
{
if (!done)
}
}
-//=======================================================================
-// function : Ellipse
-// purpose : Returns a Elips
-//=======================================================================
+//=================================================================================================
+
gp_Elips IntAna_QuadQuadGeo::Ellipse(const Standard_Integer n) const
{
if (!done)
}
}
-//=======================================================================
-// function : Parabola
-// purpose : Returns a Parabola
-//=======================================================================
+//=================================================================================================
+
gp_Parab IntAna_QuadQuadGeo::Parabola(const Standard_Integer n) const
{
if (!done)
IMPLEMENT_STANDARD_RTTIEXT(IVtkOCC_SelectableObject, SelectMgr_SelectableObject)
-//============================================================================
-// Method: Constructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkOCC_SelectableObject::IVtkOCC_SelectableObject(const IVtkOCC_Shape::Handle& theShape)
: SelectMgr_SelectableObject(PrsMgr_TOP_AllView),
myShape(theShape)
}
}
-//============================================================================
-// Method: Constructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkOCC_SelectableObject::IVtkOCC_SelectableObject()
: SelectMgr_SelectableObject(PrsMgr_TOP_AllView)
{
//
}
-//============================================================================
-// Method: Destructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkOCC_SelectableObject::~IVtkOCC_SelectableObject()
{
//
}
-//============================================================================
-// Method: SetShape
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkOCC_SelectableObject::SetShape(const IVtkOCC_Shape::Handle& theShape)
{
myShape = theShape;
myselections.Clear();
}
-//============================================================================
-// Method: ComputeSelection
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkOCC_SelectableObject::ComputeSelection(const Handle(SelectMgr_Selection)& theSelection,
const Standard_Integer theMode)
{
}
}
-//============================================================================
-// Method: BoundingBox
-// Purpose:
-//============================================================================
+//=================================================================================================
+
const Bnd_Box& IVtkOCC_SelectableObject::BoundingBox()
{
if (myShape.IsNull())
return myBndBox;
}
-//============================================================================
-// Method: BoundingBox
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkOCC_SelectableObject::BoundingBox(Bnd_Box& theBndBox)
{
BoundingBox();
IMPLEMENT_STANDARD_RTTIEXT(IVtkOCC_Shape, IVtk_IShape)
-//============================================================================
-// Method: Constructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkOCC_Shape::IVtkOCC_Shape(const TopoDS_Shape& theShape,
const Handle(Prs3d_Drawer)& theDrawerLink)
: myTopoDSShape(theShape),
buildSubShapeIdMap();
}
-//============================================================================
-// Method: Destructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkOCC_Shape::~IVtkOCC_Shape() {}
-//============================================================================
-// Method: GetSubShapeId
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtk_IdType IVtkOCC_Shape::GetSubShapeId(const TopoDS_Shape& theSubShape) const
{
Standard_Integer anIndex =
return (IVtk_IdType)anIndex;
}
-//============================================================================
-// Method: getSubIds
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtk_ShapeIdList IVtkOCC_Shape::GetSubIds(const IVtk_IdType theId) const
{
IVtk_ShapeIdList aRes;
return aRes;
}
-//============================================================================
-// Method: GetSubShape
-// Purpose:
-//============================================================================
+//=================================================================================================
+
const TopoDS_Shape& IVtkOCC_Shape::GetSubShape(const IVtk_IdType theId) const
{
return mySubShapeIds.FindKey((Standard_Integer)theId);
IMPLEMENT_STANDARD_RTTIEXT(IVtkOCC_ViewerSelector, SelectMgr_ViewerSelector)
-//============================================================================
-// Method: Constructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkOCC_ViewerSelector::IVtkOCC_ViewerSelector()
: SelectMgr_ViewerSelector(),
myPixTol(2),
{
}
-//============================================================================
-// Method: Destructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkOCC_ViewerSelector::~IVtkOCC_ViewerSelector() {}
-//============================================================================
-// Method: ConvertVtkToOccCamera
-// Purpose:
-//============================================================================
+//=================================================================================================
+
Handle(Graphic3d_Camera) IVtkOCC_ViewerSelector::ConvertVtkToOccCamera(
const IVtk_IView::Handle& theView)
{
TraverseSensitives(-1);
}
-//============================================================================
-// Method: Pick
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkOCC_ViewerSelector::Pick(double** thePoly,
const int theNbPoints,
const IVtk_IView::Handle& theView)
myModesDefinition[DM_Shading] = aTypes;
}
-//============================================================================
-// Method: Destructor
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkTools_DisplayModeFilter::~IVtkTools_DisplayModeFilter() {}
//============================================================================
return Superclass::RequestData(theRequest, theInputVector, theOutputVector);
}
-//============================================================================
-// Method: PrintSelf
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkTools_DisplayModeFilter::PrintSelf(std::ostream& theOs, vtkIndent theIndent)
{
this->Superclass::PrintSelf(theOs, theIndent);
}
}
-//============================================================================
-// Method: SetDisplaySharedVertices
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkTools_DisplayModeFilter::SetDisplaySharedVertices(const bool theDoDisplay)
{
if (myDoDisplaySharedVertices != theDoDisplay)
}
}
-//============================================================================
-// Method: SetDisplayMode
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkTools_DisplayModeFilter::SetDisplayMode(const IVtk_DisplayMode theMode)
{
if (myDisplayMode != theMode)
}
}
-//============================================================================
-// Method: GetDisplayMode
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtk_DisplayMode IVtkTools_DisplayModeFilter::GetDisplayMode() const
{
return myDisplayMode;
}
-//============================================================================
-// Method: meshTypesForMode
-// Purpose:
-//============================================================================
+//=================================================================================================
+
const IVtk_IdTypeMap& IVtkTools_DisplayModeFilter::MeshTypesForMode(IVtk_DisplayMode theMode) const
{
return myModesDefinition[theMode];
}
-//============================================================================
-// Method: setMeshTypesForMode
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkTools_DisplayModeFilter::SetMeshTypesForMode(IVtk_DisplayMode theMode,
const IVtk_IdTypeMap& theMeshTypes)
{
Modified();
}
-//============================================================================
-// Method: SetFaceBoundaryDraw
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkTools_DisplayModeFilter::SetFaceBoundaryDraw(bool theToDraw)
{
myDrawFaceBoundaries = theToDraw;
Modified();
}
-//============================================================================
-// Method: SetSmoothShading
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkTools_DisplayModeFilter::SetSmoothShading(bool theIsSmooth)
{
if (myIsSmoothShading != theIsSmooth)
//============================================================================
IVtkTools_ShapeObject::~IVtkTools_ShapeObject() {}
-//============================================================================
-// Method: SetShapeSource
-// Purpose:
-//============================================================================
+//=================================================================================================
+
void IVtkTools_ShapeObject::SetShapeSource(IVtkTools_ShapeDataSource* theDataSource)
{
myShapeSource = theDataSource;
}
-//============================================================================
-// Method: GetShapeSource
-// Purpose:
-//============================================================================
+//=================================================================================================
+
IVtkTools_ShapeDataSource* IVtkTools_ShapeObject::GetShapeSource() const
{
return myShapeSource;
#include <OpenGl_Texture.hxx>
#include <OpenGl_View.hxx>
-// =======================================================================
-// method : Constructor
-// purpose :
-// =======================================================================
+//=================================================================================================
+
OpenGl_BackgroundArray::OpenGl_BackgroundArray(const Graphic3d_TypeOfBackground theType)
: OpenGl_PrimitiveArray(NULL, Graphic3d_TOPA_TRIANGLES, NULL, NULL, NULL),
myType(theType),
myGradientParams.type = Aspect_GradientFillMethod_None;
}
-// =======================================================================
-// method : SetTextureParameters
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_BackgroundArray::SetTextureParameters(const Aspect_FillMethod theFillMethod)
{
if (myType != Graphic3d_TOB_TEXTURE)
invalidateData();
}
-// =======================================================================
-// method : SetTextureFillMethod
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_BackgroundArray::SetTextureFillMethod(const Aspect_FillMethod theFillMethod)
{
myFillMethod = theFillMethod;
invalidateData();
}
-// =======================================================================
-// method : SetGradientParameters
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_BackgroundArray::SetGradientParameters(const Quantity_Color& theColor1,
const Quantity_Color& theColor2,
const Aspect_GradientFillMethod theType)
invalidateData();
}
-// =======================================================================
-// method : SetGradientFillMethod
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_BackgroundArray::SetGradientFillMethod(const Aspect_GradientFillMethod theType)
{
if (myType != Graphic3d_TOB_GRADIENT)
invalidateData();
}
-// =======================================================================
-// method : IsDefined
-// purpose :
-// =======================================================================
+//=================================================================================================
+
bool OpenGl_BackgroundArray::IsDefined() const
{
switch (myType)
return Standard_False;
}
-// =======================================================================
-// method : invalidateData
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_BackgroundArray::invalidateData()
{
myToUpdate = Standard_True;
}
-// =======================================================================
-// method : init
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean OpenGl_BackgroundArray::init(const Handle(OpenGl_Workspace)& theWorkspace) const
{
const Handle(OpenGl_Context)& aCtx = theWorkspace->GetGlContext();
return Standard_True;
}
-// =======================================================================
-// method : createGradientArray
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean OpenGl_BackgroundArray::createGradientArray(
const Handle(OpenGl_Context)& theCtx) const
{
return Standard_True;
}
-// =======================================================================
-// method : createTextureArray
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean OpenGl_BackgroundArray::createTextureArray(
const Handle(OpenGl_Workspace)& theWorkspace) const
{
return Standard_True;
}
-// =======================================================================
-// method : createCubeMapArray
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_Boolean OpenGl_BackgroundArray::createCubeMapArray() const
{
const Graphic3d_Attribute aCubeMapAttribInfo[] = {{Graphic3d_TOA_POS, Graphic3d_TOD_VEC3}};
return Standard_True;
}
-// =======================================================================
-// method : Render
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_BackgroundArray::Render(const Handle(OpenGl_Workspace)& theWorkspace,
Graphic3d_Camera::Projection theProjection) const
{
return aD2.Modulus() / (float)aViewport[2];
}
-// =======================================================================
-// method : getDistancetoCorner
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_ShortReal OpenGl_GraduatedTrihedron::getDistanceToCorner(
const OpenGl_Vec3& theNormal,
const OpenGl_Vec3& theCenter,
+ theNormal.z() * (theZ - theCenter.z());
}
-// =======================================================================
-// method : getGridAxes
-// purpose :
-// =======================================================================
+//=================================================================================================
+
Standard_ExtCharacter OpenGl_GraduatedTrihedron::getGridAxes(const Standard_ShortReal theCorners[8],
GridAxes& theGridAxes) const
{
aContext->ApplyWorldViewMatrix();
}
-// =======================================================================
-// method : SetMinMax
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_GraduatedTrihedron::SetMinMax(const OpenGl_Vec3& theMin, const OpenGl_Vec3& theMax)
{
myMin = theMin;
myMax = theMax;
}
-// =======================================================================
-// method : OpenGl_GraduatedTrihedron::Axis constructor
-// purpose :
-// =======================================================================
+//=================================================================================================
+
OpenGl_GraduatedTrihedron::Axis::Axis(const Graphic3d_GraduatedTrihedron::AxisAspect& theAspect,
const OpenGl_Vec3& theDirection)
: Direction(theDirection),
return *this;
}
-// =======================================================================
-// method : InitArrow
-// purpose :
-// =======================================================================
+//=================================================================================================
+
void OpenGl_GraduatedTrihedron::Axis::InitArrow(const Handle(OpenGl_Context)& theContext,
const Standard_ShortReal theLength,
const OpenGl_Vec3& theNormal) const
#if !defined(__APPLE__) || defined(HAVE_XLIB)
-// =======================================================================
-// function : Resize
-// purpose : call_subr_resize
-// =======================================================================
+//=================================================================================================
+
void OpenGl_Window::Resize()
{
Graphic3d_Vec2i aWinSize;
InitDrawerAttributes();
}
-//=======================================================================
-// function : AIS_Plane
-// purpose : avec une position
-//=======================================================================
+//=================================================================================================
+
AIS_Plane::AIS_Plane(const Handle(Geom_Plane)& aComponent,
const gp_Pnt& aCenter,
const Standard_Boolean aCurrentMode)
SynchronizeAspects();
}
-//=======================================================================
-// function : ExtremityPoints
-// purpose : to avoid warning
-//=======================================================================
+//=================================================================================================
+
// void AIS_Trihedron::ExtremityPoints(TColgp_Array1OfPnt& PP) const
void ExtremityPoints(TColgp_Array1OfPnt& PP,
const Handle(Geom_Plane)& myPlane,
aPresentation->CurrentGroup()->AddPrimitiveArray(aPrims);
}
-//==========================================================================
-// function : DsgPrs_AnglePresentation::Add
-// purpose :
-//
-//==========================================================================
+//=================================================================================================
void DsgPrs_AnglePresentation::Add(const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Prs3d_Drawer)& aDrawer,
}
}
-//==========================================================================
-// function : DsgPrs_AnglePresentation::Add
-// purpose :
-//
-//==========================================================================
+//=================================================================================================
void DsgPrs_AnglePresentation::Add(const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Prs3d_Drawer)& aDrawer,
DsgPrs::ComputeSymbol(aPresentation, LA, ptarr, ptarr1, dirarr, dirarr2, ArrowPrs);
}
-//==========================================================================
-// function : DsgPrs_AnglePresentation::Add
-// purpose :
-//
-//==========================================================================
+//=================================================================================================
void DsgPrs_AnglePresentation::Add(const Handle(Prs3d_Presentation)& aPresentation,
const Handle(Prs3d_Drawer)& aDrawer,
}
}
-//==================================================
-// Function: loadMode
-// Purpose : Private Method
-//==================================================
+//=================================================================================================
+
void SelectMgr_SelectionManager::loadMode(const Handle(SelectMgr_SelectableObject)& theObject,
const Standard_Integer theMode)
{
buildBVH(aNewSel);
}
-//==================================================
-// Function: buildBVH
-// Purpose : Private Method
-//==================================================
+//=================================================================================================
+
void SelectMgr_SelectionManager::buildBVH(const Handle(SelectMgr_Selection)& theSelection)
{
if (mySelector->ToPrebuildBVH())
projects / occt.git / commitdiff