Progress indication mechanism is refactored to support incrementing progress within multithreaded algorithms.
The class Message_ProgressIndicator is only an interface to the user application.
It accumulates the progress provided by progress scopes.
The counter is protected by mutex for thread-safety.
The new class Message_ProgressScope replacing Message_ProgressSentry should be used to advance the progress.
The scopes are nested to each other to reflect the nested nature of operations.
The new class Message_ProgressRange should be used to pass the progress to sub-scopes.
All OCCT algorithms involving progress indication have been updated to new API.
Improvements in Draw_ProgressIndicator:
- Separate console mode has been added in order to make possible to put the progress into std::cout instead
or in addition to the draw interpreter, instead of trigger option "-tclOutput".
- Treatment of Ctrl-Break signal has been added.
Now any operation can be aborted by Ctrl-C or Ctrl-Break keystroke.
Added new test case 'perf fclasses progr_par' for testing of parallel work of the progress.
BOPCol_Box2DBndTreeSelector BOPTools_BoxSelector<Bnd_Box2d>
BiTgte_DataMapOfShapeBox TopTools_DataMapOfShapeBox
CDM_MessageDriver Message_Messenger
+Message_ProgressSentry Message_ProgressScope
[tcollection]
AdvApp2Var_SequenceOfNode
Adaptor2d_OffsetCurve aOC(BaseCurve, Offset) --> Adaptor2d_OffsetCurve aOC(BaseCurve, -Offset)
+subsection upgrade_750_ProgressIndicator Change of Message_ProgressIndicator
+
+The progress indication mechanism has been revised to eliminate its weak points in previous design (leading to ambiguity and unprotected from an error-prone behavior).
+Redesign also allows using progress indicator in multi-threaded algorithms in more straight-forward way with minimal overhead.
+Note, however, that multi-threaded algorithm should pre-allocate per-thread progress scopes in advance to ensure thread-safety - check new classes API for details.
+
+Classes Message_ProgressSentry and Message_ProgressScale have been removed.
+New classes Message_ProgressScope and Messge_ProgressRange replace them and should be used as main API classes to organize progress indication in the algorithms.
+Instances of the class Message_ProgressRange are used to pass the progress capability to nested levels of the algorithm
+and an instance of the class Message_ProgressScope is to be created (preferably as local variable) to manage progress at each level of the algorithm.
+The instance of Message_ProgressIndicator is not passed anymore to sub-algorithms.
+See documentation of the class Message_ProgressScope for more details and examples.
+
+Methods to deal with progress scopes and to advance progress are removed from class Message_ProgressIndicator; now it only provides interface to the application-level progress indicator.
+Virtual method Message_ProgressIndicator::Show() has changed its signature and should be updated accordingly in descendants of Message_ProgressIndicator.
+The scope passed as argument to this method can be used to obtain information on context of the current process (instead of calling method GetScope() in previous implementation).
+Methods Show(), UserBreak(), and Reset() are made protected in class Message_ProgressIndicator; method More() of Message_ProgressScope should be used to know if the cancel event has come.
+See documentation of the class Message_ProgressIndicator for more details and implementation of Draw_ProgressIndicator for an example.
+
+Lets take a look onto typical algorithm using an old API:
+@code
+class MyAlgo
+{
+public:
+ //! Algorithm entry point taking an optional Progress Indicator.
+ bool Perform (const TCollection_AsciiString& theFileName,
+ const Handle(Message_ProgressIndicator)& theProgress = Handle(Message_ProgressIndicator)())
+ {
+ Message_ProgressSentry aPSentry (theProgress, (TCollection_AsciiString("Processing ") + theFileName).ToCString(), 2);
+ {
+ Message_ProgressSentry aPSentry1 (theProgress, "Stage 1", 0, 153, 1);
+ for (int anIter = 0; anIter < 153; ++anIter, aPSentry1.Next())
+ { if (!aPSentry1.More()) { return false; } }
+ }
+ aPSentry.Next();
+ {
+ perform2 (theProgress);
+ }
+ aPSentry.Next();
+ bool wasAborted = !theProgress.IsNull() && theProgress->UserBreak();
+ return !wasAborted;
+ }
+
+private:
+ //! Nested sub-algorithm taking Progress Indicator.
+ bool perform2 (const Handle(Message_ProgressIndicator)& theProgress)
+ {
+ Message_ProgressSentry aPSentry2 (theProgress, "Stage 2", 0, 561, 1);
+ for (int anIter = 0; anIter < 561 && aPSentry2.More(); ++anIter, aPSentry2.Next()) {}
+ return aPSentry2.More();
+ }
+};
+
+// application executing an algorithm
+Handle(Message_ProgressIndicator) aProgress = new MyProgress();
+MyAlgo anAlgo;
+anAlgo.Perform ("FileName", aProgress);
+@endcode
+
+The following guidance can be used to update such code:
+- Replace `const Handle(Message_ProgressIndicator)&` with `const Message_ProgressRange&`.
+ Message_ProgressIndicator object should be now created only at place where application starts algorithms.
+- Replace `Message_ProgressSentry` with `Message_ProgressScope`.
+ Take note that Message_ProgressScope has smaller number of arguments (no "minimal value").
+ In other aspects, Message_ProgressScope mimics an iterator-style interface (with methods More() and Next())
+ close to the old Message_ProgressSentry (pay attention to extra functionality of Message_ProgressScope::Next() method below).
+- Each Message_ProgressScope should take the next Range to fill in.
+ Within old API, Message_ProgressSentry received the root Progress Indicator object and implicitly split it into ranges using error-prone logic.
+ Message_ProgressScope in new API takes Message_ProgressRange, which should be created from the Range of the parent Scope using value returned by Message_ProgressScope::Next() method.
+ Don't use the same Range passed to the algorithm for all sub-Scopes like it was possible in old API.
+- Check user abortion state using Message_ProgressScope::UserBreak() method;
+ Message_ProgressRange is a temporary object with the only purpose to create a new Message_ProgressScope,
+ and Message_ProgressIndicator should be never passed directly to algorithms.
+
+Take a look onto ported code and compare with code above to see differences:
+
+@code
+class MyAlgo
+{
+public:
+ //! Algorithm entry point taking an optional Progress Range.
+ bool Perform (const TCollection_AsciiString& theFileName,
+ const Message_ProgressRange& theProgress = Message_ProgressRange())
+ {
+ Message_ProgressScope aPSentry (theProgress, TCollection_AsciiString("Processing ") + theFileName, 2);
+ {
+ Message_ProgressScope aPSentry1 (aPSentry.Next(), "Stage 1", 153);
+ for (int anIter = 0; anIter < 153; ++anIter, aPSentry1.Next())
+ { if (!aPSentry1.More()) { return false; }; }
+ }
+ {
+ perform2 (aPSentry.Next());
+ }
+ bool wasAborted = aPSentry.UserBreak();
+ return !wasAborted;
+ }
+
+ //! Nested sub-algorithm taking Progress sub-Range.
+ bool perform2 (const Message_ProgressRange& theProgress)
+ {
+ Message_ProgressScope aPSentry2 (theProgress, "Stage 2", 561);
+ for (int anIter = 0; anIter < 561 && aPSentry2.More(); ++anIter, aPSentry2.Next()) {}
+ return aPSentry2.More();
+ }
+};
+
+// application executing an algorithm
+Handle(Message_ProgressIndicator) aProgress = new MyProgress();
+MyAlgo anAlgo;
+anAlgo.Perform ("FileName", aProgress->Start());
+@endcode
+
@subsection upgrade_750_message_messenger Message_Messenger interface change
Operators << with left argument *Handle(Message_Messenger)*, used to output messages with
// include required OCCT headers
#include <Standard_Version.hxx>
#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
//for OCC graphic
#include <Aspect_DisplayConnection.hxx>
#include <WNT_Window.hxx>
// include required OCCT headers
#include <Standard_Version.hxx>
#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
//for OCC graphic
#include <WNT_Window.hxx>
#include <WNT_WClass.hxx>
aChecker.SetNonDestructive(Standard_True);
aChecker.SetRunParallel(myRunParallel);
aChecker.SetFuzzyValue(myFuzzyValue);
- aChecker.SetProgressIndicator(myProgressIndicator);
+ aChecker.SetProgressIndicator(*myProgressScope);
//
aChecker.Perform();
Standard_Boolean hasError = aChecker.HasErrors();
pPF=new BOPAlgo_PaveFiller(aAllocator);
pPF->SetArguments(aLS);
pPF->SetRunParallel(myRunParallel);
- pPF->SetProgressIndicator(myProgressIndicator);
+ pPF->SetProgressIndicator(*myProgressScope);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
//
pPF->SetArguments(myArguments);
pPF->SetRunParallel(myRunParallel);
- pPF->SetProgressIndicator(myProgressIndicator);
+ pPF->SetProgressIndicator(*myProgressScope);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
aBS.SetRunParallel(myRunParallel);
aBS.SetContext(myContext);
aBS.SetFuzzyValue(myFuzzyValue);
- aBS.SetProgressIndicator(myProgressIndicator);
+ aBS.SetProgressIndicator(*myProgressScope);
aBS.Perform();
// Resulting solids
aBF.SetFace(aF);
aBF.SetShapes(aLE);
aBF.SetRunParallel(myRunParallel);
- aBF.SetProgressIndicator(myProgressIndicator);
+ aBF.SetProgressIndicator(*myProgressScope);
//
}// for (i=0; i<aNbS; ++i) {
//
aPSB.Shape1() = aF1;
aPSB.Shape2() = aF2;
aPSB.SetFuzzyValue(myFuzzyValue);
- aPSB.SetProgressIndicator(myProgressIndicator);
+ aPSB.SetProgressIndicator(*myProgressScope);
}
}
}
aVFI.SetVertex(aV);
aVFI.SetFace(aFIm);
aVFI.SetFuzzyValue(myFuzzyValue);
- aVFI.SetProgressIndicator(myProgressIndicator);
+ aVFI.SetProgressIndicator(*myProgressScope);
}
}
}
aBS.SetSolid(aSolid);
aBS.SetShapes(aSFS);
aBS.SetRunParallel(myRunParallel);
- aBS.SetProgressIndicator(myProgressIndicator);
+ aBS.SetProgressIndicator(*myProgressScope);
}//for (i=0; i<aNbS; ++i) {
//
Standard_Integer k, aNbBS;
aFaceSelfIntersect.SetFace(aF);
aFaceSelfIntersect.SetTolF(aTolF);
//
- aFaceSelfIntersect.SetProgressIndicator(myProgressIndicator);
+ aFaceSelfIntersect.SetProgressIndicator(*myProgressScope);
}
Standard_Integer aNbFace = aVFace.Length();
}
//
pPF->SetRunParallel(myRunParallel);
- pPF->SetProgressIndicator(myProgressIndicator);
+ pPF->SetProgressIndicator(*myProgressScope);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
#include <BOPAlgo_Options.hxx>
#include <Message_MsgFile.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_BaseAllocator.hxx>
+#include <TCollection_AsciiString.hxx>
#include <Precision.hxx>
#include <Standard_NotImplemented.hxx>
#include <Standard_ProgramError.hxx>
myReport(new Message_Report),
myRunParallel(myGlobalRunParallel),
myFuzzyValue(Precision::Confusion()),
+ myProgressScope(0L),
myUseOBB(Standard_False)
{
BOPAlgo_LoadMessages();
myReport(new Message_Report),
myRunParallel(myGlobalRunParallel),
myFuzzyValue(Precision::Confusion()),
+ myProgressScope(0L),
myUseOBB(Standard_False)
{
BOPAlgo_LoadMessages();
//purpose :
//=======================================================================
void BOPAlgo_Options::SetProgressIndicator
- (const Handle(Message_ProgressIndicator)& theObj)
+ (const Message_ProgressScope& theScope)
{
- if (!theObj.IsNull()) {
- myProgressIndicator = theObj;
- }
+ myProgressScope = &theScope;
}
+
//=======================================================================
//function : UserBreak
//purpose :
//=======================================================================
void BOPAlgo_Options::UserBreak() const
{
- if (myProgressIndicator.IsNull()) {
+ if (!myProgressScope) {
return;
}
- if (myProgressIndicator->UserBreak()) {
+ if (myProgressScope->UserBreak()) {
throw Standard_NotImplemented("BOPAlgo_Options::UserBreak(), method is not implemented");
}
}
#include <NCollection_BaseAllocator.hxx>
-class Message_ProgressIndicator;
+class Message_ProgressScope;
//! The class provides the following options for the algorithms in Boolean Component:
//! - *Memory allocation tool* - tool for memory allocations;
//!@name Progress indicator
//! Set the Progress Indicator object.
- Standard_EXPORT void SetProgressIndicator(const Handle(Message_ProgressIndicator)& theObj);
+ Standard_EXPORT void SetProgressIndicator(const Message_ProgressScope& theProgress);
public:
//!@name Usage of Oriented Bounding boxes
Handle(Message_Report) myReport;
Standard_Boolean myRunParallel;
Standard_Real myFuzzyValue;
- Handle(Message_ProgressIndicator) myProgressIndicator;
+ const Message_ProgressScope* myProgressScope;
Standard_Boolean myUseOBB;
};
aVESolver.SetEdge(aE);
aVESolver.SetPaveBlock(aPB);
aVESolver.SetFuzzyValue(myFuzzyValue);
- aVESolver.SetProgressIndicator(myProgressIndicator);
+ aVESolver.SetProgressIndicator(*myProgressScope);
}
}
//
anEdgeEdge.SetEdge2(aE2, aT21, aT22);
anEdgeEdge.SetBoxes (aBB1, aBB2);
anEdgeEdge.SetFuzzyValue(myFuzzyValue);
- anEdgeEdge.SetProgressIndicator(myProgressIndicator);
+ anEdgeEdge.SetProgressIndicator(*myProgressScope);
}//for (; aIt2.More(); aIt2.Next()) {
}//for (; aIt1.More(); aIt1.Next()) {
}//for (; myIterator->More(); myIterator->Next()) {
anEdgeEdge.SetFuzzyValue(myFuzzyValue + aTolAdd);
else
anEdgeEdge.SetFuzzyValue(myFuzzyValue);
- anEdgeEdge.SetProgressIndicator(myProgressIndicator);
+ anEdgeEdge.SetProgressIndicator(*myProgressScope);
}
}
}
aVertexFace.SetVertex(aV);
aVertexFace.SetFace(aF);
aVertexFace.SetFuzzyValue(myFuzzyValue);
- aVertexFace.SetProgressIndicator(myProgressIndicator);
+ aVertexFace.SetProgressIndicator(*myProgressScope);
}//for (; myIterator->More(); myIterator->Next()) {
//
aNbVF=aVVF.Length();
aSR = aPBRange;
BOPTools_AlgoTools::CorrectRange(aE, aF, aSR, aPBRange);
aEdgeFace.SetRange (aPBRange);
- aEdgeFace.SetProgressIndicator(myProgressIndicator);
+ aEdgeFace.SetProgressIndicator(*myProgressScope);
// Save the pair to avoid their forced intersection
BOPDS_MapOfPaveBlock* pMPB = myFPBDone.ChangeSeek(nF);
if (!pMPB)
aEdgeFace.SetFuzzyValue(myFuzzyValue + aTolAdd);
aEdgeFace.UseQuickCoincidenceCheck(Standard_True);
aEdgeFace.SetRange(IntTools_Range(aPB->Pave1().Parameter(), aPB->Pave2().Parameter()));
- aEdgeFace.SetProgressIndicator(myProgressIndicator);
+ aEdgeFace.SetProgressIndicator(*myProgressScope);
}
}
}
//
aFaceFace.SetParameters(bApprox, bCompC2D1, bCompC2D2, anApproxTol);
aFaceFace.SetFuzzyValue(myFuzzyValue);
- aFaceFace.SetProgressIndicator(myProgressIndicator);
+ aFaceFace.SetProgressIndicator(*myProgressScope);
}
else {
// for the Glue mode just add all interferences of that type
}
//
// 2 Fuse shapes
- aPF.SetProgressIndicator(myProgressIndicator);
+ aPF.SetProgressIndicator(*myProgressScope);
aPF.SetRunParallel(myRunParallel);
aPF.SetArguments(aLS);
aPF.Perform();
aBSE.SetCommonBlock(aCB);
}
aBSE.SetDS(myDS);
- aBSE.SetProgressIndicator(myProgressIndicator);
+ aBSE.SetProgressIndicator(*myProgressScope);
} // for (; aItPB.More(); aItPB.Next()) {
} // for (i=0; i<aNbPBP; ++i) {
//
BOPAlgo_MPC& aMPC=aVMPC.Appended();
aMPC.SetEdge(aE);
aMPC.SetFace(aF1F);
- aMPC.SetProgressIndicator(myProgressIndicator);
+ aMPC.SetProgressIndicator(*myProgressScope);
}
//
// On
aMPC.SetEdge(aE);
aMPC.SetFace(aF1F);
- aMPC.SetProgressIndicator(myProgressIndicator);
+ aMPC.SetProgressIndicator(*myProgressScope);
}
}// for (i=0; i<aNbFI; ++i) {
//
aMPC.SetEdge(aE);
aMPC.SetFace(aFf[m]);
aMPC.SetFlag(Standard_True);
- aMPC.SetProgressIndicator(myProgressIndicator);
+ aMPC.SetProgressIndicator(*myProgressScope);
}
}
}
BOPAlgo_PaveFiller *pPF = new BOPAlgo_PaveFiller();
pPF->SetArguments(aLS);
pPF->SetRunParallel(myRunParallel);
- pPF->SetProgressIndicator(myProgressIndicator);
+ pPF->SetProgressIndicator(*myProgressScope);
pPF->SetFuzzyValue(myFuzzyValue);
pPF->SetNonDestructive(myNonDestructive);
pPF->SetGlue(myGlue);
#include <Standard_Boolean.hxx>
#include <BRepBuilderAPI_MakeShape.hxx>
#include <BOPAlgo_Options.hxx>
-class Message_ProgressIndicator;
-class TopoDS_Shape;
+class TopoDS_Shape;
//! Provides the root interface for the API algorithms
myDSFiller->SetArguments(theArgs);
// Set options for intersection
myDSFiller->SetRunParallel(myRunParallel);
- myDSFiller->SetProgressIndicator(myProgressIndicator);
+ myDSFiller->SetProgressIndicator(*myProgressScope);
myDSFiller->SetFuzzyValue(myFuzzyValue);
myDSFiller->SetNonDestructive(myNonDestructive);
myDSFiller->SetGlue(myGlue);
{
// Set options to the builder
myBuilder->SetRunParallel(myRunParallel);
- myBuilder->SetProgressIndicator(myProgressIndicator);
+ myBuilder->SetProgressIndicator(*myProgressScope);
myBuilder->SetCheckInverted(myCheckInverted);
myBuilder->SetToFillHistory(myFillHistory);
// Perform building of the result with pre-calculated intersections
anAnalyzer.SelfInterMode() = myTestSI;
// Set options from BOPAlgo_Options
anAnalyzer.SetRunParallel(myRunParallel);
- anAnalyzer.SetProgressIndicator(myProgressIndicator);
+ anAnalyzer.SetProgressIndicator(*myProgressScope);
anAnalyzer.SetFuzzyValue(myFuzzyValue);
// Perform the check
anAnalyzer.Perform();
#include <GeomLib.hxx>
#include <gp_Pnt.hxx>
#include <gp_Vec.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_UBTreeFiller.hxx>
#include <Precision.hxx>
#include <Standard_ErrorHandler.hxx>
#include <OSD_Timer.hxx>
#endif
-void BRepBuilderAPI_Sewing::Perform(const Handle(Message_ProgressIndicator)& thePI)
+void BRepBuilderAPI_Sewing::Perform(const Message_ProgressRange& theProgress)
{
const Standard_Integer aNumberOfStages = myAnalysis + myCutting + mySewing + 2;
- Message_ProgressSentry aPS (thePI, "Sewing", 0, aNumberOfStages, 1);
+ Message_ProgressScope aPS (theProgress, "Sewing", aNumberOfStages);
#ifdef OCCT_DEBUG
Standard_Real t_total = 0., t_analysis = 0., t_assembling = 0., t_cutting = 0., t_merging = 0.;
OSD_Chronometer chr_total, chr_local;
chr_local.Reset();
chr_local.Start();
#endif
- FaceAnalysis (thePI);
+ FaceAnalysis (aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
#ifdef OCCT_DEBUG
chr_local.Stop();
chr_local.Show(t_analysis);
chr_local.Reset();
chr_local.Start();
#endif
- VerticesAssembling (thePI);
+ VerticesAssembling (aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
#ifdef OCCT_DEBUG
chr_local.Stop();
chr_local.Show(t_assembling);
chr_local.Reset();
chr_local.Start();
#endif
- Cutting (thePI);
+ Cutting (aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
#ifdef OCCT_DEBUG
chr_local.Stop();
chr_local.Show(t_cutting);
chr_local.Reset();
chr_local.Start();
#endif
- Merging (Standard_True, thePI);
+ Merging (Standard_True, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
#ifdef OCCT_DEBUG
chr_local.Stop();
chr_local.Show(t_merging);
}
else
{
- aPS.Next( 1, Handle(TCollection_HAsciiString)());
+ aPS.Next();
if (myCutting)
- aPS.Next( 1, Handle(TCollection_HAsciiString)());
- aPS.Next( 1, Handle(TCollection_HAsciiString)());
+ aPS.Next();
+ aPS.Next();
if (!aPS.More())
return;
}
std::cout << "Creating sewed shape..." << std::endl;
#endif
// examine the multiple edges if any and process sameparameter for edges if necessary
- EdgeProcessing (thePI);
+ EdgeProcessing (aPS.Next());
if (!aPS.More())
return;
CreateSewedShape();
return;
}
- EdgeRegularity (thePI);
+ EdgeRegularity (aPS.Next());
if (mySameParameterMode && myFaceMode)
SameParameterShape();
// myDegenerated
//=======================================================================
-void BRepBuilderAPI_Sewing::FaceAnalysis(const Handle(Message_ProgressIndicator)& thePI)
+void BRepBuilderAPI_Sewing::FaceAnalysis(const Message_ProgressRange& theProgress)
{
if (!myShape.IsNull() && myOldShapes.IsEmpty()) {
Add(myShape);
TopTools_MapOfShape SmallEdges;
TopTools_IndexedDataMapOfShapeListOfShape GluedVertices;
Standard_Integer i = 1;
- Message_ProgressSentry aPS (thePI, "Shape analysis", 0, myOldShapes.Extent(), 1);
+ Message_ProgressScope aPS (theProgress, "Shape analysis", myOldShapes.Extent());
for (i = 1; i <= myOldShapes.Extent() && aPS.More(); i++, aPS.Next()) {
for (TopExp_Explorer fexp(myOldShapes(i),TopAbs_FACE); fexp.More(); fexp.Next()) {
TopTools_DataMapOfShapeListOfShape& aNodeEdges,
const TopTools_IndexedDataMapOfShapeListOfShape& aBoundFaces,
const Standard_Real Tolerance,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
// Create map of node -> vertices
TopTools_IndexedDataMapOfShapeListOfShape NodeVertices;
#endif
// Merge nearest nodes
TopTools_IndexedDataMapOfShapeShape NodeNearestNode;
- Message_ProgressSentry aPS (theProgress, "Glueing nodes", 0, nbNodes, 1, Standard_True);
+ Message_ProgressScope aPS (theProgress, "Glueing nodes", nbNodes, Standard_True);
for (Standard_Integer i = 1; i <= nbNodes && aPS.More(); i++, aPS.Next()) {
const TopoDS_Vertex& node1 = TopoDS::Vertex(NodeVertices.FindKey(i));
// Find near nodes
return CreateNewNodes(NodeNearestNode,NodeVertices,aVertexNode,aNodeEdges);
}
-void BRepBuilderAPI_Sewing::VerticesAssembling(const Handle(Message_ProgressIndicator)& thePI)
+void BRepBuilderAPI_Sewing::VerticesAssembling(const Message_ProgressRange& theProgress)
{
Standard_Integer nbVert = myVertexNode.Extent();
Standard_Integer nbVertFree = myVertexNodeFree.Extent();
- Message_ProgressSentry aPS (thePI, "Vertices assembling", 0, 2, 1);
+ Message_ProgressScope aPS (theProgress, "Vertices assembling", 2);
if (nbVert || nbVertFree) {
// Fill map node -> sections
Standard_Integer i;
#ifdef OCCT_DEBUG
std::cout << "Assemble " << nbVert << " vertices on faces..." << std::endl;
#endif
- while (GlueVertices(myVertexNode,myNodeSections,myBoundFaces,myTolerance, thePI));
+ while (GlueVertices(myVertexNode,myNodeSections,myBoundFaces,myTolerance, aPS.Next()));
}
if (!aPS.More())
return;
- aPS.Next();
if (nbVertFree) {
#ifdef OCCT_DEBUG
std::cout << "Assemble " << nbVertFree << " vertices on floating edges..." << std::endl;
#endif
- while (GlueVertices(myVertexNodeFree,myNodeSections,myBoundFaces,myTolerance, thePI));
+ while (GlueVertices(myVertexNodeFree,myNodeSections,myBoundFaces,myTolerance, aPS.Next()));
}
}
}
//=======================================================================
void BRepBuilderAPI_Sewing::Merging(const Standard_Boolean /* firstTime */,
- const Handle(Message_ProgressIndicator)& thePI)
+ const Message_ProgressRange& theProgress)
{
BRep_Builder B;
// TopTools_MapOfShape MergedEdges;
- Message_ProgressSentry aPS (thePI, "Merging bounds", 0, myBoundFaces.Extent(), 1);
+ Message_ProgressScope aPS (theProgress, "Merging bounds", myBoundFaces.Extent());
TopTools_IndexedDataMapOfShapeListOfShape::Iterator anIterB(myBoundFaces);
for (; anIterB.More() && aPS.More(); anIterB.Next(), aPS.Next()) {
// myCuttingNode
//=======================================================================
-void BRepBuilderAPI_Sewing::Cutting(const Handle(Message_ProgressIndicator)& thePI)
+void BRepBuilderAPI_Sewing::Cutting(const Message_ProgressRange& theProgress)
{
Standard_Integer i, nbVertices = myVertexNode.Extent();
if (!nbVertices) return;
Standard_Real first, last;
// Iterate on all boundaries
Standard_Integer nbBounds = myBoundFaces.Extent();
- Message_ProgressSentry aPS (thePI, "Cutting bounds", 0, nbBounds, 1);
+ Message_ProgressScope aPS (theProgress, "Cutting bounds", nbBounds);
TopTools_IndexedDataMapOfShapeListOfShape::Iterator anIterB(myBoundFaces);
for (; anIterB.More() && aPS.More(); anIterB.Next(), aPS.Next()) {
const TopoDS_Edge& bound = TopoDS::Edge(anIterB.Key());
// - make the contigous edges sameparameter
//=======================================================================
-void BRepBuilderAPI_Sewing::EdgeProcessing(const Handle(Message_ProgressIndicator)& thePI)
+void BRepBuilderAPI_Sewing::EdgeProcessing(const Message_ProgressRange& theProgress)
{
// constructs sectionEdge
TopTools_IndexedMapOfShape MapFreeEdges;
TopTools_DataMapOfShapeShape EdgeFace;
- Message_ProgressSentry aPS (thePI, "Edge processing", 0, myBoundFaces.Extent(), 1);
+ Message_ProgressScope aPS (theProgress, "Edge processing", myBoundFaces.Extent());
TopTools_IndexedDataMapOfShapeListOfShape::Iterator anIterB(myBoundFaces);
for (; anIterB.More() && aPS.More(); anIterB.Next(), aPS.Next()) {
const TopoDS_Shape& bound = anIterB.Key();
//purpose : update Continuity flag on newly created edges
//=======================================================================
-void BRepBuilderAPI_Sewing::EdgeRegularity(const Handle(Message_ProgressIndicator)& thePI)
+void BRepBuilderAPI_Sewing::EdgeRegularity(const Message_ProgressRange& theProgress)
{
TopTools_IndexedDataMapOfShapeListOfShape aMapEF;
TopExp::MapShapesAndAncestors(mySewedShape, TopAbs_EDGE, TopAbs_FACE, aMapEF);
- Message_ProgressSentry aPS(thePI, "Encode edge regularity", 0, myMergedEdges.Extent(), 1);
+ Message_ProgressScope aPS(theProgress, "Encode edge regularity", myMergedEdges.Extent());
for (TopTools_MapIteratorOfMapOfShape aMEIt(myMergedEdges); aMEIt.More() && aPS.More(); aMEIt.Next(), aPS.Next())
{
TopoDS_Edge anEdge = TopoDS::Edge(myReShape->Apply(aMEIt.Value()));
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_SequenceOfReal.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class BRepTools_ReShape;
class Standard_OutOfRange;
class Standard_NoSuchObject;
class TopoDS_Shape;
-class Message_ProgressIndicator;
class TopoDS_Edge;
class TopoDS_Face;
class Geom_Surface;
Standard_EXPORT void Add (const TopoDS_Shape& shape);
//! Computing
- //! thePI - progress indicator of algorithm
- Standard_EXPORT void Perform (const Handle(Message_ProgressIndicator)& thePI = 0);
+ //! theProgress - progress indicator of algorithm
+ Standard_EXPORT void Perform (const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Gives the sewed shape
//! a null shape if nothing constructed
//! Performs cutting of sections
- //! thePI - progress indicator of processing
- Standard_EXPORT void Cutting (const Handle(Message_ProgressIndicator)& thePI = 0);
+ //! theProgress - progress indicator of processing
+ Standard_EXPORT void Cutting (const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void Merging (const Standard_Boolean passage, const Handle(Message_ProgressIndicator)& thePI = 0);
+ Standard_EXPORT void Merging (const Standard_Boolean passage, const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT Standard_Boolean IsMergedClosed (const TopoDS_Edge& Edge1, const TopoDS_Edge& Edge2, const TopoDS_Face& fase) const;
//! Merged nearest edges.
Standard_EXPORT Standard_Boolean MergedNearestEdges (const TopoDS_Shape& edge, TopTools_SequenceOfShape& SeqMergedEdge, TColStd_SequenceOfBoolean& SeqMergedOri);
- Standard_EXPORT void EdgeProcessing (const Handle(Message_ProgressIndicator)& thePI = 0);
+ Standard_EXPORT void EdgeProcessing (const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Recompute regularity on merged edges
- Standard_EXPORT void EdgeRegularity (const Handle(Message_ProgressIndicator)& thePI = 0);
+ Standard_EXPORT void EdgeRegularity (const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void CreateOutputInformations();
//! This method is called from Perform only
- //! thePI - progress indicator of processing
- Standard_EXPORT virtual void FaceAnalysis (const Handle(Message_ProgressIndicator)& thePI = 0);
+ //! theProgress - progress indicator of processing
+ Standard_EXPORT virtual void FaceAnalysis (const Message_ProgressRange& theProgress = Message_ProgressRange());
//! This method is called from Perform only
//! This method is called from Perform only
- //! thePI - progress indicator of processing
- Standard_EXPORT virtual void VerticesAssembling (const Handle(Message_ProgressIndicator)& thePI = 0);
+ //! theProgress - progress indicator of processing
+ Standard_EXPORT virtual void VerticesAssembling (const Message_ProgressRange& theProgress = Message_ProgressRange());
//! This method is called from Perform only
#include <TopExp_Explorer.hxx>
#include <TopoDS.hxx>
#include <TopoDS_Face.hxx>
+#include <TCollection_AsciiString.hxx>
#include <Geom_Surface.hxx>
#include <Geom2d_TrimmedCurve.hxx>
#include <TopTools_ListOfShape.hxx>
aSewing.Add(aSeq.Value(i));
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (theDi, 1);
- aSewing.Perform (aProgress);
+ aSewing.Perform (aProgress->Start());
aSewing.Dump();
const TopoDS_Shape& aRes = aSewing.SewedShape();
//purpose :
//=======================================================================
Handle(IGESData_IGESEntity) BRepToIGES_BREntity::TransferShape
-(const TopoDS_Shape& start)
+(const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
// TopoDS_Shape theShape;
TopoDS_Face F = TopoDS::Face(start);
BRepToIGES_BRShell BS(*this);
BS.SetModel(GetModel());
- res = BS.TransferFace(F);
+ res = BS.TransferFace(F, theProgress);
}
else if (start.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell S = TopoDS::Shell(start);
BRepToIGES_BRShell BS(*this);
BS.SetModel(GetModel());
- res = BS.TransferShell(S);
+ res = BS.TransferShell(S, theProgress);
}
else if (start.ShapeType() == TopAbs_SOLID) {
TopoDS_Solid M = TopoDS::Solid(start);
BRepToIGES_BRSolid BS(*this);
BS.SetModel(GetModel());
- res = BS.TransferSolid(M);
+ res = BS.TransferSolid(M, theProgress);
}
else if (start.ShapeType() == TopAbs_COMPSOLID) {
TopoDS_CompSolid C = TopoDS::CompSolid(start);
BRepToIGES_BRSolid BS(*this);
BS.SetModel(GetModel());
- res = BS.TransferCompSolid(C);
+ res = BS.TransferCompSolid(C, theProgress);
}
else if (start.ShapeType() == TopAbs_COMPOUND) {
TopoDS_Compound C = TopoDS::Compound(start);
BRepToIGES_BRSolid BS(*this);
BS.SetModel(GetModel());
- res = BS.TransferCompound(C);
+ res = BS.TransferCompound(C, theProgress);
}
else {
// message d`erreur
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
+#include <Message_ProgressRange.hxx>
+
class IGESData_IGESModel;
class Transfer_FinderProcess;
class IGESData_IGESEntity;
//! Returns the result of the transfert of any Shape
//! If the transfer has failed, this member return a NullEntity.
- Standard_EXPORT virtual Handle(IGESData_IGESEntity) TransferShape (const TopoDS_Shape& start);
+ Standard_EXPORT virtual Handle(IGESData_IGESEntity) TransferShape
+ (const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Records a new Fail message
Standard_EXPORT void AddFail (const TopoDS_Shape& start, const Standard_CString amess);
#include <IGESGeom_SurfaceOfRevolution.hxx>
#include <IGESGeom_TrimmedSurface.hxx>
#include <Interface_Macros.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_IncAllocator.hxx>
#include <NCollection_Map.hxx>
#include <ShapeAlgo.hxx>
// TransferShell
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferShell(const TopoDS_Shape& start)
+Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferShell(const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
if (start.ShapeType() == TopAbs_FACE) {
TopoDS_Face F = TopoDS::Face(start);
- res = TransferFace(F);
+ res = TransferFace(F, theProgress);
}
else if (start.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell S = TopoDS::Shell(start);
- res = TransferShell(S);
+ res = TransferShell(S, theProgress);
}
else {
// message d`erreur
//
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferFace(const TopoDS_Face& start)
+Handle(IGESData_IGESEntity) BRepToIGES_BRShell ::TransferFace(const TopoDS_Face& start,
+ const Message_ProgressRange&)
{
Handle(IGESData_IGESEntity) res;
-
- Handle(Message_ProgressIndicator) progress = GetTransferProcess()->GetProgress();
- if ( ! progress.IsNull() ) {
- if ( progress->UserBreak() ) return res;
- progress->Increment();
- }
if ( start.IsNull()) {
return res;
// TransferShell
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGES_BRShell::TransferShell(const TopoDS_Shell& start)
+Handle(IGESData_IGESEntity) BRepToIGES_BRShell::TransferShell(const TopoDS_Shell& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
if ( start.IsNull()) return res;
Handle(TColStd_HSequenceOfTransient) Seq = new TColStd_HSequenceOfTransient();
Handle(IGESData_IGESEntity) IFace;
- for (Ex.Init(start,TopAbs_FACE); Ex.More(); Ex.Next()) {
+ Standard_Integer nbshapes = 0;
+ for (Ex.Init(start, TopAbs_FACE); Ex.More(); Ex.Next())
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+ for (Ex.Init(start,TopAbs_FACE); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Face F = TopoDS::Face(Ex.Current());
if (F.IsNull()) {
AddWarning(start," a Face is a null entity");
}
else {
- IFace = TransferFace(F);
+ IFace = TransferFace (F, aRange);
if (!IFace.IsNull()) Seq->Append(IFace);
}
}
#include <Standard_Handle.hxx>
#include <BRepToIGES_BREntity.hxx>
+#include <Message_ProgressRange.hxx>
+
class BRepToIGES_BREntity;
class IGESData_IGESEntity;
class TopoDS_Shape;
//! Transfert an Shape entity from TopoDS to IGES
//! This entity must be a Face or a Shell.
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferShell (const TopoDS_Shape& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferShell (const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert an Shell entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferShell (const TopoDS_Shell& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferShell (const TopoDS_Shell& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert a Face entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferFace (const TopoDS_Face& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferFace (const TopoDS_Face& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
#include <IGESData_HArray1OfIGESEntity.hxx>
#include <IGESData_IGESEntity.hxx>
#include <Interface_Macros.hxx>
+#include <Message_ProgressScope.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <TopAbs_ShapeEnum.hxx>
#include <TopExp.hxx>
// TransferSolid
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferSolid(const TopoDS_Shape& start)
+Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferSolid(const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
if (start.ShapeType() == TopAbs_SOLID) {
TopoDS_Solid M = TopoDS::Solid(start);
- res = TransferSolid(M);
+ res = TransferSolid(M, theProgress);
}
else if (start.ShapeType() == TopAbs_COMPSOLID) {
TopoDS_CompSolid C = TopoDS::CompSolid(start);
- res = TransferCompSolid(C);
+ res = TransferCompSolid(C, theProgress);
}
else if (start.ShapeType() == TopAbs_COMPOUND) {
TopoDS_Compound C = TopoDS::Compound(start);
- res = TransferCompound(C);
+ res = TransferCompound(C, theProgress);
}
else {
// error message
//
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferSolid(const TopoDS_Solid& start)
+Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferSolid(const TopoDS_Solid& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
if ( start.IsNull()) return res;
BRepToIGES_BRShell BS(*this);
Handle(TColStd_HSequenceOfTransient) Seq = new TColStd_HSequenceOfTransient();
- for (Ex.Init(start,TopAbs_SHELL); Ex.More(); Ex.Next()) {
+ Standard_Integer nbshapes = 0;
+ for (Ex.Init(start, TopAbs_SHELL); Ex.More(); Ex.Next())
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+ for (Ex.Init(start,TopAbs_SHELL); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Shell S = TopoDS::Shell(Ex.Current());
if (S.IsNull()) {
AddWarning(start," an Shell is a null entity");
}
else {
- IShell = BS.TransferShell(S);
+ IShell = BS.TransferShell (S, aRange);
if (!IShell.IsNull()) Seq->Append(IShell);
}
}
// TransferCompSolid
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferCompSolid(const TopoDS_CompSolid& start)
+Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferCompSolid(const TopoDS_CompSolid& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
if ( start.IsNull()) return res;
Handle(IGESData_IGESEntity) ISolid;
Handle(TColStd_HSequenceOfTransient) Seq = new TColStd_HSequenceOfTransient();
- for (Ex.Init(start,TopAbs_SOLID); Ex.More(); Ex.Next()) {
+ Standard_Integer nbshapes = 0;
+ for (Ex.Init(start, TopAbs_SOLID); Ex.More(); Ex.Next())
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+ for (Ex.Init(start,TopAbs_SOLID); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Solid S = TopoDS::Solid(Ex.Current());
if (S.IsNull()) {
AddWarning(start," an Solid is a null entity");
}
else {
- ISolid = TransferSolid(S);
+ ISolid = TransferSolid (S, aRange);
if (!ISolid.IsNull()) Seq->Append(ISolid);
}
}
// TransferCompound
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferCompound(const TopoDS_Compound& start)
+Handle(IGESData_IGESEntity) BRepToIGES_BRSolid ::TransferCompound(const TopoDS_Compound& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
if ( start.IsNull()) return res;
BRepToIGES_BRWire BW(*this);
Handle(TColStd_HSequenceOfTransient) Seq = new TColStd_HSequenceOfTransient();
+ // count numbers of subshapes
+ Standard_Integer nbshapes = 0;
+ for (Ex.Init(start, TopAbs_SOLID); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_SHELL, TopAbs_SOLID); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_FACE, TopAbs_SHELL); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_WIRE, TopAbs_FACE); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_EDGE, TopAbs_WIRE); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_VERTEX, TopAbs_EDGE); Ex.More(); Ex.Next())
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+
// take all Solids
- for (Ex.Init(start, TopAbs_SOLID); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_SOLID); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Solid S = TopoDS::Solid(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Solid is a null entity");
}
else {
- IShape = TransferSolid(S);
+ IShape = TransferSolid (S, aRange);
if (!IShape.IsNull()) Seq->Append(IShape);
}
}
// take all isolated Shells
- for (Ex.Init(start, TopAbs_SHELL, TopAbs_SOLID); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_SHELL, TopAbs_SOLID); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Shell S = TopoDS::Shell(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Shell is a null entity");
}
else {
- IShape = BS.TransferShell(S);
+ IShape = BS.TransferShell (S, aRange);
if (!IShape.IsNull()) Seq->Append(IShape);
}
}
// take all isolated Faces
- for (Ex.Init(start, TopAbs_FACE, TopAbs_SHELL); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_FACE, TopAbs_SHELL); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Face S = TopoDS::Face(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Face is a null entity");
}
else {
- IShape = BS.TransferFace(S);
+ IShape = BS.TransferFace (S, aRange);
if (!IShape.IsNull()) Seq->Append(IShape);
}
}
// take all isolated Wires
- for (Ex.Init(start, TopAbs_WIRE, TopAbs_FACE); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_WIRE, TopAbs_FACE); Ex.More() && aPS.More(); Ex.Next(), aPS.Next())
+ {
TopoDS_Wire S = TopoDS::Wire(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Wire is a null entity");
// take all isolated Edges
- for (Ex.Init(start, TopAbs_EDGE, TopAbs_WIRE); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_EDGE, TopAbs_WIRE); Ex.More() && aPS.More(); Ex.Next(), aPS.Next())
+ {
TopoDS_Edge S = TopoDS::Edge(Ex.Current());
if (S.IsNull()) {
AddWarning(start," an Edge is a null entity");
// take all isolated Vertices
- for (Ex.Init(start, TopAbs_VERTEX, TopAbs_EDGE); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_VERTEX, TopAbs_EDGE); Ex.More() && aPS.More(); Ex.Next(), aPS.Next())
+ {
TopoDS_Vertex S = TopoDS::Vertex(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Vertex is a null entity");
}
// construct the group
- Standard_Integer nbshapes = Seq->Length();
+ nbshapes = Seq->Length();
Handle(IGESData_HArray1OfIGESEntity) Tab;
if (nbshapes >=1) {
Tab = new IGESData_HArray1OfIGESEntity(1,nbshapes);
//! Transfert a Shape entity from TopoDS to IGES
//! this entity must be a Solid or a CompSolid or a Compound.
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferSolid (const TopoDS_Shape& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferSolid (const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert a Solid entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferSolid (const TopoDS_Solid& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferSolid (const TopoDS_Solid& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert an CompSolid entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompSolid (const TopoDS_CompSolid& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompSolid (const TopoDS_CompSolid& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert a Compound entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompound (const TopoDS_Compound& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompound (const TopoDS_Compound& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
#include <IGESSolid_VertexList.hxx>
#include <Interface_Macros.hxx>
#include <Interface_Static.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <ShapeAlgo.hxx>
#include <ShapeAlgo_AlgoContainer.hxx>
#include <TColgp_HArray1OfXYZ.hxx>
//purpose :
//=======================================================================
Handle(IGESData_IGESEntity) BRepToIGESBRep_Entity::TransferShape
-(const TopoDS_Shape& start)
+(const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
//TopoDS_Shape theShape;
}
else if (start.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell S = TopoDS::Shell(start);
- res = TransferShell(S);
+ res = TransferShell(S, theProgress);
}
else if (start.ShapeType() == TopAbs_SOLID) {
TopoDS_Solid M = TopoDS::Solid(start);
- res = TransferSolid(M);
+ res = TransferSolid(M, theProgress);
}
else if (start.ShapeType() == TopAbs_COMPSOLID) {
TopoDS_CompSolid C = TopoDS::CompSolid(start);
- res = TransferCompSolid(C);
+ res = TransferCompSolid(C, theProgress);
}
else if (start.ShapeType() == TopAbs_COMPOUND) {
TopoDS_Compound C = TopoDS::Compound(start);
- res = TransferCompound(C);
+ res = TransferCompound(C, theProgress);
}
else {
// error message
Handle(IGESSolid_Face) BRepToIGESBRep_Entity ::TransferFace(const TopoDS_Face& start)
{
- Handle(Message_ProgressIndicator) progress = GetTransferProcess()->GetProgress();
- if ( ! progress.IsNull() ) {
- if ( progress->UserBreak() ) return 0;
- progress->Increment();
- }
-
Handle(IGESSolid_Face) myent = new IGESSolid_Face;
if ( start.IsNull()) return myent;
Handle(IGESData_IGESEntity) ISurf;
// TransferShell
//=============================================================================
-Handle(IGESSolid_Shell) BRepToIGESBRep_Entity ::TransferShell(const TopoDS_Shell& start)
+Handle(IGESSolid_Shell) BRepToIGESBRep_Entity ::TransferShell(const TopoDS_Shell& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESSolid_Shell) myshell = new IGESSolid_Shell;
if ( start.IsNull()) return myshell;
TColStd_SequenceOfInteger SeqFlag;
Handle(IGESSolid_Face) IFace;
- for (Ex.Init(start,TopAbs_FACE); Ex.More(); Ex.Next()) {
+ Standard_Integer nbf = 0;
+ for (Ex.Init(start, TopAbs_FACE); Ex.More(); Ex.Next())
+ nbf++;
+ Message_ProgressScope aPS(theProgress, NULL, nbf);
+ for (Ex.Init(start,TopAbs_FACE); Ex.More() && aPS.More(); Ex.Next(), aPS.Next()) {
TopoDS_Face F = TopoDS::Face(Ex.Current());
if ( start.Orientation() == TopAbs_REVERSED ) F.Reverse(); //:l4 abv 12 Jan 99: CTS22022-2: writing reversed shells
if (F.IsNull()) {
// with a Solid
//=============================================================================
-Handle(IGESSolid_ManifoldSolid) BRepToIGESBRep_Entity ::TransferSolid (const TopoDS_Solid& start)
+Handle(IGESSolid_ManifoldSolid) BRepToIGESBRep_Entity ::TransferSolid (const TopoDS_Solid& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESSolid_ManifoldSolid) mysol = new IGESSolid_ManifoldSolid;
if ( start.IsNull()) return mysol;
Handle(TColStd_HSequenceOfTransient) Seq = new TColStd_HSequenceOfTransient();
TColStd_SequenceOfInteger SeqFlag;
- for (Ex.Init(start,TopAbs_SHELL); Ex.More(); Ex.Next()) {
+ Standard_Integer nbs = 0;
+ for (Ex.Init(start, TopAbs_SHELL); Ex.More(); Ex.Next())
+ nbs++;
+ Message_ProgressScope aPS(theProgress, NULL, nbs);
+ for (Ex.Init(start,TopAbs_SHELL); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Shell S = TopoDS::Shell(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Shell is a null entity");
}
else {
- IShell = TransferShell(S);
+ IShell = TransferShell (S, aRange);
if (!IShell.IsNull()) {
Seq->Append(IShell);
if (S.Orientation() == TopAbs_FORWARD ) SeqFlag.Append(1);
// with a CompSolid
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGESBRep_Entity::TransferCompSolid (const TopoDS_CompSolid& start)
+Handle(IGESData_IGESEntity) BRepToIGESBRep_Entity::TransferCompSolid (const TopoDS_CompSolid& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) myent;
if ( start.IsNull()) return myent;
Handle(IGESSolid_ManifoldSolid) ISolid = new IGESSolid_ManifoldSolid;
Handle(TColStd_HSequenceOfTransient) Seq = new TColStd_HSequenceOfTransient();
- for (Ex.Init(start,TopAbs_SOLID); Ex.More(); Ex.Next()) {
+ Standard_Integer nbs = 0;
+ for (Ex.Init(start, TopAbs_SOLID); Ex.More(); Ex.Next())
+ nbs++;
+ Message_ProgressScope aPS(theProgress, NULL, nbs);
+ for (Ex.Init(start,TopAbs_SOLID); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Solid S = TopoDS::Solid(Ex.Current());
if (S.IsNull()) {
AddWarning(start," an Solid is a null entity");
}
else {
- ISolid = TransferSolid(S);
+ ISolid = TransferSolid (S, aRange);
if (!ISolid.IsNull()) Seq->Append(ISolid);
}
}
// with a Compound
//=============================================================================
-Handle(IGESData_IGESEntity) BRepToIGESBRep_Entity::TransferCompound (const TopoDS_Compound& start)
+Handle(IGESData_IGESEntity) BRepToIGESBRep_Entity::TransferCompound (const TopoDS_Compound& start,
+ const Message_ProgressRange& theProgress)
{
Handle(IGESData_IGESEntity) res;
if ( start.IsNull()) return res;
Handle(IGESData_IGESEntity) IShape;
Handle(TColStd_HSequenceOfTransient) Seq = new TColStd_HSequenceOfTransient();
+ // count numbers of subshapes
+ Standard_Integer nbshapes = 0;
+ for (Ex.Init(start, TopAbs_SOLID); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_SHELL, TopAbs_SOLID); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_FACE, TopAbs_SHELL); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_WIRE, TopAbs_FACE); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_EDGE, TopAbs_WIRE); Ex.More(); Ex.Next())
+ nbshapes++;
+ for (Ex.Init(start, TopAbs_VERTEX, TopAbs_EDGE); Ex.More(); Ex.Next())
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+
// take all Solids
- for (Ex.Init(start, TopAbs_SOLID); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_SOLID); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Solid S = TopoDS::Solid(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Solid is a null entity");
}
else {
- IShape = TransferSolid(S);
+ IShape = TransferSolid (S, aRange);
if (!IShape.IsNull()) Seq->Append(IShape);
}
}
// take all isolated Shells
- for (Ex.Init(start, TopAbs_SHELL, TopAbs_SOLID); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_SHELL, TopAbs_SOLID); Ex.More() && aPS.More(); Ex.Next())
+ {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Shell S = TopoDS::Shell(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Shell is a null entity");
}
else {
- IShape = TransferShell(S);
+ IShape = TransferShell (S, aRange);
if (!IShape.IsNull()) Seq->Append(IShape);
}
}
// take all isolated Faces
- for (Ex.Init(start, TopAbs_FACE, TopAbs_SHELL); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_FACE, TopAbs_SHELL); Ex.More() && aPS.More(); Ex.Next(), aPS.Next())
+ {
TopoDS_Face S = TopoDS::Face(Ex.Current());
if (S.IsNull()) {
AddWarning(start," a Face is a null entity");
// take all isolated Wires
- for (Ex.Init(start, TopAbs_WIRE, TopAbs_FACE); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_WIRE, TopAbs_FACE); Ex.More() && aPS.More(); Ex.Next(), aPS.Next())
+ {
TopoDS_Wire S = TopoDS::Wire(Ex.Current());
BRepToIGES_BRWire BW(*this);
// take all isolated Edges
- for (Ex.Init(start, TopAbs_EDGE, TopAbs_WIRE); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_EDGE, TopAbs_WIRE); Ex.More() && aPS.More(); Ex.Next(), aPS.Next())
+ {
TopoDS_Edge S = TopoDS::Edge(Ex.Current());
BRepToIGES_BRWire BW(*this);
// take all isolated Vertices
- for (Ex.Init(start, TopAbs_VERTEX, TopAbs_EDGE); Ex.More(); Ex.Next()) {
+ for (Ex.Init(start, TopAbs_VERTEX, TopAbs_EDGE); Ex.More() && aPS.More(); Ex.Next(), aPS.Next())
+ {
TopoDS_Vertex S = TopoDS::Vertex(Ex.Current());
BRepToIGES_BRWire BW(*this);
}
// construct the group
- Standard_Integer nbshapes = Seq->Length();
+ nbshapes = Seq->Length();
if (nbshapes > 0) {
Handle(IGESData_HArray1OfIGESEntity) Tab =
new IGESData_HArray1OfIGESEntity(1,nbshapes);
#include <BRepToIGES_BREntity.hxx>
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
+#include <Message_ProgressRange.hxx>
+
class IGESSolid_EdgeList;
class IGESSolid_VertexList;
class TopoDS_Vertex;
class TopoDS_CompSolid;
class TopoDS_Compound;
-
//! provides methods to transfer BRep entity from CASCADE to IGESBRep.
class BRepToIGESBRep_Entity : public BRepToIGES_BREntity
{
//! Returns the result of the transfert of any Shape
//! If the transfer has failed, this member return a NullEntity.
- Standard_EXPORT virtual Handle(IGESData_IGESEntity) TransferShape (const TopoDS_Shape& start) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(IGESData_IGESEntity) TransferShape
+ (const TopoDS_Shape& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
//! Transfert an Edge entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
//! Transfert an Shell entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESSolid_Shell) TransferShell (const TopoDS_Shell& start);
+ Standard_EXPORT Handle(IGESSolid_Shell) TransferShell (const TopoDS_Shell& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert a Solid entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESSolid_ManifoldSolid) TransferSolid (const TopoDS_Solid& start);
+ Standard_EXPORT Handle(IGESSolid_ManifoldSolid) TransferSolid (const TopoDS_Solid& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert an CompSolid entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompSolid (const TopoDS_CompSolid& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompSolid (const TopoDS_CompSolid& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfert a Compound entity from TopoDS to IGES
//! If this Entity could not be converted, this member returns a NullEntity.
- Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompound (const TopoDS_Compound& start);
+ Standard_EXPORT Handle(IGESData_IGESEntity) TransferCompound (const TopoDS_Compound& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//=======================================================================
void BRepTools::Write(const TopoDS_Shape& Sh, Standard_OStream& S,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
BRepTools_ShapeSet SS;
SS.Add(Sh);
void BRepTools::Read(TopoDS_Shape& Sh,
std::istream& S,
const BRep_Builder& B,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
BRepTools_ShapeSet SS(B);
SS.Read(S, theProgress);
Standard_Boolean BRepTools::Write(const TopoDS_Shape& Sh,
const Standard_CString File,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
std::ofstream os;
OSD_OpenStream(os, File, std::ios::out);
Standard_Boolean BRepTools::Read(TopoDS_Shape& Sh,
const Standard_CString File,
const BRep_Builder& B,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
std::filebuf fic;
std::istream in(&fic);
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
#include <Standard_CString.hxx>
-
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class TopoDS_Face;
class TopoDS_Wire;
//! Writes <Sh> on <S> in an ASCII format.
Standard_EXPORT static void Write (const TopoDS_Shape& Sh, Standard_OStream& S,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a Shape from <S> in returns it in <Sh>.
//! <B> is used to build the shape.
Standard_EXPORT static void Read (TopoDS_Shape& Sh, Standard_IStream& S, const BRep_Builder& B,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes <Sh> in <File>.
- Standard_EXPORT static Standard_Boolean Write
- (const TopoDS_Shape& Sh, const Standard_CString File,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ Standard_EXPORT static Standard_Boolean Write (const TopoDS_Shape& Sh, const Standard_CString File,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads a Shape from <File>, returns it in <Sh>.
//! <B> is used to build the shape.
- Standard_EXPORT static Standard_Boolean Read
- (TopoDS_Shape& Sh, const Standard_CString File, const BRep_Builder& B,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ Standard_EXPORT static Standard_Boolean Read (TopoDS_Shape& Sh, const Standard_CString File,
+ const BRep_Builder& B,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Evals real tolerance of edge <theE>.
//! <theC3d>, <theC2d>, <theS>, <theF>, <theL> are
Standard_EXPORT static void RemoveInternals (TopoDS_Shape& theS,
const Standard_Boolean theForce = Standard_False);
+
+protected:
+
+
+
+
+
private:
+
+
+
friend class BRepTools_WireExplorer;
friend class BRepTools_Modification;
friend class BRepTools_Modifier;
#include <BRepTools_Modification.hxx>
#include <BRepTools_Modifier.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <Standard_NoSuchObject.hxx>
#include <Standard_NullObject.hxx>
#include <TColStd_ListIteratorOfListOfTransient.hxx>
#include <Standard_NullObject.hxx>
#include <gp_Trsf.hxx>
#include <BRepTools_TrsfModification.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Geom_Surface.hxx>
static void SetShapeFlags(const TopoDS_Shape& theInSh, TopoDS_Shape& theOutSh);
static TopTools_IndexedMapOfShape MapE, MapF;
#endif
-void BRepTools_Modifier::Perform(const Handle(BRepTools_Modification)& M, const Handle(Message_ProgressIndicator) & aProgress)
+void BRepTools_Modifier::Perform(const Handle(BRepTools_Modification)& M,
+ const Message_ProgressRange& theProgress)
{
if (myShape.IsNull()) {
throw Standard_NullObject();
#endif
TopTools_DataMapIteratorOfDataMapOfShapeShape theIter(myMap);
- Message_ProgressSentry aPSentry(aProgress, "Converting Shape", 0, 2, 1);
+ Message_ProgressScope aPS(theProgress, "Converting Shape", 2);
TopTools_IndexedDataMapOfShapeListOfShape aMVE, aMEF;
TopExp::MapShapesAndAncestors(myShape, TopAbs_VERTEX, TopAbs_EDGE, aMVE);
CreateOtherVertices(aMVE, aMEF, M);
Standard_Boolean aNewGeom;
- Rebuild(myShape, M, aNewGeom, aProgress);
+ Rebuild(myShape, M, aNewGeom, aPS.Next());
- if (!aPSentry.More())
+ if (!aPS.More())
{
// The processing was broken
return;
}
- aPSentry.Next();
-
if (myShape.ShapeType() == TopAbs_FACE) {
if (myShape.Orientation() == TopAbs_REVERSED) {
myMap(myShape).Reverse();
(const TopoDS_Shape& S,
const Handle(BRepTools_Modification)& M,
Standard_Boolean& theNewGeom,
- const Handle(Message_ProgressIndicator)& aProgress)
+ const Message_ProgressRange& theProgress)
{
#ifdef DEBUG_Modifier
int iF = MapF.Contains(S) ? MapF.FindIndex(S) : 0;
for (it.Initialize(S, Standard_False); it.More(); it.Next()) ++aShapeCount;
}
- Message_ProgressSentry aPSentry(aProgress, "Converting SubShapes", 0, aShapeCount, 1);
+ Message_ProgressScope aPS(theProgress, "Converting SubShapes", aShapeCount);
//
- for (it.Initialize(S, Standard_False); it.More() && aPSentry.More(); it.Next(), aPSentry.Next()) {
+ for (it.Initialize(S, Standard_False); it.More() && aPS.More(); it.Next()) {
// always call Rebuild
Standard_Boolean isSubNewGeom = Standard_False;
- Standard_Boolean subrebuilt = Rebuild(it.Value(), M, isSubNewGeom, aProgress);
+ Standard_Boolean subrebuilt = Rebuild(it.Value(), M, isSubNewGeom, aPS.Next());
rebuild = subrebuilt || rebuild ;
theNewGeom = theNewGeom || isSubNewGeom;
}
- if (!aPSentry.More())
+ if (!aPS.More())
{
// The processing was broken
return Standard_False;
#include <TopoDS_Vertex.hxx>
#include <Standard_Boolean.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <NCollection_DataMap.hxx>
#include <TopoDS_Shape.hxx>
#include <TopTools_ShapeMapHasher.hxx>
#include <TopLoc_Location.hxx>
+#include <Message_ProgressRange.hxx>
class Standard_NullObject;
class Standard_NoSuchObject;
class TopoDS_Shape;
class BRepTools_Modification;
-class Message_ProgressIndicator;
class Geom_Curve;
class Geom_Surface;
Standard_EXPORT void Init (const TopoDS_Shape& S);
//! Performs the modifications described by <M>.
- Standard_EXPORT void Perform (const Handle(BRepTools_Modification)& M, const Handle(Message_ProgressIndicator)& aProgress = NULL);
+ Standard_EXPORT void Perform (const Handle(BRepTools_Modification)& M,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns Standard_True if the modification has
//! been computed successfully.
Standard_EXPORT Standard_Boolean Rebuild (const TopoDS_Shape& S,
const Handle(BRepTools_Modification)& M,
Standard_Boolean& theNewGeom,
- const Handle(Message_ProgressIndicator)& aProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void CreateNewVertices(
const TopTools_IndexedDataMapOfShapeListOfShape& theMVE,
#include <BRepTools.hxx>
#include <BRepTools_ShapeSet.hxx>
#include <GeomTools.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Poly.hxx>
#include <Poly_Polygon2D.hxx>
#include <Poly_Polygon3D.hxx>
//purpose :
//=======================================================================
-void BRepTools_ShapeSet::WriteGeometry (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)
+void BRepTools_ShapeSet::WriteGeometry(Standard_OStream& OS, const Message_ProgressRange& theProgress)
{
- //OCC19559
- Message_ProgressSentry aPS(theProgress, "Writing geometry", 0, 6, 1);
- myCurves2d.Write (OS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- myCurves.Write (OS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- WritePolygon3D (OS, true, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- WritePolygonOnTriangulation (OS, true, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- mySurfaces.Write (OS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- WriteTriangulation (OS, true, theProgress);
+ // Make nested progress scope for processing geometry
+ Message_ProgressScope aPS(theProgress, "Geometry", 100);
+
+ myCurves2d.Write(OS, aPS.Next(20));
+ if (aPS.UserBreak()) return;
+
+ myCurves.Write(OS, aPS.Next(20));
+ if (aPS.UserBreak()) return;
+
+ WritePolygon3D(OS, Standard_True, aPS.Next(10));
+ if (aPS.UserBreak()) return;
+
+ WritePolygonOnTriangulation(OS, Standard_True, aPS.Next(10));
+ if (aPS.UserBreak()) return;
+
+ mySurfaces.Write(OS, aPS.Next(20));
+ if (aPS.UserBreak()) return;
+
+ WriteTriangulation(OS, Standard_True, aPS.Next(20));
}
//purpose :
//=======================================================================
-void BRepTools_ShapeSet::ReadGeometry (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress)
+void BRepTools_ShapeSet::ReadGeometry(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
- //OCC19559
- Message_ProgressSentry aPS(theProgress, "Reading geometry", 0, 6, 1);
- myCurves2d.Read(IS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- myCurves.Read(IS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- ReadPolygon3D(IS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- ReadPolygonOnTriangulation(IS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- mySurfaces.Read(IS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- ReadTriangulation(IS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
+ // Make nested progress scope for processing geometry
+ Message_ProgressScope aPS(theProgress, "Geometry", 100);
+
+ myCurves2d.Read(IS, aPS.Next(20));
+ if (aPS.UserBreak()) return;
+
+ myCurves.Read(IS, aPS.Next(20));
+ if (aPS.UserBreak()) return;
+
+ ReadPolygon3D(IS, aPS.Next(15));
+ if (aPS.UserBreak()) return;
+
+ ReadPolygonOnTriangulation(IS, aPS.Next(15));
+ if (aPS.UserBreak()) return;
+
+ mySurfaces.Read(IS, aPS.Next(15));
+ if (aPS.UserBreak()) return;
+
+ ReadTriangulation(IS, aPS.Next(15));
}
//=======================================================================
//purpose :
//=======================================================================
-void BRepTools_ShapeSet::WritePolygonOnTriangulation (Standard_OStream& OS,
- const Standard_Boolean Compact,
- const Handle(Message_ProgressIndicator)& theProgress)const
+void BRepTools_ShapeSet::WritePolygonOnTriangulation(Standard_OStream& OS,
+ const Standard_Boolean Compact,
+ const Message_ProgressRange& theProgress)const
{
Standard_Integer i, j, nbpOntri = myNodes.Extent();
- Message_ProgressSentry PS(theProgress, "Polygons On Triangulation", 0, nbpOntri, 1);
+ Message_ProgressScope aPS(theProgress, "Polygons On Triangulation", nbpOntri);
if (Compact)
OS << "PolygonOnTriangulations " << nbpOntri << "\n";
else {
Handle(Poly_PolygonOnTriangulation) Poly;
Handle(TColStd_HArray1OfReal) Param;
- for (i=1; i<=nbpOntri && PS.More(); i++, PS.Next()) {
+ for (i=1; i<=nbpOntri && aPS.More(); i++, aPS.Next()) {
Poly = Handle(Poly_PolygonOnTriangulation)::DownCast(myNodes(i));
const TColStd_Array1OfInteger& Nodes = Poly->Nodes();
if (!Compact) {
//purpose :
//=======================================================================
-void BRepTools_ShapeSet::ReadPolygonOnTriangulation (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress)
+void BRepTools_ShapeSet::ReadPolygonOnTriangulation(Standard_IStream& IS,
+ const Message_ProgressRange& theProgress)
{
char buffer[255];
IS >> buffer;
Handle(Poly_PolygonOnTriangulation) Poly;
IS >> nbpol;
//OCC19559
- Message_ProgressSentry PS(theProgress, "Polygons On Triangulation", 0, nbpol, 1);
- for (i=1; i<=nbpol&& PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "Polygons On Triangulation", nbpol);
+ for (i=1; i<=nbpol&& aPS.More(); i++, aPS.Next()) {
IS >> nbnodes;
TColStd_Array1OfInteger Nodes(1, nbnodes);
for (j = 1; j <= nbnodes; j++) {
//purpose :
//=======================================================================
-void BRepTools_ShapeSet::WritePolygon3D (Standard_OStream& OS,
- const Standard_Boolean Compact,
- const Handle(Message_ProgressIndicator) &theProgress)const
+void BRepTools_ShapeSet::WritePolygon3D(Standard_OStream& OS,
+ const Standard_Boolean Compact,
+ const Message_ProgressRange& theProgress)const
{
Standard_Integer i, j, nbpol = myPolygons3D.Extent();
- Message_ProgressSentry PS(theProgress, "3D Polygons", 0, nbpol, 1);
+ Message_ProgressScope aPS(theProgress, "3D Polygons", nbpol);
if (Compact)
OS << "Polygon3D " << nbpol << "\n";
}
Handle(Poly_Polygon3D) P;
- for (i = 1; i <= nbpol && PS.More(); i++, PS.Next()) {
+ for (i = 1; i <= nbpol && aPS.More(); i++, aPS.Next()) {
P = Handle(Poly_Polygon3D)::DownCast(myPolygons3D(i));
if (Compact) {
OS << P->NbNodes() << " ";
//purpose :
//=======================================================================
-void BRepTools_ShapeSet::ReadPolygon3D (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+void BRepTools_ShapeSet::ReadPolygon3D(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
char buffer[255];
// Standard_Integer i, j, p, val, nbpol, nbnodes, hasparameters;
Handle(Poly_Polygon3D) P;
IS >> nbpol;
//OCC19559
- Message_ProgressSentry PS(theProgress, "3D Polygons", 0, nbpol, 1);
- for (i=1; i<=nbpol && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "3D Polygons", nbpol);
+ for (i=1; i<=nbpol && aPS.More(); i++, aPS.Next()) {
IS >> nbnodes;
IS >> hasparameters;
TColgp_Array1OfPnt Nodes(1, nbnodes);
void BRepTools_ShapeSet::WriteTriangulation(Standard_OStream& OS,
const Standard_Boolean Compact,
- const Handle(Message_ProgressIndicator) &theProgress)const
+ const Message_ProgressRange& theProgress)const
{
Standard_Integer i, j, nbNodes, nbtri = myTriangulations.Extent();
Standard_Integer nbTriangles = 0, n1, n2, n3;
- Message_ProgressSentry PS(theProgress, "Triangulations", 0, nbtri, 1);
+ Message_ProgressScope aPS(theProgress, "Triangulations", nbtri);
if (Compact)
OS << "Triangulations " << nbtri << "\n";
}
Handle(Poly_Triangulation) T;
- for (i = 1; i <= nbtri && PS.More(); i++, PS.Next()) {
+ for (i = 1; i <= nbtri && aPS.More(); i++, aPS.Next()) {
T = Handle(Poly_Triangulation)::DownCast(myTriangulations(i));
if (Compact) {
//purpose :
//=======================================================================
-void BRepTools_ShapeSet::ReadTriangulation (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress)
+void BRepTools_ShapeSet::ReadTriangulation(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
char buffer[255];
// Standard_Integer i, j, val, nbtri;
IS >> nbtri;
//OCC19559
- Message_ProgressSentry PS(theProgress, "Triangulations", 0, nbtri, 1);
- for (i=1; i<=nbtri && PS.More();i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "Triangulations", nbtri);
+ for (i=1; i<=nbtri && aPS.More();i++, aPS.Next()) {
IS >> nbNodes >> nbTriangles >> hasUV;
GeomTools::GetReal(IS, d);
//! Writes the geometry of me on the stream <OS> in a
//! format that can be read back by Read.
- Standard_EXPORT virtual void WriteGeometry
- (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL) Standard_OVERRIDE;
+ Standard_EXPORT virtual void WriteGeometry (Standard_OStream& OS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
//! Reads the geometry of me from the stream <IS>.
- Standard_EXPORT virtual void ReadGeometry
- (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL) Standard_OVERRIDE;
+ Standard_EXPORT virtual void ReadGeometry (Standard_IStream& IS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
//! Dumps the geometry of <S> on the stream <OS>.
- Standard_EXPORT virtual void DumpGeometry
- (const TopoDS_Shape& S, Standard_OStream& OS) const Standard_OVERRIDE;
+ Standard_EXPORT virtual void DumpGeometry (const TopoDS_Shape& S, Standard_OStream& OS) const Standard_OVERRIDE;
//! Writes the geometry of <S> on the stream <OS> in a
//! format that can be read back by Read.
- Standard_EXPORT virtual void WriteGeometry
- (const TopoDS_Shape& S, Standard_OStream& OS) const Standard_OVERRIDE;
+ Standard_EXPORT virtual void WriteGeometry (const TopoDS_Shape& S, Standard_OStream& OS) const Standard_OVERRIDE;
//! Reads the geometry of a shape of type <T> from the
//! stream <IS> and returns it in <S>.
- Standard_EXPORT virtual void ReadGeometry
- (const TopAbs_ShapeEnum T, Standard_IStream& IS, TopoDS_Shape& S) Standard_OVERRIDE;
+ Standard_EXPORT virtual void ReadGeometry (const TopAbs_ShapeEnum T, Standard_IStream& IS, TopoDS_Shape& S) Standard_OVERRIDE;
//! Inserts the shape <S2> in the shape <S1>. This
//! method must be redefined to use the correct
//! Reads the 3d polygons of me
//! from the stream <IS>.
- Standard_EXPORT void ReadPolygon3D
- (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ Standard_EXPORT void ReadPolygon3D (Standard_IStream& IS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes the 3d polygons
//! on the stream <OS> in a format that can
//! be read back by Read.
- Standard_EXPORT void WritePolygon3D
- (Standard_OStream& OS,
- const Standard_Boolean Compact = Standard_True,
- const Handle(Message_ProgressIndicator) &theProgress = NULL) const;
+ Standard_EXPORT void WritePolygon3D (Standard_OStream& OS,
+ const Standard_Boolean Compact = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Dumps the 3d polygons
//! on the stream <OS>.
//! Reads the triangulation of me
//! from the stream <IS>.
- Standard_EXPORT void ReadTriangulation
- (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ Standard_EXPORT void ReadTriangulation (Standard_IStream& IS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes the triangulation
//! on the stream <OS> in a format that can
//! be read back by Read.
- Standard_EXPORT void WriteTriangulation
- (Standard_OStream& OS,
- const Standard_Boolean Compact = Standard_True,
- const Handle(Message_ProgressIndicator) &theProgress = NULL) const;
+ Standard_EXPORT void WriteTriangulation (Standard_OStream& OS,
+ const Standard_Boolean Compact = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Dumps the triangulation
//! on the stream <OS>.
//! Reads the polygons on triangulation of me
//! from the stream <IS>.
- Standard_EXPORT void ReadPolygonOnTriangulation
- (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ Standard_EXPORT void ReadPolygonOnTriangulation (Standard_IStream& IS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes the polygons on triangulation
//! on the stream <OS> in a format that can
//! be read back by Read.
- Standard_EXPORT void WritePolygonOnTriangulation
- (Standard_OStream& OS,
- const Standard_Boolean Compact = Standard_True,
- const Handle(Message_ProgressIndicator) &theProgress = NULL) const;
+ Standard_EXPORT void WritePolygonOnTriangulation (Standard_OStream& OS,
+ const Standard_Boolean Compact = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Dumps the polygons on triangulation
//! on the stream <OS>.
Standard_EXPORT void DumpPolygonOnTriangulation (Standard_OStream& OS) const;
+
+
+
+protected:
+
+
+
+
+
private:
+
+
BRep_Builder myBuilder;
GeomTools_SurfaceSet mySurfaces;
GeomTools_CurveSet myCurves;
(BinLDrivers_DocumentSection& /*theSection*/,
Standard_IStream& theIS,
const Standard_Boolean /*isMess*/,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
// Read Shapes
OCC_CATCH_SIGNALS
Handle(BinMNaming_NamedShapeDriver) aNamedShapeDriver =
Handle(BinMNaming_NamedShapeDriver)::DownCast (aDriver);
- aNamedShapeDriver->ReadShapeSection (theIS, theProgress);
+ aNamedShapeDriver->ReadShapeSection (theIS, theRange);
}
catch(Standard_Failure const& anException) {
const TCollection_ExtendedString aMethStr
(BinLDrivers_DocumentSection& theSection,
Standard_IStream& theIS,
const Standard_Boolean isMess = Standard_False,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual void CheckShapeSection
(const Storage_Position& thePos, Standard_IStream& theIS) Standard_OVERRIDE;
void BinDrivers_DocumentStorageDriver::WriteShapeSection
(BinLDrivers_DocumentSection& theSection,
Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
const Standard_Size aShapesSectionOffset = (Standard_Size) theOS.tellp();
OCC_CATCH_SIGNALS
Handle(BinMNaming_NamedShapeDriver) aNamedShapeDriver =
Handle(BinMNaming_NamedShapeDriver)::DownCast (aDriver);
- aNamedShapeDriver->WriteShapeSection (theOS, theProgress);
+ aNamedShapeDriver->WriteShapeSection (theOS, theRange);
}
catch(Standard_Failure const& anException) {
TCollection_ExtendedString anErrorStr ("BinDrivers_DocumentStorageDriver, Shape Section :");
Standard_EXPORT virtual void WriteShapeSection
(BinLDrivers_DocumentSection& theDocSection,
Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Return true if shape should be stored with triangles.
Standard_EXPORT Standard_Boolean IsWithTriangles() const;
#include <TDF_Label.hxx>
#include <TDocStd_Document.hxx>
#include <TDocStd_Owner.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BinLDrivers_DocumentRetrievalDriver,PCDM_RetrievalDriver)
(const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
std::ifstream aFileStream;
OSD_OpenStream (aFileStream, theFileName, std::ios::in | std::ios::binary);
Handle(Storage_Data) dData;
TCollection_ExtendedString aFormat = PCDM_ReadWriter::FileFormat (aFileStream, dData);
- Read(aFileStream, dData, theNewDocument, theApplication, theProgress);
- if (!theProgress.IsNull() && theProgress->UserBreak())
+ Read(aFileStream, dData, theNewDocument, theApplication, theRange);
+ if (!theRange.More())
{
myReaderStatus = PCDM_RS_UserBreak;
return;
const Handle(Storage_Data)& theStorageData,
const Handle(CDM_Document)& theDoc,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
myReaderStatus = PCDM_RS_DriverFailure;
myMsgDriver = theApplication -> MessageDriver();
Handle(TDF_Data) aData = new TDF_Data();
std::streampos aDocumentPos = -1;
- Message_ProgressSentry aPS(theProgress, "Reading data", 0, 3, 1);
+ Message_ProgressScope aPS(theRange, "Reading data", 3);
// 2b. Read the TOC of Sections
if (aFileVer >= 3) {
theIStream.seekg ((std::streampos) aCurSection.Offset());
if (aCurSection.Name().IsEqual ((Standard_CString)SHAPESECTION_POS))
{
- ReadShapeSection (aCurSection, theIStream, false, theProgress);
+ ReadShapeSection (aCurSection, theIStream, false, aPS.Next());
if (!aPS.More())
{
myReaderStatus = PCDM_RS_UserBreak;
return;
}
- aPS.Next();
}
else
ReadSection (aCurSection, theDoc, theIStream);
CheckShapeSection(aShapeSectionPos, theIStream);
// Read Shapes
BinLDrivers_DocumentSection aCurSection;
- ReadShapeSection (aCurSection, theIStream, Standard_False, theProgress);
+ ReadShapeSection (aCurSection, theIStream, Standard_False, aPS.Next());
if (!aPS.More())
{
myReaderStatus = PCDM_RS_UserBreak;
return;
}
- aPS.Next();
}
}
} // end of reading Sections or shape section
theIStream.read ((char*)&aTag, sizeof(Standard_Integer));
// read sub-tree of the root label
- Standard_Integer nbRead = ReadSubTree (theIStream, aData->Root(), theProgress);
+ Standard_Integer nbRead = ReadSubTree (theIStream, aData->Root(), aPS.Next());
if (!aPS.More())
{
myReaderStatus = PCDM_RS_UserBreak;
return;
}
- aPS.Next();
+
Clear();
if (!aPS.More())
{
Standard_Integer BinLDrivers_DocumentRetrievalDriver::ReadSubTree
(Standard_IStream& theIS,
const TDF_Label& theLabel,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Standard_Integer nbRead = 0;
TCollection_ExtendedString aMethStr
("BinLDrivers_DocumentRetrievalDriver: ");
- Message_ProgressSentry aPS(theProgress, "Reading sub tree", 0, 2, 1, true);
+ Message_ProgressScope aPS(theRange, "Reading sub tree", 2, true);
// Read attributes:
theIS >> myPAtt;
return -1;
}
- aPS.Next();
+
// read sub-tree
- Standard_Integer nbSubRead = ReadSubTree (theIS, aLab, theProgress);
+ Standard_Integer nbSubRead = ReadSubTree (theIS, aLab, aPS.Next());
// check for error
if (nbSubRead == -1)
return -1;
(BinLDrivers_DocumentSection& theSection,
Standard_IStream& /*theIS*/,
const Standard_Boolean isMess,
- const Handle(Message_ProgressIndicator) &/*theProgress*/)
+ const Message_ProgressRange &/*theRange*/)
{
if(isMess && theSection.Length()) {
Standard_EXPORT virtual void Read (const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual void Read (Standard_IStream& theIStream,
const Handle(Storage_Data)& theStorageData,
const Handle(CDM_Document)& theDoc,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(BinMDF_ADriverTable) AttributeDrivers (const Handle(Message_Messenger)& theMsgDriver);
Standard_EXPORT virtual Standard_Integer ReadSubTree
(Standard_IStream& theIS,
const TDF_Label& theData,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRanges = Message_ProgressRange());
//! define the procedure of reading a section to file.
(BinLDrivers_DocumentSection& theSection,
Standard_IStream& theIS,
const Standard_Boolean isMess = Standard_False,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! checks the shapes section can be correctly retreived.
Standard_EXPORT virtual void CheckShapeSection (const Storage_Position& thePos, Standard_IStream& theIS);
#include <TDF_Label.hxx>
#include <TDF_Tool.hxx>
#include <TDocStd_Document.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
IMPLEMENT_STANDARD_RTTIEXT(BinLDrivers_DocumentStorageDriver,PCDM_StorageDriver)
void BinLDrivers_DocumentStorageDriver::Write
(const Handle(CDM_Document)& theDocument,
const TCollection_ExtendedString& theFileName,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
SetIsError(Standard_False);
SetStoreStatus(PCDM_SS_OK);
if (aFileStream.is_open() && aFileStream.good())
{
- Write(theDocument, aFileStream, theProgress);
+ Write(theDocument, aFileStream, theRange);
}
else
{
//purpose :
//=======================================================================
-void BinLDrivers_DocumentStorageDriver::Write (const Handle(CDM_Document)& theDoc,
- Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress)
+void BinLDrivers_DocumentStorageDriver::Write (const Handle(CDM_Document)& theDoc,
+ Standard_OStream& theOStream,
+ const Message_ProgressRange& theRange)
{
myMsgDriver = theDoc->Application()->MessageDriver();
myMapUnsupported.Clear();
myRelocTable.Clear();
myPAtt.Init();
- Message_ProgressSentry aPS(theProgress, "Writing document", 0, 3, 1);
+ Message_ProgressScope aPS(theRange, "Writing document", 3);
// Write Doc structure
- WriteSubTree (aData->Root(), theOStream, theProgress); // Doc is written
+ WriteSubTree (aData->Root(), theOStream, aPS.Next()); // Doc is written
if (!aPS.More())
{
SetIsError(Standard_True);
SetStoreStatus(PCDM_SS_UserBreak);
return;
}
- aPS.Next();
+
// 4. Write Shapes section
- WriteShapeSection (aShapesSection, theOStream, theProgress);
+ WriteShapeSection (aShapesSection, theOStream, aPS.Next());
if (!aPS.More())
{
SetIsError(Standard_True);
SetStoreStatus(PCDM_SS_UserBreak);
return;
}
- aPS.Next();
+
// Write application-defined sections
for (anIterS.Init (mySections); anIterS.More(); anIterS.Next()) {
BinLDrivers_DocumentSection& aSection = anIterS.ChangeValue();
//=======================================================================
void BinLDrivers_DocumentStorageDriver::WriteSubTree
- (const TDF_Label& theLabel,
- Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ (const TDF_Label& theLabel,
+ Standard_OStream& theOS,
+ const Message_ProgressRange& theRange)
{
// Skip empty labels
if (!myEmptyLabels.IsEmpty() && myEmptyLabels.First() == theLabel) {
myEmptyLabels.RemoveFirst();
return;
}
- Message_ProgressSentry aPS(theProgress, "Writing sub tree", 0, 2, 1, 1);
+ Message_ProgressScope aPS(theRange, "Writing sub tree", 2, true);
// Write label header: tag
Standard_Integer aTag = theLabel.Tag();
#if DO_INVERSE
SetStoreStatus(PCDM_SS_UserBreak);
return;
}
- aPS.Next();
- WriteSubTree (aChildLab, theOS, theProgress);
+ WriteSubTree (aChildLab, theOS, aPS.Next());
}
// Write the end label marker
void BinLDrivers_DocumentStorageDriver::WriteShapeSection
(BinLDrivers_DocumentSection& theSection,
Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& /*theProgress*/)
+ const Message_ProgressRange& /*theRange*/)
{
const Standard_Size aShapesSectionOffset = (Standard_Size) theOS.tellp();
theSection.Write (theOS, aShapesSectionOffset);
//! Write <theDocument> to the binary file <theFileName>
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& theDocument,
const TCollection_ExtendedString& theFileName,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Write <theDocument> to theOStream
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& theDocument,
Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(BinMDF_ADriverTable) AttributeDrivers (const Handle(Message_Messenger)& theMsgDriver);
//! Write the tree under <theLabel> to the stream <theOS>
Standard_EXPORT void WriteSubTree (const TDF_Label& theData,
Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! define the procedure of writing a section to file.
Standard_EXPORT virtual void WriteSection (const TCollection_AsciiString& theName,
//! defines the procedure of writing a shape section to file
Standard_EXPORT virtual void WriteShapeSection (BinLDrivers_DocumentSection& theDocSection,
Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Handle(BinMDF_ADriverTable) myDrivers;
BinObjMgt_SRelocationTable myRelocTable;
//=======================================================================
void BinMNaming_NamedShapeDriver::WriteShapeSection (Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
theOS << SHAPESET;
myShapeSet.SetFormatNb(myFormatNb);
- myShapeSet.Write (theOS, theProgress);
+ myShapeSet.Write (theOS, theRange);
myShapeSet.Clear();
}
//=======================================================================
void BinMNaming_NamedShapeDriver::ReadShapeSection (Standard_IStream& theIS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
// check section title string; note that some versions of OCCT (up to 6.3.1)
// might avoid writing shape section if it is empty
theIS >> aSectionTitle;
if(aSectionTitle.Length() > 0 && aSectionTitle == SHAPESET) {
myShapeSet.Clear();
- myShapeSet.Read (theIS, theProgress);
+ myShapeSet.Read (theIS, theRange);
SetFormatNb(myShapeSet.FormatNb());
}
else
//! Input the shapes from Bin Document file
Standard_EXPORT void ReadShapeSection (Standard_IStream& theIS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& therange = Message_ProgressRange());
//! Output the shapes into Bin Document file
Standard_EXPORT void WriteShapeSection (Standard_OStream& theOS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& therange = Message_ProgressRange());
//! Clear myShapeSet
Standard_EXPORT void Clear();
#include <BinTools.hxx>
#include <BinTools_ShapeSet.hxx>
#include <FSD_FileHeader.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <OSD_OpenFile.hxx>
#include <Storage_StreamTypeMismatchError.hxx>
//=======================================================================
void BinTools::Write (const TopoDS_Shape& theShape, Standard_OStream& theStream,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
BinTools_ShapeSet aShapeSet(Standard_True);
aShapeSet.SetFormatNb (3);
aShapeSet.Add (theShape);
- aShapeSet.Write (theStream, theProgress);
+ aShapeSet.Write (theStream, theRange);
aShapeSet.Write (theShape, theStream);
}
//=======================================================================
void BinTools::Read (TopoDS_Shape& theShape, Standard_IStream& theStream,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
BinTools_ShapeSet aShapeSet(Standard_True);
- aShapeSet.Read (theStream, theProgress);
+ aShapeSet.Read (theStream, theRange);
aShapeSet.Read (theShape, theStream, aShapeSet.NbShapes());
}
//=======================================================================
Standard_Boolean BinTools::Write (const TopoDS_Shape& theShape, const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
std::ofstream aStream;
aStream.precision (15);
if (!aStream.good())
return Standard_False;
- Write (theShape, aStream, theProgress);
+ Write (theShape, aStream, theRange);
aStream.close();
return aStream.good();
}
//=======================================================================
Standard_Boolean BinTools::Read (TopoDS_Shape& theShape, const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
std::filebuf aBuf;
OSD_OpenStream (aBuf, theFile, std::ios::in | std::ios::binary);
return Standard_False;
Standard_IStream aStream (&aBuf);
- Read (theShape, aStream, theProgress);
+ Read (theShape, aStream, theRange);
return aStream.good();
}
#include <Standard_ExtCharacter.hxx>
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class TopoDS_Shape;
class BinTools_ShapeSet;
//! Writes <theShape> on <theStream> in binary format.
Standard_EXPORT static void Write (const TopoDS_Shape& theShape, Standard_OStream& theStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Reads a shape from <theStream> and returns it in <theShape>.
Standard_EXPORT static void Read (TopoDS_Shape& theShape, Standard_IStream& theStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Writes <theShape> in <theFile>.
Standard_EXPORT static Standard_Boolean Write
(const TopoDS_Shape& theShape, const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Reads a shape from <theFile> and returns it in <theShape>.
Standard_EXPORT static Standard_Boolean Read
(TopoDS_Shape& theShape, const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
protected:
#include <TColgp_Array1OfPnt2d.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#define LINE 1
#define CIRCLE 2
//=======================================================================
void BinTools_Curve2dSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+ const Message_ProgressRange& theRange) const
{
Standard_Integer i, aNbCurves = myMap.Extent();
- Message_ProgressSentry aPS(theProgress, "Writing 2D curves", 0, aNbCurves, 1);
+ Message_ProgressScope aPS(theRange, "Writing 2D curves",aNbCurves);
OS << "Curve2ds "<< aNbCurves << "\n";
for (i = 1; i <= aNbCurves && aPS.More(); i++, aPS.Next()) {
WriteCurve2d(Handle(Geom2d_Curve)::DownCast(myMap(i)),OS);
//=======================================================================
void BinTools_Curve2dSet::Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
char buffer[255];
Handle(Geom2d_Curve) C;
Standard_Integer i, aNbCurves;
IS >> aNbCurves;
- Message_ProgressSentry aPS(theProgress, "Reading curves 2d", 0, aNbCurves, 1);
+ Message_ProgressScope aPS(theRange, "Reading curves 2d", aNbCurves);
IS.get();//remove <lf>
for (i = 1; i <= aNbCurves && aPS.More(); i++, aPS.Next()) {
BinTools_Curve2dSet::ReadCurve2d(IS,C);
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class Standard_OutOfRange;
class Geom2d_Curve;
//! Writes the content of me on the stream <OS> in a
//! format that can be read back by Read.
Standard_EXPORT void Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
Standard_EXPORT void Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Dumps the curve on the binary stream, that can be read back.
Standard_EXPORT static void WriteCurve2d(const Handle(Geom2d_Curve)& C, Standard_OStream& OS);
#include <TColgp_Array1OfPnt.hxx>
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#define LINE 1
#define CIRCLE 2
//=======================================================================
void BinTools_CurveSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+ const Message_ProgressRange& theRange)const
{
Standard_Integer i, nbcurv = myMap.Extent();
- Message_ProgressSentry aPS(theProgress, "Writing curves", 0, nbcurv, 1);
+ Message_ProgressScope aPS(theRange, "Writing curves", nbcurv);
OS << "Curves "<< nbcurv << "\n";
for (i = 1; i <= nbcurv &&aPS.More(); i++, aPS.Next()) {
WriteCurve(Handle(Geom_Curve)::DownCast(myMap(i)),OS);
//=======================================================================
void BinTools_CurveSet::Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
char buffer[255];
IS >> buffer;
Standard_Integer i, nbcurve;
IS >> nbcurve;
- Message_ProgressSentry aPS(theProgress, "Reading curves", 0, nbcurve, 1);
+ Message_ProgressScope aPS(theRange, "Reading curves", nbcurve);
IS.get();//remove <lf>
for (i = 1; i <= nbcurve && aPS.More(); i++, aPS.Next()) {
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class Standard_OutOfRange;
class Geom_Curve;
//! Writes the content of me on the stream <OS> in a
//! format that can be read back by Read.
Standard_EXPORT void Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
Standard_EXPORT void Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Dumps the curve on the stream in binary format
//! that can be read back.
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
#include <TopoDS_Vertex.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressRange.hxx>
#include <string.h>
//#define MDTV_DEB 1
//=======================================================================
void BinTools_ShapeSet::WriteGeometry (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+ const Message_ProgressRange& theRange)const
{
- Message_ProgressSentry aPS(theProgress, "Writing geometry", 0, 6, 1);
- myCurves2d.Write(OS, theProgress);
+ Message_ProgressScope aPS(theRange, "Writing geometry", 6);
+ myCurves2d.Write(OS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- myCurves.Write(OS, theProgress);
+ myCurves.Write(OS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- WritePolygon3D(OS, theProgress);
+ WritePolygon3D(OS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- WritePolygonOnTriangulation(OS, theProgress);
+ WritePolygonOnTriangulation(OS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- mySurfaces.Write(OS, theProgress);
+ mySurfaces.Write(OS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- WriteTriangulation(OS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
+ WriteTriangulation(OS, aPS.Next());
}
//=======================================================================
//=======================================================================
void BinTools_ShapeSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+ const Message_ProgressRange& theRange)const
{
// write the copyright
// write the geometry
//-----------------------------------------
- Message_ProgressSentry aPS(theProgress, "Writing geometry", 0, 2, 1);
+ Message_ProgressScope aPS(theRange, "Writing geometry", 2);
- WriteGeometry(OS, theProgress);
+ WriteGeometry(OS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
-
+
//-----------------------------------------
// write the shapes
//-----------------------------------------
Standard_Integer i, nbShapes = myShapes.Extent();
- Message_ProgressSentry aPSinner(theProgress, "Writing shapes", 0, nbShapes, 1);
+ Message_ProgressScope aPSinner(aPS.Next(), "Writing shapes", nbShapes);
OS << "\nTShapes " << nbShapes << "\n";
// subshapes are written first
- for (i = 1; i <= nbShapes && aPS.More(); i++, aPS.Next()) {
+ for (i = 1; i <= nbShapes && aPSinner.More(); i++, aPSinner.Next()) {
const TopoDS_Shape& S = myShapes(i);
//=======================================================================
void BinTools_ShapeSet::Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Clear();
//-----------------------------------------
// read the geometry
//-----------------------------------------
- Message_ProgressSentry aPSouter(theProgress, "Reading", 0, 2, 1);
- ReadGeometry(IS, theProgress);
+ Message_ProgressScope aPSouter(theRange, "Reading", 2);
+ ReadGeometry(IS, aPSouter.Next());
if (!aPSouter.More())
return;
- aPSouter.Next();
//-----------------------------------------
// read the shapes
//-----------------------------------------
Standard_Integer nbShapes = 0;
IS >> nbShapes;
IS.get();//remove lf
- Message_ProgressSentry aPSinner(theProgress, "Reading Shapes", 0, nbShapes, 1);
+ Message_ProgressScope aPSinner(aPSouter.Next(), "Reading Shapes", nbShapes);
for (int i = 1; i <= nbShapes && aPSinner.More(); i++, aPSinner.Next()) {
TopoDS_Shape S;
//=======================================================================
void BinTools_ShapeSet::ReadGeometry (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
- Message_ProgressSentry aPS(theProgress, "Reading geomentry", 0, 6, 1);
- myCurves2d.Read(IS, theProgress);
- if (!aPS.More())
- return;
- aPS.Next();
- myCurves.Read(IS, theProgress);
+ Message_ProgressScope aPS(theRange, "Reading geomentry", 6);
+ myCurves2d.Read(IS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- ReadPolygon3D(IS, theProgress);
+ myCurves.Read(IS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- ReadPolygonOnTriangulation(IS, theProgress);
+ ReadPolygon3D(IS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- mySurfaces.Read(IS, theProgress);
+ ReadPolygonOnTriangulation(IS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
- ReadTriangulation(IS, theProgress);
+ mySurfaces.Read(IS, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
+ ReadTriangulation(IS, aPS.Next());
}
//=======================================================================
//=======================================================================
void BinTools_ShapeSet::WritePolygonOnTriangulation
(Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress) const
+ const Message_ProgressRange& theRange) const
{
const Standard_Integer aNbPol = myNodes.Extent();
OS << "PolygonOnTriangulations " << aNbPol << "\n";
try
{
OCC_CATCH_SIGNALS
- Message_ProgressSentry aPS(theProgress, "Writing polygons on triangulation", 0, aNbPol, 1);
+ Message_ProgressScope aPS(theRange, "Writing polygons on triangulation", aNbPol);
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
{
const Handle(Poly_PolygonOnTriangulation)& aPoly = myNodes.FindKey (aPolIter);
//=======================================================================
void BinTools_ShapeSet::ReadPolygonOnTriangulation
(Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
char aHeader[255];
IS >> aHeader;
try
{
OCC_CATCH_SIGNALS
- Message_ProgressSentry aPS(theProgress, "Reading Polygones on triangulation", 0, aNbPol, 1);
+ Message_ProgressScope aPS(theRange, "Reading Polygones on triangulation", aNbPol);
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
{
Standard_Integer aNbNodes = 0;
//function : WritePolygon3D
//purpose :
//=======================================================================
-void BinTools_ShapeSet::WritePolygon3D(Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+void BinTools_ShapeSet::WritePolygon3D (Standard_OStream& OS,
+ const Message_ProgressRange& theRange)const
{
const Standard_Integer aNbPol = myPolygons3D.Extent();
OS << "Polygon3D " << aNbPol << "\n";
try
{
OCC_CATCH_SIGNALS
- Message_ProgressSentry aPS(theProgress, "Writing polygons 3D", 0, aNbPol, 1);
+ Message_ProgressScope aPS(theRange, "Writing polygons 3D", aNbPol);
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
{
const Handle(Poly_Polygon3D)& aPoly = myPolygons3D.FindKey (aPolIter);
//purpose :
//=======================================================================
void BinTools_ShapeSet::ReadPolygon3D (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
char aHeader[255];
IS >> aHeader;
try
{
OCC_CATCH_SIGNALS
- Message_ProgressSentry aPS(theProgress, "Reading polygones 3D", 0, aNbPol, 1);
+ Message_ProgressScope aPS(theRange, "Reading polygones 3D", aNbPol);
for (Standard_Integer aPolIter = 1; aPolIter <= aNbPol && aPS.More(); ++aPolIter, aPS.Next())
{
Standard_Integer aNbNodes = 0;
//purpose :
//=======================================================================
void BinTools_ShapeSet::WriteTriangulation (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress) const
+ const Message_ProgressRange& theRange) const
{
const Standard_Integer aNbTriangulations = myTriangulations.Extent();
OS << "Triangulations " << aNbTriangulations << "\n";
try
{
OCC_CATCH_SIGNALS
- Message_ProgressSentry aPS(theProgress, "Writing triangulation", 0, aNbTriangulations, 1);
+ Message_ProgressScope aPS(theRange, "Writing triangulation", aNbTriangulations);
for (Standard_Integer aTriangulationIter = 1; aTriangulationIter <= aNbTriangulations && aPS.More(); ++aTriangulationIter, aPS.Next())
{
const Handle(Poly_Triangulation)& aTriangulation = myTriangulations.FindKey (aTriangulationIter);
//purpose :
//=======================================================================
void BinTools_ShapeSet::ReadTriangulation (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
char aHeader[255];
IS >> aHeader;
try
{
OCC_CATCH_SIGNALS
- Message_ProgressSentry aPS(theProgress, "Reading triangulation", 0, aNbTriangulations, 1);
+ Message_ProgressScope aPS(theRange, "Reading triangulation", aNbTriangulations);
for (Standard_Integer aTriangulationIter = 1; aTriangulationIter <= aNbTriangulations && aPS.More(); ++aTriangulationIter, aPS.Next())
{
Standard_Integer aNbNodes = 0, aNbTriangles = 0;
//! Write the flags, the subshapes.
Standard_EXPORT virtual void Write
(Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the content of me from the binary stream <IS>. me
//! is first cleared.
//! Reads the flag, the subshapes.
Standard_EXPORT virtual void Read
(Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Writes on <OS> the shape <S>. Writes the
//! orientation, the index of the TShape and the index
//! binary format that can be read back by Read.
Standard_EXPORT virtual void WriteGeometry
(Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the geometry of me from the stream <IS>.
Standard_EXPORT virtual void ReadGeometry
(Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Reads from <IS> a shape and returns it in S.
//! <NbShapes> is the number of tshapes in the set.
//! from the stream <IS>.
Standard_EXPORT void ReadPolygon3D
(Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Writes the 3d polygons
//! on the stream <OS> in a format that can
//! be read back by Read.
Standard_EXPORT void WritePolygon3D
(Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the triangulation of me
//! from the stream <IS>.
Standard_EXPORT void ReadTriangulation
(Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Writes the triangulation
//! on the stream <OS> in a format that can
//! be read back by Read.
Standard_EXPORT void WriteTriangulation
(Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the polygons on triangulation of me
//! from the stream <IS>.
Standard_EXPORT void ReadPolygonOnTriangulation
(Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Writes the polygons on triangulation
//! on the stream <OS> in a format that can
//! be read back by Read.
Standard_EXPORT void WritePolygonOnTriangulation
(Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
private:
#include <TColStd_Array1OfInteger.hxx>
#include <TColStd_Array1OfReal.hxx>
#include <TColStd_Array2OfReal.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#define PLANE 1
#define CYLINDER 2
//=======================================================================
void BinTools_SurfaceSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+ const Message_ProgressRange& theRange)const
{
Standard_Integer i, nbsurf = myMap.Extent();
- Message_ProgressSentry aPS(theProgress, "Writing surfases", 0, nbsurf, 1);
+ Message_ProgressScope aPS(theRange, "Writing surfases", nbsurf);
OS << "Surfaces "<< nbsurf << "\n";
for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
WriteSurface(Handle(Geom_Surface)::DownCast(myMap(i)),OS);
//=======================================================================
void BinTools_SurfaceSet::Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
char buffer[255];
IS >> buffer;
Handle(Geom_Surface) S;
Standard_Integer i, nbsurf;
IS >> nbsurf;
- Message_ProgressSentry aPS(theProgress, "Reading surfaces", 0, nbsurf, 1);
+ Message_ProgressScope aPS(theRange, "Reading surfaces", nbsurf);
IS.get ();//remove <lf>
for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
BinTools_SurfaceSet::ReadSurface(IS,S);
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class Standard_OutOfRange;
class Geom_Surface;
//! Writes the content of me on the stream <OS> in
//! binary format that can be read back by Read.
Standard_EXPORT void Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) const;
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
Standard_EXPORT void Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ const Message_ProgressRange& therange = Message_ProgressRange());
//! Dumps the surface on the stream in binary
//! format that can be read back.
#include <Standard_NoSuchObject.hxx>
#include <Standard_ProgramError.hxx>
#include <UTL.hxx>
-#include <Message_ProgressSentry.hxx>
IMPLEMENT_STANDARD_RTTIEXT(CDF_Application,CDM_Application)
//=======================================================================
Handle(CDM_Document) CDF_Application::Retrieve (const TCollection_ExtendedString& aFolder,
const TCollection_ExtendedString& aName,
const Standard_Boolean UseStorageConfiguration,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
TCollection_ExtendedString nullVersion;
- return Retrieve(aFolder, aName, nullVersion, UseStorageConfiguration, theProgress);
+ return Retrieve(aFolder, aName, nullVersion, UseStorageConfiguration, theRange);
}
//=======================================================================
const TCollection_ExtendedString& aName,
const TCollection_ExtendedString& aVersion,
const Standard_Boolean UseStorageConfiguration,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Handle(CDM_MetaData) theMetaData;
CDF_TypeOfActivation theTypeOfActivation=TypeOfActivation(theMetaData);
Handle(CDM_Document) theDocument = Retrieve(theMetaData, UseStorageConfiguration,
- Standard_False, theProgress);
+ Standard_False, theRange);
myDirectory->Add(theDocument);
Activate(theDocument,theTypeOfActivation);
//=======================================================================
Handle(CDM_Document) CDF_Application::Retrieve(const Handle(CDM_MetaData)& aMetaData,
const Standard_Boolean UseStorageConfiguration,
- const Handle(Message_ProgressIndicator)& theProgress) {
- return Retrieve(aMetaData, UseStorageConfiguration, Standard_True, theProgress);
+ const Message_ProgressRange& theRange) {
+ return Retrieve(aMetaData, UseStorageConfiguration, Standard_True, theRange);
}
//=======================================================================
Handle(CDM_Document) CDF_Application::Retrieve (const Handle(CDM_MetaData)& aMetaData,
const Standard_Boolean UseStorageConfiguration,
const Standard_Boolean IsComponent,
- const Handle(Message_ProgressIndicator)& theProgress) {
+ const Message_ProgressRange& theRange) {
Handle(CDM_Document) theDocumentToReturn;
myRetrievableStatus = PCDM_RS_DriverFailure;
try {
OCC_CATCH_SIGNALS
- theReader->Read (aMetaData->FileName(), theDocument, this, theProgress);
+ theReader->Read (aMetaData->FileName(), theDocument, this, theRange);
}
catch (Standard_Failure const& anException) {
myRetrievableStatus = theReader->GetStatus();
//purpose :
//=======================================================================
Handle(CDM_Document) CDF_Application::Read (Standard_IStream& theIStream,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Handle(CDM_Document) aDoc;
Handle(Storage_Data) dData;
try
{
OCC_CATCH_SIGNALS
- aReader->Read (theIStream, dData, aDoc, this, theProgress);
+ aReader->Read (theIStream, dData, aDoc, this, theRange);
}
catch (Standard_Failure const& anException)
{
(const TCollection_ExtendedString& aFolder,
const TCollection_ExtendedString& aName,
const Standard_Boolean UseStorageConfiguration = Standard_True,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! This method retrieves a document from the database.
//! If the Document references other documents which have
const TCollection_ExtendedString& aName,
const TCollection_ExtendedString& aVersion,
const Standard_Boolean UseStorageConfiguration = Standard_True,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT PCDM_ReaderStatus CanRetrieve (const TCollection_ExtendedString& aFolder,
const TCollection_ExtendedString& aName);
//! the stream should support SEEK fuctionality
Standard_EXPORT Handle(CDM_Document) Read
(Standard_IStream& theIStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Returns instance of read driver for specified format.
//!
Standard_EXPORT Handle(CDM_Document) Retrieve
(const Handle(CDM_MetaData)& aMetaData,
const Standard_Boolean UseStorageConfiguration,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT Handle(CDM_Document) Retrieve
(const Handle(CDM_MetaData)& aMetaData,
const Standard_Boolean UseStorageConfiguration,
const Standard_Boolean IsComponent,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT Standard_Integer DocumentVersion (const Handle(CDM_MetaData)& theMetaData) Standard_OVERRIDE;
return SetName(theName);
}
-void CDF_Store::Realize (const Handle(Message_ProgressIndicator)& theProgress)
+void CDF_Store::Realize (const Message_ProgressRange& theRange)
{
Standard_ProgramError_Raise_if(!myList->IsConsistent(),"information are missing");
Handle(CDM_MetaData) m;
myText = "";
- myStatus = myList->Store(m, myText, theProgress);
+ myStatus = myList->Store(m, myText, theRange);
if(myStatus==PCDM_SS_OK) myPath = m->Path();
}
Standard_ExtString CDF_Store::Path() const {
#include <CDF_SubComponentStatus.hxx>
#include <TCollection_HExtendedString.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class CDF_StoreList;
class CDM_Document;
Standard_EXPORT Standard_Boolean SetPreviousVersion (const Standard_ExtString aPreviousVersion);
- Standard_EXPORT void Realize (const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ Standard_EXPORT void Realize (const Message_ProgressRange& theRange = Message_ProgressRange());
//! returns the complete path of the created meta-data.
Standard_EXPORT Standard_ExtString Path() const;
}
PCDM_StoreStatus CDF_StoreList::Store (Handle(CDM_MetaData)& aMetaData,
TCollection_ExtendedString& aStatusAssociatedText,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Handle(CDF_MetaDataDriver) theMetaDataDriver = Handle(CDF_Application)::DownCast((myMainDocument->Application()))->MetaDataDriver();
}
TCollection_ExtendedString theName=theMetaDataDriver->BuildFileName(theDocument);
- aDocumentStorageDriver->Write(theDocument, theName, theProgress);
+ aDocumentStorageDriver->Write(theDocument, theName, theRange);
status = aDocumentStorageDriver->GetStoreStatus();
aMetaData = theMetaDataDriver->CreateMetaData(theDocument,theName);
theDocument->SetMetaData(aMetaData);
//! order of which they had been added.
Standard_EXPORT PCDM_StoreStatus Store (Handle(CDM_MetaData)& aMetaData,
TCollection_ExtendedString& aStatusAssociatedText,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT void Init();
#include <TCollection_AsciiString.hxx>
#include <TCollection_ExtendedString.hxx>
#include <CDM_MetaDataLookUpTable.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class CDM_Reference;
class CDM_MetaData;
Standard_EXPORT virtual Handle(CDM_Document) Retrieve
(const Handle(CDM_MetaData)& aMetaData,
const Standard_Boolean UseStorageConfiguration,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) = 0;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) = 0;
//! returns -1 if the metadata has no modification counter.
Standard_EXPORT virtual Standard_Integer DocumentVersion (const Handle(CDM_MetaData)& aMetaData) = 0;
#include <Draw.hxx>
#include <Draw_Appli.hxx>
#include <Draw_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
#include <Draw_Segment3D.hxx>
#include <gp_Ax2.hxx>
#include <GProp.hxx>
TCollection_AsciiString anArgCase (argv[i]);
anArgCase.LowerCase();
- if (anArgCase == "-tcloutput")
- {
- Draw_ProgressIndicator::DefaultTclOutput() = Standard_True;
- return 0;
- }
- else if ( argv[i][1] == 't' ) Draw_ProgressIndicator::DefaultTextMode() = turn;
+ if ( argv[i][1] == 't' ) Draw_ProgressIndicator::DefaultTclMode() = turn;
+ else if (argv[i][1] == 'c') Draw_ProgressIndicator::DefaultConsoleMode() = turn;
else if ( argv[i][1] == 'g' ) Draw_ProgressIndicator::DefaultGraphMode() = turn;
else if ( ! strcmp ( argv[i], "-stop" ) && i+1 < argc )
{
return 0;
}
}
- di << "Progress Indicator defaults: text mode is ";
- if ( Draw_ProgressIndicator::DefaultTextMode() ) {
+ di << "Progress Indicator defaults: tcl mode is ";
+ if ( Draw_ProgressIndicator::DefaultTclMode() ) {
di<<"ON";
} else {
di<<"OFF";
}
- di<<", graphical mode is ";
+ di<<", console mode is ";
+ if (Draw_ProgressIndicator::DefaultConsoleMode()) {
+ di << "ON";
+ }
+ else {
+ di << "OFF";
+ }
+ di << ", graphical mode is ";
if ( Draw_ProgressIndicator::DefaultGraphMode() ) {
di<<"ON";
} else {
// Add command for DRAW-specific ProgressIndicator
theCommands.Add ( "XProgress",
- "XProgress [+|-t] [+|-g] [-tclOutput]"
- "\n\t\t: The options are:"
- "\n\t\t: +|-t, +|-g : switch on/off textual and graphical mode of Progress Indicator"
- "\n\t\t: -tclOutput : switch on data output mode in tcl"
- "\n\t\t: Allows to control the output form of Progress Indicator",
+ "XProgress [+|-t] [+|-c] [+|-g]"
+ "\n\t\t The options are:"
+ "\n\t\t +|-t : switch on/off output to tcl of Progress Indicator"
+ "\n\t\t +|-c : switch on/off output to cout of Progress Indicator"
+ "\n\t\t +|-g : switch on/off graphical mode of Progress Indicator",
XProgress,"DE: General");
theCommands.Add("binsave", "binsave shape filename\n"
BRep_Builder B;
BRepTools_ShapeSet S(B);
S.Add (N->Shape());
- S.Write (OS, Draw::GetProgressBar());
- if(!Draw::GetProgressBar().IsNull() && Draw::GetProgressBar()->UserBreak())
+ Handle(Draw_ProgressIndicator) aProgress = Draw::GetProgressBar();
+ S.Write(OS, Message_ProgressIndicator::Start(aProgress));
+ if (! aProgress.IsNull() && aProgress->UserBreak())
return;
S.Write(N->Shape(),OS);
}
{
BRep_Builder B;
BRepTools_ShapeSet S(B);
- S.Read (IS, Draw::GetProgressBar());
+ Handle(Draw_ProgressIndicator) aProgress = Draw::GetProgressBar();
+ S.Read(IS, Message_ProgressIndicator::Start(aProgress));
Handle(DBRep_DrawableShape) N;
- if(!Draw::GetProgressBar().IsNull() && Draw::GetProgressBar()->UserBreak())
+ if (! aProgress.IsNull() && aProgress->UserBreak())
return N;
TopoDS_Shape theShape;
S.Read(theShape,IS );
std::ifstream aFileStream;
OSD_OpenStream (aFileStream, path, std::ios::in | std::ios::binary);
- theStatus = A->Open (aFileStream, D, aProgress);
+ theStatus = A->Open (aFileStream, D, aProgress->Start());
}
else
{
- theStatus = A->Open (path, D, aProgress);
+ theStatus = A->Open (path, D, aProgress->Start());
}
if (theStatus == PCDM_RS_OK && !D.IsNull())
{
}
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
- A->Save (D, aProgress);
+ A->Save (D, aProgress->Start());
return 0;
}
di << "DDocStd_Save : Error\n";
{
std::ofstream aFileStream;
OSD_OpenStream (aFileStream, path, std::ios::out | std::ios::binary);
- theStatus = A->SaveAs (D, aFileStream, aProgress);
+ theStatus = A->SaveAs (D, aFileStream, aProgress->Start());
}
else
{
- theStatus = A->SaveAs(D,path, aProgress);
+ theStatus = A->SaveAs(D,path, aProgress->Start());
}
if (theStatus != PCDM_SS_OK ) {
static std::ostream spystream(&Draw_Spyfile);
-static Handle(Draw_ProgressIndicator) PInd = NULL;
+static Handle(Draw_ProgressIndicator) global_Progress = NULL;
Standard_EXPORT Standard_Boolean Draw_Interprete(const char* command);
// true if complete command
//function :
//purpose : Set/Get Progress Indicator
//=======================================================================
-void Draw::SetProgressBar(const Handle(Draw_ProgressIndicator)& thePI)
+void Draw::SetProgressBar(const Handle(Draw_ProgressIndicator)& theProgress)
{
- PInd = thePI;
+ global_Progress = theProgress;
}
Handle(Draw_ProgressIndicator) Draw::GetProgressBar()
{
- return PInd;
+ return global_Progress;
}
#ifndef _WIN32
Standard_EXPORT static void Repaint();
//! sets progress indicator
- Standard_EXPORT static void SetProgressBar (const Handle(Draw_ProgressIndicator)& thePI);
+ Standard_EXPORT static void SetProgressBar (const Handle(Draw_ProgressIndicator)& theProgress);
//! gets progress indicator
Standard_EXPORT static Handle(Draw_ProgressIndicator) GetProgressBar();
#include <Draw_ProgressIndicator.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressScale.hxx>
+#include <Message_ProgressScope.hxx>
+#include <NCollection_List.hxx>
#include <Precision.hxx>
+#include <OSD.hxx>
+#include <OSD_Exception_CTRL_BREAK.hxx>
+#include <OSD_Thread.hxx>
#include <stdio.h>
#include <time.h>
//purpose :
//=======================================================================
Draw_ProgressIndicator::Draw_ProgressIndicator (const Draw_Interpretor &di, Standard_Real theUpdateThreshold)
-: myTextMode ( DefaultTextMode() ),
+: myTclMode ( DefaultTclMode() ),
+ myConsoleMode ( DefaultConsoleMode() ),
myGraphMode ( DefaultGraphMode() ),
- myTclOutput ( DefaultTclOutput() ),
myDraw ( (Draw_Interpretor*)&di ),
myShown ( Standard_False ),
myBreak ( Standard_False ),
myUpdateThreshold ( 0.01 * theUpdateThreshold ),
myLastPosition ( -1. ),
- myStartTime ( 0 )
+ myStartTime ( 0 ),
+ myGuiThreadId (OSD_Thread::Current())
{
}
//purpose :
//=======================================================================
-Standard_Boolean Draw_ProgressIndicator::Show(const Standard_Boolean force)
+void Draw_ProgressIndicator::Show (const Message_ProgressScope& theScope, const Standard_Boolean force)
{
- if ( ! myGraphMode && ! myTextMode )
- return Standard_False;
+ if (!myGraphMode && !myTclMode && !myConsoleMode)
+ return;
// remember time of the first call to Show as process start time
if ( ! myStartTime )
{
- time_t aTimeT;
- time ( &aTimeT );
- myStartTime = (Standard_Size)aTimeT;
+ if (!myStartTime)
+ {
+ time_t aTimeT;
+ time(&aTimeT);
+ myStartTime = (Standard_Size)aTimeT;
+ }
}
// unless show is forced, show updated state only if at least 1% progress has been reached since the last update
Standard_Real aPosition = GetPosition();
if ( ! force && aPosition < 1. && Abs (aPosition - myLastPosition) < myUpdateThreshold)
- return Standard_False; // return if update interval has not elapsed
+ return; // return if update interval has not elapsed
+
myLastPosition = aPosition;
// Prepare textual progress info
aText.setf (std::ios::fixed, std:: ios::floatfield);
aText.precision(0);
aText << "Progress: " << 100. * GetPosition() << "%";
- for ( Standard_Integer i=GetNbScopes(); i >=1; i-- ) {
- const Message_ProgressScale &scale = GetScope ( i );
- if ( scale.GetName().IsNull() ) continue; // skip unnamed scopes
- aText << " " << scale.GetName()->ToCString() << ": ";
+ NCollection_List<const Message_ProgressScope*> aScopes;
+ for (const Message_ProgressScope* aPS = &theScope; aPS; aPS = aPS->Parent())
+ aScopes.Prepend(aPS);
+ for (NCollection_List<const Message_ProgressScope*>::Iterator it(aScopes); it.More(); it.Next())
+ {
+ const Message_ProgressScope* aPS = it.Value();
+ if (!aPS->Name()) continue; // skip unnamed scopes
+ aText << " " << aPS->Name() << ": ";
- // if scope has subscopes, print end of subscope as it s current position
- Standard_Real locPos = ( (i >1 && GetPosition()!=0) ? GetScope ( i-1 ).GetLast() : GetPosition() );
// print progress info differently for finite and infinite scopes
- if ( scale.GetInfinite() )
+ Standard_Real aVal = aPS->Value();
+ if (aPS->IsInfinite())
{
- Standard_Real aVal = scale.BaseToLocal(locPos);
if (Precision::IsInfinite(aVal))
{
aText << "finished";
}
else
{
- aText << scale.BaseToLocal ( locPos ) << " / " << scale.GetMax();
+ aText << aVal << " / " << aPS->MaxValue();
}
}
- // Show graphic progress bar
- if ( myGraphMode ) {
-
+ // Show graphic progress bar.
+ // It will be updated only within GUI thread.
+ if (myGraphMode && myGuiThreadId == OSD_Thread::Current())
+ {
// In addition, write elapsed/estimated/remaining time
if ( GetPosition() > 0.01 ) {
time_t aTimeT;
aCommand.setf(std::ios::fixed, std::ios::floatfield);
aCommand.precision(0);
aCommand << ".xprogress.bar coords progress 2 2 " << (1 + 400 * GetPosition()) << " 21;";
- aCommand << ".xprogress.bar coords progress_next 2 2 " << (1 + 400 * GetScope(1).GetLast()) << " 21;";
+ aCommand << ".xprogress.bar coords progress_next 2 2 " << (1 + 400 * theScope.GetPortion()) << " 21;";
aCommand << ".xprogress.text configure -text \"" << aText.str() << "\";";
aCommand << "update";
myDraw->Eval (aCommand.str().c_str());
}
// Print textual progress info
- if (myTextMode)
+ if (myTclMode && myDraw)
{
- if (myTclOutput && myDraw)
- {
- *myDraw << aText.str().c_str() << "\n";
- }
- else
- {
- std::cout << aText.str().c_str() << "\n";
- }
+ *myDraw << aText.str().c_str() << "\n";
+ }
+ if (myConsoleMode)
+ {
+ std::cout << aText.str().c_str() << "\n";
}
- return Standard_True;
}
//=======================================================================
Standard_Boolean Draw_ProgressIndicator::UserBreak()
{
- if ( StopIndicator() == this ) {
+ if ( StopIndicator() == this )
+ {
// std::cout << "Progress Indicator - User Break: " << StopIndicator() << ", " << (void*)this << std::endl;
myBreak = Standard_True;
myDraw->Eval ( "XProgress -stop 0" );
}
+ else
+ {
+ // treatment of Ctrl-Break signal
+ try
+ {
+ OSD::ControlBreak();
+ }
+ catch (OSD_Exception_CTRL_BREAK)
+ {
+ myBreak = Standard_True;
+ }
+ }
return myBreak;
}
//=======================================================================
-//function : SetTextMode
-//purpose : Sets text output mode (on/off)
+//function : SetTclMode
+//purpose : Sets Tcl output mode (on/off)
//=======================================================================
-void Draw_ProgressIndicator::SetTextMode(const Standard_Boolean theTextMode)
+void Draw_ProgressIndicator::SetTclMode(const Standard_Boolean theTclMode)
{
- myTextMode = theTextMode;
+ myTclMode = theTclMode;
}
//=======================================================================
-//function : GetTextMode
-//purpose : Returns text output mode (on/off)
+//function : GetTclMode
+//purpose : Returns Tcl output mode (on/off)
//=======================================================================
-Standard_Boolean Draw_ProgressIndicator::GetTextMode() const
+Standard_Boolean Draw_ProgressIndicator::GetTclMode() const
{
- return myTextMode;
+ return myTclMode;
+}
+
+//=======================================================================
+//function : SetConsoleMode
+//purpose : Sets Console output mode (on/off)
+//=======================================================================
+
+void Draw_ProgressIndicator::SetConsoleMode(const Standard_Boolean theMode)
+{
+ myConsoleMode = theMode;
+}
+
+//=======================================================================
+//function : GetConsoleMode
+//purpose : Returns Console output mode (on/off)
+//=======================================================================
+
+Standard_Boolean Draw_ProgressIndicator::GetConsoleMode() const
+{
+ return myConsoleMode;
}
//=======================================================================
}
//=======================================================================
-//function : DefaultTextMode
+//function : DefaultTclMode
//purpose :
//=======================================================================
-Standard_Boolean &Draw_ProgressIndicator::DefaultTextMode()
+Standard_Boolean &Draw_ProgressIndicator::DefaultTclMode()
{
- static Standard_Boolean defTextMode = Standard_False;
- return defTextMode;
+ static Standard_Boolean defTclMode = Standard_False;
+ return defTclMode;
}
//=======================================================================
-//function : DefaultGraphMode
+//function : DefaultConsoleMode
//purpose :
//=======================================================================
-Standard_Boolean &Draw_ProgressIndicator::DefaultGraphMode()
+Standard_Boolean &Draw_ProgressIndicator::DefaultConsoleMode()
{
- static Standard_Boolean defGraphMode = Standard_False;
- return defGraphMode;
+ static Standard_Boolean defConsoleMode = Standard_False;
+ return defConsoleMode;
}
//=======================================================================
-//function : DefaultTclOutput
-//purpose :
+//function : DefaultGraphMode
+//purpose :
//=======================================================================
-Standard_Boolean &Draw_ProgressIndicator::DefaultTclOutput()
+Standard_Boolean &Draw_ProgressIndicator::DefaultGraphMode()
{
- static Standard_Boolean defTclOutput = Standard_False;
- return defTclOutput;
+ static Standard_Boolean defGraphMode = Standard_False;
+ return defGraphMode;
}
//=======================================================================
//! Destructor; calls Reset()
Standard_EXPORT ~Draw_ProgressIndicator();
- //! Sets text output mode (on/off)
- Standard_EXPORT void SetTextMode (const Standard_Boolean theTextMode);
-
- //! Gets text output mode (on/off)
- Standard_EXPORT Standard_Boolean GetTextMode() const;
+ //! Sets tcl output mode (on/off).
+ Standard_EXPORT void SetTclMode (const Standard_Boolean theTclMode);
+ //! Gets tcl output mode (on/off).
+ Standard_EXPORT Standard_Boolean GetTclMode() const;
+
+ //! Sets console output mode (on/off).
+ //! If it is on then progress is shown in the standard output.
+ Standard_EXPORT void SetConsoleMode(const Standard_Boolean theMode);
+
+ //! Gets console output mode (on/off)
+ Standard_EXPORT Standard_Boolean GetConsoleMode() const;
+
//! Sets graphical output mode (on/off)
Standard_EXPORT void SetGraphMode (const Standard_Boolean theGraphMode);
//! Gets graphical output mode (on/off)
Standard_EXPORT Standard_Boolean GetGraphMode() const;
- //! Sets tcl output mode (on/off)
- void SetTclOutput (const Standard_Boolean theTclOutput) { myTclOutput = theTclOutput; }
-
- //! Gets tcl output mode (on/off)
- Standard_Boolean GetTclOutput() const { return myTclOutput; }
-
//! Clears/erases opened TCL windows if any
//! and sets myBreak to False
Standard_EXPORT virtual void Reset() Standard_OVERRIDE;
//! Defines method Show of Progress Indicator
- Standard_EXPORT virtual Standard_Boolean Show (const Standard_Boolean force = Standard_True) Standard_OVERRIDE;
+ Standard_EXPORT virtual void Show (const Message_ProgressScope& theScope,
+ const Standard_Boolean force = Standard_True) Standard_OVERRIDE;
//! Redefines method UserBreak of Progress Indicator
Standard_EXPORT virtual Standard_Boolean UserBreak() Standard_OVERRIDE;
- Standard_EXPORT static Standard_Boolean& DefaultTextMode();
-
- //! Get/Set default values for output modes
- Standard_EXPORT static Standard_Boolean& DefaultGraphMode();
+ //! Get/Set default value for tcl mode
+ Standard_EXPORT static Standard_Boolean& DefaultTclMode();
- //! Get/Set default values for tcl output mode
- Standard_EXPORT static Standard_Boolean& DefaultTclOutput();
+ //! Get/Set default value for console mode
+ Standard_EXPORT static Standard_Boolean& DefaultConsoleMode();
+
+ //! Get/Set default value for graph mode
+ Standard_EXPORT static Standard_Boolean& DefaultGraphMode();
//! Internal method for implementation of UserBreak mechanism;
//! note that it uses static variable and thus not thread-safe!
DEFINE_STANDARD_RTTIEXT(Draw_ProgressIndicator,Message_ProgressIndicator)
private:
- Standard_Boolean myTextMode;
+ Standard_Boolean myTclMode;
+ Standard_Boolean myConsoleMode;
Standard_Boolean myGraphMode;
- Standard_Boolean myTclOutput;
Draw_Interpretor* myDraw;
Standard_Boolean myShown;
Standard_Boolean myBreak;
Standard_Real myUpdateThreshold;
Standard_Real myLastPosition;
Standard_Size myStartTime;
+ Standard_ThreadId myGuiThreadId;
};
#endif // _Draw_ProgressIndicator_HeaderFile
// find a tool
Draw_SaveAndRestore* tool = Draw_First;
Handle(Draw_ProgressIndicator) progress = new Draw_ProgressIndicator ( di, 1 );
- progress->SetScale ( 0, 100, 1 );
- progress->NewScope(100,"Writing");
- progress->Show();
while (tool) {
if (tool->Test(D)) break;
return 1;
}
Draw::SetProgressBar( 0 );
- progress->EndScope();
- progress->Show();
}
os << "0\n\n";
if (!in.fail()) {
// search a tool
Handle(Draw_ProgressIndicator) progress = new Draw_ProgressIndicator ( di, 1 );
- progress->NewScope(100,"Reading");
- progress->Show();
+ Draw::SetProgressBar(progress);
Draw_SaveAndRestore* tool = Draw_First;
Draw_SaveAndRestore* aDBRepTool = NULL;
if (!strcmp(typ,toolName)) break;
if (!strcmp("DBRep_DrawableShape",toolName))
aDBRepTool = tool;
- Draw::SetProgressBar(progress);
tool = tool->Next();
}
return 1;
}
Draw::SetProgressBar( 0 );
- progress->EndScope();
- progress->Show();
}
di << name;
#include <TColgp_SequenceOfVec.hxx>
#include <TColStd_HArray1OfReal.hxx>
#include <TColStd_SequenceOfInteger.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <stdio.h>
// Function : Perform
// Calculates the surface filled with loaded constraints
//---------------------------------------------------------
-void GeomPlate_BuildPlateSurface::Perform(const Handle(Message_ProgressIndicator) & aProgress)
+void GeomPlate_BuildPlateSurface::Perform(const Message_ProgressRange& theProgress)
{
#ifdef OCCT_DEBUG
// Timing
//======================================================================
// Initial Surface
//======================================================================
+ Message_ProgressScope aPS(theProgress, NULL, 100, Standard_True);
if (!mySurfInitIsGive)
- ComputeSurfInit(aProgress);
+ {
+ ComputeSurfInit (aPS.Next(10));
+ if (aPS.UserBreak())
+ return;
+ }
else {
if (NTLinCont>=2)
// Construction of the surface
//====================================================================
- myPlate.SolveTI(myDegree, ComputeAnisotropie(), aProgress);
+ myPlate.SolveTI(myDegree, ComputeAnisotropie(), aPS.Next(90));
- if (!aProgress.IsNull() && aProgress->UserBreak())
+ if (aPS.UserBreak())
{
return;
}
//====================================================================
//Construction of the surface
//====================================================================
- myPlate.SolveTI(myDegree, ComputeAnisotropie(), aProgress);
+ myPlate.SolveTI(myDegree, ComputeAnisotropie(), aPS.Next(90));
- if (!aProgress.IsNull() && aProgress->UserBreak())
+ if (aPS.UserBreak())
{
return;
}
// there are point constraints.
//-------------------------------------------------------------------------
-void GeomPlate_BuildPlateSurface::ComputeSurfInit(const Handle(Message_ProgressIndicator) & aProgress)
+void GeomPlate_BuildPlateSurface::ComputeSurfInit(const Message_ProgressRange& theProgress)
{
Standard_Integer nopt=2, popt=2, Np=1;
Standard_Boolean isHalfSpace = Standard_True;
//====================================================================
// Construction of the surface
//====================================================================
- myPlate.SolveTI(2, ComputeAnisotropie(), aProgress);
- if (!aProgress.IsNull() && aProgress->UserBreak())
+ myPlate.SolveTI(2, ComputeAnisotropie(), theProgress);
+ if (theProgress.UserBreak())
{
return;
}
class Geom2d_Curve;
class Adaptor3d_HCurve;
class Adaptor2d_HCurve2d;
-class Message_ProgressIndicator;
//! Exceptions
//! Standard_RangeError if the value of the constraint is
//! null or if plate is not done.
- Standard_EXPORT void Perform(const Handle(Message_ProgressIndicator) & aProgress = Handle(Message_ProgressIndicator)());
+ Standard_EXPORT void Perform(const Message_ProgressRange& theProgress = Message_ProgressRange());
//! returns the CurveConstraints of order order
Standard_EXPORT Handle(GeomPlate_CurveConstraint) CurveConstraint (const Standard_Integer order) const;
Standard_EXPORT Handle(Adaptor2d_HCurve2d) ProjectedCurve (Handle(Adaptor3d_HCurve)& Curv);
- Standard_EXPORT void ComputeSurfInit(const Handle(Message_ProgressIndicator) & aProgress);
+ Standard_EXPORT void ComputeSurfInit(const Message_ProgressRange& theProgress);
Standard_EXPORT void Intersect (Handle(GeomPlate_HArray1OfSequenceOfReal)& PntInter, Handle(GeomPlate_HArray1OfSequenceOfReal)& PntG1G1);
#include <gp_Hypr2d.hxx>
#include <gp_Lin2d.hxx>
#include <gp_Parab2d.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <Standard_OutOfRange.hxx>
//purpose :
//=======================================================================
-void GeomTools_Curve2dSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator) &theProgress)const
+void GeomTools_Curve2dSet::Write(Standard_OStream& OS, const Message_ProgressRange& theProgress)const
{
std::streamsize prec = OS.precision(17);
Standard_Integer i, nbsurf = myMap.Extent();
OS << "Curve2ds "<< nbsurf << "\n";
- //OCC19559
- Message_ProgressSentry PS(theProgress, "2D Curves", 0, nbsurf, 1);
- for (i = 1; i <= nbsurf && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "2D Curves", nbsurf);
+ for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
PrintCurve2d(Handle(Geom2d_Curve)::DownCast(myMap(i)),OS,Standard_True);
}
OS.precision(prec);
//purpose :
//=======================================================================
-void GeomTools_Curve2dSet::Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress)
+void GeomTools_Curve2dSet::Read(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
char buffer[255];
IS >> buffer;
Standard_Integer i, nbcurve;
IS >> nbcurve;
- //OCC19559
- Message_ProgressSentry PS(theProgress, "2D Curves", 0, nbcurve, 1);
- for (i = 1; i <= nbcurve && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "2D Curves", nbcurve);
+ for (i = 1; i <= nbcurve && aPS.More(); i++, aPS.Next()) {
Handle(Geom2d_Curve) C = GeomTools_Curve2dSet::ReadCurve2d (IS);
myMap.Add(C);
}
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
#include <Standard_Boolean.hxx>
-class Message_ProgressIndicator;
+#include <Message_ProgressRange.hxx>
+
class Standard_OutOfRange;
class Geom2d_Curve;
//! Writes the content of me on the stream <OS> in a
//! format that can be read back by Read.
Standard_EXPORT void Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL) const;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
Standard_EXPORT void Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Dumps the curve on the stream, if compact is True
//! use the compact format that can be read back.
#include <gp_Hypr.hxx>
#include <gp_Lin.hxx>
#include <gp_Parab.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <Standard_OutOfRange.hxx>
//purpose :
//=======================================================================
-void GeomTools_CurveSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+void GeomTools_CurveSet::Write(Standard_OStream& OS, const Message_ProgressRange& theProgress)const
{
std::streamsize prec = OS.precision(17);
Standard_Integer i, nbcurve = myMap.Extent();
OS << "Curves "<< nbcurve << "\n";
- //OCC19559
- Message_ProgressSentry PS(theProgress, "3D Curves", 0, nbcurve, 1);
- for (i = 1; i <= nbcurve && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "3D Curves", nbcurve);
+ for (i = 1; i <= nbcurve && aPS.More(); i++, aPS.Next()) {
PrintCurve(Handle(Geom_Curve)::DownCast(myMap(i)),OS,Standard_True);
}
OS.precision(prec);
//purpose :
//=======================================================================
-void GeomTools_CurveSet::Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+void GeomTools_CurveSet::Read(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
char buffer[255];
IS >> buffer;
Standard_Integer i, nbcurve;
IS >> nbcurve;
- //OCC19559
- Message_ProgressSentry PS(theProgress, "3D Curves", 0, nbcurve, 1);
- for (i = 1; i <= nbcurve && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "3D Curves", nbcurve);
+ for (i = 1; i <= nbcurve && aPS.More(); i++, aPS.Next()) {
Handle(Geom_Curve) C = GeomTools_CurveSet::ReadCurve (IS);
myMap.Add(C);
}
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
#include <Standard_Boolean.hxx>
-class Message_ProgressIndicator;
+#include <Message_ProgressRange.hxx>
+
class Standard_OutOfRange;
class Geom_Curve;
//! Writes the content of me on the stream <OS> in a
//! format that can be read back by Read.
Standard_EXPORT void Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
Standard_EXPORT void Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Dumps the curve on the stream, if compact is True
//! use the compact format that can be read back.
#include <gp_Pln.hxx>
#include <gp_Sphere.hxx>
#include <gp_Torus.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <Standard_OutOfRange.hxx>
//purpose :
//=======================================================================
-void GeomTools_SurfaceSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress)const
+void GeomTools_SurfaceSet::Write(Standard_OStream& OS, const Message_ProgressRange& theProgress)const
{
std::streamsize prec = OS.precision(17);
Standard_Integer i, nbsurf = myMap.Extent();
OS << "Surfaces "<< nbsurf << "\n";
- //OCC19559
- Message_ProgressSentry PS(theProgress, "Surfaces", 0, nbsurf, 1);
- for (i = 1; i <= nbsurf && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "Surfaces", nbsurf);
+ for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
PrintSurface(Handle(Geom_Surface)::DownCast(myMap(i)),OS,Standard_True);
}
OS.precision(prec);
//purpose :
//=======================================================================
-void GeomTools_SurfaceSet::Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress)
+void GeomTools_SurfaceSet::Read(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
char buffer[255];
IS >> buffer;
Standard_Integer i, nbsurf;
IS >> nbsurf;
- //OCC19559
- Message_ProgressSentry PS(theProgress, "Surfaces", 0, nbsurf, 1);
- for (i = 1; i <= nbsurf && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope aPS(theProgress, "Surfaces", nbsurf);
+ for (i = 1; i <= nbsurf && aPS.More(); i++, aPS.Next()) {
Handle(Geom_Surface) S = GeomTools_SurfaceSet::ReadSurface (IS);
myMap.Add(S);
}
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
#include <Standard_Boolean.hxx>
-class Message_ProgressIndicator;
+#include <Message_ProgressRange.hxx>
+
class Standard_OutOfRange;
class Geom_Surface;
//! Writes the content of me on the stream <OS> in a
//! format that can be read back by Read.
Standard_EXPORT void Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
Standard_EXPORT void Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Dumps the surface on the stream, if compact is True
//! use the compact format that can be read back.
#include <XSControl_WorkSession.hxx>
//=======================================================================
-//function : Transfer
-//purpose : basic working method
+//function : checkColorRange
+//purpose :
//=======================================================================
static void checkColorRange (Standard_Real& theCol)
{
return;
}
-Standard_Boolean IGESCAFControl_Reader::Transfer (Handle(TDocStd_Document) &doc)
+//=======================================================================
+//function : Transfer
+//purpose : basic working method
+//=======================================================================
+Standard_Boolean IGESCAFControl_Reader::Transfer (Handle(TDocStd_Document) &doc,
+ const Message_ProgressRange& theProgress)
{
// read all shapes
Standard_Integer num;// = NbRootsForTransfer();
// TransferOneRoot ( i );
//}
- TransferRoots(); // replaces the above
+ TransferRoots(theProgress); // replaces the above
num = NbShapes();
if ( num <=0 ) return Standard_False;
//=======================================================================
Standard_Boolean IGESCAFControl_Reader::Perform (const Standard_CString filename,
- Handle(TDocStd_Document) &doc)
+ Handle(TDocStd_Document) &doc,
+ const Message_ProgressRange& theProgress)
{
if ( ReadFile ( filename ) != IFSelect_RetDone ) return Standard_False;
- return Transfer ( doc );
+ return Transfer ( doc, theProgress );
}
//! Translates currently loaded IGES file into the document
//! Returns True if succeeded, and False in case of fail
- Standard_EXPORT Standard_Boolean Transfer (Handle(TDocStd_Document)& theDoc);
+ Standard_EXPORT Standard_Boolean Transfer (Handle(TDocStd_Document)& theDoc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_Boolean Perform (const TCollection_AsciiString& theFileName, Handle(TDocStd_Document)& theDoc)
- { return Perform (theFileName.ToCString(), theDoc); }
+ Standard_Boolean Perform (const TCollection_AsciiString& theFileName,
+ Handle(TDocStd_Document)& theDoc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange())
+ { return Perform (theFileName.ToCString(), theDoc, theProgress); }
//! Translate IGES file given by filename into the document
//! Return True if succeeded, and False in case of fail
- Standard_EXPORT Standard_Boolean Perform (const Standard_CString theFileName, Handle(TDocStd_Document)& theDoc);
+ Standard_EXPORT Standard_Boolean Perform (const Standard_CString theFileName,
+ Handle(TDocStd_Document)& theDoc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Set ColorMode for indicate read Colors or not.
void SetColorMode (const Standard_Boolean theMode)
#include <IGESGraph_DefinitionLevel.hxx>
#include <IGESSolid_Face.hxx>
#include <IGESBasic_Name.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_DataMap.hxx>
#include <Standard_Transient.hxx>
#include <TCollection_AsciiString.hxx>
//purpose :
//=======================================================================
-Standard_Boolean IGESCAFControl_Writer::Transfer (const Handle(TDocStd_Document) &doc)
+Standard_Boolean IGESCAFControl_Writer::Transfer (const Handle(TDocStd_Document) &doc,
+ const Message_ProgressRange& theProgress)
{
// translate free top-level shapes of the DECAF document
Handle(XCAFDoc_ShapeTool) STool = XCAFDoc_DocumentTool::ShapeTool( doc->Main() );
TDF_LabelSequence labels;
STool->GetFreeShapes ( labels );
- return Transfer (labels);
+ return Transfer (labels, theProgress);
}
//=======================================================================
//purpose :
//=======================================================================
-Standard_Boolean IGESCAFControl_Writer::Transfer (const TDF_Label& label)
+Standard_Boolean IGESCAFControl_Writer::Transfer (const TDF_Label& label,
+ const Message_ProgressRange& theProgress)
{
TDF_LabelSequence labels;
labels.Append( label );
- return Transfer( labels );
+ return Transfer( labels, theProgress );
}
//=======================================================================
//purpose :
//=======================================================================
-Standard_Boolean IGESCAFControl_Writer::Transfer (const TDF_LabelSequence& labels)
+Standard_Boolean IGESCAFControl_Writer::Transfer (const TDF_LabelSequence& labels,
+ const Message_ProgressRange& theProgress)
{
if ( labels.Length() <=0 ) return Standard_False;
- for ( Standard_Integer i=1; i <= labels.Length(); i++ ) {
+ Message_ProgressScope aPS(theProgress, "Labels", labels.Length());
+ for ( Standard_Integer i=1; i <= labels.Length() && aPS.More(); i++ )
+ {
TopoDS_Shape shape = XCAFDoc_ShapeTool::GetShape ( labels.Value(i) );
if ( ! shape.IsNull() )
- AddShape ( shape );
+ AddShape (shape, aPS.Next());
// IGESControl_Writer::Transfer ( shape );
}
//=======================================================================
Standard_Boolean IGESCAFControl_Writer::Perform (const Handle(TDocStd_Document) &doc,
- const Standard_CString filename)
+ const Standard_CString filename,
+ const Message_ProgressRange& theProgress)
{
- if ( ! Transfer ( doc ) ) return Standard_False;
+ if ( ! Transfer ( doc, theProgress ) ) return Standard_False;
return Write ( filename ) == IFSelect_RetDone;
}
//=======================================================================
Standard_Boolean IGESCAFControl_Writer::Perform (const Handle(TDocStd_Document) &doc,
- const TCollection_AsciiString &filename)
+ const TCollection_AsciiString &filename,
+ const Message_ProgressRange& theProgress)
{
- if ( ! Transfer ( doc ) ) return Standard_False;
+ if ( ! Transfer ( doc, theProgress ) ) return Standard_False;
return Write ( filename.ToCString() ) == IFSelect_RetDone;
}
//! Transfers a document to a IGES model
//! Returns True if translation is OK
- Standard_EXPORT Standard_Boolean Transfer (const Handle(TDocStd_Document)& doc);
+ Standard_EXPORT Standard_Boolean Transfer (const Handle(TDocStd_Document)& doc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers labels to a IGES model
//! Returns True if translation is OK
- Standard_EXPORT Standard_Boolean Transfer (const TDF_LabelSequence& labels);
+ Standard_EXPORT Standard_Boolean Transfer (const TDF_LabelSequence& labels,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers label to a IGES model
//! Returns True if translation is OK
- Standard_EXPORT Standard_Boolean Transfer (const TDF_Label& label);
+ Standard_EXPORT Standard_Boolean Transfer (const TDF_Label& label,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc, const TCollection_AsciiString& filename);
+ Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc,
+ const TCollection_AsciiString& filename,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers a document and writes it to a IGES file
//! Returns True if translation is OK
- Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc, const Standard_CString filename);
+ Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc,
+ const Standard_CString filename,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Set ColorMode for indicate write Colors or not.
Standard_EXPORT void SetColorMode (const Standard_Boolean colormode);
Handle(Transfer_Binder) IGESControl_ActorWrite::Transfer
(const Handle(Transfer_Finder)& start,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
XSAlgo::AlgoContainer()->PrepareForTransfer();
shape = XSAlgo::AlgoContainer()->ProcessShape( shape, Tol, maxTol,
"write.iges.resource.name",
"write.iges.sequence", info,
- FP->GetProgress() );
+ theProgress );
// modified by NIZHNY-EAP Tue Aug 29 11:17:01 2000 ___END___
BRepToIGES_BREntity BR0; BR0.SetModel(modl); BR0.SetTransferProcess(FP);
BRepToIGESBRep_Entity BR1; BR1.SetModel(modl); BR1.SetTransferProcess(FP);
- if (themodetrans == 0) ent = BR0.TransferShape(shape);
- if (themodetrans == 1) ent = BR1.TransferShape(shape);
+ if (themodetrans == 0) ent = BR0.TransferShape(shape, theProgress);
+ if (themodetrans == 1) ent = BR1.TransferShape(shape, theProgress);
// modified by NIZHNY-EAP Tue Aug 29 11:37:18 2000 ___BEGIN___
XSAlgo::AlgoContainer()->MergeTransferInfo(FP, info);
// modified by NIZHNY-EAP Tue Aug 29 11:37:25 2000 ___END___
//!
//! ModeTrans may be : 0 -> groups of Faces
//! or 1 -> BRep
- Standard_EXPORT virtual Handle(Transfer_Binder) Transfer (const Handle(Transfer_Finder)& start, const Handle(Transfer_FinderProcess)& FP) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transfer
+ (const Handle(Transfer_Finder)& start,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
IFSelect_ReturnStatus IGESControl_Controller::TransferWriteShape (const TopoDS_Shape& shape,
const Handle(Transfer_FinderProcess)& FP,
const Handle(Interface_InterfaceModel)& model,
- const Standard_Integer modetrans) const
+ const Standard_Integer modetrans,
+ const Message_ProgressRange& theProgress) const
{
- return XSControl_Controller::TransferWriteShape (shape,FP,model,modetrans);
+ return XSControl_Controller::TransferWriteShape(shape, FP, model, modetrans, theProgress);
}
//=======================================================================
//! -2 bad model (requires an IGESModel)
//! modeshape : 0 groupe of face (version < 5.1)
//! 1 BREP-version 5.1 of IGES
- Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteShape (const TopoDS_Shape& shape, const Handle(Transfer_FinderProcess)& FP, const Handle(Interface_InterfaceModel)& model, const Standard_Integer modetrans = 0) const Standard_OVERRIDE;
+ Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteShape
+ (const TopoDS_Shape& shape,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(Interface_InterfaceModel)& model,
+ const Standard_Integer modetrans = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const Standard_OVERRIDE;
//! Standard Initialisation. It creates a Controller for IGES and
//! records it to various names, available to select it later
#include <IGESSelect_WorkLibrary.hxx>
#include <Interface_Macros.hxx>
#include <Interface_Static.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <OSD_OpenFile.hxx>
#include <ShapeAnalysis_ShapeTolerance.hxx>
#include <Standard_Stream.hxx>
myEditor (model,IGESSelect_WorkLibrary::DefineProtocol()) ,
myWriteMode (modecr) , myIsComputed (Standard_False) { }
-Standard_Boolean IGESControl_Writer::AddShape (const TopoDS_Shape& theShape)
+Standard_Boolean IGESControl_Writer::AddShape (const TopoDS_Shape& theShape,
+ const Message_ProgressRange& theProgress)
{
if (theShape.IsNull()) return Standard_False;
- // for progress indication
- Handle(Message_ProgressIndicator) progress = myTP->GetProgress();
- if ( ! progress.IsNull() ) {
- Standard_Integer nbfaces=0;
- for( TopExp_Explorer exp(theShape,TopAbs_FACE); exp.More(); exp.Next() )
- nbfaces++;
- progress->SetScale ( "Faces", 0, nbfaces, 1 );
- }
-
XSAlgo::AlgoContainer()->PrepareForTransfer();
+ Message_ProgressScope aPS(theProgress, NULL, 2);
// modified by NIZHNY-EAP Tue Aug 29 11:16:54 2000 ___BEGIN___
Handle(Standard_Transient) info;
Standard_Real Tol = Interface_Static::RVal("write.precision.val");
TopoDS_Shape Shape = XSAlgo::AlgoContainer()->ProcessShape( theShape, Tol, maxTol,
"write.iges.resource.name",
"write.iges.sequence", info,
- progress );
+ aPS.Next());
+ if (!aPS.More())
+ return Standard_False;
+
// modified by NIZHNY-EAP Tue Aug 29 11:17:01 2000 ___END___
BRepToIGES_BREntity B0; B0.SetTransferProcess(myTP); B0.SetModel(myModel);
BRepToIGESBRep_Entity B1; B1.SetTransferProcess(myTP); B1.SetModel(myModel);
- Handle(IGESData_IGESEntity) ent = myWriteMode? B1.TransferShape(Shape) : B0.TransferShape(Shape);
+ Handle(IGESData_IGESEntity) ent = myWriteMode?
+ B1.TransferShape (Shape, aPS.Next()) : B0.TransferShape(Shape, aPS.Next());
+ if (!aPS.More())
+ return Standard_False;
if(ent.IsNull())
return Standard_False;
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
#include <Standard_OStream.hxx>
+#include <Message_ProgressRange.hxx>
+
class Transfer_FinderProcess;
class IGESData_IGESModel;
class TopoDS_Shape;
//! Translates a Shape to IGES Entities and adds them to the model
//! Returns True if done, False if Shape not suitable for IGES or null
- Standard_EXPORT Standard_Boolean AddShape (const TopoDS_Shape& sh);
+ Standard_EXPORT Standard_Boolean AddShape (const TopoDS_Shape& sh,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Translates a Geometry (Surface or Curve) to IGES Entities and
//! adds them to the model
#include <Interface_InterfaceModel.hxx>
#include <Interface_Macros.hxx>
#include <Interface_Static.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <ShapeExtend_Explorer.hxx>
#include <ShapeFix_ShapeTolerance.hxx>
#include <Standard_ErrorHandler.hxx>
//purpose :
//=======================================================================
Handle(Transfer_Binder) IGESToBRep_Actor::Transfer
-(const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP)
+(const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
DeclareAndCast(IGESData_IGESModel,mymodel,themodel);
DeclareAndCast(IGESData_IGESEntity,ent,start);
(typnum == 408) || (typnum == 308)) {
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentry(TP->GetProgress(), "Transfer stage", 0, 2, 1);
+ Message_ProgressScope aPS(theProgress, "Transfer stage", 2);
XSAlgo::AlgoContainer()->PrepareForTransfer();
IGESToBRep_CurveAndSurface CAS;
{
try {
OCC_CATCH_SIGNALS
- shape = CAS.TransferGeometry(ent);
+ shape = CAS.TransferGeometry(ent, aPS.Next());
}
catch(Standard_Failure const&) {
shape.Nullify();
}
}
-
- // Switch to fix stage.
- aPSentry.Next();
// fixing shape
Handle(Standard_Transient) info;
shape = XSAlgo::AlgoContainer()->ProcessShape( shape, theeps, CAS.GetMaxTol(),
"read.iges.resource.name",
"read.iges.sequence", info,
- TP->GetProgress() );
+ aPS.Next());
XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems);
}
#include <Standard_Real.hxx>
#include <Transfer_ActorOfTransientProcess.hxx>
#include <Standard_Boolean.hxx>
+#include <Message_ProgressRange.hxx>
+
class Interface_InterfaceModel;
class Standard_Transient;
class Transfer_Binder;
class Transfer_TransientProcess;
-
class IGESToBRep_Actor;
DEFINE_STANDARD_HANDLE(IGESToBRep_Actor, Transfer_ActorOfTransientProcess)
Standard_EXPORT virtual Standard_Boolean Recognize (const Handle(Standard_Transient)& start) Standard_OVERRIDE;
- Standard_EXPORT virtual Handle(Transfer_Binder) Transfer (const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transfer
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
//! Returns the tolerance which was actually used, either from
//! the file or from statics
#include <IGESToBRep_TopoSurface.hxx>
#include <Interface_Macros.hxx>
#include <Message_Msg.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Precision.hxx>
#include <ShapeBuild_Edge.hxx>
#include <ShapeExtend_WireData.hxx>
//purpose :
//=======================================================================
TopoDS_Shape IGESToBRep_BRepEntity::TransferBRepEntity
- (const Handle(IGESData_IGESEntity)& start)
+ (const Handle(IGESData_IGESEntity)& start,
+ const Message_ProgressRange& theProgress)
{
TopoDS_Shape res;
}
else if (start->IsKind(STANDARD_TYPE(IGESSolid_Shell))) {
DeclareAndCast(IGESSolid_Shell, st514, start);
- res = TransferShell(st514);
+ res = TransferShell(st514, theProgress);
}
else if (start->IsKind(STANDARD_TYPE(IGESSolid_ManifoldSolid))) {
DeclareAndCast(IGESSolid_ManifoldSolid, st186, start);
- res = TransferManifoldSolid(st186);
+ res = TransferManifoldSolid(st186, theProgress);
}
else {
Message_Msg Msg1005("IGES_1005");
//purpose :
//=======================================================================
TopoDS_Shape IGESToBRep_BRepEntity::TransferShell
- (const Handle(IGESSolid_Shell)& start)
+ (const Handle(IGESSolid_Shell)& start,
+ const Message_ProgressRange& theProgress)
{
TopoDS_Shape res;
Standard_Integer nbfaces = start->NbFaces();
if (nbfaces != 0) {
Standard_Boolean closed = Standard_True; //:39
- Handle(Message_ProgressIndicator) progress = GetTransferProcess()->GetProgress();
- if ( ! progress.IsNull() ) progress->SetScale ( "Face", 0, nbfaces, 1 );
- for (Standard_Integer iface = 1; iface <= nbfaces; iface++) {
- if ( ! progress.IsNull() ) {
- progress->Increment();
- if ( progress->UserBreak() ) break;
- }
+ Message_ProgressScope aPS(theProgress, "Face", nbfaces);
+ for (Standard_Integer iface = 1; iface <= nbfaces && aPS.More(); iface++, aPS.Next()) {
Handle(IGESSolid_Face) face = start->Face(iface);
Standard_Boolean orientation = start->Orientation(iface);
TopoDS_Shape Sh = TransferFace(face);
//purpose :
//=======================================================================
TopoDS_Shape IGESToBRep_BRepEntity::TransferManifoldSolid
- (const Handle(IGESSolid_ManifoldSolid)& start)
+ (const Handle(IGESSolid_ManifoldSolid)& start,
+ const Message_ProgressRange& theProgress)
{
TopoDS_Shape res;
Handle(IGESSolid_Shell) shell = start->Shell();
Standard_Boolean isoriented = start->OrientationFlag();
Standard_Integer nbshell = start->NbVoidShells();
- TopoDS_Shape Sh = TransferShell(shell);
+ TopoDS_Shape Sh = TransferShell(shell, theProgress);
if (!Sh.IsNull()) {
if (Sh.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell Shell = TopoDS::Shell(Sh);
if (nbshell != 0) {
// progress scope without name, since usually we have single shell in solid
- Message_ProgressSentry PS ( GetTransferProcess()->GetProgress(), 0, 0, nbshell, 1 );
- for (Standard_Integer ishell=1; ishell<= nbshell && PS.More(); ishell++, PS.Next()) {
+ Message_ProgressScope aPS (theProgress, NULL, nbshell);
+ for (Standard_Integer ishell=1; ishell<= nbshell && aPS.More(); ishell++) {
Handle(IGESSolid_Shell) voidshell= start->VoidShell(ishell);
// Standard_Boolean orientation = start->VoidOrientationFlag(ishell);
- TopoDS_Shape aSh = TransferShell(voidshell);
+ TopoDS_Shape aSh = TransferShell (voidshell, aPS.Next());
if (!aSh.IsNull()) {
if (aSh.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell Shell = TopoDS::Shell(aSh);
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
+#include <Message_ProgressRange.hxx>
+
class IGESToBRep_CurveAndSurface;
class TopoDS_Shape;
class IGESData_IGESEntity;
Standard_EXPORT IGESToBRep_BRepEntity(const Standard_Real eps, const Standard_Real epsGeom, const Standard_Real epsCoeff, const Standard_Boolean mode, const Standard_Boolean modeapprox, const Standard_Boolean optimized);
//! Transfer the BRepEntity" : Face, Shell or ManifoldSolid.
- Standard_EXPORT TopoDS_Shape TransferBRepEntity (const Handle(IGESData_IGESEntity)& start);
+ Standard_EXPORT TopoDS_Shape TransferBRepEntity (const Handle(IGESData_IGESEntity)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfer the entity number "index" of the VertexList "start"
Standard_EXPORT TopoDS_Vertex TransferVertex (const Handle(IGESSolid_VertexList)& start, const Standard_Integer index);
Standard_EXPORT TopoDS_Shape TransferFace (const Handle(IGESSolid_Face)& start);
//! Transfer the Shell Entity
- Standard_EXPORT TopoDS_Shape TransferShell (const Handle(IGESSolid_Shell)& start);
+ Standard_EXPORT TopoDS_Shape TransferShell (const Handle(IGESSolid_Shell)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfer the ManifoldSolid Entity
- Standard_EXPORT TopoDS_Shape TransferManifoldSolid (const Handle(IGESSolid_ManifoldSolid)& start);
+ Standard_EXPORT TopoDS_Shape TransferManifoldSolid (const Handle(IGESSolid_ManifoldSolid)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
#include <Interface_Static.hxx>
#include <Message_Messenger.hxx>
#include <Message_Msg.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Precision.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
//=======================================================================
TopoDS_Shape IGESToBRep_CurveAndSurface::TransferCurveAndSurface
- (const Handle(IGESData_IGESEntity)& start)
+ (const Handle(IGESData_IGESEntity)& start,
+ const Message_ProgressRange& theProgress)
{
TopoDS_Shape res;
if (start.IsNull()) {
}
else if (IGESToBRep::IsBRepEntity(start)) {
IGESToBRep_BRepEntity TS(*this);
- res = TS.TransferBRepEntity(start);
+ res = TS.TransferBRepEntity(start, theProgress);
}
else {
Message_Msg msg1015("IGES_1015");
//=======================================================================
TopoDS_Shape IGESToBRep_CurveAndSurface::TransferGeometry
- (const Handle(IGESData_IGESEntity)& start)
+ (const Handle(IGESData_IGESEntity)& start,
+ const Message_ProgressRange& theProgress)
{
// Declaration of messages//
// DCE 22/12/98
return res;
try {
OCC_CATCH_SIGNALS
- res = TransferCurveAndSurface(start);
+ res = TransferCurveAndSurface(start, theProgress);
}
catch(Standard_Failure const&) {
Message_Msg msg1015("IGES_1015");
else {
try {
OCC_CATCH_SIGNALS
- res = TransferGeometry(stsub);
+ res = TransferGeometry(stsub, theProgress);
}
catch(Standard_Failure const&) {
res.Nullify();
SendFail( st308, msg210);
return res;
}
- Message_ProgressSentry PS ( myTP->GetProgress(), "Subfigure item", 0, st308->NbEntities(), 1 );
- for (Standard_Integer i=1; i <= st308->NbEntities() && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope PS (theProgress, "Subfigure item", st308->NbEntities());
+ for (Standard_Integer i=1; i <= st308->NbEntities() && PS.More(); i++)
+ {
+ Message_ProgressRange aRange = PS.Next();
TopoDS_Shape item;
if (st308->AssociatedEntity(i).IsNull()) {
Message_Msg msg1020("IGES_1020");
else {
try {
OCC_CATCH_SIGNALS
- item = TransferGeometry(st308->AssociatedEntity(i));
+ item = TransferGeometry (st308->AssociatedEntity(i), aRange);
}
catch(Standard_Failure const&) {
item.Nullify();
SendFail(st402f1, msg202);
return res;
}
- Message_ProgressSentry PS ( myTP->GetProgress(), "Group item", 0, st402f1->NbEntities(), 1 );
+ Message_ProgressScope PS (theProgress, "Group item", st402f1->NbEntities());
Standard_Boolean ProblemInGroup = Standard_False;
- for (Standard_Integer i=1; i <= st402f1->NbEntities() && PS.More(); i++, PS.Next()) {
+ for (Standard_Integer i=1; i <= st402f1->NbEntities() && PS.More(); i++)
+ {
+ Message_ProgressRange aRange = PS.Next();
TopoDS_Shape item;
if (st402f1->Entity(i).IsNull()) {
Message_Msg msg1020("IGES_1020");
else {
try {
OCC_CATCH_SIGNALS
- item = TransferGeometry(st402f1->Entity(i));
+ item = TransferGeometry (st402f1->Entity(i), aRange);
}
catch(Standard_Failure const&) {
item.Nullify();
SendFail(st402f7, msg202);
return res;
}
- Message_ProgressSentry PS ( myTP->GetProgress(), "Group item", 0, st402f7->NbEntities(), 1 );
+ Message_ProgressScope PS (theProgress, "Group item", st402f7->NbEntities());
Standard_Boolean ProblemInGroup = Standard_False;
- for (Standard_Integer i=1; i <= st402f7->NbEntities() && PS.More(); i++, PS.Next()) {
+ for (Standard_Integer i=1; i <= st402f7->NbEntities() && PS.More(); i++)
+ {
+ Message_ProgressRange aRange = PS.Next();
TopoDS_Shape item;
if (st402f7->Entity(i).IsNull()) {
Message_Msg msg1020("IGES_1020");
else {
try {
OCC_CATCH_SIGNALS
- item = TransferGeometry(st402f7->Entity(i));
+ item = TransferGeometry (st402f7->Entity(i), aRange);
}
catch(Standard_Failure const&) {
item.Nullify();
#include <Standard_Real.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
+#include <Message_ProgressRange.hxx>
+
class Geom_Surface;
class IGESData_IGESModel;
class Transfer_TransientProcess;
class IGESData_IGESEntity;
class Message_Msg;
-
//! Provides methods to transfer CurveAndSurface from IGES to CASCADE.
class IGESToBRep_CurveAndSurface
{
//! Returns the result of the transfert of any IGES Curve
//! or Surface Entity. If the transfer has failed, this
//! member return a NullEntity.
- Standard_EXPORT TopoDS_Shape TransferCurveAndSurface (const Handle(IGESData_IGESEntity)& start);
+ Standard_EXPORT TopoDS_Shape TransferCurveAndSurface (const Handle(IGESData_IGESEntity)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns the result of the transfert the geometry of
//! any IGESEntity. If the transfer has failed, this
//! member return a NullEntity.
- Standard_EXPORT TopoDS_Shape TransferGeometry (const Handle(IGESData_IGESEntity)& start);
+ Standard_EXPORT TopoDS_Shape TransferGeometry (const Handle(IGESData_IGESEntity)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Records a new Fail message
void SendFail (const Handle(IGESData_IGESEntity)& start, const Message_Msg& amsg);
#include <Interface_Static.hxx>
#include <Message_Messenger.hxx>
#include <Message_Msg.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <OSD_Timer.hxx>
#include <ShapeAlgo.hxx>
#include <ShapeAlgo_AlgoContainer.hxx>
//function : TransferRoots
//purpose : Transfers all Roots Entities
//=======================================================================
-void IGESToBRep_Reader::TransferRoots (const Standard_Boolean onlyvisible)
+void IGESToBRep_Reader::TransferRoots (const Standard_Boolean onlyvisible,
+ const Message_ProgressRange& theProgress)
{
if (theModel.IsNull() || theProc.IsNull()) return;
// sln 11.06.2002 OCC448
Interface_Static::SetIVal("read.iges.onlyvisible",onlyvisible);
- Message_ProgressSentry PS ( theProc->GetProgress(), "Root", 0, nb, 1 );
- for (Standard_Integer i = 1; i <= nb && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope PS (theProgress, "Root", nb);
+ for (Standard_Integer i = 1; i <= nb && PS.More(); i++)
+ {
+ Message_ProgressRange aRange = PS.Next();
Handle(IGESData_IGESEntity) ent = theModel->Entity(i);
if ( SH.IsShared(ent) || ! theActor->Recognize (ent) ) continue;
if (level > 0) {
theDone = Standard_True;
try {
OCC_CATCH_SIGNALS
- TP.Transfer(ent);
+ TP.Transfer (ent, aRange);
shape = TransferBRep::ShapeResult (theProc,ent);
}
catch(Standard_Failure const&) {
//function : Transfer
//purpose : Transfers an Entity given
//=======================================================================
-Standard_Boolean IGESToBRep_Reader::Transfer(const Standard_Integer num)
+Standard_Boolean IGESToBRep_Reader::Transfer(const Standard_Integer num,
+ const Message_ProgressRange& theProgress)
{
Handle(Message_Messenger) TF = theProc->Messenger();
theDone = Standard_False;
Handle(IGESData_IGESEntity) ent = theModel->Entity(num);
- Message_ProgressSentry PS ( theProc->GetProgress(), "OneEnt", 0, 1, 1 ); //skl
+ Message_ProgressScope aPS(theProgress, "OneEnt", 2);
XSAlgo::AlgoContainer()->PrepareForTransfer();
IGESToBRep_CurveAndSurface CAS;
{
try {
OCC_CATCH_SIGNALS
- shape = CAS.TransferGeometry (ent);
+ shape = CAS.TransferGeometry (ent, aPS.Next());
+ if (aPS.UserBreak())
+ return Standard_False;
}
catch(Standard_Failure const&) {
Message_Msg msg1015("IGES_1015");
shape = XSAlgo::AlgoContainer()->ProcessShape( shape, eps*CAS.GetUnitFactor(), CAS.GetMaxTol(),
"read.iges.resource.name",
"read.iges.sequence", info,
- theProc->GetProgress() );
+ aPS.Next() );
+ if (aPS.UserBreak())
+ return Standard_False;
+
XSAlgo::AlgoContainer()->MergeTransferInfo(theProc, info, nbTPitems);
ShapeExtend_Explorer SBE;
}
}
- PS.Relieve(); //skl
-
char t [20];
t[0]='\0';
Standard_Real second, cpu;
#include <Standard_Integer.hxx>
#include <Standard_CString.hxx>
#include <Standard_Real.hxx>
+#include <Message_ProgressRange.hxx>
+
class IGESData_IGESModel;
class IGESToBRep_Actor;
class Transfer_TransientProcess;
class TopoDS_Shape;
-
//! A simple way to read geometric IGES data.
//! Encapsulates reading file and calling transfer tools
class IGESToBRep_Reader
//! IGES file. Standard_True is the default value and means that only
//! visible root entities are translated. Standard_False
//! translates all of the roots (visible and invisible).
- Standard_EXPORT void TransferRoots (const Standard_Boolean onlyvisible = Standard_True);
+ Standard_EXPORT void TransferRoots (const Standard_Boolean onlyvisible = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers an Entity given its rank in the Model (Root or not)
//! Returns True if it is recognized as Geom-Topol.
//! (But it can have failed : see IsDone)
- Standard_EXPORT Standard_Boolean Transfer (const Standard_Integer num);
+ Standard_EXPORT Standard_Boolean Transfer (const Standard_Integer num,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns True if the LAST Transfer/TransferRoots was a success
Standard_EXPORT Standard_Boolean IsDone() const;
Message_PrinterSystemLog.hxx
Message_ProgressIndicator.cxx
Message_ProgressIndicator.hxx
-Message_ProgressIndicator.lxx
-Message_ProgressScale.cxx
-Message_ProgressScale.hxx
-Message_ProgressScale.lxx
-Message_ProgressSentry.cxx
+Message_ProgressRange.hxx
+Message_ProgressScope.hxx
Message_ProgressSentry.hxx
-Message_ProgressSentry.lxx
Message_SequenceOfPrinters.hxx
-Message_SequenceOfProgressScale.hxx
Message_Status.hxx
Message_StatusType.hxx
Message_Alert.cxx
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-
#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressScale.hxx>
-#include <Standard_Type.hxx>
-#include <TCollection_HAsciiString.hxx>
IMPLEMENT_STANDARD_RTTIEXT(Message_ProgressIndicator,Standard_Transient)
//=======================================================================
//function : Message_ProgressIndicator
-//purpose :
-//=======================================================================
-Message_ProgressIndicator::Message_ProgressIndicator ()
-{
- Reset();
-}
-
-//=======================================================================
-//function : Reset
-//purpose :
-//=======================================================================
-
-void Message_ProgressIndicator::Reset ()
-{
- myPosition = 0.;
-
- Message_ProgressScale scale;
- scale.SetName ( "Step" );
- scale.SetSpan ( 0., 1. );
-
- myScopes.Clear();
- myScopes.Append ( scale );
-}
-
+//purpose :
//=======================================================================
-//function : SetScale
-//purpose :
-//=======================================================================
-
-void Message_ProgressIndicator::SetScale (const Standard_Real min,
- const Standard_Real max,
- const Standard_Real step,
- const Standard_Boolean isInf)
+Message_ProgressIndicator::Message_ProgressIndicator()
+: myPosition(0.),
+ myRootScope (NULL)
{
- Message_ProgressScale &scale = myScopes.ChangeValue(1);
- scale.SetRange ( min, max );
- scale.SetStep ( step );
- scale.SetInfinite ( isInf );
+ myRootScope = new Message_ProgressScope (this);
}
-
-//=======================================================================
-//function : GetScale
-//purpose :
-//=======================================================================
-void Message_ProgressIndicator::GetScale (Standard_Real &min,
- Standard_Real &max,
- Standard_Real &step,
- Standard_Boolean &isInf) const
-{
- const Message_ProgressScale &scale = myScopes(1);
- min = scale.GetMin();
- max = scale.GetMax();
- step = scale.GetStep();
- isInf = scale.GetInfinite();
-}
-
//=======================================================================
-//function : SetValue
-//purpose :
+//function : ~Message_ProgressIndicator
+//purpose :
//=======================================================================
-
-void Message_ProgressIndicator::SetValue (const Standard_Real val)
+Message_ProgressIndicator::~Message_ProgressIndicator()
{
- const Message_ProgressScale &scale = myScopes(1);
- Standard_Real p = scale.LocalToBase ( val );
- if ( myPosition < p ) {
- myPosition = Min ( p, 1. );
- Show(Standard_False);
- }
+ // Avoid calling Increment() from myRootScope.Close()
+ myRootScope->myProgress = 0;
+ myRootScope->myIsActive = false;
+ delete myRootScope;
}
//=======================================================================
-//function : GetValue
-//purpose :
+//function : Start()
+//purpose :
//=======================================================================
-
-Standard_Real Message_ProgressIndicator::GetValue () const
+Message_ProgressRange Message_ProgressIndicator::Start()
{
- return myScopes(1).BaseToLocal ( myPosition );
-}
-
-//=======================================================================
-//function : NewScope
-//purpose :
-//=======================================================================
-
-Standard_Boolean Message_ProgressIndicator::NewScope (const Standard_Real span,
- const Handle(TCollection_HAsciiString) &name)
-{
- Message_ProgressScale scale;
- scale.SetName ( name );
- scale.SetSpan ( myPosition, myScopes(1).LocalToBase ( GetValue() + span ) );
- myScopes.Prepend ( scale );
- Show(Standard_False); // to update textual representation, if any
- return myPosition < 1.;
-}
-
-//=======================================================================
-//function : EndScope
-//purpose :
-//=======================================================================
-
-Standard_Boolean Message_ProgressIndicator::EndScope ()
-{
- Standard_Real end = myScopes(1).GetLast();
- Standard_Boolean ret = ( myScopes.Length() >1 );
- if ( ret ) myScopes.Remove(1);
- if ( myPosition != end ) {
- myPosition = end;
- Show(Standard_False);
- }
- return ret;
-}
-
-//=======================================================================
-//function : NextScope
-//purpose :
-//=======================================================================
-
-Standard_Boolean Message_ProgressIndicator::NextScope (const Standard_Real span,
- const Standard_CString name)
-{
- Message_ProgressScale &scale = myScopes.ChangeValue(1);
- if ( myPosition != scale.GetLast() ) {
- myPosition = scale.GetLast();
- Show(Standard_False);
- }
- if ( myScopes.Length() <2 ) return Standard_False;
-
- if ( name ) scale.SetName ( name );
- const Message_ProgressScale &scale2 = myScopes(2);
- scale.SetSpan ( myPosition, scale2.LocalToBase ( scale2.BaseToLocal(myPosition) + span ) );
-// if ( myMax - myMin <= gp::Resolution() ) return myLast;
-// Standard_Real next = ( myMax - myMin <= gp::Resolution() ? 1. - myPosition :
-// span * ( scale2.GetLast() - scale2.GetFirst() ) /
-// ( scale2.GetMax() - scale2.GetMin() ) );
-// scale.SetSpan ( myPosition, myPosition + next );
- return myPosition < 1.;
+ myPosition = 0.;
+ myRootScope->myValue = 0.;
+ Reset();
+ Show (*myRootScope, Standard_False);
+ return myRootScope->Next();
}
//=======================================================================
-//function : UserBreak
-//purpose :
+//function : Start()
+//purpose :
//=======================================================================
-
-Standard_Boolean Message_ProgressIndicator::UserBreak ()
+Message_ProgressRange Message_ProgressIndicator::Start
+ (const Handle(Message_ProgressIndicator)& theProgress)
{
- return Standard_False;
+ return theProgress.IsNull() ? Message_ProgressRange() : theProgress->Start();
}
-
#ifndef _Message_ProgressIndicator_HeaderFile
#define _Message_ProgressIndicator_HeaderFile
-#include <Standard.hxx>
-#include <Standard_Type.hxx>
+#include <Standard_TypeDef.hxx>
+#include <Standard_Mutex.hxx>
+#include <Standard_Handle.hxx>
-#include <Standard_Real.hxx>
-#include <Message_SequenceOfProgressScale.hxx>
-#include <Standard_Transient.hxx>
-#include <Standard_CString.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_Integer.hxx>
-class TCollection_HAsciiString;
-class Message_ProgressScale;
-
-
-class Message_ProgressIndicator;
DEFINE_STANDARD_HANDLE(Message_ProgressIndicator, Standard_Transient)
-//! Defines abstract interface from program to the "user".
+class Message_ProgressRange;
+class Message_ProgressScope;
+
+//! Defines abstract interface from program to the user.
//! This includes progress indication and user break mechanisms.
//!
-//! The process that uses the progress indicator interacts with it as
-//! with a scale whose range and step can be configured according to
-//! the nature of the process.
-//! The scale can be made "infinite", which means it will grow
-//! non-linearly, and end of scale will be approached asymptotically at
-//! infinite number of steps. In that case the range defines
-//! a number of steps corresponding to position at 1/2 of scale.
-//! The current position can be either set directly (in a range from
-//! current position to maximum scale value), or incremented step
-//! by step.
-//!
-//! Progress indication mechanism is adapted for convenient
-//! usage in hiererchical processes that require indication of
-//! progress at several levels of the process nesting.
-//! For that purpose, it is possible to create restricted sub-scope of
-//! indication by specifying part of a current scale to be
-//! used by the subprocess.
-//! When subprocess works with progress indicator in the restricted
-//! scope, it has the same interface to a scale, while actually it
-//! deals only with part of the whole scale.
+//! The progress indicator controls the progress scale with range from 0 to 1.
//!
-//! The recommended way to implement progress indication in the algorithm
-//! is to use class Message_ProgressSentry that provides iterator-like
-//! interface for incrementing progress and opening nested scopes.
+//! Method Start() should be called once, at the top level of the call stack,
+//! to reset progress indicator and get access to the root range:
+//!
+//! @code{.cpp}
+//! Handle(Message_ProgressIndicator) aProgress = ...;
+//! anAlgorithm.Perform (aProgress->Start());
+//! @endcode
//!
-//! NOTE:
-//! Currently there is no support for concurrent progress
-//! indicator that could be useful in multithreaded applications.
+//! To advance the progress indicator in the algorithm,
+//! use the class Message_ProgressScope that provides iterator-like
+//! interface for incrementing progress; see documentation of that
+//! class for details.
+//! The object of class Message_ProgressRange will automatically advance
+//! the indicator if it is not passed to any Message_ProgressScope.
//!
-//! The user break is implemented as virtual function that should
-//! return True in case if break signal from the user is received.
+//! The progress indicator supports concurrent processing and
+//! can be used in multithreaded applications.
//!
-//! The derived class should take care of visualisation of the
-//! progress indicator (e.g. show total position at the graphical bar,
+//! The derived class should be created to connect this interface to
+//! actual implementation of progress indicator, to take care of visualization
+//! of the progress (e.g. show total position at the graphical bar,
//! print scopes in text mode, or else), and for implementation
//! of user break mechanism (if necessary).
+//!
+//! See details in documentation of methods Show() and UserBreak().
class Message_ProgressIndicator : public Standard_Transient
{
-
+ DEFINE_STANDARD_RTTIEXT(Message_ProgressIndicator, Standard_Transient)
public:
+ //!@name Initialization of progress indication
-
- //! Drops all scopes and sets scale from 0 to 100, step 1
- //! This scale has name "Step"
- Standard_EXPORT virtual void Reset();
-
- void SetName (const Standard_CString name);
-
- //! Set (optional) name for scale
- void SetName (const Handle(TCollection_HAsciiString)& name);
-
- //! Set range for current scale
- void SetRange (const Standard_Real min, const Standard_Real max);
-
- //! Set step for current scale
- void SetStep (const Standard_Real step);
-
- //! Set or drop infinite mode for the current scale
- void SetInfinite (const Standard_Boolean isInf = Standard_True);
-
- void SetScale (const Standard_CString name, const Standard_Real min, const Standard_Real max, const Standard_Real step, const Standard_Boolean isInf = Standard_False);
-
- //! Set all parameters for current scale
- Standard_EXPORT void SetScale (const Standard_Real min, const Standard_Real max, const Standard_Real step, const Standard_Boolean isInf = Standard_False);
-
- //! Returns all parameters for current scale
- Standard_EXPORT void GetScale (Standard_Real& min, Standard_Real& max, Standard_Real& step, Standard_Boolean& isInf) const;
-
- Standard_EXPORT void SetValue (const Standard_Real val);
-
- //! Set and get progress value at current scale
- //! If the value to be set is more than currently set one, or out
- //! of range for the current scale, it is limited by that range
- Standard_EXPORT Standard_Real GetValue() const;
-
- void Increment();
-
- //! Increment the progress value by the default of specified step
- void Increment (const Standard_Real step);
-
- Standard_Boolean NewScope (const Standard_CString name = 0);
-
- Standard_Boolean NewScope (const Handle(TCollection_HAsciiString)& name);
-
- Standard_Boolean NewScope (const Standard_Real span, const Standard_CString name = 0);
-
- //! Creates new scope on a part of a current scale from current
- //! position with span either equal to default step, or specified
- //! The scale for the new scope will have specified name and
- //! ranged from 0 to 100 with step 1
- //! Returns False if something is wrong in arguments or in current
- //! position of progress indicator; scope is opened anyway
- Standard_EXPORT Standard_Boolean NewScope (const Standard_Real span, const Handle(TCollection_HAsciiString)& name);
-
- //! Close the current scope and thus return to previous scale
- //! Updates position to be at the end of the closing scope
- //! Returns False if no scope is opened
- Standard_EXPORT Standard_Boolean EndScope();
-
- Standard_Boolean NextScope (const Standard_CString name = 0);
-
- //! Optimized version of { return EndScope() && NewScope(); }
- Standard_EXPORT Standard_Boolean NextScope (const Standard_Real span, const Standard_CString name = 0);
-
- //! Should return True if user has send a break signal.
- //! Default implementation returns False.
- Standard_EXPORT virtual Standard_Boolean UserBreak();
-
- //! Update presentation of the progress indicator
- //! Called when progress position is changed
- //! Flag force is intended for forcing update in case if it is
- //! optimized; all internal calls from ProgressIndicator are
- //! done with this flag equal to False
- Standard_EXPORT virtual Standard_Boolean Show (const Standard_Boolean force = Standard_True) = 0;
-
- //! Returns total progress position on the basic scale
- //! ranged from 0. to 1.
- Standard_Real GetPosition() const;
-
- //! Returns current number of opened scopes
- //! This number is always >=1 as top-level scale is always present
- Standard_Integer GetNbScopes() const;
-
- //! Returns data for scale of index-th scope
- //! The first scope is current one, the last is the top-level one
- const Message_ProgressScale& GetScope (const Standard_Integer index) const;
+ //! Resets the indicator to zero, calls Reset(), and returns the range.
+ //! This range refers to the scope that has no name and is initialized
+ //! with max value 1 and step 1.
+ //! Use this method to get the top level range for progress indication.
+ Standard_EXPORT Message_ProgressRange Start();
+ //! If argument is non-null handle, returns theProgress->Start().
+ //! Otherwise, returns dummy range that can be safely used in the algorithms
+ //! but not bound to progress indicator.
+ Standard_EXPORT static Message_ProgressRange Start
+ (const Handle(Message_ProgressIndicator)& theProgress);
+protected:
+ //!@name Virtual methods to be defined by descendant.
+
+ //! Should return True if user has sent a break signal.
+ //!
+ //! This method can be called concurrently, thus implementation should
+ //! be thread-safe. It should not call Show() or Position() to
+ //! avoid possible data races. The method should return as soon
+ //! as possible to avoid delaying the calling algorithm.
+ //!
+ //! Default implementation returns False.
+ virtual Standard_Boolean UserBreak()
+ {
+ return Standard_False;
+ }
+
+ //! Virtual method to be defined by descendant.
+ //! Should update presentation of the progress indicator.
+ //!
+ //! It is called whenever progress position is changed.
+ //! Calls to this method from progress indicator are protected by mutex so that
+ //! it is never called concurrently for the same progress indicator instance.
+ //! Show() should return as soon as possible to reduce thread contention
+ //! in multithreaded algorithms.
+ //!
+ //! It is recommended to update (redraw, output etc.) only if progress advanced
+ //! by at least 1% from previous update.
+ //!
+ //! Flag isForce is intended for forcing update in case if it is
+ //! optimized; all calls to it from inside the core mechanism are
+ //! done with this flag equal to False.
+ //!
+ //! The parameter theScope is the current scope being advanced;
+ //! it can be used to show the names and ranges of the on-going scope and
+ //! its parents, providing more visibility of the current stage of the process.
+ virtual void Show (const Message_ProgressScope& theScope,
+ const Standard_Boolean isForce) = 0;
+
+ //! Call-back method called by Start(), can be redefined by descendants
+ //! if some actions are needed when the indicator is restarted.
+ virtual void Reset() {}
+
+public:
+ //!@name Auxiliary methods
+ //! Returns total progress position ranged from 0 to 1.
+ //! Should not be called concurrently while the progress is advancing
+ //! except from implementation of method Show().
+ Standard_Real GetPosition() const
+ {
+ return myPosition;
+ }
- DEFINE_STANDARD_RTTIEXT(Message_ProgressIndicator,Standard_Transient)
+ //! Destructor
+ Standard_EXPORT ~Message_ProgressIndicator();
protected:
-
- //! Constructor, just calls own Reset() (not yet redefined)
+ //! Constructor
Standard_EXPORT Message_ProgressIndicator();
-
-
private:
+ //! Increment the progress value by the specified step,
+ //! then calls Show() to update presentation.
+ //! The parameter theScope is reference to the caller object;
+ //! it is passed to Show() where can be used to track context of the process.
+ void Increment (const Standard_Real theStep, const Message_ProgressScope& theScope);
- Standard_Real myPosition;
- Message_SequenceOfProgressScale myScopes;
+private:
+ Standard_Real myPosition; //!< Total progress position ranged from 0 to 1
+ Standard_Mutex myMutex; //!< Protection of myPosition from concurrent increment
+ Message_ProgressScope* myRootScope; //!< The root progress scope
+private:
+ friend class Message_ProgressScope; //!< Friend: can call Increment()
+ friend class Message_ProgressRange; //!< Friend: can call Increment()
};
+#include <Message_ProgressScope.hxx>
-#include <Message_ProgressIndicator.lxx>
-
-
+//=======================================================================
+//function : Increment
+//purpose :
+//=======================================================================
+inline void Message_ProgressIndicator::Increment(const Standard_Real theStep,
+ const Message_ProgressScope& theScope)
+{
+ // protect incrementation by mutex to avoid problems in multithreaded scenarios
+ Standard_Mutex::Sentry aSentry(myMutex);
+ myPosition = Min(myPosition + theStep, 1.);
+ // show progress indicator; note that this call is protected by
+ // the same mutex to avoid concurrency and ensure that this call
+ // to Show() will see the position exactly as it was just set above
+ Show(theScope, Standard_False);
+}
#endif // _Message_ProgressIndicator_HeaderFile
+++ /dev/null
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Message_ProgressScale.hxx>
-#include <TCollection_HAsciiString.hxx>
-
-//=======================================================================
-//function : SetName
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::SetName (const Standard_CString name)
-{
- if (name != 0)
- myScopes.ChangeValue(1).SetName ( name );
-}
-
-//=======================================================================
-//function : SetName
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::SetName (const Handle(TCollection_HAsciiString) &name)
-{
- if (!name.IsNull())
- myScopes.ChangeValue(1).SetName ( name );
-}
-
-//=======================================================================
-//function : SetRange
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::SetRange (const Standard_Real min,
- const Standard_Real max)
-{
- myScopes.ChangeValue(1).SetRange ( min, max );
-}
-
-//=======================================================================
-//function : SetStep
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::SetStep (const Standard_Real step)
-{
- myScopes.ChangeValue(1).SetStep ( step );
-}
-
-//=======================================================================
-//function : SetInfinite
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::SetInfinite (const Standard_Boolean isInf)
-{
- myScopes.ChangeValue(1).SetInfinite ( isInf );
-}
-
-//=======================================================================
-//function : SetScale
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::SetScale (const Standard_CString name,
- const Standard_Real min,
- const Standard_Real max,
- const Standard_Real step,
- const Standard_Boolean isInf)
-{
- SetName ( name );
- SetScale ( min, max, step, isInf );
-}
-
-//=======================================================================
-//function : Increment
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::Increment ()
-{
- Increment ( myScopes(1).GetStep() );
-}
-
-//=======================================================================
-//function : Increment
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressIndicator::Increment (const Standard_Real step)
-{
- SetValue ( GetValue() + step );
-}
-
-//=======================================================================
-//function : NewScope
-//purpose :
-//=======================================================================
-
-inline Standard_Boolean Message_ProgressIndicator::NewScope (const Standard_CString name)
-{
- return NewScope ( name ? new TCollection_HAsciiString ( name ) : 0 );
-}
-
-//=======================================================================
-//function : NewScope
-//purpose :
-//=======================================================================
-
-inline Standard_Boolean Message_ProgressIndicator::NewScope (const Handle(TCollection_HAsciiString) &name)
-{
- return NewScope ( myScopes(1).GetStep(), name );
-}
-
-//=======================================================================
-//function : NewScope
-//purpose :
-//=======================================================================
-
-inline Standard_Boolean Message_ProgressIndicator::NewScope (const Standard_Real span,
- const Standard_CString name)
-{
- return NewScope ( span, name ? new TCollection_HAsciiString ( name ) : 0 );
-}
-
-//=======================================================================
-//function : NextScope
-//purpose :
-//=======================================================================
-
-inline Standard_Boolean Message_ProgressIndicator::NextScope (const Standard_CString name)
-{
- return NextScope ( myScopes.Length() >1 ? myScopes(1).GetStep() : 1., name );
-}
-
-//=======================================================================
-//function : GetPosition
-//purpose :
-//=======================================================================
-
-inline Standard_Real Message_ProgressIndicator::GetPosition () const
-{
- return myPosition;
-}
-
-//=======================================================================
-//function : GetNbScopes
-//purpose :
-//=======================================================================
-
-inline Standard_Integer Message_ProgressIndicator::GetNbScopes () const
-{
- return myScopes.Length();
-}
-
-//=======================================================================
-//function : GetScope
-//purpose :
-//=======================================================================
-
-inline const Message_ProgressScale &Message_ProgressIndicator::GetScope (const Standard_Integer index) const
-{
- return myScopes(index);
-}
--- /dev/null
+// Copyright (c) 2020 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Message_ProgressRange_HeaderFile
+#define _Message_ProgressRange_HeaderFile
+
+#include <Standard_TypeDef.hxx>
+
+class Message_ProgressScope;
+
+//! Auxiliary class representing a part of the global progress scale allocated by
+//! a step of the progress scope, see Message_ProgressScope::Next().
+//!
+//! A range object takes responsibility of advancing the progress by the size of
+//! allocated step, which is then performed depending on how it is used:
+//!
+//! - If Message_ProgressScope object is created using this range as argument, then
+//! this respondibility is taken over by that scope.
+//!
+//! - Otherwise, a range advances progress directly upon destruction.
+//!
+//! A range object can be copied, the responsibility for progress advancement is
+//! then taken by the copy.
+//! The same range object may be used (either copied or used to create scope) only once.
+//! Any consequenct attempts to use range will give no result on the progress;
+//! in debug mode, an assert message will be generated.
+//!
+//! @sa Message_ProgressScope for more details
+class Message_ProgressRange
+{
+public:
+ //! Constructor of the range
+ Message_ProgressRange()
+ : myParentScope (0), myDelta (0), myWasUsed (false)
+ {}
+
+ //! Copy constructor disarms the source.
+ Message_ProgressRange (const Message_ProgressRange& theOther)
+ : myParentScope (theOther.myParentScope),
+ myDelta (theOther.myDelta),
+ myWasUsed (theOther.myWasUsed)
+ {
+ // discharge theOther
+ theOther.myWasUsed = true;
+ }
+
+ //! Copy assignment disarms the source.
+ Message_ProgressRange& operator=(const Message_ProgressRange& theOther)
+ {
+ myParentScope = theOther.myParentScope;
+ myDelta = theOther.myDelta;
+ myWasUsed = theOther.myWasUsed;
+ theOther.myWasUsed = true;
+ return *this;
+ }
+
+ //! Returns true if ProgressIndicator signals UserBreak
+ Standard_Boolean UserBreak() const;
+
+ //! Returns false if ProgressIndicator signals UserBreak
+ Standard_Boolean More() const
+ {
+ return !UserBreak();
+ }
+
+ //! Returns true if this progress range is attached to some indicator.
+ Standard_Boolean IsActive() const;
+
+ //! Closes the current range and advances indicator
+ void Close();
+
+ //! Destructor
+ ~Message_ProgressRange()
+ {
+ Close();
+ }
+
+private:
+ //! Constructor is private
+ Message_ProgressRange (const Message_ProgressScope& theParent, Standard_Real theDelta)
+ : myParentScope (&theParent),
+ myDelta (theDelta),
+ myWasUsed (false)
+ {}
+
+private:
+ const Message_ProgressScope* myParentScope; //!< Pointer to parent scope
+ Standard_Real myDelta; //!< Step of incrementation
+ mutable Standard_Boolean myWasUsed; //!< Flag indicating that this range
+ //! was used to create a new scope
+
+ friend class Message_ProgressScope;
+};
+
+#include <Message_ProgressIndicator.hxx>
+
+//=======================================================================
+//function : IsActive
+//purpose :
+//=======================================================================
+inline Standard_Boolean Message_ProgressRange::IsActive() const
+{
+ return !myWasUsed && myParentScope && myParentScope->myProgress;
+}
+
+//=======================================================================
+//function : UserBreak
+//purpose :
+//=======================================================================
+inline Standard_Boolean Message_ProgressRange::UserBreak() const
+{
+ return myParentScope && myParentScope->myProgress && myParentScope->myProgress->UserBreak();
+}
+
+//=======================================================================
+//function : Close
+//purpose :
+//=======================================================================
+inline void Message_ProgressRange::Close()
+{
+ if (!IsActive())
+ return;
+
+ myParentScope->myProgress->Increment(myDelta, *myParentScope);
+ myParentScope = 0;
+ myWasUsed = true;
+}
+
+#endif // _Message_ProgressRange_HeaderFile
+++ /dev/null
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-
-#include <Message_ProgressScale.hxx>
-#include <TCollection_HAsciiString.hxx>
-
-static const Standard_Real Message_ProgressScale_ZERO = 1e-10;
-static const Standard_Real Message_ProgressScale_INFINITE = 1e100;
-
-//=======================================================================
-//function : Message_ProgressScale
-//purpose :
-//=======================================================================
-
-Message_ProgressScale::Message_ProgressScale () :
- myMin(0.), myMax(100.), myStep(1.), myInfinite(Standard_False),
- myFirst(0.), myLast(1.)
-{
-}
-
-//=======================================================================
-//function : LocalToBase
-//purpose :
-//=======================================================================
-
-Standard_Real Message_ProgressScale::LocalToBase (const Standard_Real val) const
-{
- if ( val <= myMin ) return myFirst;
- if ( myMax - myMin <= Message_ProgressScale_ZERO ) return myLast;
-
- if ( ! myInfinite ) {
- if ( val >= myMax ) return myLast;
- return myFirst + ( myLast - myFirst ) * ( val - myMin ) / ( myMax - myMin );
- }
- Standard_Real x = ( val - myMin ) / ( myMax - myMin );
-// return myFirst + ( myLast - myFirst ) * ( 1. - exp ( -x ) ); // exponent
- return myFirst + ( myLast - myFirst ) * x / ( 1. + x ); // hyperbola
-}
-
-//=======================================================================
-//function : BaseToLocal
-//purpose :
-//=======================================================================
-
-Standard_Real Message_ProgressScale::BaseToLocal (const Standard_Real val) const
-{
- if ( myLast - val <= Message_ProgressScale_ZERO )
- return myInfinite ? Message_ProgressScale_INFINITE : myMax;
- if ( ! myInfinite )
- return myMin + ( myMax - myMin ) * ( val - myFirst ) / ( myLast - myFirst );
-// Standard_Real x = log ( ( val - myFirst ) / ( myLast - val ) ); // exponent
- Standard_Real x = ( val - myFirst ) / ( myLast - val ); // hyperbola
- return myMin + x * ( myMax - myMin );
-}
+++ /dev/null
-// Created on: 2002-02-20
-// Created by: Andrey BETENEV
-// Copyright (c) 2002-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef _Message_ProgressScale_HeaderFile
-#define _Message_ProgressScale_HeaderFile
-
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-
-#include <Standard_Real.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_CString.hxx>
-class TCollection_HAsciiString;
-
-
-//! Internal data structure for scale in ProgressIndicator
-//!
-//! Basically it defines three things:
-//! - name that can be used for generating user messages
-//! - limits and characteristics of the current scale,
-//! along with derived coefficients to map it into basic scale [0-1]
-//! - methods for conversion of values from current scale
-//! to basic one and back
-//!
-//! NOTE: There is no special protection against bad input data
-//! like min > max etc. except cases when it can cause exception
-class Message_ProgressScale
-{
-public:
-
- DEFINE_STANDARD_ALLOC
-
-
- //! Creates scale ranged from 0 to 100 with step 1
- Standard_EXPORT Message_ProgressScale();
-
- void SetName (const Standard_CString theName);
-
- //! Sets scale name
- void SetName (const Handle(TCollection_HAsciiString)& theName);
-
- //! Gets scale name
- //! Name may be Null handle if not set
- Handle(TCollection_HAsciiString) GetName() const;
-
- //! Sets minimum value of scale
- void SetMin (const Standard_Real theMin);
-
- //! Gets minimum value of scale
- Standard_Real GetMin() const;
-
- //! Sets minimum value of scale
- void SetMax (const Standard_Real theMax);
-
- //! Gets minimum value of scale
- Standard_Real GetMax() const;
-
- //! Set both min and max
- void SetRange (const Standard_Real min, const Standard_Real max);
-
- //! Sets default step
- void SetStep (const Standard_Real theStep);
-
- //! Gets default step
- Standard_Real GetStep() const;
-
- //! Sets flag for infinite scale
- void SetInfinite (const Standard_Boolean theInfinite = Standard_True);
-
- //! Gets flag for infinite scale
- Standard_Boolean GetInfinite() const;
-
- //! Set all scale parameters
- void SetScale (const Standard_Real min, const Standard_Real max, const Standard_Real step, const Standard_Boolean theInfinite = Standard_True);
-
- //! Defines span occupied by the scale on the basis scale
- void SetSpan (const Standard_Real first, const Standard_Real last);
-
- Standard_Real GetFirst() const;
-
- //! Return information on span occupied by the scale on the base scale
- Standard_Real GetLast() const;
-
- Standard_EXPORT Standard_Real LocalToBase (const Standard_Real val) const;
-
- //! Convert value from this scale to base one and back
- Standard_EXPORT Standard_Real BaseToLocal (const Standard_Real val) const;
-
-
-
-
-protected:
-
-
-
-
-
-private:
-
-
-
- Handle(TCollection_HAsciiString) myName;
- Standard_Real myMin;
- Standard_Real myMax;
- Standard_Real myStep;
- Standard_Boolean myInfinite;
- Standard_Real myFirst;
- Standard_Real myLast;
-
-
-};
-
-
-#include <Message_ProgressScale.lxx>
-
-
-
-
-
-#endif // _Message_ProgressScale_HeaderFile
+++ /dev/null
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <TCollection_HAsciiString.hxx>
-
-//=======================================================================
-//function : SetName
-//purpose : Sets scale name
-//=======================================================================
-
-inline void Message_ProgressScale::SetName(const Standard_CString theName)
-{
- myName = new TCollection_HAsciiString ( theName );
-}
-
-//=======================================================================
-//function : SetName
-//purpose : Sets scale name
-//=======================================================================
-
-inline void Message_ProgressScale::SetName(const Handle(TCollection_HAsciiString)& theName)
-{
- myName = theName;
-}
-
-//=======================================================================
-//function : GetName
-//purpose : Returns scale name
-//=======================================================================
-
-inline Handle(TCollection_HAsciiString) Message_ProgressScale::GetName() const
-{
- return myName;
-}
-
-//=======================================================================
-//function : SetMin
-//purpose : Sets minimum value of scale
-//=======================================================================
-
-inline void Message_ProgressScale::SetMin(const Standard_Real theMin)
-{
- myMin = theMin;
-}
-
-//=======================================================================
-//function : GetMin
-//purpose : Returns minimum value of scale
-//=======================================================================
-
-inline Standard_Real Message_ProgressScale::GetMin() const
-{
- return myMin;
-}
-
-//=======================================================================
-//function : SetMax
-//purpose : Sets minimum value of scale
-//=======================================================================
-
-inline void Message_ProgressScale::SetMax(const Standard_Real theMax)
-{
- myMax = theMax;
-}
-
-//=======================================================================
-//function : GetMax
-//purpose : Returns minimum value of scale
-//=======================================================================
-
-inline Standard_Real Message_ProgressScale::GetMax() const
-{
- return myMax;
-}
-
-//=======================================================================
-//function : SetRange
-//purpose : Sets both min and max
-//=======================================================================
-
-inline void Message_ProgressScale::SetRange(const Standard_Real theMin,
- const Standard_Real theMax)
-{
- myMin = theMin;
- myMax = theMax;
-}
-
-//=======================================================================
-//function : SetStep
-//purpose : Sets default step
-//=======================================================================
-
-inline void Message_ProgressScale::SetStep(const Standard_Real theStep)
-{
- myStep = theStep;
-}
-
-//=======================================================================
-//function : GetStep
-//purpose : Returns default step
-//=======================================================================
-
-inline Standard_Real Message_ProgressScale::GetStep() const
-{
- return myStep;
-}
-
-//=======================================================================
-//function : SetInfinite
-//purpose : Sets flag for infinite scale
-//=======================================================================
-
-inline void Message_ProgressScale::SetInfinite(const Standard_Boolean theInfinite)
-{
- myInfinite = theInfinite;
-}
-
-//=======================================================================
-//function : GetInfinite
-//purpose : Returns flag for infinite scale
-//=======================================================================
-
-inline Standard_Boolean Message_ProgressScale::GetInfinite() const
-{
- return myInfinite;
-}
-
-//=======================================================================
-//function : SetScale
-//purpose : Set all scale parameters
-//=======================================================================
-
-inline void Message_ProgressScale::SetScale(const Standard_Real theMin,
- const Standard_Real theMax,
- const Standard_Real theStep,
- const Standard_Boolean theInfinite)
-{
- myMin = theMin;
- myMax = theMax;
- myStep = theStep;
- myInfinite = theInfinite;
-}
-
-//=======================================================================
-//function : SetSpan
-//purpose : Sets span on a basis scale
-//=======================================================================
-
-inline void Message_ProgressScale::SetSpan(const Standard_Real theFirst,
- const Standard_Real theLast)
-{
- myFirst = theFirst;
- myLast = theLast;
-}
-
-//=======================================================================
-//function : GetFirst
-//purpose :
-//=======================================================================
-
-inline Standard_Real Message_ProgressScale::GetFirst () const
-{
- return myFirst;
-}
-
-//=======================================================================
-//function : GetLast
-//purpose :
-//=======================================================================
-
-inline Standard_Real Message_ProgressScale::GetLast () const
-{
- return myLast;
-}
-
--- /dev/null
+// Created on: 2002-02-22
+// Created by: Andrey BETENEV
+// Copyright (c) 2002-2014 OPEN CASCADE SAS
+//
+// This file is part of Open CASCADE Technology software library.
+//
+// This library is free software; you can redistribute it and/or modify it under
+// the terms of the GNU Lesser General Public License version 2.1 as published
+// by the Free Software Foundation, with special exception defined in the file
+// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
+// distribution for complete text of the license and disclaimer of any warranty.
+//
+// Alternatively, this file may be used under the terms of Open CASCADE
+// commercial license or contractual agreement.
+
+#ifndef _Message_ProgressScope_HeaderFile
+#define _Message_ProgressScope_HeaderFile
+
+#include <Standard_Assert.hxx>
+#include <Standard_TypeDef.hxx>
+#include <Standard_DefineAlloc.hxx>
+#include <Standard_Handle.hxx>
+#include <Precision.hxx>
+#include <TCollection_AsciiString.hxx>
+
+class Message_ProgressRange;
+class Message_ProgressIndicator;
+
+//! Message_ProgressScope class provides convenient way to advance progress
+//! indicator in context of complex program organized in hierarchical way,
+//! where usually it is difficult (or even not possible) to consider process
+//! as linear with fixed step.
+//!
+//! On every level (sub-operation) in hierarchy of operations
+//! the local instance of the Message_ProgressScope class is created.
+//! It takes a part of the upper-level scope (via Message_ProgressRange) and provides
+//! a way to consider this part as independent scale with locally defined range.
+//!
+//! The position on the local scale may be advanced using the method Next(),
+//! which allows iteration-like advancement. This method can take argument to
+//! advance on the needed value. And, this method returns ProgressRange object
+//! that takes responsibility of making the specified step at its destruction.
+//! The ProgressRange can be used to create a new progress sub-scope.
+//!
+//! It is important that sub-scope must have life time less than
+//! the life time of its parent scope that provided the range.
+//!
+//! The scope has a name that can be used in visualization of the progress.
+//! It can be null. Note that the string is not copied, just pointer is stored.
+//! So, the pointer must point to the string with life time
+//! greater than that of the scope object.
+//!
+//! In multithreaded programs, for each task running concurrently it is recommended
+//! to create a separate progress scope. The same instance of the progress scope
+//! must not be used concurrently from different threads.
+//!
+//! A progress scope created with empty constructor is not connected to any
+//! progress indicator, and passing the range created on it to any algorithm
+//! allows it executing safely without progress indication.
+//!
+//! Example of preparation of progress indicator:
+//!
+//! @code{.cpp}
+//! Handle(Message_ProgressIndicator) aProgress = ...; // assume it can be null
+//! func (Message_ProgressIndicator::Start (aProgress));
+//! @endcode
+//!
+//! Example of usage in sequential process:
+//!
+//! @code{.cpp}
+//! Message_ProgressScope aWholePS(aRange, "Whole process", 100);
+//!
+//! // do one step taking 20%
+//! func1 (aWholePS.Next (20)); // func1 will take 20% of the whole scope
+//! if (aWholePS.UserBreak()) // exit prematurely if the user requested break
+//! return;
+//!
+//! // ... do next step taking 50%
+//! func2 (aWholePS.Next (50));
+//! if (aWholePS.UserBreak())
+//! return;
+//! @endcode
+//!
+//! Example of usage in nested cycle:
+//!
+//! @code{.cpp}
+//! // Outer cycle
+//! Message_ProgressScope anOuter (theProgress, "Outer", nbOuter);
+//! for (Standard_Integer i = 0; i < nbOuter && anOuter.More(); i++)
+//! {
+//! // Inner cycle
+//! Message_ProgressScope anInner (anOuter.Next(), "Inner", nbInner);
+//! for (Standard_Integer j = 0; j < nbInner && anInner.More(); j++)
+//! {
+//! // Cycle body
+//! func (anInner.Next());
+//! }
+//! }
+//! @endcode
+//!
+//! Example of use in function:
+//!
+//! @code{.cpp}
+//! //! Implementation of iterative algorithm showing its progress
+//! func (const Message_ProgressRange& theProgress)
+//! {
+//! // Create local scope covering the given progress range.
+//! // Set this scope to count aNbSteps steps.
+//! Message_ProgressScope aScope (theProgress, "", aNbSteps);
+//! for (Standard_Integer i = 0; i < aNbSteps && aScope.More(); i++)
+//! {
+//! // Optional: pass range returned by method Next() to the nested algorithm
+//! // to allow it to show its progress too (by creating its own scope object).
+//! // In any case the progress will advance to the next step by the end of the func2 call.
+//! func2 (aScope.Next());
+//! }
+//! }
+//! @endcode
+//!
+//! Example of usage in parallel process:
+//!
+//! @code{.cpp}
+//! struct Task
+//! {
+//! Data& Data;
+//! Message_ProgressRange Range;
+//!
+//! Task (const Data& theData, const Message_ProgressRange& theRange)
+//! : Data (theData), Range (theRange) {}
+//! };
+//! struct Functor
+//! {
+//! void operator() (Task& theTask) const
+//! {
+//! // Note: it is essential that this method is executed only once
+//! // for the same Task object
+//! Message_ProgressScope aPS (theTask.Range, "Processing task", 1);
+//! if (aPS.More())
+//! {
+//! // ... process data
+//! }
+//! }
+//! };
+//! ...
+//! {
+//! std::vector<Data> aData = ...;
+//! std::vector<Task> aTasks;
+//!
+//! Message_ProgressScope aPS (aRootRange, "Data processing", aData.size());
+//! for (Standard_Integer i = 0; i < aData.size(); ++i)
+//! aTasks.push_back (Task (aData[i], aPS.Next()));
+//!
+//! OSD_Parallel::ForEach (aTasks.begin(), aTasks.end(), Functor());
+//! }
+//! @endcode
+class Message_ProgressScope
+{
+public:
+ class NullString; //!< auxiliary type for passing NULL name to Message_ProgressScope constructor
+public: //! @name Preparation methods
+
+ //! Creates dummy scope.
+ //! It can be safely passed to algorithms; no progress indication will be done.
+ Message_ProgressScope()
+ : myProgress (0),
+ myParent (0),
+ myName (0),
+ myPortion (1.), myMax (1.), myValue (0.),
+ myIsActive (false),
+ myIsOwnName (false),
+ myIsInfinite (false)
+ {}
+
+ //! Creates a new scope taking responsibility of the part of the progress
+ //! scale described by theRange. The new scope has own range from 0 to
+ //! theMax, which is mapped to the given range.
+ //!
+ //! The topmost scope is created and owned by Message_ProgressIndicator
+ //! and its pointer is contained in the Message_ProgressRange returned by the Start() method of progress indicator.
+ //!
+ //! @param theRange [in][out] range to fill (will be disarmed)
+ //! @param theName [in] new scope name
+ //! @param theMax [in] number of steps in scope
+ //! @param isInfinite [in] infinite flag
+ Message_ProgressScope (const Message_ProgressRange& theRange,
+ const TCollection_AsciiString& theName,
+ Standard_Real theMax,
+ Standard_Boolean isInfinite = false);
+
+ //! Creates a new scope taking responsibility of the part of the progress
+ //! scale described by theRange. The new scope has own range from 0 to
+ //! theMax, which is mapped to the given range.
+ //!
+ //! The topmost scope is created and owned by Message_ProgressIndicator
+ //! and its pointer is contained in the Message_ProgressRange returned by the Start() method of progress indicator.
+ //!
+ //! @param theRange [in][out] range to fill (will be disarmed)
+ //! @param theName [in] new scope name constant (will be stored by pointer with no deep copy)
+ //! @param theMax [in] number of steps in scope
+ //! @param isInfinite [in] infinite flag
+ template<size_t N>
+ Message_ProgressScope (const Message_ProgressRange& theRange,
+ const char (&theName)[N],
+ Standard_Real theMax,
+ Standard_Boolean isInfinite = false);
+
+ //! Creates a new scope taking responsibility of the part of the progress
+ //! scale described by theRange. The new scope has own range from 0 to
+ //! theMax, which is mapped to the given range.
+ //!
+ //! The topmost scope is created and owned by Message_ProgressIndicator
+ //! and its pointer is contained in the Message_ProgressRange returned by the Start() method of progress indicator.
+ //!
+ //! @param theRange [in][out] range to fill (will be disarmed)
+ //! @param theName [in] empty scope name (only NULL is accepted as argument)
+ //! @param theMax [in] number of steps in scope
+ //! @param isInfinite [in] infinite flag
+ Message_ProgressScope (const Message_ProgressRange& theRange,
+ const NullString* theName,
+ Standard_Real theMax,
+ Standard_Boolean isInfinite = false);
+
+ //! Sets the name of the scope.
+ void SetName (const TCollection_AsciiString& theName)
+ {
+ if (myIsOwnName)
+ {
+ Standard::Free (myName);
+ myIsOwnName = false;
+ }
+ myName = NULL;
+ if (!theName.IsEmpty())
+ {
+ myIsOwnName = true;
+ myName = (char* )Standard::Allocate (theName.Length() + 1);
+ char* aName = (char* )myName;
+ memcpy (aName, theName.ToCString(), theName.Length());
+ aName[theName.Length()] = '\0';
+ }
+ }
+
+ //! Sets the name of the scope; can be null.
+ //! Note! Just pointer to the given string is copied,
+ //! so do not pass string from a temporary variable whose
+ //! lifetime is less than that of this object.
+ template<size_t N>
+ void SetName (const char (&theName)[N])
+ {
+ if (myIsOwnName)
+ {
+ Standard::Free (myName);
+ myIsOwnName = false;
+ }
+ myName = theName;
+ }
+
+public: //! @name Advance by iterations
+
+ //! Returns true if ProgressIndicator signals UserBreak
+ Standard_Boolean UserBreak() const;
+
+ //! Returns false if ProgressIndicator signals UserBreak
+ Standard_Boolean More() const
+ {
+ return !UserBreak();
+ }
+
+ //! Advances position by specified step and returns the range
+ //! covering this step
+ Message_ProgressRange Next (Standard_Real theStep = 1.);
+
+public: //! @name Auxiliary methods to use in ProgressIndicator
+
+ //! Force update of presentation of the progress indicator.
+ //! Should not be called concurrently.
+ void Show();
+
+ //! Returns true if this progress scope is attached to some indicator.
+ Standard_Boolean IsActive() const
+ {
+ return myIsActive;
+ }
+
+ //! Returns the name of the scope (may be null).
+ //! Scopes with null name (e.g. root scope) should
+ //! be bypassed when reporting progress to the user.
+ Standard_CString Name() const
+ {
+ return myName;
+ }
+
+ //! Returns parent scope (null for top-level scope)
+ const Message_ProgressScope* Parent() const
+ {
+ return myParent;
+ }
+
+ //! Returns the maximal value of progress in this scope
+ Standard_Real MaxValue() const
+ {
+ return myMax;
+ }
+
+ //! Returns the current value of progress in this scope.
+ //! If this scope is being advanced by sub-scoping, that value is
+ //! computed by mapping current global progress into this scope range.
+ Standard_Real Value() const
+ {
+ return myIsActive ? myValue : myMax;
+ }
+
+ //! Returns the infinite flag
+ Standard_Boolean IsInfinite() const
+ {
+ return myIsInfinite;
+ }
+
+ //! Get the portion of the indicator covered by this scope (from 0 to 1)
+ Standard_Real GetPortion() const
+ {
+ return myPortion;
+ }
+
+public: //! @name Destruction, allocation
+
+ //! Destructor - closes the scope and adds its scale to the total progress
+ ~Message_ProgressScope()
+ {
+ Relieve();
+ if (myIsOwnName)
+ {
+ Standard::Free (myName);
+ myIsOwnName = false;
+ myName = NULL;
+ }
+ }
+
+ //! Closes the scope and adds its scale to the total progress.
+ //! Relieved scope should not be used.
+ void Relieve();
+
+ DEFINE_STANDARD_ALLOC
+
+private: //! @name Internal methods
+
+ //! Creates a top-level scope with default range [0,1] and step 1.
+ //! Called only by Message_ProgressIndicator constructor.
+ Message_ProgressScope (Message_ProgressIndicator* theProgress);
+
+ //! Convert value from this scale to global one
+ Standard_Real localToGlobal(const Standard_Real theVal) const;
+
+ //! Convert value from global scale to this one
+ Standard_Real globalToLocal(const Standard_Real theVal) const;
+
+private:
+ //! Copy constructor is prohibited
+ Message_ProgressScope (const Message_ProgressScope& theOther);
+
+ //! Copy assignment is prohibited
+ Message_ProgressScope& operator= (const Message_ProgressScope& theOther);
+
+private:
+
+ Message_ProgressIndicator* myProgress; //!< Pointer to progress indicator instance
+ const Message_ProgressScope* myParent; //!< Pointer to parent scope
+ Standard_CString myName; //!< Name of the operation being done in this scope, or null
+
+ Standard_Real myPortion; //!< The portion of the global scale covered by this scope (from 0 to 1)
+ Standard_Real myMax; //!< Maximal value of progress in this scope
+ Standard_Real myValue; //!< Current position advanced within this scope [0, Max]
+
+ Standard_Boolean myIsActive; //!< flag indicating armed/disarmed state
+ Standard_Boolean myIsOwnName; //!< flag indicating if name was allocated or not
+ Standard_Boolean myIsInfinite; //!< Option to advance by hyperbolic law
+
+private:
+ friend class Message_ProgressIndicator;
+ friend class Message_ProgressRange;
+};
+
+#include <Message_ProgressRange.hxx>
+
+//=======================================================================
+//function : Message_ProgressScope
+//purpose :
+//=======================================================================
+inline Message_ProgressScope::Message_ProgressScope (Message_ProgressIndicator* theProgress)
+: myProgress(theProgress),
+ myParent(0),
+ myName(0),
+ myPortion(1.),
+ myMax(1.),
+ myValue(0.),
+ myIsActive(theProgress != NULL),
+ myIsOwnName(false),
+ myIsInfinite(false)
+{
+}
+
+//=======================================================================
+//function : Message_ProgressScope
+//purpose :
+//=======================================================================
+inline Message_ProgressScope::Message_ProgressScope (const Message_ProgressRange& theRange,
+ const TCollection_AsciiString& theName,
+ Standard_Real theMax,
+ Standard_Boolean isInfinite)
+: myProgress (theRange.myParentScope != NULL ? theRange.myParentScope->myProgress : NULL),
+ myParent (theRange.myParentScope),
+ myName (NULL),
+ myPortion (theRange.myDelta),
+ myMax (Max (1.e-6, theMax)), // protection against zero range
+ myValue (0.),
+ myIsActive (myProgress != NULL && !theRange.myWasUsed),
+ myIsOwnName (false),
+ myIsInfinite (isInfinite)
+{
+ SetName (theName);
+ Standard_ASSERT_VOID (! theRange.myWasUsed, "Message_ProgressRange is used to initialize more than one scope");
+ theRange.myWasUsed = true; // Disarm the range
+}
+
+//=======================================================================
+//function : Message_ProgressScope
+//purpose :
+//=======================================================================
+template<size_t N>
+Message_ProgressScope::Message_ProgressScope (const Message_ProgressRange& theRange,
+ const char (&theName)[N],
+ Standard_Real theMax,
+ Standard_Boolean isInfinite)
+: myProgress (theRange.myParentScope != NULL ? theRange.myParentScope->myProgress : NULL),
+ myParent (theRange.myParentScope),
+ myName (theName),
+ myPortion (theRange.myDelta),
+ myMax (Max (1.e-6, theMax)), // protection against zero range
+ myValue (0.),
+ myIsActive (myProgress != NULL && !theRange.myWasUsed),
+ myIsOwnName (false),
+ myIsInfinite (isInfinite)
+{
+ Standard_ASSERT_VOID (! theRange.myWasUsed, "Message_ProgressRange is used to initialize more than one scope");
+ theRange.myWasUsed = true; // Disarm the range
+}
+
+//=======================================================================
+//function : Message_ProgressScope
+//purpose :
+//=======================================================================
+inline Message_ProgressScope::Message_ProgressScope (const Message_ProgressRange& theRange,
+ const NullString* ,
+ Standard_Real theMax,
+ Standard_Boolean isInfinite)
+: myProgress (theRange.myParentScope != NULL ? theRange.myParentScope->myProgress : NULL),
+ myParent (theRange.myParentScope),
+ myName (NULL),
+ myPortion (theRange.myDelta),
+ myMax (Max (1.e-6, theMax)), // protection against zero range
+ myValue (0.),
+ myIsActive (myProgress != NULL && !theRange.myWasUsed),
+ myIsOwnName (false),
+ myIsInfinite (isInfinite)
+{
+ Standard_ASSERT_VOID (! theRange.myWasUsed, "Message_ProgressRange is used to initialize more than one scope");
+ theRange.myWasUsed = true; // Disarm the range
+}
+
+//=======================================================================
+//function : Relieve
+//purpose :
+//=======================================================================
+inline void Message_ProgressScope::Relieve()
+{
+ if (!myIsActive)
+ {
+ return;
+ }
+
+ // Advance indicator to the end of the scope
+ Standard_Real aCurr = localToGlobal (myValue);
+ myValue = (myIsInfinite ? Precision::Infinite() : myMax);
+ Standard_Real aDelta = myPortion - aCurr;
+ if (aDelta > 0.)
+ {
+ myProgress->Increment (aDelta, *this);
+ }
+ Standard_ASSERT_VOID (myParent == 0 || myParent->myIsActive,
+ "Parent progress scope has been closed before child");
+
+ myIsActive = false;
+}
+
+//=======================================================================
+//function : UserBreak
+//purpose :
+//=======================================================================
+inline Standard_Boolean Message_ProgressScope::UserBreak() const
+{
+ return myProgress && myProgress->UserBreak();
+}
+
+//=======================================================================
+//function : Next
+//purpose :
+//=======================================================================
+inline Message_ProgressRange Message_ProgressScope::Next (Standard_Real theStep)
+{
+ if (myIsActive)
+ {
+ if (theStep > 0.)
+ {
+ Standard_Real aCurr = localToGlobal (myValue);
+ Standard_Real aNext = localToGlobal (myValue += theStep);
+ Standard_Real aDelta = aNext - aCurr;
+ if (aDelta > 0.)
+ {
+ return Message_ProgressRange (*this, aDelta);
+ }
+ }
+ }
+ return Message_ProgressRange();
+}
+
+//=======================================================================
+//function : Show
+//purpose :
+//=======================================================================
+
+inline void Message_ProgressScope::Show ()
+{
+ if (myIsActive)
+ {
+ myProgress->Show (*this, Standard_True);
+ }
+}
+
+//=======================================================================
+//function : localToGlobal
+//purpose :
+//=======================================================================
+inline Standard_Real Message_ProgressScope::localToGlobal (const Standard_Real theVal) const
+{
+ if (theVal <= 0.)
+ return 0.;
+
+ if (!myIsInfinite)
+ {
+ if (myMax - theVal < RealSmall())
+ return myPortion;
+ return myPortion * theVal / myMax;
+ }
+
+ double x = theVal / myMax;
+ // return myPortion * ( 1. - std::exp ( -x ) ); // exponent
+ return myPortion * x / (1. + x); // hyperbola
+}
+
+//=======================================================================
+//function : globalToLocal
+//purpose :
+//=======================================================================
+
+inline Standard_Real Message_ProgressScope::globalToLocal (const Standard_Real theVal) const
+{
+ // if at end of the scope (or behind), report the maximum
+ Standard_Real aDist = myPortion - theVal;
+ if (aDist <= Precision::Confusion())
+ return myIsInfinite ? Precision::Infinite() : myMax;
+
+ if (!myIsInfinite)
+ return myMax * theVal / myPortion;
+
+ // Standard_Real x = log (theVal / aDist); // exponent
+ Standard_Real x = theVal / aDist; // hyperbola
+ return x * myMax;
+}
+
+#endif // _Message_ProgressScope_HeaderFile
+++ /dev/null
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
-#include <TCollection_HAsciiString.hxx>
-
-//=======================================================================
-//function : Message_ProgressSentry
-//purpose :
-//=======================================================================
-Message_ProgressSentry::Message_ProgressSentry (const Handle(Message_ProgressIndicator) &progress,
- const Standard_CString name,
- const Standard_Real min,
- const Standard_Real max,
- const Standard_Real step,
- const Standard_Boolean isInf,
- const Standard_Real newScopeSpan) :
- myProgress(progress), myActive(!progress.IsNull())
-{
- if ( ! myActive ) return;
- progress->SetName ( name );
- progress->SetScale ( min, max, step, isInf );
- progress->NewScope ( newScopeSpan >0 ? newScopeSpan : step );
-}
-
-//=======================================================================
-//function : Message_ProgressSentry
-//purpose :
-//=======================================================================
-
-Message_ProgressSentry::Message_ProgressSentry (const Handle(Message_ProgressIndicator) &progress,
- const Handle(TCollection_HAsciiString) &name,
- const Standard_Real min,
- const Standard_Real max,
- const Standard_Real step,
- const Standard_Boolean isInf,
- const Standard_Real newScopeSpan) :
- myProgress(progress), myActive(!progress.IsNull())
-{
- if ( ! myActive ) return;
- progress->SetName ( name );
- progress->SetScale ( min, max, step, isInf );
- progress->NewScope ( newScopeSpan >0 ? newScopeSpan : step );
-}
-// Created on: 2002-02-22
-// Created by: Andrey BETENEV
-// Copyright (c) 2002-2014 OPEN CASCADE SAS
+// Copyright (c) 2020 OPEN CASCADE SAS
//
// This file is part of Open CASCADE Technology software library.
//
// Alternatively, this file may be used under the terms of Open CASCADE
// commercial license or contractual agreement.
-#ifndef _Message_ProgressSentry_HeaderFile
-#define _Message_ProgressSentry_HeaderFile
+#ifndef Message_ProgressSentry_HeaderFile
+#define Message_ProgressSentry_HeaderFile
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
+#include <Message_ProgressScope.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_CString.hxx>
-#include <Standard_Real.hxx>
-class Message_ProgressIndicator;
-class TCollection_HAsciiString;
-
-
-//! This class is a tool allowing to manage opening/closing
-//! scopes in the ProgressIndicator in convenient and safe way.
-//!
-//! Its main features are:
-//! - Set all parameters for the current scale on the given
-//! ProgressIndicator and open a new scope at one line
-//! - Iterator-like interface to opening next scopes and
-//! check for user break
-//! - Automatic scope closing in destructor
-//! - Safe for NULL ProgressIndicator (just does nothing)
-//!
-//! Example of usage in nested process:
-//!
-//! @code{.cpp}
-//! Handle(Draw_ProgressIndicator) aProgress = ...;
-//!
-//! // Outer cycle
-//! Message_ProgressSentry anOuter (aProgress, "Outer", 0, nbOuter, 1);
-//! for (int i = 0; i < nbOuter && anOuter.More(); i++, anOuter.Next())
-//! {
-//! // Inner cycle
-//! Message_ProgressSentry anInner (aProgress, "Inner", 0, nbInner, 1);
-//! for (int j = 0; j < nbInner && anInner.More(); j++, anInner.Next())
-//! {
-//! // Cycle body
-//! }
-//! }
-//! @endcode
-
-class Message_ProgressSentry
+//! Functionality of this class (Message_ProgressSentry) has been superseded by Message_ProgressScope.
+//! This class is kept just to simplify transition of an old code and will be removed in future.
+class Standard_DEPRECATED("Deprecated class, Message_ProgressScope should be used instead")
+Message_ProgressSentry : public Message_ProgressScope
{
public:
-
- DEFINE_STANDARD_ALLOC
-
-
- Standard_EXPORT Message_ProgressSentry(const Handle(Message_ProgressIndicator)& PI, const Standard_CString name, const Standard_Real min, const Standard_Real max, const Standard_Real step, const Standard_Boolean isInf = Standard_False, const Standard_Real newScopeSpan = 0.0);
-
- //! Creates an instance of ProgressSentry attaching it to
- //! the specified ProgressIndicator, selects parameters of
- //! the current scale, and opens a new scope with specified
- //! span (equal to step by default)
- Standard_EXPORT Message_ProgressSentry(const Handle(Message_ProgressIndicator)& PI, const Handle(TCollection_HAsciiString)& name, const Standard_Real min, const Standard_Real max, const Standard_Real step, const Standard_Boolean isInf = Standard_False, const Standard_Real newScopeSpan = 0.0);
-
- //! Moves progress indicator to the end of the current scale
- //! and relieves sentry from its duty. Methods other than Show()
- //! will do nothing after this one is called.
- void Relieve();
-~Message_ProgressSentry()
-{
- Relieve();
-}
-
- void Next (const Standard_CString name = 0) const;
-
- void Next (const Standard_Real span, const Standard_CString name = 0) const;
-
- //! Closes current scope and opens next one
- //! with either specified or default span
- void Next (const Standard_Real span, const Handle(TCollection_HAsciiString)& name) const;
-
- //! Returns False if ProgressIndicator signals UserBreak
- Standard_Boolean More() const;
-
- //! Forces update of progress indicator display
- void Show() const;
-
-
-
-
-protected:
-
-
-
-
+ //! Deprecated constructor, Message_ProgressScope should be created instead.
+ Message_ProgressSentry (const Message_ProgressRange& theRange,
+ const Standard_CString theName,
+ const Standard_Real theMin,
+ const Standard_Real theMax,
+ const Standard_Real theStep,
+ const Standard_Boolean theIsInf = Standard_False,
+ const Standard_Real theNewScopeSpan = 0.0)
+ : Message_ProgressScope (theRange, theName, theMax, theIsInf)
+ {
+ if (theMin != 0.0 || theStep != 1.0 || theNewScopeSpan != 0.0)
+ {
+ throw Standard_ProgramError ("Message_ProgressSentry, invalid parameters");
+ }
+ }
private:
-
-
-
- Handle(Message_ProgressIndicator) myProgress;
- Standard_Boolean myActive;
-
-
+ //! Message_ProgressRange should be passed to constructor instead of Message_ProgressIndicator.
+ Message_ProgressSentry (const Handle(Message_ProgressIndicator)& theProgress,
+ const Standard_CString theName,
+ const Standard_Real theMin,
+ const Standard_Real theMax,
+ const Standard_Real theStep,
+ const Standard_Boolean theIsInf = Standard_False,
+ const Standard_Real theNewScopeSpan = 0.0);
};
-
-#include <Message_ProgressSentry.lxx>
-
-
-
-
-
-#endif // _Message_ProgressSentry_HeaderFile
+#endif // Message_ProgressSentry_HeaderFile
+++ /dev/null
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#include <Message_ProgressIndicator.hxx>
-
-//=======================================================================
-//function : Relieve
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressSentry::Relieve ()
-{
- if ( ! myActive ) return;
- myProgress->EndScope();
- myActive = 0;
-}
-
-//=======================================================================
-//function : Next
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressSentry::Next (const Standard_CString name) const
-{
- if ( myActive ) myProgress->NextScope(name);
-}
-
-//=======================================================================
-//function : Next
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressSentry::Next (const Standard_Real span,
- const Standard_CString name) const
-{
- if ( myActive ) myProgress->NextScope(span, name);
-}
-
-//=======================================================================
-//function : Next
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressSentry::Next (const Standard_Real span,
- const Handle(TCollection_HAsciiString)& name) const
-{
- if ( myActive ) {
- myProgress->EndScope();
- myProgress->NewScope(span, name);
- }
-}
-
-//=======================================================================
-//function : More
-//purpose :
-//=======================================================================
-
-inline Standard_Boolean Message_ProgressSentry::More () const
-{
- return myActive ? ! myProgress->UserBreak() : Standard_True;
-}
-
-//=======================================================================
-//function : Show
-//purpose :
-//=======================================================================
-
-inline void Message_ProgressSentry::Show () const
-{
- if ( ! myProgress.IsNull() ) myProgress->Show();
-}
+++ /dev/null
-// Created on: 1999-07-29
-// Created by: Roman LYGIN
-// Copyright (c) 1999 Matra Datavision
-// Copyright (c) 1999-2014 OPEN CASCADE SAS
-//
-// This file is part of Open CASCADE Technology software library.
-//
-// This library is free software; you can redistribute it and/or modify it under
-// the terms of the GNU Lesser General Public License version 2.1 as published
-// by the Free Software Foundation, with special exception defined in the file
-// OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
-// distribution for complete text of the license and disclaimer of any warranty.
-//
-// Alternatively, this file may be used under the terms of Open CASCADE
-// commercial license or contractual agreement.
-
-#ifndef Message_SequenceOfProgressScale_HeaderFile
-#define Message_SequenceOfProgressScale_HeaderFile
-
-#include <Message_ProgressScale.hxx>
-#include <NCollection_Sequence.hxx>
-
-typedef NCollection_Sequence<Message_ProgressScale> Message_SequenceOfProgressScale;
-
-
-#endif
#include <Standard_Transient.hxx>
#include <Standard_IStream.hxx>
#include <Storage_Data.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class PCDM_DriverError;
class CDM_Document;
Standard_EXPORT virtual void Read (const TCollection_ExtendedString& aFileName,
const Handle(CDM_Document)& aNewDocument,
const Handle(CDM_Application)& anApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) = 0;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) = 0;
Standard_EXPORT virtual void Read (Standard_IStream& theIStream,
const Handle(Storage_Data)& theStorageData,
const Handle(CDM_Document)& theDoc,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) = 0;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) = 0;
PCDM_ReaderStatus GetStatus() const;
void PCDM_StorageDriver::Write (const Handle(CDM_Document)& aDocument,
const TCollection_ExtendedString& aFileName,
- const Handle(Message_ProgressIndicator) &/*theProgress*/)
+ const Message_ProgressRange &/*theRange*/)
{
Handle(Storage_Schema) theSchema = new Storage_Schema;
//=======================================================================
void PCDM_StorageDriver::Write (const Handle(CDM_Document)& /*aDocument*/,
Standard_OStream& /*theOStream*/,
- const Handle(Message_ProgressIndicator)& /*theProgress*/)
+ const Message_ProgressRange& /*theRange*/)
{
}
//! document and the Schema method to write the persistent document.
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& aDocument,
const TCollection_ExtendedString& aFileName,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Write <theDocument> to theOStream
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& theDocument,
Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT void SetFormat (const TCollection_ExtendedString& aformat);
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& aDocument,
const TCollection_ExtendedString& aFileName,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) = 0;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) = 0;
//! Write <theDocument> to theOStream
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& theDocument,
Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) = 0;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) = 0;
DEFINE_STANDARD_RTTIEXT(PCDM_Writer,Standard_Transient)
#include <Plate_Plate.hxx>
#include <Plate_SampledCurveConstraint.hxx>
#include <Standard_ErrorHandler.hxx>
-#include <Message_ProgressIndicator.hxx>
//=======================================================================
//function : Plate_Plate
//=======================================================================
void Plate_Plate::SolveTI(const Standard_Integer ord,
- const Standard_Real anisotropie,
- const Handle(Message_ProgressIndicator) & aProgress)
+ const Standard_Real anisotropie,
+ const Message_ProgressRange& theProgress)
{
Standard_Integer IterationNumber=0;
OK = Standard_False;
if(myLScalarConstraints.IsEmpty())
{
if(myLXYZConstraints.IsEmpty())
- SolveTI1(IterationNumber, aProgress);
+ SolveTI1(IterationNumber, theProgress);
else
- SolveTI2(IterationNumber, aProgress);
+ SolveTI2(IterationNumber, theProgress);
}
else
- SolveTI3(IterationNumber, aProgress);
+ SolveTI3(IterationNumber, theProgress);
}
// only PinPointConstraints are loaded
//=======================================================================
-void Plate_Plate::SolveTI1(const Standard_Integer IterationNumber, const Handle(Message_ProgressIndicator) & aProgress)
+void Plate_Plate::SolveTI1(const Standard_Integer IterationNumber,
+ const Message_ProgressRange& theProgress)
{
// computation of square matrix members
Standard_Real pivot_max = 1.e-12;
OK = Standard_True;
- math_Gauss algo_gauss(mat,pivot_max, aProgress);
+ Message_ProgressScope aScope (theProgress, NULL, 10);
+ math_Gauss algo_gauss(mat,pivot_max, aScope.Next (7));
- if (!aProgress.IsNull() && aProgress->UserBreak())
+ if (aScope.UserBreak())
{
OK = Standard_False;
return;
mat(i,i) = 1.e-8;
}
pivot_max = 1.e-18;
- math_Gauss thealgo(mat,pivot_max, aProgress);
+
+ math_Gauss thealgo(mat,pivot_max, aScope.Next (3));
+
+ if (aScope.UserBreak())
+ {
+ OK = Standard_False;
+ return;
+ }
algo_gauss = thealgo;
OK = algo_gauss.IsDone();
}
// LinearXYZ constraints are provided but no LinearScalar one
//=======================================================================
-void Plate_Plate::SolveTI2(const Standard_Integer IterationNumber, const Handle(Message_ProgressIndicator) & aProgress)
+void Plate_Plate::SolveTI2(const Standard_Integer IterationNumber,
+ const Message_ProgressRange& theProgress)
{
// computation of square matrix members
Standard_Real pivot_max = 1.e-12;
OK = Standard_True; // ************ JHH
- math_Gauss algo_gauss(mat,pivot_max, aProgress);
+ Message_ProgressScope aScope (theProgress, NULL, 10);
+ math_Gauss algo_gauss(mat,pivot_max, aScope.Next (7));
- if (!aProgress.IsNull() && aProgress->UserBreak ())
+ if (aScope.UserBreak())
{
OK = Standard_False;
return;
mat(i,i) = 1.e-8;
}
pivot_max = 1.e-18;
- math_Gauss thealgo1(mat,pivot_max, aProgress);
- algo_gauss = thealgo1;
+
+ math_Gauss thealgo1(mat,pivot_max, aScope.Next (3));
+
+ if (aScope.UserBreak())
+ {
+ OK = Standard_False;
+ return;
+ }
+ algo_gauss = thealgo1;
OK = algo_gauss.IsDone();
}
//purpose : to solve the set of constraints in the most general situation
//=======================================================================
-void Plate_Plate::SolveTI3(const Standard_Integer IterationNumber, const Handle(Message_ProgressIndicator) & aProgress)
+void Plate_Plate::SolveTI3(const Standard_Integer IterationNumber,
+ const Message_ProgressRange& theProgress)
{
// computation of square matrix members
Standard_Real pivot_max = 1.e-12;
OK = Standard_True; // ************ JHH
- math_Gauss algo_gauss(mat,pivot_max, aProgress);
+ Message_ProgressScope aScope (theProgress, NULL, 10);
+ math_Gauss algo_gauss(mat,pivot_max, aScope.Next (7));
- if (!aProgress.IsNull() && aProgress->UserBreak ())
+ if (aScope.UserBreak())
{
OK = Standard_False;
return;
mat(2*n_dimsousmat+i,2*n_dimsousmat+i) = 1.e-8;
}
pivot_max = 1.e-18;
- math_Gauss thealgo2(mat,pivot_max, aProgress);
+
+ math_Gauss thealgo2(mat,pivot_max, aScope.Next (3));
+
+ if (aScope.UserBreak())
+ {
+ OK = Standard_False;
+ return;
+ }
algo_gauss = thealgo2;
OK = algo_gauss.IsDone();
}
#include <Standard_Real.hxx>
#include <TColgp_HArray2OfXYZ.hxx>
#include <TColgp_SequenceOfXY.hxx>
+#include <Message_ProgressScope.hxx>
class Plate_PinpointConstraint;
class Plate_LinearXYZConstraint;
class gp_XYZ;
class gp_XY;
class math_Matrix;
-class Message_ProgressIndicator;
//! This class implement a variationnal spline algorithm able
Standard_EXPORT void SolveTI (const Standard_Integer ord = 4,
const Standard_Real anisotropie = 1.0,
- const Handle(Message_ProgressIndicator) & aProgress = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! returns True if all has been correctly done.
Standard_EXPORT Standard_Boolean IsDone() const;
gp_XY& Points (const Standard_Integer index) const;
- Standard_EXPORT void SolveTI1 (const Standard_Integer IterationNumber, const Handle(Message_ProgressIndicator) & aProgress = NULL);
+ Standard_EXPORT void SolveTI1 (const Standard_Integer IterationNumber,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void SolveTI2 (const Standard_Integer IterationNumber, const Handle(Message_ProgressIndicator) & aProgress = NULL);
+ Standard_EXPORT void SolveTI2 (const Standard_Integer IterationNumber,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void SolveTI3 (const Standard_Integer IterationNumber, const Handle(Message_ProgressIndicator) & aProgress = NULL);
+ Standard_EXPORT void SolveTI3 (const Standard_Integer IterationNumber,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void fillXYZmatrix (math_Matrix& mat, const Standard_Integer i0, const Standard_Integer j0, const Standard_Integer ncc1, const Standard_Integer ncc2) const;
#include <OSD_Exception_ACCESS_VIOLATION.hxx>
#include <OSD_Exception_STACK_OVERFLOW.hxx>
#include <OSD.hxx>
+#include <OSD_Timer.hxx>
#include <OSD_ThreadPool.hxx>
+#include <OSD_Parallel.hxx>
#include <STEPCAFControl_Writer.hxx>
#include <STEPControl_StepModelType.hxx>
#include <Interface_Static.hxx>
#include <XSControl_WorkSession.hxx>
#include <Transfer_TransientProcess.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <XSControl_TransferReader.hxx>
#include <Geom_Plane.hxx>
Standard_Integer nbInner = (argc > 2 ? Draw::Atoi(argv[2]) : 2);
Standard_Boolean isInf = (argc > 3 && ! strcmp (argv[3], "-inf"));
- // test behavior of progress indicator when using nested scopes with names set by Sentry objects
+ // test behavior of progress indicator when using nested scopes with names
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (di, 1);
- aProgress->SetTextMode (Standard_True);
- aProgress->SetTclOutput (Standard_True);
// Outer cycle
- Message_ProgressSentry anOuter (aProgress, "Outer", 0, nbOuter, 1);
- for (int i = 0; i < nbOuter && anOuter.More(); i++, anOuter.Next())
+ Message_ProgressScope anOuter (aProgress->Start(), "Outer", nbOuter);
+ for (int i = 0; i < nbOuter && anOuter.More(); i++)
{
// Inner cycle
- Message_ProgressSentry anInner (aProgress, "Inner", 0, nbInner, 1, isInf);
- for (int j = 0; j < nbInner && anInner.More(); j++, anInner.Next())
+ Message_ProgressScope anInner (anOuter.Next(), "Inner", nbInner, isInf);
+ for (int j = 0; j < (isInf ? 2 * nbInner : nbInner) && anInner.More(); j++, anInner.Next())
{
// Cycle body
}
return 0;
}
+namespace
+{
+ struct Task
+ {
+ Message_ProgressRange Range;
+ math_Matrix Mat1, Mat2, Mat3;
+
+ Task(const Message_ProgressRange& thePR, int theSize)
+ : Range(thePR),
+ Mat1(1, theSize, 1, theSize, 0.12345), Mat2(1, theSize, 1, theSize, 12345),
+ Mat3(1, theSize, 1, theSize)
+ {}
+ };
+ struct Functor
+ {
+ void operator()(Task& theTask) const
+ {
+ Message_ProgressScope aPS(theTask.Range, NULL, 1);
+ if (aPS.More())
+ {
+ if (theTask.Mat1.RowNumber() > 1)
+ theTask.Mat3 = theTask.Mat1 * theTask.Mat2;
+ }
+ }
+ };
+}
+
+Standard_Integer OCC25748(Draw_Interpretor& di, Standard_Integer argc, const char ** argv)
+{
+ // test behavior of progress indicator in multi-threaded execution
+ Standard_Integer nIter = 1000;
+ Standard_Integer aMatSize = 1;
+ Standard_Boolean isProgress = false;
+ Standard_Boolean isParallel = false;
+
+ for (int i = 1; i < argc; i++)
+ {
+ if (strcmp(argv[i], "-niter") == 0)
+ nIter = Draw::Atoi(argv[++i]);
+ else if (strcmp(argv[i], "-matsize") == 0)
+ aMatSize = Draw::Atoi(argv[++i]);
+ else if (strcmp(argv[i], "-progr") == 0)
+ isProgress = true;
+ else if (strcmp(argv[i], "-parallel") == 0)
+ isParallel = true;
+ else
+ {
+ di.PrintHelp("OCC25748");
+ return 1;
+ }
+ }
+
+ OSD_Timer aTimerWhole;
+ aTimerWhole.Start();
+
+ Handle(Draw_ProgressIndicator) aProgress;
+ if (isProgress)
+ {
+ aProgress = new Draw_ProgressIndicator(di, 1);
+ }
+ Message_ProgressScope aPS(Message_ProgressIndicator::Start(aProgress),
+ "Parallel data processing", nIter);
+
+ std::vector<Task> aTasks;
+ aTasks.reserve (nIter);
+ for (int i = 0; i < nIter; i++)
+ {
+ aTasks.push_back (Task (aPS.Next(), aMatSize));
+ }
+
+ OSD_Timer aTimer;
+ aTimer.Start();
+ OSD_Parallel::ForEach(aTasks.begin(), aTasks.end(), Functor(), !isParallel);
+ aTimer.Stop();
+
+ aTimerWhole.Stop();
+
+ TCollection_AsciiString aText(nIter);
+ aText += (isParallel ? " parallel" : " sequential");
+ if (aMatSize > 1)
+ aText = aText + " calculations on matrices " + aMatSize + "x" + aMatSize;
+ else
+ aText += " empty tasks";
+ if (isProgress)
+ aText += " with progress";
+ di << "COUNTER " << aText << ": " << aTimer.ElapsedTime();
+ di << "\nCOUNTER " << "including preparations" << ": " << aTimerWhole.ElapsedTime();
+ return 0;
+}
+
void QABugs::Commands_11(Draw_Interpretor& theCommands) {
const char *group = "QABugs";
theCommands.Add("OCC23429", "OCC23429 res shape tool [appr]", __FILE__, OCC23429, group);
theCommands.Add("OCC28478", "OCC28478 [nb_outer=3 [nb_inner=2] [-inf]: test progress indicator on nested cycles", __FILE__, OCC28478, group);
theCommands.Add("OCC31189", "OCC31189: check stream buffer interface of Message_Messenger", __FILE__, OCC31189, group);
+ theCommands.Add("OCC25748", "OCC25748 [-niter val] [-matsize val] [-progr] [-parallel]\n"
+ "\t\ttest progress indicator in parallel execution", __FILE__, OCC25748, group);
return;
}
#include <BRep_Tool.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <OSD_OpenFile.hxx>
#include <OSD_ThreadPool.hxx>
//! Main constructor.
CafReader_GltfReaderFunctor (RWGltf_CafReader* myCafReader,
NCollection_Vector<TopoDS_Face>& theFaceList,
- Message_ProgressSentry& theSentry,
+ const Message_ProgressRange& theProgress,
const OSD_ThreadPool::Launcher& theThreadPool,
const TCollection_AsciiString& theErrPrefix)
: myCafReader (myCafReader),
myFaceList (&theFaceList),
- mySentry (&theSentry),
myErrPrefix (theErrPrefix),
+ myProgress (theProgress, "Loading glTF triangulation", Max (1, theFaceList.Size())),
myThreadPool(theThreadPool),
myTlsData (theThreadPool.LowerThreadIndex(), theThreadPool.UpperThreadIndex())
{
if (myThreadPool.HasThreads())
{
Standard_Mutex::Sentry aLock (&myMutex);
- mySentry->Next();
+ myProgress.Next();
}
else
{
- mySentry->Next();
+ myProgress.Next();
}
}
RWGltf_CafReader* myCafReader;
NCollection_Vector<TopoDS_Face>* myFaceList;
- Message_ProgressSentry* mySentry;
TCollection_AsciiString myErrPrefix;
mutable Standard_Mutex myMutex;
+ mutable Message_ProgressScope myProgress;
const OSD_ThreadPool::Launcher& myThreadPool;
- mutable NCollection_Array1<GltfReaderTLS>
- myTlsData;
-
+ mutable NCollection_Array1<GltfReaderTLS> myTlsData;
};
//================================================================
// Purpose :
//================================================================
Standard_Boolean RWGltf_CafReader::performMesh (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe)
{
+ Message_ProgressScope aPSentry (theProgress, "Reading glTF", 2);
+ aPSentry.Show();
+
std::ifstream aFile;
OSD_OpenStream (aFile, theFile.ToCString(), std::ios::in | std::ios::binary);
if (!aFile.is_open()
}
#endif
- if (!aDoc.Parse (theProgress))
+ if (!aDoc.Parse (aPSentry.Next()))
{
return false;
}
if (!theToProbe
- && !readLateData (aDoc.FaceList(), theFile, theProgress))
+ && !readLateData (aDoc.FaceList(), theFile, aPSentry.Next()))
{
return false;
}
//================================================================
Standard_Boolean RWGltf_CafReader::readLateData (NCollection_Vector<TopoDS_Face>& theFaces,
const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
- Message_ProgressSentry aPSentryTris (theProgress, "Loading glTF triangulation", 0, Max (1, theFaces.Size()), 1);
const Handle(OSD_ThreadPool)& aThreadPool = OSD_ThreadPool::DefaultPool();
const int aNbThreads = myToParallel ? Min (theFaces.Size(), aThreadPool->NbDefaultThreadsToLaunch()) : 1;
OSD_ThreadPool::Launcher aLauncher (*aThreadPool, aNbThreads);
- CafReader_GltfReaderFunctor aFunctor (this, theFaces, aPSentryTris, aLauncher,
+ CafReader_GltfReaderFunctor aFunctor (this, theFaces, theProgress, aLauncher,
TCollection_AsciiString ("File '") + theFile + "' defines invalid glTF!\n");
aLauncher.Perform (theFaces.Lower(), theFaces.Upper() + 1, aFunctor);
return Standard_True;
#ifndef _RWGltf_CafReader_HeaderFile
#define _RWGltf_CafReader_HeaderFile
+#include <Message_ProgressRange.hxx>
#include <NCollection_Vector.hxx>
#include <RWMesh_CafReader.hxx>
#include <TopoDS_Face.hxx>
//! Read the mesh from specified file.
Standard_EXPORT virtual Standard_Boolean performMesh (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe) Standard_OVERRIDE;
//! Create primitive array reader context.
//! Read late data from RWGltf_GltfLatePrimitiveArray stored as Poly_Triangulation within faces.
Standard_EXPORT virtual Standard_Boolean readLateData (NCollection_Vector<TopoDS_Face>& theFaces,
const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
protected:
class CafReader_GltfReaderFunctor;
#include <gp_Quaternion.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_DataMap.hxx>
#include <OSD_OpenFile.hxx>
#include <OSD_File.hxx>
// =======================================================================
bool RWGltf_CafWriter::Perform (const Handle(TDocStd_Document)& theDocument,
const TColStd_IndexedDataMapOfStringString& theFileInfo,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
TDF_LabelSequence aRoots;
Handle(XCAFDoc_ShapeTool) aShapeTool = XCAFDoc_DocumentTool::ShapeTool (theDocument->Main());
const TDF_LabelSequence& theRootLabels,
const TColStd_MapOfAsciiString* theLabelFilter,
const TColStd_IndexedDataMapOfStringString& theFileInfo,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
- Message_ProgressSentry aPSentry (theProgress, "Writing glTF file", 0, 2, 1);
- if (!writeBinData (theDocument, theRootLabels, theLabelFilter, theProgress))
+ Message_ProgressScope aPSentry (theProgress, "Writing glTF file", 2);
+ if (!writeBinData (theDocument, theRootLabels, theLabelFilter, aPSentry.Next()))
{
return false;
}
- aPSentry.Next();
if (!aPSentry.More())
{
return false;
}
- return writeJson (theDocument, theRootLabels, theLabelFilter, theFileInfo, theProgress);
+ return writeJson (theDocument, theRootLabels, theLabelFilter, theFileInfo, aPSentry.Next());
}
// =======================================================================
bool RWGltf_CafWriter::writeBinData (const Handle(TDocStd_Document)& theDocument,
const TDF_LabelSequence& theRootLabels,
const TColStd_MapOfAsciiString* theLabelFilter,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
myBuffViewPos.ByteOffset = 0;
myBuffViewPos.ByteLength = 0;
return false;
}
- Message_ProgressSentry aPSentryBin (theProgress, "Binary data", 0, 4, 1);
+ Message_ProgressScope aPSentryBin (theProgress, "Binary data", 4);
Standard_Integer aNbAccessors = 0;
const TDF_LabelSequence& theRootLabels,
const TColStd_MapOfAsciiString* theLabelFilter,
const TColStd_IndexedDataMapOfStringString& theFileInfo,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
#ifdef HAVE_RAPIDJSON
myWriter.reset();
// write vertex arrays
- Message_ProgressSentry aPSentryBin (theProgress, "Header data", 0, 2, 1);
+ Message_ProgressScope aPSentryBin (theProgress, "Header data", 2);
const Standard_Integer aBinDataBufferId = 0;
const Standard_Integer aDefSamplerId = 0;
#include <memory>
-class Message_ProgressIndicator;
+class Message_ProgressRange;
class RWMesh_FaceIterator;
class RWGltf_GltfOStreamWriter;
class RWGltf_GltfMaterialMap;
const TDF_LabelSequence& theRootLabels,
const TColStd_MapOfAsciiString* theLabelFilter,
const TColStd_IndexedDataMapOfStringString& theFileInfo,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Write glTF file and associated binary file.
//! Triangulation data should be precomputed within shapes!
//! @return FALSE on file writing failure
Standard_EXPORT virtual bool Perform (const Handle(TDocStd_Document)& theDocument,
const TColStd_IndexedDataMapOfStringString& theFileInfo,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
protected:
Standard_EXPORT virtual bool writeBinData (const Handle(TDocStd_Document)& theDocument,
const TDF_LabelSequence& theRootLabels,
const TColStd_MapOfAsciiString* theLabelFilter,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Write JSON file with glTF structure (should be called after writeBinData()).
//! @param theDocument [in] input document
const TDF_LabelSequence& theRootLabels,
const TColStd_MapOfAsciiString* theLabelFilter,
const TColStd_IndexedDataMapOfStringString& theFileInfo,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
protected:
#include <gp_Quaternion.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <OSD_File.hxx>
#include <OSD_OpenFile.hxx>
#include <OSD_Path.hxx>
// function : gltfParseScene
// purpose :
// =======================================================================
-bool RWGltf_GltfJsonParser::gltfParseScene (const Handle(Message_ProgressIndicator)& theProgress)
+bool RWGltf_GltfJsonParser::gltfParseScene (const Message_ProgressRange& theProgress)
{
// search default scene
const RWGltf_JsonValue* aDefScene = myGltfRoots[RWGltf_GltfRootElement_Scenes].FindChild (*myGltfRoots[RWGltf_GltfRootElement_Scene].Root());
// =======================================================================
bool RWGltf_GltfJsonParser::gltfParseSceneNodes (TopTools_SequenceOfShape& theShapeSeq,
const RWGltf_JsonValue& theSceneNodes,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
if (!theSceneNodes.IsArray())
{
return false;
}
- Message_ProgressSentry aPSentry (theProgress, "Reading scene nodes", 0, theSceneNodes.Size(), 1);
+ Message_ProgressScope aPS (theProgress, "Reading scene nodes", theSceneNodes.Size());
for (rapidjson::Value::ConstValueIterator aSceneNodeIter = theSceneNodes.Begin();
- aSceneNodeIter != theSceneNodes.End() && aPSentry.More(); ++aSceneNodeIter, aPSentry.Next())
+ aSceneNodeIter != theSceneNodes.End() && aPS.More(); ++aSceneNodeIter)
{
const RWGltf_JsonValue* aSceneNode = myGltfRoots[RWGltf_GltfRootElement_Nodes].FindChild (*aSceneNodeIter);
if (aSceneNode == NULL)
}
TopoDS_Shape aNodeShape;
- if (!gltfParseSceneNode (aNodeShape, getKeyString (*aSceneNodeIter), *aSceneNode, theProgress))
+ if (!gltfParseSceneNode (aNodeShape, getKeyString (*aSceneNodeIter), *aSceneNode, aPS.Next()))
{
return false;
}
bool RWGltf_GltfJsonParser::gltfParseSceneNode (TopoDS_Shape& theNodeShape,
const TCollection_AsciiString& theSceneNodeId,
const RWGltf_JsonValue& theSceneNode,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
const RWGltf_JsonValue* aName = findObjectMember (theSceneNode, "name");
//const RWGltf_JsonValue* aJointName = findObjectMember (theSceneNode, "jointName");
&& aMeshes_1->IsArray())
{
// glTF 1.0
- Message_ProgressSentry aPSentry (theProgress, "Reading scene meshes", 0, aMeshes_1->Size(), 1);
+ Message_ProgressScope aPS (theProgress, "Reading scene meshes", aMeshes_1->Size());
for (rapidjson::Value::ConstValueIterator aMeshIter = aMeshes_1->Begin();
- aMeshIter != aMeshes_1->End() && aPSentry.More(); ++aMeshIter, aPSentry.Next())
+ aMeshIter != aMeshes_1->End() && aPS.More(); ++aMeshIter)
{
const RWGltf_JsonValue* aMesh = myGltfRoots[RWGltf_GltfRootElement_Meshes].FindChild (*aMeshIter);
if (aMesh == NULL)
}
TopoDS_Shape aMeshShape;
- if (!gltfParseMesh (aMeshShape, getKeyString (*aMeshIter), *aMesh, theProgress))
+ if (!gltfParseMesh (aMeshShape, getKeyString (*aMeshIter), *aMesh, aPS.Next()))
{
theNodeShape = aNodeShape;
bindNodeShape (theNodeShape, aNodeLoc, theSceneNodeId, aName);
bool RWGltf_GltfJsonParser::gltfParseMesh (TopoDS_Shape& theMeshShape,
const TCollection_AsciiString& theMeshId,
const RWGltf_JsonValue& theMesh,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
const RWGltf_JsonValue* aName = findObjectMember (theMesh, "name");
const RWGltf_JsonValue* aPrims = findObjectMember (theMesh, "primitives");
bool RWGltf_GltfJsonParser::gltfParsePrimArray (const Handle(RWGltf_GltfLatePrimitiveArray)& theMeshData,
const TCollection_AsciiString& theMeshId,
const RWGltf_JsonValue& thePrimArray,
- const Handle(Message_ProgressIndicator)& /*theProgress*/)
+ const Message_ProgressRange& /*theProgress*/)
{
const RWGltf_JsonValue* anAttribs = findObjectMember (thePrimArray, "attributes");
const RWGltf_JsonValue* anIndices = findObjectMember (thePrimArray, "indices");
// function : Parse
// purpose :
// =======================================================================
-bool RWGltf_GltfJsonParser::Parse (const Handle(Message_ProgressIndicator)& theProgress)
+bool RWGltf_GltfJsonParser::Parse (const Message_ProgressRange& theProgress)
{
- Message_ProgressSentry aPSentry (theProgress, "Reading Gltf", 0, 2, 1);
+ Message_ProgressScope aPS (theProgress, "Parsing glTF", 1);
#ifdef HAVE_RAPIDJSON
{
if (!gltfParseRoots())
gltfParseAsset();
gltfParseMaterials();
- if (!gltfParseScene (theProgress))
+ if (!gltfParseScene (aPS.Next()))
{
return false;
}
}
- aPSentry.Next();
- if (!aPSentry.More())
+ if (!aPS.More())
{
return false;
}
#include <Graphic3d_Vec.hxx>
#include <Message_Gravity.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_IndexedMap.hxx>
#include <RWGltf_GltfLatePrimitiveArray.hxx>
void SetMeshNameAsFallback (bool theToFallback) { myUseMeshNameAsFallback = theToFallback; }
//! Parse glTF document.
- Standard_EXPORT bool Parse (const Handle(Message_ProgressIndicator)& theProgress);
+ Standard_EXPORT bool Parse (const Message_ProgressRange& theProgress);
//! Return face list for loading triangulation.
NCollection_Vector<TopoDS_Face>& FaceList() { return myFaceList; }
Standard_EXPORT bool gltfParseRoots();
//! Parse default scene.
- Standard_EXPORT bool gltfParseScene (const Handle(Message_ProgressIndicator)& theProgress);
+ Standard_EXPORT bool gltfParseScene (const Message_ProgressRange& theProgress);
//! Parse document metadata.
Standard_EXPORT void gltfParseAsset();
//! Parse scene array of nodes recursively.
Standard_EXPORT bool gltfParseSceneNodes (TopTools_SequenceOfShape& theShapeSeq,
const RWGltf_JsonValue& theSceneNodes,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Parse scene node recursively.
Standard_EXPORT bool gltfParseSceneNode (TopoDS_Shape& theNodeShape,
const TCollection_AsciiString& theSceneNodeId,
const RWGltf_JsonValue& theSceneNode,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Parse mesh element.
Standard_EXPORT bool gltfParseMesh (TopoDS_Shape& theMeshShape,
const TCollection_AsciiString& theMeshId,
const RWGltf_JsonValue& theMesh,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Parse primitive array.
Standard_EXPORT bool gltfParsePrimArray (const Handle(RWGltf_GltfLatePrimitiveArray)& theMeshData,
const TCollection_AsciiString& theMeshName,
const RWGltf_JsonValue& thePrimArray,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Parse accessor.
Standard_EXPORT bool gltfParseAccessor (const Handle(RWGltf_GltfLatePrimitiveArray)& theMeshData,
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <BRep_Builder.hxx>
#include <OSD_Path.hxx>
#include <OSD_Timer.hxx>
// purpose :
// =======================================================================
Standard_Boolean RWMesh_CafReader::perform (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe)
{
Standard_Integer aNewRootsLower = 1;
OSD_Timer aLoadingTimer;
aLoadingTimer.Start();
const Standard_Boolean isDone = performMesh (theFile, theProgress, theToProbe);
- if (theToProbe
- || (!theProgress.IsNull() && theProgress->UserBreak()))
+ if (theToProbe || theProgress.UserBreak())
{
return isDone;
}
#ifndef _RWMesh_CafReader_HeaderFile
#define _RWMesh_CafReader_HeaderFile
+#include <Message_ProgressRange.hxx>
#include <NCollection_IndexedMap.hxx>
#include <RWMesh_CoordinateSystemConverter.hxx>
#include <RWMesh_NodeAttributes.hxx>
#include <TDF_Label.hxx>
#include <TopTools_SequenceOfShape.hxx>
-class Message_ProgressIndicator;
class TDocStd_Document;
class XCAFDoc_ShapeTool;
class XCAFDoc_ColorTool;
//! Read the data from specified file.
//! The Document instance should be set beforehand.
bool Perform (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
return perform (theFile, theProgress, Standard_False);
}
//! The main purpose is collecting metadata and external references - for copying model into a new location, for example.
//! Can be NOT implemented (unsupported by format / reader).
Standard_Boolean ProbeHeader (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress = Handle(Message_ProgressIndicator)())
+ const Message_ProgressRange& theProgress = Message_ProgressRange())
{
return perform (theFile, theProgress, Standard_True);
}
//! @param optional progress indicator
//! @param theToProbe flag indicating that mesh data should be skipped and only basing information to be read
Standard_EXPORT virtual Standard_Boolean perform (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe);
//! Read the mesh from specified file - interface to be implemented by sub-classes.
Standard_EXPORT virtual Standard_Boolean performMesh (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe) = 0;
//! @name tools for filling XDE document
//purpose :
//=============================================================================
Handle(Poly_Triangulation) RWObj::ReadFile (const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
RWObj_TriangulationReader aReader;
aReader.SetCreateShapes (Standard_False);
#ifndef _RWObj_HeaderFile
#define _RWObj_HeaderFile
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
#include <OSD_Path.hxx>
#include <Poly_Triangulation.hxx>
#include <Standard_Macro.hxx>
//! Read specified OBJ file and returns its content as triangulation.
//! In case of error, returns Null handle.
Standard_EXPORT static Handle(Poly_Triangulation) ReadFile (const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& aProgInd = NULL);
+ const Message_ProgressRange& aProgress = Message_ProgressRange());
};
#include <RWObj_CafReader.hxx>
-#include <Message_ProgressSentry.hxx>
-
IMPLEMENT_STANDARD_RTTIEXT(RWObj_CafReader, RWMesh_CafReader)
//================================================================
// Purpose :
//================================================================
Standard_Boolean RWObj_CafReader::performMesh (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe)
{
Handle(RWObj_TriangulationReader) aCtx = createReaderContext();
//! Read the mesh from specified file.
Standard_EXPORT virtual Standard_Boolean performMesh (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe) Standard_OVERRIDE;
protected:
#include <gp_XY.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_IncAllocator.hxx>
#include <OSD_OpenFile.hxx>
#include <OSD_Path.hxx>
// Purpose :
// ================================================================
Standard_Boolean RWObj_Reader::read (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe)
{
myMemEstim = 0;
const Standard_Integer aNbMiBTotal = Standard_Integer(aFileLen / (1024 * 1024));
Standard_Integer aNbMiBPassed = 0;
- Message_ProgressSentry aPSentry (theProgress, "Reading text OBJ file", 0, aNbMiBTotal, 1);
+ Message_ProgressScope aPS (theProgress, "Reading text OBJ file", aNbMiBTotal);
OSD_Timer aTimer;
aTimer.Start();
aPosition += aReadBytes;
if (aTimer.ElapsedTime() > 1.0)
{
- if (!aPSentry.More())
+ if (!aPS.More())
{
return false;
}
const Standard_Integer aNbMiBRead = Standard_Integer(aPosition / (1024 * 1024));
- for (; aNbMiBPassed < aNbMiBRead; ++aNbMiBPassed) { aPSentry.Next(); }
+ aPS.Next (aNbMiBRead - aNbMiBPassed);
+ aNbMiBPassed = aNbMiBRead;
aTimer.Reset();
aTimer.Start();
}
Message::SendWarning (TCollection_AsciiString("Warning: OBJ reader, ") + myNbElemsBig + " polygon(s) have been split into triangles");
}
- for (; aNbMiBPassed < aNbMiBTotal; ++aNbMiBPassed) { aPSentry.Next(); }
return true;
}
#include <Graphic3d_Vec4.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
#include <NCollection_Array1.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_IndexedMap.hxx>
//! Unicode paths can be given in UTF-8 encoding.
//! Returns true if success, false on error or user break.
Standard_Boolean Read (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
return read (theFile, theProgress, Standard_False);
}
//! @return TRUE if success, FALSE on error or user break.
//! @sa FileComments(), ExternalFiles(), NbProbeNodes(), NbProbeElems().
Standard_Boolean Probe (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
return read (theFile, theProgress, Standard_True);
}
//! Unicode paths can be given in UTF-8 encoding.
//! Returns true if success, false on error or user break.
Standard_EXPORT Standard_Boolean read (const TCollection_AsciiString& theFile,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean theToProbe);
//! @name interface methods which should be implemented by sub-class
#include <RWStl.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_Vector.hxx>
#include <OSD_File.hxx>
#include <OSD_OpenFile.hxx>
//purpose :
//=============================================================================
Handle(Poly_Triangulation) RWStl::ReadFile (const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
Reader aReader;
aReader.Read (theFile, theProgress);
//purpose :
//=============================================================================
Handle(Poly_Triangulation) RWStl::ReadFile (const OSD_Path& theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
OSD_File aFile(theFile);
if (!aFile.Exists())
//purpose :
//=============================================================================
Handle(Poly_Triangulation) RWStl::ReadBinary (const OSD_Path& theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
OSD_File aFile(theFile);
if (!aFile.Exists())
//purpose :
//=============================================================================
Handle(Poly_Triangulation) RWStl::ReadAscii (const OSD_Path& theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
OSD_File aFile (theFile);
if (!aFile.Exists())
//=============================================================================
Standard_Boolean RWStl::WriteBinary (const Handle(Poly_Triangulation)& theMesh,
const OSD_Path& thePath,
- const Handle(Message_ProgressIndicator)& theProgInd)
+ const Message_ProgressRange& theProgress)
{
if (theMesh.IsNull() || theMesh->NbTriangles() <= 0)
{
return Standard_False;
}
- Standard_Boolean isOK = writeBinary (theMesh, aFile, theProgInd);
+ Standard_Boolean isOK = writeBinary (theMesh, aFile, theProgress);
fclose (aFile);
return isOK;
//=============================================================================
Standard_Boolean RWStl::WriteAscii (const Handle(Poly_Triangulation)& theMesh,
const OSD_Path& thePath,
- const Handle(Message_ProgressIndicator)& theProgInd)
+ const Message_ProgressRange& theProgress)
{
if (theMesh.IsNull() || theMesh->NbTriangles() <= 0)
{
return Standard_False;
}
- Standard_Boolean isOK = writeASCII (theMesh, aFile, theProgInd);
+ Standard_Boolean isOK = writeASCII (theMesh, aFile, theProgress);
fclose (aFile);
return isOK;
}
//=============================================================================
Standard_Boolean RWStl::writeASCII (const Handle(Poly_Triangulation)& theMesh,
FILE* theFile,
- const Handle(Message_ProgressIndicator)& theProgInd)
+ const Message_ProgressRange& theProgress)
{
// note that space after 'solid' is necessary for many systems
if (fwrite ("solid \n", 1, 7, theFile) != 7)
memset (aBuffer, 0, sizeof(aBuffer));
const Standard_Integer NBTriangles = theMesh->NbTriangles();
- Message_ProgressSentry aPS (theProgInd, "Triangles", 0,
- NBTriangles, 1);
+ Message_ProgressScope aPS (theProgress, "Triangles", NBTriangles);
const TColgp_Array1OfPnt& aNodes = theMesh->Nodes();
const Poly_Array1OfTriangle& aTriangles = theMesh->Triangles();
//=============================================================================
Standard_Boolean RWStl::writeBinary (const Handle(Poly_Triangulation)& theMesh,
FILE* theFile,
- const Handle(Message_ProgressIndicator)& theProgInd)
+ const Message_ProgressRange& theProgress)
{
char aHeader[80] = "STL Exported by OpenCASCADE [www.opencascade.com]";
if (fwrite (aHeader, 1, 80, theFile) != 80)
}
const Standard_Integer aNBTriangles = theMesh->NbTriangles();
- Message_ProgressSentry aPS (theProgInd, "Triangles", 0,
- aNBTriangles, 1);
+ Message_ProgressScope aPS (theProgress, "Triangles", aNBTriangles);
const Standard_Size aNbChunkTriangles = 4096;
const Standard_Size aChunkSize = aNbChunkTriangles * THE_STL_SIZEOF_FACET;
#ifndef _RWStl_HeaderFile
#define _RWStl_HeaderFile
-#include <Message_ProgressIndicator.hxx>
#include <OSD_Path.hxx>
#include <Poly_Triangulation.hxx>
#include <Standard_Macro.hxx>
+#include <Message_ProgressScope.hxx>
//! This class provides methods to read and write triangulation from / to the STL files.
class RWStl
//! Returns false if the cannot be opened;
Standard_EXPORT static Standard_Boolean WriteBinary (const Handle(Poly_Triangulation)& theMesh,
const OSD_Path& thePath,
- const Handle(Message_ProgressIndicator)& theProgInd = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! write the meshing in a file following the
//! Ascii format of an STL file.
//! Returns false if the cannot be opened;
Standard_EXPORT static Standard_Boolean WriteAscii (const Handle(Poly_Triangulation)& theMesh,
const OSD_Path& thePath,
- const Handle(Message_ProgressIndicator)& theProgInd = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Read specified STL file and returns its content as triangulation.
//! In case of error, returns Null handle.
Standard_EXPORT static Handle(Poly_Triangulation) ReadFile (const OSD_Path& theFile,
- const Handle(Message_ProgressIndicator)& aProgInd = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& aProgInd = Message_ProgressRange());
//! Read specified STL file and returns its content as triangulation.
//! In case of error, returns Null handle.
Standard_EXPORT static Handle(Poly_Triangulation) ReadFile (const Standard_CString theFile,
- const Handle(Message_ProgressIndicator)& aProgInd = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& aProgInd = Message_ProgressRange());
//! Read triangulation from a binary STL file
//! In case of error, returns Null handle.
Standard_EXPORT static Handle(Poly_Triangulation) ReadBinary (const OSD_Path& thePath,
- const Handle(Message_ProgressIndicator)& theProgInd = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Read triangulation from an Ascii STL file
//! In case of error, returns Null handle.
Standard_EXPORT static Handle(Poly_Triangulation) ReadAscii (const OSD_Path& thePath,
- const Handle(Message_ProgressIndicator)& theProgInd = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
private:
//! Write ASCII version.
static Standard_Boolean writeASCII (const Handle(Poly_Triangulation)& theMesh,
FILE *theFile,
- const Handle(Message_ProgressIndicator)& theProgInd);
+ const Message_ProgressRange& theProgress);
//! Write binary version.
static Standard_Boolean writeBinary (const Handle(Poly_Triangulation)& theMesh,
FILE *theFile,
- const Handle(Message_ProgressIndicator)& theProgInd);
+ const Message_ProgressRange& theProgress);
};
#endif
#include <gp_XY.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_IncAllocator.hxx>
#include <FSD_BinaryFile.hxx>
//==============================================================================
Standard_Boolean RWStl_Reader::Read (const char* theFile,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
std::filebuf aBuf;
OSD_OpenStream (aBuf, theFile, std::ios::in | std::ios::binary);
Standard_ReadLineBuffer aBuffer (THE_BUFFER_SIZE);
+ // Note: here we are trying to handle rare but realistic case of
+ // STL files which are composed of several STL data blocks
+ // running translation in cycle.
+ // For this reason use infinite (logarithmic) progress scale,
+ // but in special mode so that the first cycle will take ~ 70% of it
+ Message_ProgressScope aPS (theProgress, NULL, 1, true);
while (aStream.good())
{
if (isAscii)
{
- if (!ReadAscii (aStream, aBuffer, theEnd, theProgress))
+ if (!ReadAscii (aStream, aBuffer, theEnd, aPS.Next(2)))
{
break;
}
}
else
{
- if (!ReadBinary (aStream, theProgress))
+ if (!ReadBinary (aStream, aPS.Next(2)))
{
break;
}
Standard_Boolean RWStl_Reader::ReadAscii (Standard_IStream& theStream,
Standard_ReadLineBuffer& theBuffer,
const std::streampos theUntilPos,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
// use method seekpos() to get true 64-bit offset to enable
// handling of large files (VS 2010 64-bit)
// report progress every 1 MiB of read data
const int aStepB = 1024 * 1024;
const Standard_Integer aNbSteps = 1 + Standard_Integer((GETPOS(theUntilPos) - aStartPos) / aStepB);
- Message_ProgressSentry aPSentry (theProgress, "Reading text STL file", 0, aNbSteps, 1);
+ Message_ProgressScope aPS (theProgress, "Reading text STL file", aNbSteps);
int64_t aProgressPos = aStartPos + aStepB;
int aNbLine = 1;
- while (aPSentry.More())
+ while (aPS.More())
{
if (GETPOS(theStream.tellg()) > aProgressPos)
{
- aPSentry.Next();
+ aPS.Next();
aProgressPos += aStepB;
}
aNbLine += 2;
}
- return aPSentry.More();
+ return aPS.More();
}
//==============================================================================
//==============================================================================
Standard_Boolean RWStl_Reader::ReadBinary (Standard_IStream& theStream,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
/*
// the size of the file (minus the header size)
// don't trust the number of triangles which is coded in the file
// sometimes it is wrong, and with this technique we don't need to swap endians for integer
- Message_ProgressSentry aPSentry (theProgress, "Reading binary STL file", 0, aNbFacets, 1);
+ Message_ProgressScope aPS (theProgress, "Reading binary STL file", aNbFacets);
Standard_Integer aNbRead = 0;
// allocate buffer for 80 triangles
const size_t aFaceDataLen = aVec3Size * 4 + 2;
const char* aBufferPtr = aBuffer;
Standard_Integer aNbFacesInBuffer = 0;
- for (Standard_Integer aNbFacetRead = 0; aNbFacetRead < aNbFacets && aPSentry.More();
- ++aNbFacetRead, ++aNbRead, --aNbFacesInBuffer, aBufferPtr += aFaceDataLen, aPSentry.Next())
+ for (Standard_Integer aNbFacetRead = 0; aNbFacetRead < aNbFacets && aPS.More();
+ ++aNbFacetRead, ++aNbRead, --aNbFacesInBuffer, aBufferPtr += aFaceDataLen, aPS.Next())
{
// read more data
if (aNbFacesInBuffer <= 0)
}
}
- return true;
+ return aPS.More();
}
#define _RWStl_Reader_HeaderFile
#include <gp_XYZ.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <Standard_ReadLineBuffer.hxx>
+#include <Standard_IStream.hxx>
+
+class Message_ProgressRange;
//! An abstract class implementing procedure to read STL file.
//!
//! Format is recognized automatically by analysis of the file header.
//! Returns true if success, false on error or user break.
Standard_EXPORT Standard_Boolean Read (const char* theFile,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Guess whether the stream is an Ascii STL file, by analysis of the first bytes (~200).
//! The function attempts to put back the read symbols to the stream which thus must support ungetc().
//! Stops after reading the number of triangles recorded in the file header.
//! Returns true if success, false on error or user break.
Standard_EXPORT Standard_Boolean ReadBinary (Standard_IStream& theStream,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
//! Reads data from the stream assumed to contain Ascii STL data.
//! The stream can be opened either in binary or in Ascii mode.
Standard_EXPORT Standard_Boolean ReadAscii (Standard_IStream& theStream,
Standard_ReadLineBuffer& theBuffer,
const std::streampos theUntilPos,
- const Handle(Message_ProgressIndicator)& theProgress);
+ const Message_ProgressRange& theProgress);
public:
#include <StepData_StepModel.hxx>
#include <HeaderSection_FileSchema.hxx>
#include <Interface_Static.hxx>
+#include <Message_ProgressScope.hxx>
#include <NCollection_DataMap.hxx>
#include <OSD_Path.hxx>
#include <Quantity_Color.hxx>
//purpose :
//=======================================================================
-Standard_Boolean STEPCAFControl_Reader::TransferOneRoot(const Standard_Integer num,
- Handle(TDocStd_Document) &doc)
+Standard_Boolean STEPCAFControl_Reader::TransferOneRoot (const Standard_Integer num,
+ Handle(TDocStd_Document) &doc,
+ const Message_ProgressRange& theProgress)
{
TDF_LabelSequence Lseq;
- return Transfer(myReader, num, doc, Lseq);
+ return Transfer (myReader, num, doc, Lseq, Standard_False, theProgress);
}
//purpose :
//=======================================================================
-Standard_Boolean STEPCAFControl_Reader::Transfer(Handle(TDocStd_Document) &doc)
+Standard_Boolean STEPCAFControl_Reader::Transfer (Handle(TDocStd_Document) &doc,
+ const Message_ProgressRange& theProgress)
{
TDF_LabelSequence Lseq;
- return Transfer(myReader, 0, doc, Lseq);
+ return Transfer (myReader, 0, doc, Lseq, Standard_False, theProgress);
}
//purpose :
//=======================================================================
-Standard_Boolean STEPCAFControl_Reader::Perform(const Standard_CString filename,
- Handle(TDocStd_Document) &doc)
+Standard_Boolean STEPCAFControl_Reader::Perform (const Standard_CString filename,
+ Handle(TDocStd_Document) &doc,
+ const Message_ProgressRange& theProgress)
{
- if (ReadFile(filename) != IFSelect_RetDone) return Standard_False;
- return Transfer(doc);
+ if (ReadFile (filename) != IFSelect_RetDone)
+ {
+ return Standard_False;
+ }
+ return Transfer (doc, theProgress);
}
//purpose :
//=======================================================================
-Standard_Boolean STEPCAFControl_Reader::Perform(const TCollection_AsciiString &filename,
- Handle(TDocStd_Document) &doc)
+Standard_Boolean STEPCAFControl_Reader::Perform (const TCollection_AsciiString &filename,
+ Handle(TDocStd_Document) &doc,
+ const Message_ProgressRange& theProgress)
{
- if (ReadFile(filename.ToCString()) != IFSelect_RetDone) return Standard_False;
- return Transfer(doc);
+ if ( ReadFile (filename.ToCString()) != IFSelect_RetDone)
+ {
+ return Standard_False;
+ }
+ return Transfer (doc, theProgress);
}
//purpose : basic working method
//=======================================================================
-Standard_Boolean STEPCAFControl_Reader::Transfer(STEPControl_Reader &reader,
- const Standard_Integer nroot,
- Handle(TDocStd_Document) &doc,
- TDF_LabelSequence &Lseq,
- const Standard_Boolean asOne)
+Standard_Boolean STEPCAFControl_Reader::Transfer (STEPControl_Reader &reader,
+ const Standard_Integer nroot,
+ Handle(TDocStd_Document) &doc,
+ TDF_LabelSequence &Lseq,
+ const Standard_Boolean asOne,
+ const Message_ProgressRange& theProgress)
{
reader.ClearShapes();
Standard_Integer i;
// Read all shapes
Standard_Integer num = reader.NbRootsForTransfer();
- if (num <= 0) return Standard_False;
+ if (num <=0) return Standard_False;
+
+ Message_ProgressScope aPSRoot (theProgress, NULL, 2);
+
if (nroot) {
if (nroot > num) return Standard_False;
- reader.TransferOneRoot(nroot);
+ reader.TransferOneRoot (nroot, aPSRoot.Next());
}
else {
- for (i = 1; i <= num; i++) reader.TransferOneRoot(i);
+ Message_ProgressScope aPS (aPSRoot.Next(), NULL, num);
+ for (i = 1; i <= num && aPS.More(); i++)
+ reader.TransferOneRoot (i, aPS.Next());
}
+ if (aPSRoot.UserBreak())
+ return Standard_False;
+
num = reader.NbShapes();
if (num <= 0) return Standard_False;
// and fill map SDR -> extern file
STEPConstruct_ExternRefs ExtRefs(reader.WS());
ExtRefs.LoadExternRefs();
- for (i = 1; i <= ExtRefs.NbExternRefs(); i++) {
+ Message_ProgressScope aPSE (aPSRoot.Next(), NULL, ExtRefs.NbExternRefs());
+ for (i = 1; i <= ExtRefs.NbExternRefs() && aPSE.More(); i++)
+ {
+ Message_ProgressRange aRange = aPSE.Next();
// check extern ref format
Handle(TCollection_HAsciiString) format = ExtRefs.Format(i);
if (!format.IsNull()) {
if (!PDFileMap.IsBound(PD)) continue; // this PD is not concerned by current transfer
// read extern file (or use existing data) and record its data
- Handle(STEPCAFControl_ExternFile) EF =
- ReadExternFile(filename, fullname.ToCString(), doc);
- PDFileMap.Bind(PD, EF);
+ Handle(STEPCAFControl_ExternFile) EF =
+ ReadExternFile (filename, fullname.ToCString(), doc, aRange);
+ PDFileMap.Bind (PD, EF);
}
// and insert them to the document
//purpose :
//=======================================================================
-Handle(STEPCAFControl_ExternFile) STEPCAFControl_Reader::ReadExternFile(const Standard_CString file,
- const Standard_CString fullname,
- Handle(TDocStd_Document)& doc)
+Handle(STEPCAFControl_ExternFile) STEPCAFControl_Reader::ReadExternFile (const Standard_CString file,
+ const Standard_CString fullname,
+ Handle(TDocStd_Document)& doc,
+ const Message_ProgressRange& theProgress)
{
// if the file is already read, associate it with SDR
if (myFiles.IsBound(file)) {
// transfer in single-result mode
if (EF->GetLoadStatus() == IFSelect_RetDone) {
TDF_LabelSequence labels;
- EF->SetTransferStatus(Transfer(sr, 0, doc, labels, Standard_True));
- if (labels.Length() > 0) EF->SetLabel(labels.Value(1));
+ EF->SetTransferStatus (Transfer (sr, 0, doc, labels, Standard_False, theProgress));
+ if (labels.Length() > 0) EF->SetLabel (labels.Value(1));
}
// add read file to dictionary
//! Translates currently loaded STEP file into the document
//! Returns True if succeeded, and False in case of fail
//! Provided for use like single-file reader
- Standard_EXPORT Standard_Boolean TransferOneRoot (const Standard_Integer num, Handle(TDocStd_Document)& doc);
+ Standard_EXPORT Standard_Boolean TransferOneRoot (const Standard_Integer num,
+ Handle(TDocStd_Document)& doc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Translates currently loaded STEP file into the document
//! Returns True if succeeded, and False in case of fail
//! Provided for use like single-file reader
- Standard_EXPORT Standard_Boolean Transfer (Handle(TDocStd_Document)& doc);
+ Standard_EXPORT Standard_Boolean Transfer (Handle(TDocStd_Document)& doc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT Standard_Boolean Perform (const TCollection_AsciiString& filename, Handle(TDocStd_Document)& doc);
+ Standard_EXPORT Standard_Boolean Perform (const TCollection_AsciiString& filename,
+ Handle(TDocStd_Document)& doc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Translate STEP file given by filename into the document
//! Return True if succeeded, and False in case of fail
- Standard_EXPORT Standard_Boolean Perform (const Standard_CString filename, Handle(TDocStd_Document)& doc);
+ Standard_EXPORT Standard_Boolean Perform (const Standard_CString filename,
+ Handle(TDocStd_Document)& doc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns data on external files
//! Returns Null handle if no external files are read
//! Returns True if succeeded, and False in case of fail
//! If asOne is True, in case of multiple results composes
//! them into assembly. Fills sequence of produced labels
- Standard_EXPORT Standard_Boolean Transfer (STEPControl_Reader& rd, const Standard_Integer num, Handle(TDocStd_Document)& doc, TDF_LabelSequence& Lseq, const Standard_Boolean asOne = Standard_False);
+ Standard_EXPORT Standard_Boolean Transfer (STEPControl_Reader& rd,
+ const Standard_Integer num,
+ Handle(TDocStd_Document)& doc,
+ TDF_LabelSequence& Lseq,
+ const Standard_Boolean asOne = Standard_False,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Add a shape to a document
//! Depending on a case, this shape can be added as one, or
//! Reads (or if returns already read) extern file with
//! given name
- Standard_EXPORT Handle(STEPCAFControl_ExternFile) ReadExternFile (const Standard_CString file, const Standard_CString fullpath, Handle(TDocStd_Document)& doc);
+ Standard_EXPORT Handle(STEPCAFControl_ExternFile) ReadExternFile (const Standard_CString file,
+ const Standard_CString fullpath,
+ Handle(TDocStd_Document)& doc,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads style assignments from STEP model and sets
//! corresponding color assignments in the DECAF document
#include <Interface_EntityIterator.hxx>
#include <Interface_Static.hxx>
#include <Message_Messenger.hxx>
+#include <Message_ProgressScope.hxx>
#include <MoniTool_DataMapIteratorOfDataMapOfShapeTransient.hxx>
#include <OSD_Path.hxx>
#include <Quantity_TypeOfColor.hxx>
//purpose :
//=======================================================================
-Standard_Boolean STEPCAFControl_Writer::Transfer( const Handle(TDocStd_Document) &doc,
- const STEPControl_StepModelType mode,
- const Standard_CString multi )
+Standard_Boolean STEPCAFControl_Writer::Transfer(const Handle(TDocStd_Document) &doc,
+ const STEPControl_StepModelType mode,
+ const Standard_CString multi,
+ const Message_ProgressRange& theProgress)
{
Handle(XCAFDoc_ShapeTool) STool = XCAFDoc_DocumentTool::ShapeTool( doc->Main() );
if ( STool.IsNull() ) return Standard_False;
TDF_LabelSequence labels;
STool->GetFreeShapes ( labels );
- return Transfer ( myWriter, labels, mode, multi );
+ return Transfer(myWriter, labels, mode, multi, Standard_False, theProgress);
}
//purpose :
//=======================================================================
-Standard_Boolean STEPCAFControl_Writer::Transfer( const TDF_Label& L,
- const STEPControl_StepModelType mode,
- const Standard_CString multi )
+Standard_Boolean STEPCAFControl_Writer::Transfer(const TDF_Label& L,
+ const STEPControl_StepModelType mode,
+ const Standard_CString multi,
+ const Message_ProgressRange& theProgress)
{
TDF_LabelSequence labels;
labels.Append ( L );
- return Transfer ( myWriter, labels, mode, multi );
+ return Transfer(myWriter, labels, mode, multi, Standard_False, theProgress);
}
//=======================================================================
//purpose :
//=======================================================================
-Standard_Boolean STEPCAFControl_Writer::Transfer( const TDF_LabelSequence& labels,
- const STEPControl_StepModelType mode,
- const Standard_CString multi )
+Standard_Boolean STEPCAFControl_Writer::Transfer(const TDF_LabelSequence& labels,
+ const STEPControl_StepModelType mode,
+ const Standard_CString multi,
+ const Message_ProgressRange& theProgress)
{
- return Transfer( myWriter, labels, mode, multi );
+ return Transfer(myWriter, labels, mode, multi, Standard_False, theProgress);
}
//=======================================================================
//=======================================================================
Standard_Boolean STEPCAFControl_Writer::Perform (const Handle(TDocStd_Document) &doc,
- const Standard_CString filename)
+ const Standard_CString filename,
+ const Message_ProgressRange& theProgress)
{
- if ( ! Transfer ( doc ) ) return Standard_False;
+ if (!Transfer(doc, STEPControl_AsIs, 0L, theProgress)) return Standard_False;
return Write ( filename ) == IFSelect_RetDone;
}
//=======================================================================
Standard_Boolean STEPCAFControl_Writer::Perform (const Handle(TDocStd_Document) &doc,
- const TCollection_AsciiString &filename)
+ const TCollection_AsciiString &filename,
+ const Message_ProgressRange& theProgress)
{
- if ( ! Transfer ( doc ) ) return Standard_False;
+ if ( ! Transfer ( doc, STEPControl_AsIs, 0L, theProgress ) ) return Standard_False;
return Write ( filename.ToCString() ) == IFSelect_RetDone;
}
//=======================================================================
Standard_Boolean STEPCAFControl_Writer::Transfer (STEPControl_Writer &writer,
- const TDF_LabelSequence &labels,
- const STEPControl_StepModelType mode,
- const Standard_CString multi,
- const Standard_Boolean isExternFile)
+ const TDF_LabelSequence &labels,
+ const STEPControl_StepModelType mode,
+ const Standard_CString multi,
+ const Standard_Boolean isExternFile,
+ const Message_ProgressRange& theProgress)
{
if ( labels.Length() <=0 ) return Standard_False;
// translate free top-level shapes of the DECAF document
Standard_Integer ap = Interface_Static::IVal ("write.step.schema");
TDF_LabelSequence sublabels;
- for ( Standard_Integer i=1; i <= labels.Length(); i++ ) {
+ Message_ProgressScope aPS(theProgress, "Labels", labels.Length());
+ for ( Standard_Integer i=1; i <= labels.Length() && aPS.More(); i++)
+ {
+ Message_ProgressRange aRange = aPS.Next();
TDF_Label L = labels.Value(i);
if ( myLabels.IsBound ( L ) ) continue; // already processed
if ( XCAFDoc_ShapeTool::IsAssembly ( L ) || XCAFDoc_ShapeTool::IsReference ( L ) )
Actor->RegisterAssembly ( shape );
- writer.Transfer(shape,mode,Standard_False);
+ writer.Transfer(shape, mode, Standard_False, aRange);
Actor->SetStdMode ( Standard_True ); // restore default behaviour
}
else {
// translate final solids
- TopoDS_Shape Sass = TransferExternFiles ( L, mode, sublabels, multi );
+ Message_ProgressScope aPS1 (aRange, NULL, 2);
+ TopoDS_Shape Sass = TransferExternFiles(L, mode, sublabels, multi, aPS1.Next());
+ if (aPS1.UserBreak())
+ return Standard_False;
// translate main assembly structure
/*
*/
Standard_Integer assemblymode = Interface_Static::IVal ("write.step.assembly");
Interface_Static::SetCVal ("write.step.assembly", "On");
- writer.Transfer ( Sass, STEPControl_AsIs );
+ writer.Transfer ( Sass, STEPControl_AsIs, Standard_True, aPS1.Next());
Interface_Static::SetIVal ("write.step.assembly", assemblymode);
Interface_Static::SetIVal ("write.step.schema", ap);
}
}
+ if (aPS.UserBreak())
+ return Standard_False;
writer.WS()->ComputeGraph(Standard_True );// added by skl 03.11.2003 since we use
// writer.Transfer() wihtout compute graph
//=======================================================================
TopoDS_Shape STEPCAFControl_Writer::TransferExternFiles (const TDF_Label &L,
- const STEPControl_StepModelType mode,
- TDF_LabelSequence &labels,
- const Standard_CString prefix)
+ const STEPControl_StepModelType mode,
+ TDF_LabelSequence &labels,
+ const Standard_CString prefix,
+ const Message_ProgressRange& theProgress)
{
// if label already translated, just return the shape
if ( myLabels.IsBound ( L ) ) {
Standard_Integer assemblymode = Interface_Static::IVal ("write.step.assembly");
Interface_Static::SetCVal ("write.step.assembly", "Off");
const Standard_CString multi = 0;
- EF->SetTransferStatus ( Transfer ( sw, Lseq, mode, multi, Standard_True ) );
+ EF->SetTransferStatus ( Transfer ( sw, Lseq, mode, multi, Standard_True, theProgress) );
Interface_Static::SetIVal ("write.step.assembly", assemblymode);
myLabEF.Bind ( L, EF );
myFiles.Bind ( name->ToCString(), EF );
XCAFDoc_ShapeTool::GetComponents ( L, comp, Standard_False );
labels.Append ( aCurL );
- for ( Standard_Integer k=1; k <= comp.Length(); k++ ) {
+ Message_ProgressScope aPS(theProgress, NULL, comp.Length());
+ for ( Standard_Integer k=1; k <= comp.Length() && aPS.More(); k++ ) {
TDF_Label lab = comp(k);
TDF_Label ref;
if ( ! XCAFDoc_ShapeTool::GetReferredShape ( lab, ref ) ) continue;
- TopoDS_Shape Scomp = TransferExternFiles ( ref, mode, labels, prefix );
+ TopoDS_Shape Scomp = TransferExternFiles(ref, mode, labels, prefix, aPS.Next());
Scomp.Location ( XCAFDoc_ShapeTool::GetLocation ( lab ) );
B.Add ( C, Scomp );
}
//! mode (with external refs), and string pointed by <multi>
//! gives prefix for names of extern files (can be empty string)
//! Returns True if translation is OK
- Standard_EXPORT Standard_Boolean Transfer (const Handle(TDocStd_Document)& doc, const STEPControl_StepModelType mode = STEPControl_AsIs, const Standard_CString multi = 0);
+ Standard_EXPORT Standard_Boolean Transfer (const Handle(TDocStd_Document)& doc,
+ const STEPControl_StepModelType mode = STEPControl_AsIs,
+ const Standard_CString multi = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Method to transfer part of the document specified by label
- Standard_EXPORT Standard_Boolean Transfer (const TDF_Label& L, const STEPControl_StepModelType mode = STEPControl_AsIs, const Standard_CString multi = 0 );
+ Standard_EXPORT Standard_Boolean Transfer (const TDF_Label& L,
+ const STEPControl_StepModelType mode = STEPControl_AsIs,
+ const Standard_CString multi = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc, const TCollection_AsciiString& filename);
+ Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc,
+ const TCollection_AsciiString& filename,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers a document and writes it to a STEP file
//! Returns True if translation is OK
- Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc, const Standard_CString filename);
+ Standard_EXPORT Standard_Boolean Perform (const Handle(TDocStd_Document)& doc,
+ const Standard_CString filename,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns data on external files
//! Returns Null handle if no external files are read
protected:
//! Mehod to writing sequence of root assemblies or part of the file specified by use by one label
- Standard_EXPORT Standard_Boolean Transfer (const TDF_LabelSequence& L, const STEPControl_StepModelType mode = STEPControl_AsIs, const Standard_CString multi = 0);
+ Standard_EXPORT Standard_Boolean Transfer (const TDF_LabelSequence& L,
+ const STEPControl_StepModelType mode = STEPControl_AsIs,
+ const Standard_CString multi = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers labels to a STEP model
//! Returns True if translation is OK
//! isExternFile setting from TransferExternFiles method
- Standard_EXPORT Standard_Boolean Transfer (STEPControl_Writer& wr, const TDF_LabelSequence& labels, const STEPControl_StepModelType mode = STEPControl_AsIs, const Standard_CString multi = 0, const Standard_Boolean isExternFile = Standard_False) ;
+ Standard_EXPORT Standard_Boolean Transfer (STEPControl_Writer& wr,
+ const TDF_LabelSequence& labels,
+ const STEPControl_StepModelType mode = STEPControl_AsIs,
+ const Standard_CString multi = 0,
+ const Standard_Boolean isExternFile = Standard_False,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) ;
//! Parses assembly structure of label L, writes all the simple
//! shapes each to its own file named by name of its label plus
//! Returns shape representing that assembly structure
//! in the form of nested empty compounds (and a sequence of
//! labels which are newly written nodes of this assembly)
- Standard_EXPORT TopoDS_Shape TransferExternFiles (const TDF_Label& L, const STEPControl_StepModelType mode, TDF_LabelSequence& Lseq, const Standard_CString prefix = "");
+ Standard_EXPORT TopoDS_Shape TransferExternFiles (const TDF_Label& L,
+ const STEPControl_StepModelType mode,
+ TDF_LabelSequence& Lseq,
+ const Standard_CString prefix = "",
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Write external references to STEP
Standard_EXPORT Standard_Boolean WriteExternRefs (const Handle(XSControl_WorkSession)& WS, const TDF_LabelSequence& labels) const;
#include <Interface_Macros.hxx>
#include <Interface_Static.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <OSD_Timer.hxx>
#include <Precision.hxx>
#include <Standard_ErrorHandler.hxx>
Handle(Transfer_Binder) STEPControl_ActorRead::Transfer
(const Handle(Standard_Transient)& start,
- const Handle(Transfer_TransientProcess)& TP)
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
// [BEGIN] Get version of preprocessor (to detect I-Deas case) (ssv; 23.11.2010)
Handle(StepData_StepModel) aStepModel = Handle(StepData_StepModel)::DownCast ( TP->Model() );
}
}
// [END] Get version of preprocessor (to detect I-Deas case) (ssv; 23.11.2010)
- return TransferShape (start, TP, Standard_True, Standard_True);
+ return TransferShape (start, TP, Standard_True, Standard_True, theProgress);
}
//function : TransferEntity
//purpose :
//=======================================================================
- Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(
- const Handle(StepBasic_ProductDefinition)& PD,
- const Handle(Transfer_TransientProcess)& TP,
- const Standard_Boolean theUseTrsf)
+ Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
+ (const Handle(StepBasic_ProductDefinition)& PD,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Standard_Boolean theUseTrsf,
+ const Message_ProgressRange& theProgress)
+
{
Message_Messenger::StreamBuffer sout = TP->Messenger()->SendInfo();
Handle(TransferBRep_ShapeBinder) shbinder;
return shbinder;
// common progress indicator for translation of own shapes and sub-assemblies
- Message_ProgressSentry PS ( TP->GetProgress(), "Part", 0, nbEnt, 1 );
+ Message_ProgressScope PS(theProgress, "Part", nbEnt);
Standard_Integer nbComponents=0, nbShapes=0;
// translate sub-assemblies
- for ( Standard_Integer nbNauo =1; nbNauo <= listNAUO->Length() && PS.More(); nbNauo++, PS.Next()) {
+ for ( Standard_Integer nbNauo =1; nbNauo <= listNAUO->Length() && PS.More(); nbNauo++) {
Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO =
Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(listNAUO->Value(nbNauo));
sout<<" -- Actor : Ent.n0 "<<TP->Model()->Number(PD)<<" -> Shared Ent.no"<<TP->Model()->Number(NAUO)<<std::endl;
#endif
Handle(Transfer_Binder) binder;
- if (!TP->IsBound(NAUO)) binder = TransferEntity(NAUO,TP);
+ Message_ProgressRange aRange = PS.Next();
+ if (!TP->IsBound(NAUO)) binder = TransferEntity(NAUO,TP, aRange);
else binder = TP->Find(NAUO);
TopoDS_Shape theResult = TransferBRep::ShapeResult (binder);
}
// translate shapes assigned directly
- for(Standard_Integer i=1; i <= listSDR->Length() && PS.More(); i++, PS.Next()) {
+ for(Standard_Integer i=1; i <= listSDR->Length() && PS.More(); i++) {
Handle(StepShape_ShapeDefinitionRepresentation) sdr =
Handle(StepShape_ShapeDefinitionRepresentation)::DownCast(listSDR->Value(i));
Handle(StepShape_ShapeRepresentation) rep = Handle(StepShape_ShapeRepresentation)::DownCast(sdr->UsedRepresentation());
if ( rep.IsNull() )
continue;
+ Message_ProgressScope aPS1(PS.Next(), NULL, 2);
+
// translate SDR representation
Standard_Boolean isBound = Standard_True;
// SKL for bug 29068: transformation need to applied only for "main" ShapeDefinitionRepresentation.
Standard_Boolean useTrsf = theUseTrsf && (i <= nbNotAspect);
Handle(Transfer_Binder) binder = TP->Find(rep);
if (binder.IsNull())
- binder = TransferEntity(rep, TP, isBound, useTrsf);
+ binder = TransferEntity(rep, TP, isBound, useTrsf, aPS1.Next());
// if SDR is obtained from ShapeAspect and representation items have already been tramnslated,
// this means that that ShapeAspect is used to refer to sub-shape of the main shape
// SKL for bug 29068: parameter useTrsf is used because if root entity has connection with other
// by ShapeRepresentationRelationship then result after such transferring need to transform also.
// This case is from test "bugs modalg_7 bug30196"
- binder = TransferEntity(SRR, TP, nbrep, useTrsf);
+ binder = TransferEntity(SRR, TP, nbrep, useTrsf, aPS1.Next());
if (! binder.IsNull()) {
theResult = TransferBRep::ShapeResult (binder);
Result1 = theResult;
//purpose :
//=======================================================================
-Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepRepr_NextAssemblyUsageOccurrence)& NAUO ,
- const Handle(Transfer_TransientProcess)& TP)
+Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
+ (const Handle(StepRepr_NextAssemblyUsageOccurrence)& NAUO,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
- Handle(TransferBRep_ShapeBinder) shbinder;
+ Handle(TransferBRep_ShapeBinder) shbinder;
Handle(StepBasic_ProductDefinition) PD;
const Interface_Graph& graph = TP->Graph();
gp_Trsf Trsf;
shbinder.Nullify();
if(IsDepend) {
-
+ Message_ProgressScope aPS(theProgress, NULL, 2);
+
if(!PD.IsNull()) {
binder = TP->Find(PD);
- if ( binder.IsNull() ) binder = TransferEntity(PD,TP);
+ if (binder.IsNull()) binder = TransferEntity(PD, TP, Standard_False, aPS.Next());
theResult = TransferBRep::ShapeResult(binder);
if (!theResult.IsNull()) {
if (iatrsf) {
if ( theResult.IsNull() && !SRR.IsNull() ) {
binder = TP->Find(SRR);
if ( binder.IsNull() ) {
- binder = TransferEntity(SRR,TP);
+ binder = TransferEntity(SRR, TP, 0, Standard_False, aPS.Next());
theResult = TransferBRep::ShapeResult (binder);
if (!theResult.IsNull())
shbinder = new TransferBRep_ShapeBinder (theResult);
const Handle(StepShape_ShapeRepresentation)& sr,
const Handle(Transfer_TransientProcess)& TP,
Standard_Boolean& isBound,
- const Standard_Boolean theUseTrsf)
+ const Standard_Boolean theUseTrsf,
+ const Message_ProgressRange& theProgress)
{
NM_DETECTED = Standard_False;
Handle(TransferBRep_ShapeBinder) shbinder;
B.MakeCompound (comp);
TopoDS_Shape OneResult;
Standard_Integer nsh = 0;
- Message_ProgressSentry PS ( TP->GetProgress(), "Sub-assembly", 0, nb, 1 );
// [BEGIN] Proceed with non-manifold topology (ssv; 12.11.2010)
Standard_Boolean isNMMode = Interface_Static::IVal("read.step.nonmanifold") != 0;
// [END] Proceed with non-manifold topology (ssv; 12.11.2010)
gp_Trsf aTrsf;
- for (Standard_Integer i = 1; i <= nb && PS.More(); i ++,PS.Next()) {
- //for (i = 1; i <= nb ; i ++) {
+ Message_ProgressScope aPSRoot(theProgress, "Sub-assembly", isManifold ? 1 : 2);
+ Message_ProgressScope aPS (aPSRoot.Next(), "Transfer", nb);
+ for (Standard_Integer i = 1; i <= nb && aPS.More(); i ++)
+ {
+ Message_ProgressRange aRange = aPS.Next();
#ifdef TRANSLOG
if (TP->TraceLevel() > 2)
sout<<" -- Actor, shape_representation.item n0. "<<i<<std::endl;
}
Handle(Transfer_Binder) binder;
if (!TP->IsBound(anitem)) {
- binder = TransferShape(anitem, TP, isManifold);
+ binder = TransferShape(anitem, TP, isManifold, Standard_False, aRange);
}
else {
isBound = Standard_True;
// [BEGIN] Proceed with non-manifold topology (ssv; 12.11.2010)
if (!isManifold) {
+ Message_ProgressScope aPS1 (aPSRoot.Next(), "Process", 1);
Handle(Standard_Transient) info;
// IMPORTANT: any fixing on non-manifold topology must be done after the shape is transferred from STEP
XSAlgo::AlgoContainer()->ProcessShape( comp, myPrecision, myMaxTol,
"read.step.resource.name",
"read.step.sequence", info,
- TP->GetProgress(), Standard_True);
+ aPS1.Next(), Standard_True);
XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems);
if (fixedResult.ShapeType() == TopAbs_COMPOUND)
//purpose :
//=======================================================================
-Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepShape_ContextDependentShapeRepresentation)& CDSR,
- const Handle(Transfer_TransientProcess)& TP)
+Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
+ (const Handle(StepShape_ContextDependentShapeRepresentation)& CDSR,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
Handle(TransferBRep_ShapeBinder) shbinder;
//:j2: treat SRRs here in order to compare them with NAUO
Handle(Transfer_Binder) binder;
Standard_Boolean isBound = Standard_False;
- if (!TP->IsBound(rep)) binder = TransferEntity(rep,TP,isBound);
- else binder = TP->Find(rep);
- theResult = TransferBRep::ShapeResult (binder);
+ if (!TP->IsBound(rep)) binder = TransferEntity(rep, TP, isBound, Standard_False, theProgress);
+ else binder = TP->Find(rep);
+ theResult = TransferBRep::ShapeResult(binder);
if ( ! theResult.IsNull() ) {
if ( iatrsf ) {
const Handle(StepRepr_ShapeRepresentationRelationship)& und,
const Handle(Transfer_TransientProcess)& TP,
const Standard_Integer nbrep,
- const Standard_Boolean theUseTrsf)
+ const Standard_Boolean theUseTrsf,
+ const Message_ProgressRange& theProgress)
{
// REPRESENTATION_RELATIONSHIP et la famille
Handle(TransferBRep_ShapeBinder) shbinder;
Standard_Boolean iatrsf = ComputeSRRWT ( und, TP, Trsf );
// Transfert : que faut-il prendre au juste ?
-
- for (Standard_Integer i = 1; i <= 2; i ++) {
+ Message_ProgressScope aPS(theProgress, NULL, 2);
+ for (Standard_Integer i = 1; i <= 2 && aPS.More(); i++)
+ {
+ Message_ProgressRange aRange = aPS.Next();
if(nbrep && nbrep != i)
continue;
Handle(StepRepr_Representation) anitemt;
Handle(StepShape_ShapeRepresentation) anitem = Handle(StepShape_ShapeRepresentation)::DownCast(anitemt);
Handle(Transfer_Binder) binder;
Standard_Boolean isBound = Standard_False;
- if (!TP->IsBound(anitem)) binder = TransferEntity(anitem, TP, isBound, theUseTrsf);
- else binder = TP->Find(anitem);
+ if (!TP->IsBound(anitem)) binder = TransferEntity(anitem, TP, isBound, theUseTrsf, aRange);
+ else binder = TP->Find(anitem);
TopoDS_Shape theResult = TransferBRep::ShapeResult (binder);
if (!theResult.IsNull()) {
OneResult = theResult;
//purpose :
//=======================================================================
-Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::OldWay(const Handle(Standard_Transient)& start,
- const Handle(Transfer_TransientProcess)& TP)
+Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::OldWay
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
Message_Messenger::StreamBuffer sout = TP->Messenger()->SendInfo();
const Interface_Graph& graph = TP->Graph();
}
}
+ Message_ProgressScope aPSRoot(theProgress, NULL, 2);
+
#ifdef TRANSLOG
if (TP->TraceLevel() > 2)
sout<<" -- Actor : case shape_definition_representation."<<std::endl;
#endif
Handle(Transfer_Binder) binder = TP->Find(rep);
- if (binder.IsNull()) binder = TP->Transferring(rep);
+ {
+ Message_ProgressRange aRange = aPSRoot.Next();
+ if (binder.IsNull())
+ {
+ binder = TP->Transferring(rep, aRange);
+ }
+ }
+ if (aPSRoot.UserBreak())
+ return shbinder;
//:j2 if (!binder.IsNull()) return binder;
// SDR designant des CDSR (lien implicite, via la UsedRepr)
Handle(Standard_Type) tSRR = STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship);
Standard_Integer nbitem=0;
for (subs.Start();subs.More();subs.Next()) nbitem++;
- Message_ProgressSentry PS ( TP->GetProgress(), "Sub", 0, nbitem, 1 );
- for (subs.Start(); subs.More() && PS.More(); subs.Next() ,PS.Next()) {
+ Message_ProgressScope PS (aPSRoot.Next(), "Sub", nbitem);
+ for (subs.Start(); subs.More() && PS.More(); subs.Next())
+ {
+ Message_ProgressRange aRange = PS.Next();
Handle(Standard_Transient) anitem = subs.Value();
if ( anitem->DynamicType() != tCDSR && anitem->DynamicType() != tSRR ) continue;
// DeclareAndCast(StepShape_ContextDependentShapeRepresentation,anitem,subs.Value());
sout<<" -- Actor : Ent.n0 "<<TP->Model()->Number(start)<<" -> Shared Ent.no"<<TP->Model()->Number(anitem)<<std::endl;
#endif
- if (!TP->IsBound(anitem)) binder = TP->Transferring(anitem);
+ if (!TP->IsBound(anitem)) binder = TP->Transferring(anitem, aRange);
else binder = TP->Find(anitem);
TopoDS_Shape theResult = TransferBRep::ShapeResult (binder);
if (!theResult.IsNull()) {
//purpose :
//=======================================================================
-Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepGeom_GeometricRepresentationItem)& start,
- const Handle(Transfer_TransientProcess)& TP,
- const Standard_Boolean isManifold)
+Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
+ (const Handle(StepGeom_GeometricRepresentationItem)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Standard_Boolean isManifold,
+ const Message_ProgressRange& theProgress)
{
Message_Messenger::StreamBuffer sout = TP->Messenger()->SendInfo();
Handle(TransferBRep_ShapeBinder) shbinder;
myShapeBuilder.SetMaxTol(myMaxTol);
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentry(TP->GetProgress(), "Transfer stage", 0, 2, 1);
+ Message_ProgressScope aPS(theProgress, "Transfer stage", isManifold ? 2 : 1);
try {
OCC_CATCH_SIGNALS
- if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrep))) {
- myShapeBuilder.Init(GetCasted(StepShape_FacetedBrep, start), TP);
- found = Standard_True;
- }
- else if (start->IsKind(STANDARD_TYPE(StepShape_BrepWithVoids))) {
- myShapeBuilder.Init(GetCasted(StepShape_BrepWithVoids, start), TP);
- found = Standard_True;
- }
- else if (start->IsKind(STANDARD_TYPE(StepShape_ManifoldSolidBrep))) {
- myShapeBuilder.Init(GetCasted(StepShape_ManifoldSolidBrep, start), TP);
- found = Standard_True;
- }
- else if (start->IsKind(STANDARD_TYPE(StepShape_ShellBasedSurfaceModel))) {
- myShapeBuilder.Init(GetCasted(StepShape_ShellBasedSurfaceModel, start), TP, myNMTool);
- found = Standard_True;
- }
- else if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrepAndBrepWithVoids))) {
- myShapeBuilder.Init(GetCasted(StepShape_FacetedBrepAndBrepWithVoids, start), TP);
- found = Standard_True;
- }
- else if (start->IsKind(STANDARD_TYPE(StepShape_GeometricSet))) {
- myShapeBuilder.Init(GetCasted(StepShape_GeometricSet, start), TP, this, isManifold);
- found = Standard_True;
- }
- else if (start->IsKind(STANDARD_TYPE(StepShape_EdgeBasedWireframeModel))) {
- myShapeBuilder.Init(GetCasted(StepShape_EdgeBasedWireframeModel, start), TP);
- found = Standard_True;
- }
- else if (start->IsKind(STANDARD_TYPE(StepShape_FaceBasedSurfaceModel))) {
- myShapeBuilder.Init(GetCasted(StepShape_FaceBasedSurfaceModel, start), TP);
- found = Standard_True;
+ Message_ProgressRange aRange = aPS.Next();
+ if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrep))) {
+ myShapeBuilder.Init(GetCasted(StepShape_FacetedBrep, start), TP, aRange);
+ found = Standard_True;
+ }
+ else if (start->IsKind(STANDARD_TYPE(StepShape_BrepWithVoids))) {
+ myShapeBuilder.Init(GetCasted(StepShape_BrepWithVoids, start), TP, aRange);
+ found = Standard_True;
+ }
+ else if (start->IsKind(STANDARD_TYPE(StepShape_ManifoldSolidBrep))) {
+ myShapeBuilder.Init(GetCasted(StepShape_ManifoldSolidBrep, start), TP, aRange);
+ found = Standard_True;
+ }
+ else if (start->IsKind(STANDARD_TYPE(StepShape_ShellBasedSurfaceModel))) {
+ myShapeBuilder.Init(GetCasted(StepShape_ShellBasedSurfaceModel, start), TP, myNMTool, aRange);
+ found = Standard_True;
+ }
+ else if (start->IsKind(STANDARD_TYPE(StepShape_FacetedBrepAndBrepWithVoids))) {
+ myShapeBuilder.Init(GetCasted(StepShape_FacetedBrepAndBrepWithVoids, start), TP, aRange);
+ found = Standard_True;
+ }
+ else if (start->IsKind(STANDARD_TYPE(StepShape_GeometricSet))) {
+ myShapeBuilder.Init(GetCasted(StepShape_GeometricSet, start), TP, this, isManifold, aRange);
+ found = Standard_True;
+ }
+ else if (start->IsKind(STANDARD_TYPE(StepShape_EdgeBasedWireframeModel))) {
+ myShapeBuilder.Init(GetCasted(StepShape_EdgeBasedWireframeModel, start), TP);
+ found = Standard_True;
+ }
+ else if (start->IsKind(STANDARD_TYPE(StepShape_FaceBasedSurfaceModel))) {
+ myShapeBuilder.Init(GetCasted(StepShape_FaceBasedSurfaceModel, start), TP);
+ found = Standard_True;
+ }
}
-}
catch(Standard_Failure const&) {
TP->AddFail(start,"Exeption is raised. Entity was not translated.");
TP->Bind(start, shbinder);
return shbinder;
}
- aPSentry.Next();
+ if (aPS.UserBreak())
+ return shbinder;
if (found && myShapeBuilder.IsDone()) {
mappedShape = myShapeBuilder.Value();
XSAlgo::AlgoContainer()->ProcessShape( mappedShape, myPrecision, myMaxTol,
"read.step.resource.name",
"read.step.sequence", info,
- TP->GetProgress() );
+ aPS.Next());
XSAlgo::AlgoContainer()->MergeTransferInfo(TP, info, nbTPitems);
}
}
//purpose :
//=======================================================================
-Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepRepr_MappedItem)& mapit,
- const Handle(Transfer_TransientProcess)& TP)
+Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
+ (const Handle(StepRepr_MappedItem)& mapit,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
Handle(TransferBRep_ShapeBinder) shbinder;
DownCast(mapit->MappingSource()->MappedRepresentation());
Standard_Boolean isBound = Standard_False;
Handle(Transfer_Binder) binder = TP->Find(maprep);
- if (binder.IsNull()) binder = TransferEntity(maprep,TP,isBound);
+ if (binder.IsNull()) binder = TransferEntity(maprep,TP,isBound, Standard_False, theProgress);
shbinder = Handle(TransferBRep_ShapeBinder)::DownCast(binder);
if (shbinder.IsNull()) TP->AddWarning(mapit,"No Shape Produced");
else {
//purpose :
//=======================================================================
-Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity(const Handle(StepShape_FaceSurface)& fs,
- const Handle(Transfer_TransientProcess)& TP)
+Handle(TransferBRep_ShapeBinder) STEPControl_ActorRead::TransferEntity
+ (const Handle(StepShape_FaceSurface)& fs,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
// Cas bien utile meme si non reconnu explicitement
TopoDS_Shape shape = XSAlgo::AlgoContainer()->ProcessShape(S, myPrecision, myMaxTol,
"read.step.resource.name",
"read.step.sequence", info,
- TP->GetProgress());
+ theProgress);
// TopoDS_Shape shape = XSAlgo::AlgoContainer()->PerformFixShape( S, TP, myPrecision, myMaxTol );
if (shape != S)
sb->SetResult(shape);
const Handle(Standard_Transient)& start,
const Handle(Transfer_TransientProcess)& TP,
const Standard_Boolean isManifold,
- const Standard_Boolean theUseTrsf)
+ const Standard_Boolean theUseTrsf,
+ const Message_ProgressRange& theProgress)
{
if (start.IsNull()) return NullResult();
XSAlgo::AlgoContainer()->PrepareForTransfer();
TCollection_AsciiString aProdMode = Interface_Static::CVal("read.step.product.mode");
if(!aProdMode.IsEqual("ON") &&
start->IsKind(STANDARD_TYPE(StepShape_ShapeDefinitionRepresentation)))
- shbinder = OldWay(start,TP);
+ shbinder = OldWay(start,TP, theProgress);
//skl
else if (start->IsKind(STANDARD_TYPE(StepBasic_ProductDefinition))) {
Handle(StepBasic_ProductDefinition) PD =
Handle(StepBasic_ProductDefinition)::DownCast(start);
- shbinder = TransferEntity(PD, TP, theUseTrsf);
+ shbinder = TransferEntity(PD, TP, theUseTrsf, theProgress);
}
// NextAssemblyUsageOccurrence
else if (start->IsKind(STANDARD_TYPE(StepRepr_NextAssemblyUsageOccurrence))) {
Handle(StepRepr_NextAssemblyUsageOccurrence) NAUO =
Handle(StepRepr_NextAssemblyUsageOccurrence)::DownCast(start);
- shbinder = TransferEntity(NAUO, TP);
+ shbinder = TransferEntity(NAUO, TP, theProgress);
}
//end skl
else if (start->IsKind(STANDARD_TYPE(StepShape_ShapeRepresentation))) {
DeclareAndCast(StepShape_ShapeRepresentation,sr,start);
Standard_Boolean isBound = Standard_False;
- shbinder = TransferEntity(sr,TP,isBound);
+ shbinder = TransferEntity(sr,TP,isBound, Standard_False, theProgress);
}
// --------------------------------------------------------------
else if (start->IsKind(STANDARD_TYPE(StepShape_ContextDependentShapeRepresentation))) {
DeclareAndCast(StepShape_ContextDependentShapeRepresentation,CDSR,start);
- shbinder = TransferEntity(CDSR,TP);
+ shbinder = TransferEntity(CDSR,TP, theProgress);
}
else if (start->IsKind (STANDARD_TYPE(StepRepr_ShapeRepresentationRelationship)) ) {
// REPRESENTATION_RELATIONSHIP et la famille
DeclareAndCast(StepRepr_ShapeRepresentationRelationship,und,start);
- shbinder = TransferEntity(und,TP);
+ shbinder = TransferEntity(und,TP, 0, Standard_False, theProgress);
}
else if (start->IsKind (STANDARD_TYPE(StepGeom_GeometricRepresentationItem)) ) {
// Here starts the entity to be treated : Shape Representation Subtype
// It can be also other Root entities
DeclareAndCast(StepGeom_GeometricRepresentationItem,git,start);
- shbinder = TransferEntity(git, TP, isManifold);
+ shbinder = TransferEntity(git, TP, isManifold, theProgress);
}
else if (start->IsKind(STANDARD_TYPE(StepRepr_MappedItem))) {
DeclareAndCast(StepRepr_MappedItem,mapit,start);
- shbinder= TransferEntity(mapit,TP);
+ shbinder= TransferEntity(mapit,TP, theProgress);
}
else if (start->IsKind(STANDARD_TYPE(StepShape_FaceSurface))) {
DeclareAndCast(StepShape_FaceSurface,fs,start);
- shbinder = TransferEntity(fs,TP);
+ shbinder = TransferEntity(fs,TP, theProgress);
}
// if (!shbinder.IsNull()) TP->Bind(start,binder);
#include <Standard_Integer.hxx>
#include <TopTools_ListOfShape.hxx>
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepRepr_Representation;
class Standard_Transient;
class Transfer_Binder;
Standard_EXPORT virtual Standard_Boolean Recognize (const Handle(Standard_Transient)& start) Standard_OVERRIDE;
- Standard_EXPORT virtual Handle(Transfer_Binder) Transfer (const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transfer
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
//! theUseTrsf - special flag for using Axis2Placement from ShapeRepresentation for transform root shape
Standard_EXPORT Handle(Transfer_Binder) TransferShape (
const Handle(Standard_Transient)& start,
const Handle(Transfer_TransientProcess)& TP,
const Standard_Boolean isManifold = Standard_True,
- const Standard_Boolean theUseTrsf = Standard_False);
+ const Standard_Boolean theUseTrsf = Standard_False,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! set units and tolerances context by given ShapeRepresentation
Standard_EXPORT void PrepareUnits (const Handle(StepRepr_Representation)& rep, const Handle(Transfer_TransientProcess)& TP);
Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity (
const Handle(StepBasic_ProductDefinition)& PD,
const Handle(Transfer_TransientProcess)& TP,
- const Standard_Boolean theUseTrsf = Standard_False);
+ const Standard_Boolean theUseTrsf = Standard_False,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers next assembly usage occurence entity
- Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity (const Handle(StepRepr_NextAssemblyUsageOccurrence)& NAUO, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity
+ (const Handle(StepRepr_NextAssemblyUsageOccurrence)& NAUO,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers shape representation entity
//! theUseTrsf - special flag for using Axis2Placement from ShapeRepresentation for transform root shape
const Handle(StepShape_ShapeRepresentation)& sr,
const Handle(Transfer_TransientProcess)& TP,
Standard_Boolean& isBound,
- const Standard_Boolean theUseTrsf = Standard_False);
+ const Standard_Boolean theUseTrsf = Standard_False,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers context dependent shape representation entity
- Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity (const Handle(StepShape_ContextDependentShapeRepresentation)& CDSR, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity
+ (const Handle(StepShape_ContextDependentShapeRepresentation)& CDSR,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers shape representation relationship entity
//! theUseTrsf - special flag for using Axis2Placement from ShapeRepresentation for transform root shape
const Handle(StepRepr_ShapeRepresentationRelationship)& und,
const Handle(Transfer_TransientProcess)& TP,
const Standard_Integer nbrep = 0,
- const Standard_Boolean theUseTrsf = Standard_False);
+ const Standard_Boolean theUseTrsf = Standard_False,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers geometric representation item entity such as ManifoldSolidBRep ,...etc
- Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity (const Handle(StepGeom_GeometricRepresentationItem)& git, const Handle(Transfer_TransientProcess)& TP, const Standard_Boolean isManifold);
+ Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity
+ (const Handle(StepGeom_GeometricRepresentationItem)& git,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Standard_Boolean isManifold,
+ const Message_ProgressRange& theProgress);
//! Transfers mapped item
- Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity (const Handle(StepRepr_MappedItem)& mapit, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity
+ (const Handle(StepRepr_MappedItem)& mapit,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress);
//! Transfers FaceSurface entity
- Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity (const Handle(StepShape_FaceSurface)& fs, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT Handle(TransferBRep_ShapeBinder) TransferEntity
+ (const Handle(StepShape_FaceSurface)& fs,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress);
Handle(TransferBRep_ShapeBinder) TransferEntity( const Handle(StepRepr_ConstructiveGeometryRepresentationRelationship)& theCGRR,
const Handle(Transfer_TransientProcess)& theTP);
//! Tranlates file by old way when CDSR are roots . Acts only if "read.step.product_mode" is equal Off.
- Standard_EXPORT Handle(TransferBRep_ShapeBinder) OldWay (const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT Handle(TransferBRep_ShapeBinder) OldWay
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress);
#include <Interface_Macros.hxx>
#include <Interface_MSG.hxx>
#include <Interface_Static.hxx>
+#include <Message_ProgressScope.hxx>
#include <MoniTool_DataMapOfShapeTransient.hxx>
#include <OSD_Timer.hxx>
#include <ShapeAnalysis_ShapeTolerance.hxx>
//=======================================================================
Handle(Transfer_Binder) STEPControl_ActorWrite::Transfer (const Handle(Transfer_Finder)& start,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
XSAlgo::AlgoContainer()->PrepareForTransfer();
Handle(StepShape_ShapeDefinitionRepresentation) sdr = SDRTool.SDRValue();
// transfer shape
- Handle(Transfer_Binder) resbind = TransferShape (mapper,sdr,FP);
+ Handle(Transfer_Binder) resbind = TransferShape (mapper,sdr,FP, 0L, Standard_True, theProgress);
// Handle(StepShape_ShapeRepresentation) resultat;
// FP->GetTypedTransient (resbind,STANDARD_TYPE(StepShape_ShapeRepresentation),resultat);
}
-Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape (const Handle(Transfer_Finder)& start,
- const Handle(StepShape_ShapeDefinitionRepresentation)& SDR0,
- const Handle(Transfer_FinderProcess)& FP,
- const Handle(TopTools_HSequenceOfShape)& shapeGroup,
- const Standard_Boolean isManifold)
+Handle(Transfer_Binder) STEPControl_ActorWrite::TransferShape
+ (const Handle(Transfer_Finder)& start,
+ const Handle(StepShape_ShapeDefinitionRepresentation)& SDR0,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(TopTools_HSequenceOfShape)& shapeGroup,
+ const Standard_Boolean isManifold,
+ const Message_ProgressRange& theProgress)
{
STEPControl_StepModelType mymode = Mode();
Handle(TransferBRep_ShapeMapper) mapper = Handle(TransferBRep_ShapeMapper)::DownCast(start);
// MODE ASSEMBLY : if Compound, (sub-)assembly
if ( IsAssembly(theShape) )
- return TransferCompound(start, SDR0, FP);
+ return TransferCompound(start, SDR0, FP, theProgress);
+
+ Message_ProgressScope aPSRoot(theProgress, NULL, 2);
// [BEGIN] Separate manifold topology from non-manifold in group mode 0 (ssv; 18.11.2010)
Standard_Boolean isNMMode = Interface_Static::IVal("write.step.nonmanifold") != 0;
// Complete SDR with shape representations.
// NOTE: aNMBinder is connected now with this SDR. It will be added to the resulting
// binder in the end of this invocation of TransferShape
- for (Standard_Integer i = 1; i <= aNMItemsNb; i++) {
+ Message_ProgressScope aPS (aPSRoot.Next(), NULL, aNMItemsNb);
+ for (Standard_Integer i = 1; i <= aNMItemsNb && aPS.More(); i++) {
Handle(TransferBRep_ShapeMapper) aMapper = TransferBRep::ShapeMapper( FP, RepItemSeq->Value(i) );
- TransferShape(aMapper, sdr, FP, NonManifoldGroup, Standard_False);
+ TransferShape(aMapper, sdr, FP, NonManifoldGroup, Standard_False, aPS.Next());
}
// Nothing else needed for pure non-manifold topology, return
}
// [END] Separate manifold topology from non-manifold in group mode 0 (ssv; 18.11.2010)
+ if (aPSRoot.UserBreak())
+ return Handle(Transfer_Binder)();
+
// create a list of items to translate
Handle(TopTools_HSequenceOfShape) RepItemSeq = new TopTools_HSequenceOfShape();
else if (theShape.ShapeType() == TopAbs_COMPSOLID) {
FP->AddWarning(start,"NonManifold COMPSOLID was translated like a set of SOLIDs");
if ( GroupMode() > 0)
- return TransferCompound(start, SDR0, FP);
+ return TransferCompound(start, SDR0, FP, aPSRoot.Next());
else {
TopExp_Explorer SolidExp;
for (SolidExp.Init(theShape, TopAbs_SOLID);
//ptv 10.11.00: allow to write empty Compound: if (GroupMode() >0)
ItemSeq->Append (myContext.GetDefaultAxis());
STEPControl_StepModelType trmode = mymode;
- for (Standard_Integer i = 1; i <= nbs; i++) {
+ Message_ProgressScope aPS (aPSRoot.Next(), NULL, nbs);
+ for (Standard_Integer i = 1; i <= nbs && aPS.More(); i++) {
TopoDS_Shape xShape = RepItemSeq->Value(i);
if(mymode == STEPControl_AsIs) {
Handle(Standard_Transient) info;
Standard_Real maxTol = Interface_Static::RVal("read.maxprecision.val");
+ Message_ProgressScope aPS1 (aPS.Next(), NULL, 2);
+
TopoDS_Shape aShape;
aShape = XSAlgo::AlgoContainer()->ProcessShape(xShape, Tol, maxTol,
"write.step.resource.name",
"write.step.sequence", info,
- FP->GetProgress() );
+ aPS1.Next());
+ if (aPS1.UserBreak())
+ return Handle(Transfer_Binder)();
+
if (!isManifold) {
mergeInfoForNM(FP, info);
}
for ( TopoDS_Iterator It ( aSolid ); It.More(); It.Next() )
if (It.Value().ShapeType() == TopAbs_SHELL) nbShells++;
if ( nbShells >1 ) {
- TopoDSToStep_MakeBrepWithVoids MkBRepWithVoids(aSolid,FP);
+ TopoDSToStep_MakeBrepWithVoids MkBRepWithVoids(aSolid,FP, aPS1.Next());
MkBRepWithVoids.Tolerance() = Tol;
if (MkBRepWithVoids.IsDone()) {
item = MkBRepWithVoids.Value();
}
if ( nbShells ==1 ) {
- TopoDSToStep_MakeManifoldSolidBrep MkManifoldSolidBrep(aSolid,FP);
+ TopoDSToStep_MakeManifoldSolidBrep MkManifoldSolidBrep(aSolid,FP, aPS1.Next());
MkManifoldSolidBrep.Tolerance() = Tol;
if (MkManifoldSolidBrep.IsDone()) {
item = MkManifoldSolidBrep.Value();
}
else if (aShape.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell aShell = TopoDS::Shell(aShape);
- TopoDSToStep_MakeManifoldSolidBrep MkManifoldSolidBrep(aShell,FP);
+ TopoDSToStep_MakeManifoldSolidBrep MkManifoldSolidBrep(aShell,FP, aPS1.Next());
MkManifoldSolidBrep.Tolerance() = Tol;
if (MkManifoldSolidBrep.IsDone()) {
item = MkManifoldSolidBrep.Value();
{
if (aShape.ShapeType() == TopAbs_SOLID) {
TopoDS_Solid aSolid = TopoDS::Solid(aShape);
- TopoDSToStep_MakeBrepWithVoids MkBRepWithVoids(aSolid,FP);
+ TopoDSToStep_MakeBrepWithVoids MkBRepWithVoids(aSolid,FP, aPS1.Next());
MkBRepWithVoids.Tolerance() = Tol;
if (MkBRepWithVoids.IsDone()) {
item = MkBRepWithVoids.Value();
}
if (aShape.ShapeType() == TopAbs_SOLID) {
TopoDS_Solid aSolid = TopoDS::Solid(aShape);
- TopoDSToStep_MakeFacetedBrep MkFacetedBrep(aSolid,FP);
+ TopoDSToStep_MakeFacetedBrep MkFacetedBrep(aSolid,FP, aPS1.Next());
MkFacetedBrep.Tolerance() = Tol;
if (MkFacetedBrep.IsDone()) {
item = MkFacetedBrep.Value();
if (aShape.ShapeType() == TopAbs_SOLID) {
TopoDS_Solid aSolid = TopoDS::Solid(aShape);
TopoDSToStep_MakeFacetedBrepAndBrepWithVoids
- MkFacetedBrepAndBrepWithVoids(aSolid,FP);
+ MkFacetedBrepAndBrepWithVoids(aSolid,FP, aPS1.Next());
MkFacetedBrepAndBrepWithVoids.Tolerance() = Tol;
if (MkFacetedBrepAndBrepWithVoids.IsDone()) {
item = MkFacetedBrepAndBrepWithVoids.Value();
if (aShape.ShapeType() == TopAbs_SOLID) {
TopoDS_Solid aSolid = TopoDS::Solid(aShape);
TopoDSToStep_MakeShellBasedSurfaceModel
- MkShellBasedSurfaceModel(aSolid, FP);
+ MkShellBasedSurfaceModel(aSolid, FP, aPS1.Next());
MkShellBasedSurfaceModel.Tolerance() = Tol;
if (MkShellBasedSurfaceModel.IsDone()) {
item = MkShellBasedSurfaceModel.Value();
else if (aShape.ShapeType() == TopAbs_SHELL) {
TopoDS_Shell aShell = TopoDS::Shell(aShape);
// Non-manifold topology is stored via NMSSR containing series of SBSM (ssv; 13.11.2010)
- TopoDSToStep_MakeShellBasedSurfaceModel MkShellBasedSurfaceModel(aShell, FP);
+ TopoDSToStep_MakeShellBasedSurfaceModel MkShellBasedSurfaceModel(aShell, FP, aPS1.Next());
MkShellBasedSurfaceModel.Tolerance() = Tol;
if (MkShellBasedSurfaceModel.IsDone()) {
item = MkShellBasedSurfaceModel.Value();
else if (aShape.ShapeType() == TopAbs_FACE) {
TopoDS_Face aFace = TopoDS::Face(aShape);
TopoDSToStep_MakeShellBasedSurfaceModel
- MkShellBasedSurfaceModel(aFace, FP);
+ MkShellBasedSurfaceModel(aFace, FP, aPS1.Next());
MkShellBasedSurfaceModel.Tolerance() = Tol;
if (MkShellBasedSurfaceModel.IsDone()) {
item = MkShellBasedSurfaceModel.Value();
//purpose :
//=======================================================================
-Handle(Transfer_Binder) STEPControl_ActorWrite::TransferCompound (const Handle(Transfer_Finder)& start,
- const Handle(StepShape_ShapeDefinitionRepresentation)& SDR0,
- const Handle(Transfer_FinderProcess)& FP)
+Handle(Transfer_Binder) STEPControl_ActorWrite::TransferCompound
+ (const Handle(Transfer_Finder)& start,
+ const Handle(StepShape_ShapeDefinitionRepresentation)& SDR0,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
Handle(TransferBRep_ShapeMapper) mapper = Handle(TransferBRep_ShapeMapper)::DownCast(start);
Handle(Transfer_Binder) binder;
Handle(TColStd_HSequenceOfTransient) ItemSeq = new TColStd_HSequenceOfTransient();
ItemSeq->Append (myContext.GetDefaultAxis());
myContext.NextLevel();
- for ( i = 1; i <= nbs; i ++) {
+ Message_ProgressScope aPS(theProgress, NULL, nbs);
+ for (i = 1; i <= nbs && aPS.More(); i++) {
Handle(TransferBRep_ShapeMapper) subs = TransferBRep::ShapeMapper (FP,RepItemSeq->Value(i));
Handle(StepGeom_Axis2Placement3d) AX1;
- Handle(Transfer_Binder) bnd = TransferSubShape(subs, SDR0, AX1, FP, NonManifoldGroup, isManifold);
+ Handle(Transfer_Binder) bnd = TransferSubShape(subs, SDR0, AX1, FP, NonManifoldGroup, isManifold, aPS.Next());
if (!AX1.IsNull()) ItemSeq->Append (AX1);
// copy binders so as to have all roots in upper binder, but do not conflict
//purpose :
//=======================================================================
-Handle(Transfer_Binder) STEPControl_ActorWrite::TransferSubShape (const Handle(Transfer_Finder)& start,
- const Handle(StepShape_ShapeDefinitionRepresentation)& SDR0,
- Handle(StepGeom_Axis2Placement3d)& AX1,
- const Handle(Transfer_FinderProcess)& FP,
- const Handle(TopTools_HSequenceOfShape)& shapeGroup,
- const Standard_Boolean isManifold)
+Handle(Transfer_Binder) STEPControl_ActorWrite::TransferSubShape
+ (const Handle(Transfer_Finder)& start,
+ const Handle(StepShape_ShapeDefinitionRepresentation)& SDR0,
+ Handle(StepGeom_Axis2Placement3d)& AX1,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(TopTools_HSequenceOfShape)& shapeGroup,
+ const Standard_Boolean isManifold,
+ const Message_ProgressRange& theProgress)
{
Handle(TransferBRep_ShapeMapper) mapper = Handle(TransferBRep_ShapeMapper)::DownCast(start);
if (mapper.IsNull()) return NullResult();
//:abv 20.05.02: see comment in TransferShape(): added "! iasdr ||"
Handle(Transfer_Binder) resprod = TransientResult(sdr); //KA - OCC7141(skl 10.11.2004)
if ( ! iasdr || resbind.IsNull() ) {
- resbind = TransferShape(mapper, sdr, FP, shapeGroup, isManifold);
+ resbind = TransferShape(mapper, sdr, FP, shapeGroup, isManifold, theProgress);
Handle(Transfer_Binder) oldbind = FP->Find ( mapper );
if ( ! oldbind.IsNull() && !resbind.IsNull()) resbind->AddResult ( oldbind );
FP->Bind (mapper,resbind);
Standard_EXPORT virtual Standard_Boolean Recognize (const Handle(Transfer_Finder)& start) Standard_OVERRIDE;
- Standard_EXPORT virtual Handle(Transfer_Binder) Transfer (const Handle(Transfer_Finder)& start, const Handle(Transfer_FinderProcess)& FP) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transfer
+ (const Handle(Transfer_Finder)& start,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
- Standard_EXPORT Handle(Transfer_Binder) TransferSubShape (const Handle(Transfer_Finder)& start, const Handle(StepShape_ShapeDefinitionRepresentation)& SDR, Handle(StepGeom_Axis2Placement3d)& AX1, const Handle(Transfer_FinderProcess)& FP, const Handle(TopTools_HSequenceOfShape)& shapeGroup = NULL, const Standard_Boolean isManifold = Standard_True);
+ Standard_EXPORT Handle(Transfer_Binder) TransferSubShape
+ (const Handle(Transfer_Finder)& start,
+ const Handle(StepShape_ShapeDefinitionRepresentation)& SDR,
+ Handle(StepGeom_Axis2Placement3d)& AX1,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(TopTools_HSequenceOfShape)& shapeGroup = NULL,
+ const Standard_Boolean isManifold = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT Handle(Transfer_Binder) TransferShape (const Handle(Transfer_Finder)& start, const Handle(StepShape_ShapeDefinitionRepresentation)& SDR, const Handle(Transfer_FinderProcess)& FP, const Handle(TopTools_HSequenceOfShape)& shapeGroup = NULL, const Standard_Boolean isManifold = Standard_True);
+ Standard_EXPORT Handle(Transfer_Binder) TransferShape
+ (const Handle(Transfer_Finder)& start,
+ const Handle(StepShape_ShapeDefinitionRepresentation)& SDR,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(TopTools_HSequenceOfShape)& shapeGroup = NULL,
+ const Standard_Boolean isManifold = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT Handle(Transfer_Binder) TransferCompound (const Handle(Transfer_Finder)& start, const Handle(StepShape_ShapeDefinitionRepresentation)& SDR, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT Handle(Transfer_Binder) TransferCompound
+ (const Handle(Transfer_Finder)& start,
+ const Handle(StepShape_ShapeDefinitionRepresentation)& SDR,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT void SetMode (const STEPControl_StepModelType M);
(const TopoDS_Shape& shape,
const Handle(Transfer_FinderProcess)& FP,
const Handle(Interface_InterfaceModel)& model,
- const Standard_Integer modeshape) const
+ const Standard_Integer modeshape,
+ const Message_ProgressRange& theProgress) const
{
if (modeshape < 0 || modeshape > 4) return IFSelect_RetError;
Handle(STEPControl_ActorWrite) ActWrite =
if (!ActWrite.IsNull())
ActWrite->SetGroupMode (Interface_Static::IVal("write.step.assembly"));
- return XSControl_Controller::TransferWriteShape (shape,FP,model,modeshape);
+ return XSControl_Controller::TransferWriteShape(shape, FP, model, modeshape, theProgress);
}
Standard_Boolean STEPControl_Controller::Init ()
//! Returns a status : 0 OK 1 No result 2 Fail -1 bad modeshape
//! -2 bad model (requires a StepModel)
//! modeshape : 1 Facetted BRep, 2 Shell, 3 Manifold Solid
- Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteShape (const TopoDS_Shape& shape, const Handle(Transfer_FinderProcess)& FP, const Handle(Interface_InterfaceModel)& model, const Standard_Integer modetrans = 0) const Standard_OVERRIDE;
+ Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteShape
+ (const TopoDS_Shape& shape,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(Interface_InterfaceModel)& model,
+ const Standard_Integer modetrans = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const Standard_OVERRIDE;
//! Standard Initialisation. It creates a Controller for STEP
//! and records it to various names, available to select it later
//purpose :
//=======================================================================
-Standard_Boolean STEPControl_Reader::TransferRoot (const Standard_Integer num)
+Standard_Boolean STEPControl_Reader::TransferRoot (const Standard_Integer num,
+ const Message_ProgressRange& theProgress)
{
- return TransferOneRoot (num);
+ return TransferOneRoot(num, theProgress);
}
//=======================================================================
//! Default is the first one
//! Returns True if a shape has resulted, false else
//! Same as inherited TransferOneRoot, kept for compatibility
- Standard_EXPORT Standard_Boolean TransferRoot (const Standard_Integer num = 1);
+ Standard_EXPORT Standard_Boolean TransferRoot (const Standard_Integer num = 1,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Determines the list of root entities from Model which are candidate for
//! a transfer to a Shape (type of entities is PRODUCT)
#include <Interface_InterfaceModel.hxx>
#include <Interface_Macros.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <STEPControl_ActorWrite.hxx>
#include <STEPControl_Controller.hxx>
#include <StepData_StepModel.hxx>
//=======================================================================
IFSelect_ReturnStatus STEPControl_Writer::Transfer
- (const TopoDS_Shape& sh, const STEPControl_StepModelType mode,
- const Standard_Boolean compgraph)
+ (const TopoDS_Shape& sh,
+ const STEPControl_StepModelType mode,
+ const Standard_Boolean compgraph,
+ const Message_ProgressRange& theProgress)
{
Standard_Integer mws = -1;
switch (mode) {
if (mws < 0) return IFSelect_RetError; // cas non reconnu
thesession->TransferWriter()->SetTransferMode (mws);
- // for progress indicator.
- Handle(Message_ProgressIndicator) progress = WS()->TransferWriter()->FinderProcess()->GetProgress();
- if ( ! progress.IsNull() ) {
- Standard_Integer nbfaces=0;
- for( TopExp_Explorer exp(sh, TopAbs_FACE); exp.More(); exp.Next()) nbfaces++;
- progress->SetScale ( "Face", 0, nbfaces, 1 );
- progress->Show();
- }
-
- return thesession->TransferWriteShape(sh,compgraph);
+ return thesession->TransferWriteShape(sh, compgraph, theProgress);
}
#include <STEPControl_StepModelType.hxx>
#include <Standard_CString.hxx>
#include <Standard_Integer.hxx>
+#include <Message_ProgressRange.hxx>
+
class XSControl_WorkSession;
class StepData_StepModel;
class TopoDS_Shape;
//! shell_based_surface_model entity.
//! - STEPControlStd_GeometricCurveSet translates a shape into a STEP
//! geometric_curve_set entity.
- Standard_EXPORT IFSelect_ReturnStatus Transfer (const TopoDS_Shape& sh, const STEPControl_StepModelType mode, const Standard_Boolean compgraph = Standard_True);
+ Standard_EXPORT IFSelect_ReturnStatus Transfer
+ (const TopoDS_Shape& sh,
+ const STEPControl_StepModelType mode,
+ const Standard_Boolean compgraph = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes a STEP model in the file identified by filename.
Standard_EXPORT IFSelect_ReturnStatus Write (const Standard_CString filename);
}
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (di, 1);
- sfs->Perform (aProgress);
+ sfs->Perform (aProgress->Start());
DBRep::Set (res,sfs->Shape());
if ( mess )
#include <ShapeUpgrade_UnifySameDomain.hxx>
#include <SWDRAW.hxx>
#include <SWDRAW_ShapeUpgrade.hxx>
+#include <TCollection_AsciiString.hxx>
#include <TColGeom2d_HArray1OfCurve.hxx>
#include <TColGeom_HArray1OfCurve.hxx>
#include <TColGeom_HArray2OfSurface.hxx>
#include <ShapeBuild_ReShape.hxx>
#include <Standard_ErrorHandler.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
//=======================================================================
//function : ApplyModifier
const Handle(BRepTools_Modification) &M,
TopTools_DataMapOfShapeShape &context,
BRepTools_Modifier& MD,
- const Handle(Message_ProgressIndicator) & aProgress,
+ const Message_ProgressRange& theProgress,
const Handle(ShapeBuild_ReShape) & aReShape)
{
// protect against INTERNAL/EXTERNAL shapes
B.MakeCompound ( C );
Standard_Integer aShapeCount = SF.NbChildren();
- Message_ProgressSentry aPSentry(aProgress, "Applying Modifier For Solids", 0, aShapeCount, 1);
- for ( TopoDS_Iterator it(SF); it.More() && aPSentry.More(); it.Next(), aPSentry.Next() ) {
+ Message_ProgressScope aPS(theProgress, "Applying Modifier For Solids", aShapeCount);
+ for ( TopoDS_Iterator it(SF); it.More() && aPS.More(); it.Next()) {
TopoDS_Shape shape = it.Value();
TopLoc_Location L = shape.Location(), nullLoc;
shape.Location ( nullLoc );
TopoDS_Shape res;
+ Message_ProgressRange aRange = aPS.Next();
if ( context.IsBound ( shape ) )
res = context.Find ( shape ).Oriented ( shape.Orientation() );
else
- res = ApplyModifier ( shape, M, context ,MD, aProgress);
+ res = ApplyModifier ( shape, M, context ,MD, aRange);
if ( ! res.IsSame ( shape ) ) {
context.Bind ( shape, res );
B.Add ( C, res );
}
- if ( !aPSentry.More() )
+ if ( !aPS.More() )
{
// Was cancelled
return S;
return C.Oriented ( S.Orientation() );
}
- Message_ProgressSentry aPSentry(aProgress, "Modify the Shape", 0, 1, 1);
+ Message_ProgressScope aPS(theProgress, "Modify the Shape", 1);
// Modify the shape
MD.Init(SF);
- MD.Perform(M, aProgress);
+ MD.Perform(M, aPS.Next());
- if ( !aPSentry.More() || !MD.IsDone() ) return S;
+ if ( !aPS.More() || !MD.IsDone() ) return S;
if ( !aReShape.IsNull() )
{
for(TopoDS_Iterator theIterator(SF,Standard_False);theIterator.More();theIterator.Next())
#include <Standard_Integer.hxx>
#include <GeomAbs_Shape.hxx>
#include <Standard_Boolean.hxx>
+#include <Message_ProgressRange.hxx>
+
class TopoDS_Shape;
class BRepTools_Modification;
class BRepTools_Modifier;
-class Message_ProgressIndicator;
class ShapeBuild_ReShape;
class ShapeCustom_RestrictionParameters;
class ShapeCustom_Surface;
//! Applies modifier to shape and checks sharing in the case assemblies.
- Standard_EXPORT static TopoDS_Shape ApplyModifier (const TopoDS_Shape& S, const Handle(BRepTools_Modification)& M, TopTools_DataMapOfShapeShape& context, BRepTools_Modifier& MD, const Handle(Message_ProgressIndicator)& aProgress = NULL, const Handle(ShapeBuild_ReShape)& aReShape = NULL);
+ Standard_EXPORT static TopoDS_Shape ApplyModifier
+ (const TopoDS_Shape& S, const Handle(BRepTools_Modification)& M,
+ TopTools_DataMapOfShapeShape& context, BRepTools_Modifier& MD,
+ const Message_ProgressRange& theProgress = Message_ProgressRange(),
+ const Handle(ShapeBuild_ReShape)& aReShape = NULL);
//! Returns a new shape without indirect surfaces.
Standard_EXPORT static TopoDS_Shape DirectFaces (const TopoDS_Shape& S);
#include <TopTools_IndexedDataMapOfShapeListOfShape.hxx>
#include <TopExp.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Message_Msg.hxx>
#include <ShapeExtend_BasicMsgRegistrator.hxx>
Standard_Boolean ShapeFix::SameParameter(const TopoDS_Shape& shape,
const Standard_Boolean enforce,
const Standard_Real preci,
- const Handle(Message_ProgressIndicator)& theProgress,
+ const Message_ProgressRange& theProgress,
const Handle(ShapeExtend_BasicMsgRegistrator)& theMsgReg)
{
// Calculate number of edges
Message_Msg doneMsg("FixEdge.SameParameter.MSG0");
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentryForSameParam(theProgress, "Fixing same parameter problem", 0, 2, 1);
+ Message_ProgressScope aPSForSameParam(theProgress, "Fixing same parameter problem", 2);
{
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentry(theProgress, "Fixing edge", 0, aNbEdges, 1);
+ Message_ProgressScope aPS (aPSForSameParam.Next(), "Fixing edge", aNbEdges);
while ( ex.More() )
{
TopoDS_Edge E;
- while ( ex.More() && aPSentry.More() )
+ while ( ex.More() && aPS.More() )
{
numedge ++;
int ierr = 0;
}
// Complete step in current progress scope
- aPSentry.Next();
+ aPS.Next();
} // -- end while
// Halt algorithm in case of user's abort
- if ( !aPSentry.More() )
+ if ( !aPS.More() )
return Standard_False;
}
}
- // Switch to "Update tolerances" step
- aPSentryForSameParam.Next();
{
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentry(theProgress, "Update tolerances", 0, aNbFaces, 1);
+ Message_ProgressScope aPS (aPSForSameParam.Next(), "Update tolerances", aNbFaces);
//:i2 abv 21 Aug 98: ProSTEP TR8 Motor.rle face 710:
// Update tolerance of edges on planes (no pcurves are stored)
- for ( TopExp_Explorer exp ( shape, TopAbs_FACE ); exp.More() && aPSentry.More(); exp.Next(), aPSentry.Next() )
+ for ( TopExp_Explorer exp ( shape, TopAbs_FACE ); exp.More() && aPS.More(); exp.Next(), aPS.Next() )
{
TopoDS_Face face = TopoDS::Face ( exp.Current() );
Handle(Geom_Surface) Surf = BRep_Tool::Surface ( face );
}
}
}
-
- // Halt algorithm in case of user's abort
- if ( !aPSentry.More() )
- return Standard_False;
}
+ // Halt algorithm in case of user's abort
+ if (!aPS.More())
+ return Standard_False;
}
if (!status) {
#include <Standard_Boolean.hxx>
#include <Standard_Real.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <ShapeExtend_BasicMsgRegistrator.hxx>
+#include <Message_ProgressRange.hxx>
class TopoDS_Shape;
-class Message_ProgressIndicator;
class ShapeExtend_BasicMsgRegistrator;
class ShapeBuild_ReShape;
class ShapeFix_Root;
//! been processed. The passed progress indicator allows user
//! to consult the current progress stage and abort algorithm
//! if needed.
- Standard_EXPORT static Standard_Boolean SameParameter (const TopoDS_Shape& shape, const Standard_Boolean enforce, const Standard_Real preci = 0.0, const Handle(Message_ProgressIndicator)& theProgress = 0, const Handle(ShapeExtend_BasicMsgRegistrator)& theMsgReg = 0);
+ Standard_EXPORT static Standard_Boolean SameParameter
+ (const TopoDS_Shape& shape, const Standard_Boolean enforce,
+ const Standard_Real preci = 0.0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange(),
+ const Handle(ShapeExtend_BasicMsgRegistrator)& theMsgReg = 0);
//! Runs EncodeRegularity from BRepLib taking into account
//! shared components of assemblies, so that each component
#include <BRep_Builder.hxx>
#include <BRepTools.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Precision.hxx>
#include <ShapeBuild_ReShape.hxx>
#include <ShapeExtend_BasicMsgRegistrator.hxx>
//purpose :
//=======================================================================
-Standard_Boolean ShapeFix_Shape::Perform(const Handle(Message_ProgressIndicator)& theProgress)
+Standard_Boolean ShapeFix_Shape::Perform(const Message_ProgressRange& theProgress)
{
Standard_Integer savFixSmallAreaWireMode = 0;
Standard_Integer savFixVertexTolMode = myFixVertexTolMode;
// Open progress indication scope for the following fix stages:
// - Fix on Solid or Shell;
// - Fix same parameterization;
- Message_ProgressSentry aPSentry(theProgress, "Fixing stage", 0, 2, 1);
+ Message_ProgressScope aPS(theProgress, "Fixing stage", 2);
switch ( st ) {
case TopAbs_COMPOUND:
Standard_Integer aShapesNb = S.NbChildren();
// Open progress indication scope for sub-shape fixing
- Message_ProgressSentry aPSentrySubShape(theProgress, "Fixing sub-shape", 0, aShapesNb, 1);
- for ( TopoDS_Iterator anIter(S); anIter.More() && aPSentrySubShape.More(); anIter.Next(), aPSentrySubShape.Next() )
+ Message_ProgressScope aPSSubShape(aPS.Next(), "Fixing sub-shape", aShapesNb);
+ for ( TopoDS_Iterator anIter(S); anIter.More() && aPSSubShape.More(); anIter.Next())
{
myShape = anIter.Value();
- if ( Perform(theProgress) )
+ if (Perform (aPSSubShape.Next()))
status = Standard_True;
}
- if ( !aPSentrySubShape.More() )
+ if ( !aPSSubShape.More() )
return Standard_False; // aborted execution
myFixSameParameterMode = savFixSameParameterMode;
myFixSolid->Init(TopoDS::Solid(S));
myFixSolid->SetContext(Context());
- if ( myFixSolid->Perform(theProgress) )
+ if (myFixSolid->Perform (aPS.Next()))
status = Standard_True;
myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE4 );
sfsh->Init( TopoDS::Shell(S) );
sfsh->SetContext( Context() );
- if ( sfsh->Perform(theProgress) )
+ if (sfsh->Perform (aPS.Next()))
status = Standard_True;
myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE4 );
case TopAbs_SHAPE :
default : break;
}
-
- // Switch to the second progress indication scope if it exists
- aPSentry.Next();
+ if (!aPS.More())
+ return Standard_False; // aborted execution
myResult = Context()->Apply(S);
if ( NeedFix(myFixSameParameterMode) )
{
- SameParameter(myResult, Standard_False, theProgress);
+ SameParameter (myResult, Standard_False, aPS.Next());
+ if (!aPS.More())
+ return Standard_False; // aborted execution
}
if( NeedFix( myFixVertexTolMode))
{
void ShapeFix_Shape::SameParameter(const TopoDS_Shape& sh,
const Standard_Boolean enforce,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
ShapeFix::SameParameter(sh, enforce, 0.0, theProgress);
}
#include <Standard_Boolean.hxx>
#include <ShapeExtend_Status.hxx>
#include <Standard_Real.hxx>
-
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class ShapeFix_Solid;
-class Message_ProgressIndicator;
class ShapeFix_Shell;
class ShapeFix_Face;
class ShapeFix_Wire;
Standard_EXPORT void Init (const TopoDS_Shape& shape);
//! Iterates on sub- shape and performs fixes
- Standard_EXPORT Standard_Boolean Perform (const Handle(Message_ProgressIndicator)& theProgress = 0);
+ Standard_EXPORT Standard_Boolean Perform (const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns resulting shape
Standard_EXPORT TopoDS_Shape Shape() const;
//! Fixes same parameterization problem on the passed shape
//! by updating tolerances of the corresponding topological
//! entitites.
- Standard_EXPORT void SameParameter (const TopoDS_Shape& shape, const Standard_Boolean enforce, const Handle(Message_ProgressIndicator)& theProgress = 0);
+ Standard_EXPORT void SameParameter (const TopoDS_Shape& shape, const Standard_Boolean enforce,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
TopoDS_Shape myResult;
Handle(ShapeFix_Solid) myFixSolid;
#include <BRep_Tool.hxx>
#include <BRepBndLib.hxx>
#include <Message_Msg.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Precision.hxx>
#include <ShapeAnalysis_Shell.hxx>
#include <ShapeBuild_ReShape.hxx>
//purpose :
//=======================================================================
-Standard_Boolean ShapeFix_Shell::Perform(const Handle(Message_ProgressIndicator)& theProgress)
+Standard_Boolean ShapeFix_Shell::Perform(const Message_ProgressRange& theProgress)
{
Standard_Boolean status = Standard_False;
if ( Context().IsNull() )
Standard_Integer aNbFaces = S.NbChildren();
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentry(theProgress, "Fixing face", 0, aNbFaces, 1);
+ Message_ProgressScope aPS(theProgress, "Fixing face", aNbFaces);
- for( TopoDS_Iterator iter(S); iter.More() && aPSentry.More(); iter.Next(), aPSentry.Next() )
+ for( TopoDS_Iterator iter(S); iter.More() && aPS.More(); iter.Next(), aPS.Next() )
{
TopoDS_Shape sh = iter.Value();
TopoDS_Face tmpFace = TopoDS::Face(sh);
}
// Halt algorithm in case of user's abort
- if ( !aPSentry.More() )
+ if ( !aPS.More() )
return Standard_False;
}
#include <Standard.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <TopoDS_Shell.hxx>
#include <TopoDS_Compound.hxx>
#include <ShapeFix_Root.hxx>
#include <ShapeExtend_Status.hxx>
+#include <Message_ProgressRange.hxx>
class ShapeFix_Face;
class ShapeExtend_BasicMsgRegistrator;
//! then calls FixFaceOrientation). The passed progress
//! indicator allows user to consult the current progress
//! stage and abort algorithm if needed.
- Standard_EXPORT Standard_Boolean Perform (const Handle(Message_ProgressIndicator)& theProgress = 0);
+ Standard_EXPORT Standard_Boolean Perform (const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Fixes orientation of faces in shell.
//! Changes orientation of face in the shell, if it is oriented opposite
#include <Geom_Surface.hxx>
#include <gp_Pnt.hxx>
#include <Message_Msg.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Precision.hxx>
#include <ShapeAnalysis.hxx>
#include <ShapeAnalysis_Curve.hxx>
//purpose :
//=======================================================================
-Standard_Boolean ShapeFix_Solid::Perform(const Handle(Message_ProgressIndicator)& theProgress)
+Standard_Boolean ShapeFix_Solid::Perform(const Message_ProgressRange& theProgress)
{
Standard_Boolean status = Standard_False;
aNbShells++;
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentry(theProgress, "Fixing solid stage", 0, 2, 1);
+ Message_ProgressScope aPS(theProgress, "Fixing solid stage", 2);
if ( NeedFix(myFixShellMode) )
{
// Start progress scope (no need to check if progress exists -- it is safe)
- Message_ProgressSentry aPSentryFixShell(theProgress, "Fixing shell", 0, aNbShells, 1);
+ Message_ProgressScope aPSFixShell(aPS.Next(), "Fixing shell", aNbShells);
// Fix shell by shell using ShapeFix_Shell tool
- for ( TopExp_Explorer aExpSh(S, TopAbs_SHELL); aExpSh.More() && aPSentryFixShell.More(); aExpSh.Next(), aPSentryFixShell.Next() )
+ for ( TopExp_Explorer aExpSh(S, TopAbs_SHELL); aExpSh.More() && aPSFixShell.More(); aExpSh.Next())
{
TopoDS_Shape sh = aExpSh.Current();
myFixShell->Init( TopoDS::Shell(sh) );
- if ( myFixShell->Perform(theProgress) )
+ if (myFixShell->Perform (aPSFixShell.Next()))
{
status = Standard_True;
myStatus |= ShapeExtend::EncodeStatus ( ShapeExtend_DONE1 );
}
// Halt algorithm in case of user's abort
- if ( !aPSentryFixShell.More() )
+ if ( !aPSFixShell.More() )
return Standard_False;
}
else
NbShells = aNbShells;
}
- // Switch to the second stage
- aPSentry.Next();
-
if (!NeedFix(myFixShellOrientationMode))
{
myShape = Context()->Apply(myShape);
BRep_Builder aB;
TopoDS_Compound aComp;
aB.MakeCompound(aComp);
- Message_ProgressSentry aPSentryCreatingSolid(theProgress, "Creating solid",
- 0, aMapSolids.Extent(), 1);
- for(Standard_Integer i =1; (i <= aMapSolids.Extent()) && (aPSentryCreatingSolid.More());
- i++, aPSentryCreatingSolid.Next())
+ Message_ProgressScope aPSCreatingSolid (aPS.Next(), "Creating solid", aMapSolids.Extent());
+ for(Standard_Integer i =1; (i <= aMapSolids.Extent()) && (aPSCreatingSolid.More());
+ i++, aPSCreatingSolid.Next())
{
TopoDS_Shape aResSh =aMapSolids.FindKey(i);
if(aResShape.ShapeType() == TopAbs_SHELL && myCreateOpenSolidMode) {
aB.Add(aComp,aResSh);
}
- if ( !aPSentryCreatingSolid.More() )
+ if ( !aPSCreatingSolid.More() )
return Standard_False; // aborted execution
Context()->Replace(aResShape,aComp);
}
#include <Standard_Real.hxx>
class ShapeFix_Shell;
class TopoDS_Solid;
-class Message_ProgressIndicator;
+class Message_ProgressScope;
class TopoDS_Shell;
class ShapeExtend_BasicMsgRegistrator;
//! (calls ShapeFix_Shell for each subshell). The passed
//! progress indicator allows user to consult the current
//! progress stage and abort algorithm if needed.
- Standard_EXPORT virtual Standard_Boolean Perform (const Handle(Message_ProgressIndicator)& theProgress = 0);
+ Standard_EXPORT virtual Standard_Boolean Perform (const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Calls MakeSolid and orients the solid to be "not infinite"
Standard_EXPORT TopoDS_Solid SolidFromShell (const TopoDS_Shell& shell);
#include <NCollection_DataMap.hxx>
#include <Message_Messenger.hxx>
#include <Message_Msg.hxx>
+#include <Message_ProgressScope.hxx>
#include <ShapeProcess.hxx>
#include <ShapeProcess_Context.hxx>
#include <ShapeProcess_Operator.hxx>
//=======================================================================
Standard_Boolean ShapeProcess::Perform (const Handle(ShapeProcess_Context)& context,
- const Standard_CString seq)
+ const Standard_CString seq,
+ const Message_ProgressRange& theProgress)
{
context->SetScope ( seq );
// iterate on operators in the sequence
Standard_Boolean isDone = Standard_False;
- for (i=1; i<=sequenceOfOperators.Length(); i++) {
+ Message_ProgressScope aPS(theProgress, NULL, sequenceOfOperators.Length());
+ for (i = 1; i<=sequenceOfOperators.Length() && aPS.More(); i++)
+ {
oper = sequenceOfOperators.Value(i);
+ Message_ProgressRange aRange = aPS.Next();
if ( context->TraceLevel() >=2 ) {
Message_Msg SMSG5 ("SP.Sequence.Info.Operator"); //Operator %d/%d: %s
context->SetScope ( oper.ToCString() );
try {
OCC_CATCH_SIGNALS
- if ( op->Perform(context) )
+ if (op->Perform(context, aRange))
isDone = Standard_True;
}
catch (Standard_Failure const& anException) {
#include <Standard_Boolean.hxx>
#include <Standard_CString.hxx>
+#include <Message_ProgressRange.hxx>
+
class ShapeProcess_Operator;
class ShapeProcess_Context;
class ShapeProcess_Context;
//! Performs a specified sequence of operators on Context
//! Resource file and other data should be already loaded
//! to Context (including description of sequence seq)
- Standard_EXPORT static Standard_Boolean Perform (const Handle(ShapeProcess_Context)& context, const Standard_CString seq);
+ Standard_EXPORT static Standard_Boolean Perform
+ (const Handle(ShapeProcess_Context)& context,
+ const Standard_CString seq,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <Resource_Manager.hxx>
#include <ShapeProcess_Context.hxx>
#include <Standard_ErrorHandler.hxx>
return myMessenger;
}
-//=======================================================================
-//function : SetProgress
-//purpose :
-//=======================================================================
-
-void ShapeProcess_Context::SetProgress (const Handle(Message_ProgressIndicator)& progress)
-{
- myProgress = progress;
-}
-
-//=======================================================================
-//function : Progress
-//purpose :
-//=======================================================================
-
-Handle(Message_ProgressIndicator) ShapeProcess_Context::Progress() const
-{
- return myProgress;
-}
-
//=======================================================================
//function : SetTraceLevel
//purpose :
#include <Standard_Real.hxx>
class Resource_Manager;
class Message_Messenger;
-class Message_ProgressIndicator;
class TCollection_AsciiString;
//! Returns Messenger used for outputting messages.
Standard_EXPORT Handle(Message_Messenger) Messenger() const;
- //! Sets Progress Indicator.
- Standard_EXPORT void SetProgress (const Handle(Message_ProgressIndicator)& theProgress);
-
- //! Returns Progress Indicator.
- Standard_EXPORT Handle(Message_ProgressIndicator) Progress() const;
-
//! Sets trace level used for outputting messages
//! - 0: no trace at all
//! - 1: errors
Handle(Resource_Manager) myRC;
Handle(TColStd_HSequenceOfHAsciiString) myScope;
Handle(Message_Messenger) myMessenger;
- Handle(Message_ProgressIndicator) myProgress;
Standard_Integer myTraceLev;
#include <ShapeProcess_Context.hxx>
-typedef Standard_Boolean (*ShapeProcess_OperFunc) (const Handle(ShapeProcess_Context)& context);
+class Message_ProgressRange;
+
+typedef Standard_Boolean (*ShapeProcess_OperFunc) (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange& theProgress);
#endif
#include <BRepTools_Modification.hxx>
#include <BRepTools_Modifier.hxx>
#include <Message_MsgFile.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <Precision.hxx>
#include <ShapeBuild_ReShape.hxx>
#include <ShapeCustom_BSplineRestriction.hxx>
//purpose :
//=======================================================================
-static Standard_Boolean directfaces (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean directfaces (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean sameparam (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean sameparam (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
ShapeFix::SameParameter ( ctx->Result(),
ctx->BooleanVal ( "Force", Standard_False ),
ctx->RealVal ( "Tolerance3d", Precision::Confusion() /* -1 */),
- NULL, msg );
+ Message_ProgressRange(), msg );
if ( !msg.IsNull() )
{
//purpose :
//=======================================================================
-static Standard_Boolean settol (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean settol (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean splitangle (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean splitangle (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean bsplinerestriction (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean bsplinerestriction (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean torevol (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean torevol (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean swepttoelem (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean swepttoelem (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean shapetobezier (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean shapetobezier (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean converttobspline (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean converttobspline (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose : Split by Continuity
//=======================================================================
-static Standard_Boolean splitcontinuity (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean splitcontinuity (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean splitclosedfaces (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean splitclosedfaces (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean fixfacesize (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean fixfacesize (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean fixwgaps (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean fixwgaps (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean dropsmallsolids (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean dropsmallsolids (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx =
Handle(ShapeProcess_ShapeContext)::DownCast (context);
//purpose :
//=======================================================================
-static Standard_Boolean mergesmalledges (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean mergesmalledges (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
//purpose :
//=======================================================================
-static Standard_Boolean fixshape (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean fixshape (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange& theProgress)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
sfw->FixSelfIntersectingEdgeMode() = ctx->IntegerVal ( "FixSelfIntersectingEdgeMode", -1 );
sfw->FixIntersectingEdgesMode() = ctx->IntegerVal ( "FixIntersectingEdgesMode", -1 );
sfw->FixNonAdjacentIntersectingEdgesMode() = ctx->IntegerVal ( "FixNonAdjacentIntersectingEdgesMode", -1 );
+ Message_ProgressScope aPS(theProgress, NULL, 2);
if (sfw->FixTailMode() == 1)
{
sfw->FixTailMode() = 0;
sfs->Init(ctx->Result());
- sfs->Perform(ctx->Progress());
+ sfs->Perform (aPS.Next());
sfw->FixTailMode() = 1;
- if (!ctx->Progress().IsNull() && ctx->Progress()->UserBreak())
+ if (aPS.UserBreak())
{
return Standard_False;
}
}
sfs->Init(ctx->Result());
- sfs->Perform(ctx->Progress());
- if (!ctx->Progress().IsNull() && ctx->Progress()->UserBreak())
+ sfs->Perform (aPS.Next());
+ if (aPS.UserBreak())
{
return Standard_False;
}
//purpose :
//=======================================================================
-static Standard_Boolean spltclosededges (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean spltclosededges (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx =
Handle(ShapeProcess_ShapeContext)::DownCast ( context );
// and isn't valid in STEP => before writing into STEP it is necessary
// to split this vertex (each wire must has one vertex)
//=======================================================================
-static Standard_Boolean splitcommonvertex (const Handle(ShapeProcess_Context)& context)
+static Standard_Boolean splitcommonvertex (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange&)
{
Handle(ShapeProcess_ShapeContext) ctx = Handle(ShapeProcess_ShapeContext)::DownCast ( context );
if ( ctx.IsNull() ) return Standard_False;
#include <Standard_Transient.hxx>
#include <Standard_Boolean.hxx>
-class ShapeProcess_Context;
-
+#include <Message_ProgressRange.hxx>
+class ShapeProcess_Context;
class ShapeProcess_Operator;
DEFINE_STANDARD_HANDLE(ShapeProcess_Operator, Standard_Transient)
//! Performs operation and eventually records
//! changes in the context
- Standard_EXPORT virtual Standard_Boolean Perform (const Handle(ShapeProcess_Context)& context) = 0;
+ Standard_EXPORT virtual Standard_Boolean Perform
+ (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) = 0;
//purpose :
//=======================================================================
-Standard_Boolean ShapeProcess_UOperator::Perform (const Handle(ShapeProcess_Context)& context)
+Standard_Boolean ShapeProcess_UOperator::Perform (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange& theProgress)
{
- return myFunc ( context );
+ return myFunc(context, theProgress);
}
Standard_EXPORT ShapeProcess_UOperator(const ShapeProcess_OperFunc func);
//! Performs operation and records changes in the context
- Standard_EXPORT virtual Standard_Boolean Perform (const Handle(ShapeProcess_Context)& context) Standard_OVERRIDE;
+ Standard_EXPORT virtual Standard_Boolean Perform
+ (const Handle(ShapeProcess_Context)& context,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
TopoDS_Shape ShapeProcessAPI_ApplySequence::PrepareShape(const TopoDS_Shape& shape,
const Standard_Boolean /*fillmap*/,
- const TopAbs_ShapeEnum /*until*/)
+ const TopAbs_ShapeEnum /*until*/,
+ const Message_ProgressRange& theProgress)
{
if (shape.IsNull())
return shape;
TCollection_AsciiString str(mySeq);
str += ".exec.op";
if ( rsc->Find ( str.ToCString() ) ) {
- ShapeProcess::Perform ( myContext, mySeq.ToCString() );
+ ShapeProcess::Perform(myContext, mySeq.ToCString(), theProgress);
}
return myContext->Result();
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <TopAbs_ShapeEnum.hxx>
+#include <Message_ProgressRange.hxx>
+
class ShapeProcess_ShapeContext;
class TopoDS_Shape;
-
//! Applies one of the sequence read from resource file.
class ShapeProcessAPI_ApplySequence
{
//! If <fillmap> is True adds history "shape-shape" into myMap
//! for shape and its subshapes until level <until> (included).
//! If <until> is TopAbs_SHAPE, all the subshapes are considered.
- Standard_EXPORT TopoDS_Shape PrepareShape (const TopoDS_Shape& shape, const Standard_Boolean fillmap = Standard_False, const TopAbs_ShapeEnum until = TopAbs_SHAPE);
+ Standard_EXPORT TopoDS_Shape PrepareShape (const TopoDS_Shape& shape,
+ const Standard_Boolean fillmap = Standard_False,
+ const TopAbs_ShapeEnum until = TopAbs_SHAPE,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Clears myMap with accumulated history.
Standard_EXPORT void ClearMap();
void StdLDrivers_DocumentRetrievalDriver::Read (const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& ,
- const Handle(Message_ProgressIndicator)& /*theProgress*/)
+ const Message_ProgressRange& /*theRange*/)
{
// Read header data and persistent document
Storage_HeaderData aHeaderData;
const Handle(Storage_Data)& /*theStorageData*/,
const Handle(CDM_Document)& /*theDoc*/,
const Handle(CDM_Application)& /*theApplication*/,
- const Handle(Message_ProgressIndicator)& /*theProgress*/)
+ const Message_ProgressRange& /*theRange*/)
{
throw Standard_NotImplemented("Reading from stream is not supported by StdLDrivers_DocumentRetrievalDriver");
}
Standard_EXPORT virtual void Read (const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
//! Override pure virtual method (raises exception Standard_NotImplemented)
Standard_EXPORT virtual void Read (Standard_IStream& theIStream,
const Handle(Storage_Data)& theStorageData,
const Handle(CDM_Document)& theDoc,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT (StdLDrivers_DocumentRetrievalDriver, PCDM_RetrievalDriver)
#include <Geom_Surface.hxx>
#include <Interface_Static.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Precision.hxx>
#include <ShapeFix_ShapeTolerance.hxx>
#include <Standard_ErrorHandler.hxx>
done = Standard_False;
}
-// ============================================================================
-// Method : StepToTopoDS_Builder::StepToTopoDS_Builder
-// Purpose : Constructor with a ManifoldSolidBrep
-// ============================================================================
-
-StepToTopoDS_Builder::StepToTopoDS_Builder
-(const Handle(StepShape_ManifoldSolidBrep)& aManifoldSolid,
- const Handle(Transfer_TransientProcess)& TP)
-{
- Init(aManifoldSolid, TP);
-}
-
-// ============================================================================
-// Method : StepToTopoDS_Builder::StepToTopoDS_Builder
-// Purpose : Constructor woth a BrepWithVoids
-// ============================================================================
-
-StepToTopoDS_Builder::StepToTopoDS_Builder
-(const Handle(StepShape_BrepWithVoids)& aBRepWithVoids,
- const Handle(Transfer_TransientProcess)& TP)
-{
- Init(aBRepWithVoids, TP);
-}
-
-// ============================================================================
-// Method : StepToTopoDS_Builder::StepToTopoDS_Builder
-// Purpose : Constructor with a FacetedBrep
-// ============================================================================
-
-StepToTopoDS_Builder::StepToTopoDS_Builder
-(const Handle(StepShape_FacetedBrep)& aFB,
- const Handle(Transfer_TransientProcess)& TP)
-{
- Init(aFB, TP);
-}
-
-// ============================================================================
-// Method : StepToTopoDS_Builder::StepToTopoDS_Builder
-// Purpose : Constructor with a FacetedBrepAndBrepWithVoids
-// ============================================================================
-
-StepToTopoDS_Builder::StepToTopoDS_Builder
-(const Handle(StepShape_FacetedBrepAndBrepWithVoids)& aFBABWV,
- const Handle(Transfer_TransientProcess)& TP)
-{
- Init(aFBABWV, TP);
-}
-
-// ============================================================================
-// Method : StepToTopoDS_Builder::StepToTopoDS_Builder
-// Purpose : Constructor with a ShellBasedSurfaceModel
-// ============================================================================
-
-StepToTopoDS_Builder::StepToTopoDS_Builder
-(const Handle(StepShape_ShellBasedSurfaceModel)& aSBSM,
- const Handle(Transfer_TransientProcess)& TP,
- StepToTopoDS_NMTool& NMTool)
-{
- Init(aSBSM, TP, NMTool);
-}
-
// ============================================================================
// Method : Init
// Purpose : Init with a ManifoldSolidBrep
void StepToTopoDS_Builder::Init
(const Handle(StepShape_ManifoldSolidBrep)& aManifoldSolid,
- const Handle(Transfer_TransientProcess)& TP)
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
Message_Messenger::StreamBuffer sout = TP->Messenger()->SendInfo();
// Initialisation of the Tool
myTranShell.SetMaxTol(MaxTol());
// Non-manifold topology is not referenced by ManifoldSolidBrep (ssv; 14.11.2010)
StepToTopoDS_NMTool dummyNMTool;
- myTranShell.Init(aShell, myTool, dummyNMTool);
+ myTranShell.Init(aShell, myTool, dummyNMTool, theProgress);
if (myTranShell.IsDone()) {
TopoDS_Shape Sh = myTranShell.Value();
void StepToTopoDS_Builder::Init
(const Handle(StepShape_BrepWithVoids)& aBRepWithVoids,
- const Handle(Transfer_TransientProcess)& TP)
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
Message_Messenger::StreamBuffer sout = TP->Messenger()->SendInfo();
// Initialisation of the Tool
BRep_Builder B;
B.MakeSolid(S);
- Message_ProgressSentry PS ( TP->GetProgress(), "Shell", 0, Nb+1, 1 );
+ Message_ProgressScope PS (theProgress, "Shell", Nb+1);
StepToTopoDS_TranslateShell myTranShell;
aCShell = Handle(StepShape_ClosedShell)::DownCast(aBRepWithVoids->Outer());
// Non-manifold topology is not referenced by BrepWithVoids (ssv; 14.11.2010)
StepToTopoDS_NMTool dummyNMTool;
- myTranShell.Init(aCShell, myTool, dummyNMTool);
-
- PS.Next();
+ myTranShell.Init(aCShell, myTool, dummyNMTool, PS.Next());
if (myTranShell.IsDone()) {
Sh = myTranShell.Value();
// Voids
- for (Standard_Integer i=1; i<=Nb && PS.More(); i++, PS.Next()) {
+ for (Standard_Integer i=1; i<=Nb && PS.More(); i++) {
aCShell = aBRepWithVoids->VoidsValue(i);
- myTranShell.Init(aCShell, myTool, dummyNMTool);
+ myTranShell.Init(aCShell, myTool, dummyNMTool, PS.Next());
if (myTranShell.IsDone()) {
Sh = myTranShell.Value();
Sh.Closed(Standard_True);
// ============================================================================
void StepToTopoDS_Builder::Init(const Handle(StepShape_FacetedBrep)& aFB,
- const Handle(Transfer_TransientProcess)& TP)
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
// Initialisation of the Tool
myTranShell.SetMaxTol(MaxTol());
// Non-manifold topology is not referenced by FacetedBrep (ss; 14.11.2010)
StepToTopoDS_NMTool dummyNMTool;
- myTranShell.Init(aCShell, myTool, dummyNMTool);
+ myTranShell.Init(aCShell, myTool, dummyNMTool, theProgress);
if (myTranShell.IsDone()) {
Sh = myTranShell.Value();
void StepToTopoDS_Builder::Init
(const Handle(StepShape_FacetedBrepAndBrepWithVoids)& aFBABWV,
- const Handle(Transfer_TransientProcess)& TP)
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
// Initialisation of the Tool
aCShell = Handle(StepShape_ClosedShell)::DownCast(aFBABWV->Outer());
TopoDS_Shape Sh;
+ Message_ProgressScope aPSRoot(theProgress, NULL, 2);
+
StepToTopoDS_TranslateShell myTranShell;
myTranShell.SetPrecision(Precision()); //gka
myTranShell.SetMaxTol(MaxTol());
// Non-manifold topology is not referenced by FacetedBrepAndBrepWithVoids (ss; 14.11.2010)
StepToTopoDS_NMTool dummyNMTool;
- myTranShell.Init(aCShell, myTool, dummyNMTool);
+ myTranShell.Init(aCShell, myTool, dummyNMTool, aPSRoot.Next());
if (myTranShell.IsDone()) {
Sh = myTranShell.Value();
B.Add(S,Sh);
Standard_Integer Nb, i;
Nb = aFBABWV->NbVoids();
- for ( i=1; i<=Nb; i++ ) {
+ Message_ProgressScope aPS (aPSRoot.Next(), NULL, Nb);
+ for ( i=1; i<=Nb && aPS.More(); i++) {
aCShell = aFBABWV->VoidsValue(i);
- myTranShell.Init(aCShell, myTool, dummyNMTool);
+ myTranShell.Init(aCShell, myTool, dummyNMTool, aPS.Next());
if (myTranShell.IsDone()) {
Sh = myTranShell.Value();
Sh.Closed(Standard_True);
void StepToTopoDS_Builder::Init
(const Handle(StepShape_ShellBasedSurfaceModel)& aSBSM,
const Handle(Transfer_TransientProcess)& TP,
- StepToTopoDS_NMTool& NMTool)
+ StepToTopoDS_NMTool& NMTool,
+ const Message_ProgressRange& theProgress)
{
Message_Messenger::StreamBuffer sout = TP->Messenger()->SendInfo();
// Initialisation of the Tool
myTranShell.SetPrecision(Precision());
myTranShell.SetMaxTol(MaxTol());
- Message_ProgressSentry PS ( TP->GetProgress(), "Shell", 0, Nb, 1 );
- for (Standard_Integer i = 1; i <= Nb && PS.More(); i++, PS.Next()) {
+ Message_ProgressScope PS ( theProgress, "Shell", Nb);
+ for (Standard_Integer i = 1; i <= Nb && PS.More(); i++)
+ {
+ Message_ProgressRange aRange = PS.Next();
aShell = aSBSM->SbsmBoundaryValue(i);
aOpenShell = aShell.OpenShell();
aClosedShell = aShell.ClosedShell();
if (!aOpenShell.IsNull()) {
- myTranShell.Init(aOpenShell, myTool, NMTool);
+ myTranShell.Init(aOpenShell, myTool, NMTool, aRange);
if (myTranShell.IsDone()) {
Shl = TopoDS::Shell(myTranShell.Value());
Shl.Closed(Standard_False);
}
}
else if (!aClosedShell.IsNull()) {
- myTranShell.Init(aClosedShell, myTool, NMTool);
+ myTranShell.Init(aClosedShell, myTool, NMTool, aRange);
if (myTranShell.IsDone()) {
Shl = TopoDS::Shell(myTranShell.Value());
Shl.Closed(Standard_True);
(const Handle(StepShape_GeometricSet)& GCS,
const Handle(Transfer_TransientProcess)& TP,
const Handle(Transfer_ActorOfTransientProcess)& RA,
- const Standard_Boolean isManifold)
+ const Standard_Boolean isManifold,
+ const Message_ProgressRange& theProgress)
{
// Start Mapping
TopoDS_Compound S;
Standard_Real preci = Precision(); //gka
Standard_Real maxtol = MaxTol();
Standard_Integer nbElem = GCS->NbElements();
- for (i = 1; i <= nbElem ; i++) {
+ Message_ProgressScope aPS(theProgress, NULL, nbElem);
+ for (i = 1; i <= nbElem && aPS.More(); i++)
+ {
+ Message_ProgressRange aRange = aPS.Next();
StepShape_GeometricSetSelect aGSS = GCS->ElementsValue(i);
Handle(Standard_Transient) ent = aGSS.Value();
Handle(STEPControl_ActorRead) anActor = Handle(STEPControl_ActorRead)::DownCast(RA);
Handle(Transfer_Binder) binder;
if( !anActor.IsNull())
- binder = anActor->TransferShape(GRI, TP, isManifold);
+ binder = anActor->TransferShape(GRI, TP, isManifold, Standard_False, aRange);
if (!binder.IsNull())
{
res = TransferBRep::ShapeResult(binder);
#include <TopoDS_Shape.hxx>
#include <StepToTopoDS_Root.hxx>
#include <Standard_Boolean.hxx>
+#include <Message_ProgressRange.hxx>
+
class StdFail_NotDone;
class StepShape_ManifoldSolidBrep;
class Transfer_TransientProcess;
Standard_EXPORT StepToTopoDS_Builder();
- Standard_EXPORT StepToTopoDS_Builder(const Handle(StepShape_ManifoldSolidBrep)& S, const Handle(Transfer_TransientProcess)& TP);
-
- Standard_EXPORT StepToTopoDS_Builder(const Handle(StepShape_BrepWithVoids)& S, const Handle(Transfer_TransientProcess)& TP);
-
- Standard_EXPORT StepToTopoDS_Builder(const Handle(StepShape_FacetedBrep)& S, const Handle(Transfer_TransientProcess)& TP);
-
- Standard_EXPORT StepToTopoDS_Builder(const Handle(StepShape_FacetedBrepAndBrepWithVoids)& S, const Handle(Transfer_TransientProcess)& TP);
-
- Standard_EXPORT StepToTopoDS_Builder(const Handle(StepShape_ShellBasedSurfaceModel)& S, const Handle(Transfer_TransientProcess)& TP, StepToTopoDS_NMTool& NMTool);
-
- Standard_EXPORT StepToTopoDS_Builder(const Handle(StepShape_GeometricSet)& S, const Handle(Transfer_TransientProcess)& TP);
-
- Standard_EXPORT void Init (const Handle(StepShape_ManifoldSolidBrep)& S, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT void Init (const Handle(StepShape_ManifoldSolidBrep)& S,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void Init (const Handle(StepShape_BrepWithVoids)& S, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT void Init (const Handle(StepShape_BrepWithVoids)& S,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void Init (const Handle(StepShape_FacetedBrep)& S, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT void Init (const Handle(StepShape_FacetedBrep)& S,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void Init (const Handle(StepShape_FacetedBrepAndBrepWithVoids)& S, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT void Init (const Handle(StepShape_FacetedBrepAndBrepWithVoids)& S,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void Init (const Handle(StepShape_ShellBasedSurfaceModel)& S, const Handle(Transfer_TransientProcess)& TP, StepToTopoDS_NMTool& NMTool);
+ Standard_EXPORT void Init (const Handle(StepShape_ShellBasedSurfaceModel)& S,
+ const Handle(Transfer_TransientProcess)& TP,
+ StepToTopoDS_NMTool& NMTool,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void Init (const Handle(StepShape_EdgeBasedWireframeModel)& S, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT void Init (const Handle(StepShape_EdgeBasedWireframeModel)& S,
+ const Handle(Transfer_TransientProcess)& TP);
- Standard_EXPORT void Init (const Handle(StepShape_FaceBasedSurfaceModel)& S, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT void Init (const Handle(StepShape_FaceBasedSurfaceModel)& S,
+ const Handle(Transfer_TransientProcess)& TP);
- Standard_EXPORT void Init (const Handle(StepShape_GeometricSet)& S, const Handle(Transfer_TransientProcess)& TP, const Handle(Transfer_ActorOfTransientProcess)& RA = NULL, const Standard_Boolean isManifold = Standard_False);
+ Standard_EXPORT void Init (const Handle(StepShape_GeometricSet)& S,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Handle(Transfer_ActorOfTransientProcess)& RA = NULL,
+ const Standard_Boolean isManifold = Standard_False,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const TopoDS_Shape& Value() const;
TopoDS_Shape StepToTopoDS_MakeTransformed::TranslateMappedItem
(const Handle(StepRepr_MappedItem)& mapit,
- const Handle(Transfer_TransientProcess)& TP)
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
TopoDS_Shape theResult;
// La Shape, et la mise en position
Handle(StepRepr_Representation) maprep = mapit->MappingSource()->MappedRepresentation();
Handle(Transfer_Binder) binder = TP->Find(maprep);
- if (binder.IsNull()) binder = TP->Transferring(maprep);
+ if (binder.IsNull()) binder = TP->Transferring(maprep, theProgress);
Handle(TransferBRep_ShapeBinder) shbinder =
Handle(TransferBRep_ShapeBinder)::DownCast(binder);
if (shbinder.IsNull()) TP->AddWarning(mapit,"No Shape Produced");
#include <gp_Trsf.hxx>
#include <StepToTopoDS_Root.hxx>
#include <Standard_Boolean.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepGeom_Axis2Placement3d;
class StepGeom_CartesianTransformationOperator3d;
class gp_Trsf;
class StepRepr_MappedItem;
class Transfer_TransientProcess;
-
//! Produces instances by Transformation of a basic item
class StepToTopoDS_MakeTransformed : public StepToTopoDS_Root
{
//! Hence, the transformation from MappingOrigin and MappingTarget
//! is computed, the MappedRepr. is converted to a Shape, then
//! transformed as an instance of this Shape
- Standard_EXPORT TopoDS_Shape TranslateMappedItem (const Handle(StepRepr_MappedItem)& mapit, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT TopoDS_Shape TranslateMappedItem (const Handle(StepRepr_MappedItem)& mapit,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//: gka 09.04.99: S4136: improving tolerance management
#include <BRep_Builder.hxx>
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_ConnectedFaceSet.hxx>
#include <StepShape_FaceSurface.hxx>
done = Standard_False;
}
-// ============================================================================
-// Method : StepToTopoDS_TranslateShell::StepToTopoDS_TranslateShell()
-// Purpose : Constructor with a ConnectedFaceSet and a Tool
-// ============================================================================
-
-StepToTopoDS_TranslateShell::StepToTopoDS_TranslateShell
-(const Handle(StepShape_ConnectedFaceSet)& CFS, StepToTopoDS_Tool& T, StepToTopoDS_NMTool& NMTool)
-{
- Init(CFS, T, NMTool);
-}
-
// ============================================================================
// Method : Init
// Purpose : Init with a ConnectedFaceSet and a Tool
// ============================================================================
void StepToTopoDS_TranslateShell::Init
-(const Handle(StepShape_ConnectedFaceSet)& CFS, StepToTopoDS_Tool& aTool, StepToTopoDS_NMTool& NMTool)
+(const Handle(StepShape_ConnectedFaceSet)& CFS,
+ StepToTopoDS_Tool& aTool,
+ StepToTopoDS_NMTool& NMTool,
+ const Message_ProgressRange& theProgress)
{
//bug15697
if(CFS.IsNull())
myTranFace.SetPrecision(Precision()); //gka
myTranFace.SetMaxTol(MaxTol());
- Message_ProgressSentry PS ( TP->GetProgress(), "Face", 0, NbFc, 1 );
+ Message_ProgressScope PS ( theProgress, "Face", NbFc);
for (Standard_Integer i = 1; i <= NbFc && PS.More(); i++, PS.Next()) {
#ifdef OCCT_DEBUG
std::cout << "Processing Face : " << i << std::endl;
#include <StepToTopoDS_TranslateShellError.hxx>
#include <TopoDS_Shape.hxx>
#include <StepToTopoDS_Root.hxx>
+#include <Message_ProgressRange.hxx>
+
class StdFail_NotDone;
class StepShape_ConnectedFaceSet;
class StepToTopoDS_Tool;
Standard_EXPORT StepToTopoDS_TranslateShell();
- Standard_EXPORT StepToTopoDS_TranslateShell(const Handle(StepShape_ConnectedFaceSet)& CFS, StepToTopoDS_Tool& T, StepToTopoDS_NMTool& NMTool);
-
- Standard_EXPORT void Init (const Handle(StepShape_ConnectedFaceSet)& CFS, StepToTopoDS_Tool& T, StepToTopoDS_NMTool& NMTool);
+ Standard_EXPORT void Init (const Handle(StepShape_ConnectedFaceSet)& CFS,
+ StepToTopoDS_Tool& T,
+ StepToTopoDS_NMTool& NMTool,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const TopoDS_Shape& Value() const;
//=============================================================================
Standard_Boolean StlAPI_Writer::Write (const TopoDS_Shape& theShape,
const Standard_CString theFileName,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theProgress)
{
Standard_Integer aNbNodes = 0;
Standard_Integer aNbTriangles = 0;
#ifndef _StlAPI_Writer_HeaderFile
#define _StlAPI_Writer_HeaderFile
-#include <Poly_Triangulation.hxx>
-#include <Standard.hxx>
-#include <Standard_DefineAlloc.hxx>
-#include <Standard_Handle.hxx>
-#include <Standard_Boolean.hxx>
-#include <Standard_CString.hxx>
+#include <Message_ProgressScope.hxx>
#include <Message_ProgressIndicator.hxx>
class TopoDS_Shape;
//! \return the error state.
Standard_EXPORT Standard_Boolean Write (const TopoDS_Shape& theShape,
const Standard_CString theFileName,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
private:
Standard_Boolean myASCIIMode;
#include <TDocStd_PathParser.hxx>
#include <OSD_Thread.hxx>
-#include<Message_ProgressSentry.hxx>
-
IMPLEMENT_STANDARD_RTTIEXT(TDocStd_Application,CDF_Application)
// TDocStd_Owner attribute have pointer of closed TDocStd_Document
//purpose :
//=======================================================================
-PCDM_ReaderStatus TDocStd_Application::Open(const TCollection_ExtendedString& path,
- Handle(TDocStd_Document)& aDoc,
- const Handle(Message_ProgressIndicator)& theProgress)
+PCDM_ReaderStatus TDocStd_Application::Open (const TCollection_ExtendedString& path,
+ Handle(TDocStd_Document)& aDoc,
+ const Message_ProgressRange& theRange)
{
PCDM_ReaderStatus status = PCDM_RS_DriverFailure;
TDocStd_PathParser tool (path);
{
OCC_CATCH_SIGNALS
Handle(TDocStd_Document) D =
- Handle(TDocStd_Document)::DownCast(Retrieve(directory, file, Standard_True, theProgress));
+ Handle(TDocStd_Document)::DownCast(Retrieve(directory, file, Standard_True, theRange));
CDF_Application::Open(D);
aDoc = D;
}
//function : Open
//purpose :
//=======================================================================
-PCDM_ReaderStatus TDocStd_Application::Open(Standard_IStream& theIStream,
- Handle(TDocStd_Document)& theDoc,
- const Handle(Message_ProgressIndicator)& theProgress)
+PCDM_ReaderStatus TDocStd_Application::Open (Standard_IStream& theIStream,
+ Handle(TDocStd_Document)& theDoc,
+ const Message_ProgressRange& theRange)
{
try
{
OCC_CATCH_SIGNALS
- Handle(TDocStd_Document) D = Handle(TDocStd_Document)::DownCast(Read(theIStream, theProgress));
+ Handle(TDocStd_Document) D = Handle(TDocStd_Document)::DownCast(Read(theIStream, theRange));
if (!D.IsNull())
{
//purpose :
//=======================================================================
-PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,
- const TCollection_ExtendedString& path,
- const Handle(Message_ProgressIndicator)& theProgress)
+PCDM_StoreStatus TDocStd_Application::SaveAs (const Handle(TDocStd_Document)& D,
+ const TCollection_ExtendedString& path,
+ const Message_ProgressRange& theRange)
{
TDocStd_PathParser tool (path);
TCollection_ExtendedString directory = tool.Trek();
storer.SetName (file);
try {
OCC_CATCH_SIGNALS
- storer.Realize (theProgress);
+ storer.Realize (theRange);
}
catch (Standard_Failure const& anException) {
if (!MessageDriver().IsNull()) {
//=======================================================================
PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& theDoc,
Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
try
{
}
aDocStorageDriver->SetFormat(theDoc->StorageFormat());
- aDocStorageDriver->Write(theDoc, theOStream, theProgress);
+ aDocStorageDriver->Write(theDoc, theOStream, theRange);
if (aDocStorageDriver->GetStoreStatus() == PCDM_SS_OK)
{
//=======================================================================
PCDM_StoreStatus TDocStd_Application::Save (const Handle(TDocStd_Document)& D,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
PCDM_StoreStatus status = PCDM_SS_OK;
if (D->IsSaved()) {
CDF_Store storer (D);
try{
OCC_CATCH_SIGNALS
- storer.Realize (theProgress);
+ storer.Realize (theRange);
}
catch (Standard_Failure const& anException) {
if (!MessageDriver().IsNull()) {
PCDM_StoreStatus TDocStd_Application::SaveAs(const Handle(TDocStd_Document)& D,
const TCollection_ExtendedString& path,
TCollection_ExtendedString& theStatusMessage,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
TDocStd_PathParser tool (path);
PCDM_StoreStatus aStatus = PCDM_SS_Failure;
storer.SetName (file);
try {
OCC_CATCH_SIGNALS
- storer.Realize (theProgress);
+ storer.Realize (theRange);
}
catch (Standard_Failure const& anException) {
if (!MessageDriver().IsNull()) {
PCDM_StoreStatus TDocStd_Application::SaveAs (const Handle(TDocStd_Document)& theDoc,
Standard_OStream& theOStream,
TCollection_ExtendedString& theStatusMessage,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
try
{
}
aDocStorageDriver->SetFormat(theDoc->StorageFormat());
- aDocStorageDriver->Write(theDoc, theOStream, theProgress);
+ aDocStorageDriver->Write(theDoc, theOStream, theRange);
if (aDocStorageDriver->GetStoreStatus() == PCDM_SS_OK)
{
//=======================================================================
PCDM_StoreStatus TDocStd_Application::Save (const Handle(TDocStd_Document)& D,
- TCollection_ExtendedString& theStatusMessage,
- const Handle(Message_ProgressIndicator)& theProgress)
+ TCollection_ExtendedString& theStatusMessage,
+ const Message_ProgressRange& theRange)
{
PCDM_StoreStatus status = PCDM_SS_OK;
if (D->IsSaved()) {
CDF_Store storer (D);
try {
OCC_CATCH_SIGNALS
- storer.Realize (theProgress);
+ storer.Realize (theRange);
}
catch (Standard_Failure const& anException) {
if (!MessageDriver().IsNull()) {
//! to depend on the value returned by IsInSession.
Standard_EXPORT PCDM_ReaderStatus Open (const TCollection_ExtendedString& path,
Handle(TDocStd_Document)& aDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Retrieves aDoc from standard SEEKABLE stream theIStream.
//! the stream should support SEEK fuctionality
Standard_EXPORT PCDM_ReaderStatus Open (Standard_IStream& theIStream, Handle(TDocStd_Document)& theDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Save the active document in the file <name> in the
//! path <path> ; o verwrites the file if it already exists.
Standard_EXPORT PCDM_StoreStatus SaveAs (const Handle(TDocStd_Document)& aDoc,
const TCollection_ExtendedString& path,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Save theDoc to standard SEEKABLE stream theOStream.
//! the stream should support SEEK fuctionality
Standard_EXPORT PCDM_StoreStatus SaveAs (const Handle(TDocStd_Document)& theDoc,
Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Save aDoc active document.
//! Exceptions:
//! Standard_NotImplemented if the document
//! was not retrieved in the applicative session by using Open.
Standard_EXPORT PCDM_StoreStatus Save (const Handle(TDocStd_Document)& aDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Save the active document in the file <name> in the
//! path <path> . overwrite the file if it
Standard_EXPORT PCDM_StoreStatus SaveAs (const Handle(TDocStd_Document)& aDoc,
const TCollection_ExtendedString& path,
TCollection_ExtendedString& theStatusMessage,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Save theDoc TO standard SEEKABLE stream theOStream.
//! the stream should support SEEK fuctionality
Standard_EXPORT PCDM_StoreStatus SaveAs (const Handle(TDocStd_Document)& theDoc,
Standard_OStream& theOStream,
TCollection_ExtendedString& theStatusMessage,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Save the document overwriting the previous file
Standard_EXPORT PCDM_StoreStatus Save (const Handle(TDocStd_Document)& aDoc,
TCollection_ExtendedString& theStatusMessage,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Notification that is fired at each OpenTransaction event.
Standard_EXPORT virtual void OnOpenTransaction (const Handle(TDocStd_Document)& theDoc);
#include <GeomTools.hxx>
#include <gp_Ax3.hxx>
#include <gp_Vec.hxx>
-#include <Message_ProgressSentry.hxx>
#include <Precision.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Stream.hxx>
+#include <Message_ProgressScope.hxx>
#include <TopLoc_Location.hxx>
#include <TopTools_LocationSet.hxx>
//purpose :
//=======================================================================
-void TopTools_LocationSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator) &theProgress) const
+void TopTools_LocationSet::Write(Standard_OStream& OS, const Message_ProgressRange& theProgress) const
{
std::streamsize prec = OS.precision(15);
OS << "Locations " << nbLoc << "\n";
//OCC19559
- Message_ProgressSentry PS(theProgress, "Locations", 0, nbLoc, 1);
+ Message_ProgressScope PS(theProgress, "Locations", nbLoc);
for (i = 1; i <= nbLoc && PS.More(); i++, PS.Next()) {
TopLoc_Location L = myMap(i);
//purpose :
//=======================================================================
-void TopTools_LocationSet::Read (Standard_IStream& IS, const Handle(Message_ProgressIndicator) &theProgress)
+void TopTools_LocationSet::Read(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
myMap.Clear();
gp_Trsf T;
//OCC19559
- Message_ProgressSentry PS(theProgress, "Locations", 0, nbLoc, 1);
+ Message_ProgressScope PS(theProgress, "Locations", nbLoc);
for (i = 1; i <= nbLoc&& PS.More(); i++, PS.Next()) {
Standard_Integer typLoc;
IS >> typLoc;
#include <Standard_Integer.hxx>
#include <Standard_OStream.hxx>
#include <Standard_IStream.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class Standard_OutOfRange;
class TopLoc_Location;
//!
//! It can create Locations.
//!
-//! It can be written and read from a stream.
+//! It can be write and read from a stream.
class TopTools_LocationSet
{
public:
//! Writes the content of me on the stream <OS> in a
//! format that can be read back by Read.
Standard_EXPORT void Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) const;
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
Standard_EXPORT void Read (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
private:
// authentification we cut last '\r' in the line (which will
// be present if file is in DOS coding)
-#include <Message_ProgressIndicator.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <TCollection_AsciiString.hxx>
#include <TopoDS_Iterator.hxx>
#include <TopoDS_Shape.hxx>
//purpose :
//=======================================================================
-void TopTools_ShapeSet::Write (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator) &theProgress)
+void TopTools_ShapeSet::Write(Standard_OStream& OS, const Message_ProgressRange& theProgress)
{
// always use C locale for writing shapes
std::locale anOldLocale = OS.imbue (std::locale::classic());
//-----------------------------------------
// write the locations
//-----------------------------------------
- Message_ProgressSentry aPS(theProgress, "Writing Shapes", 0, 3, 1);
- myLocations.Write(OS, theProgress);
- if (!aPS.More())
+
+ Message_ProgressScope aPS(theProgress, "Writing", 100);
+
+ myLocations.Write(OS, aPS.Next(10));
+
+ if (aPS.UserBreak()) {
+ OS << "Interrupted by the user\n";
+ OS.imbue (anOldLocale);
return;
- aPS.Next();
+ }
//-----------------------------------------
// write the geometry
//-----------------------------------------
- WriteGeometry(OS, theProgress);
- if (!aPS.More())
+ WriteGeometry(OS, aPS.Next(75));
+
+ if (aPS.UserBreak()) {
+ OS << "Interrupted by the user\n";
+ OS.imbue(anOldLocale);
return;
- aPS.Next();
+ }
//-----------------------------------------
// write the shapes
OS << "\nTShapes " << nbShapes << "\n";
// subshapes are written first
- //OCC19559
- Message_ProgressSentry aPSinner(theProgress, "Shapes", 0, nbShapes, 1);
- for (i = 1; i <= nbShapes && aPSinner.More(); i++, aPSinner.Next()) {
+ Message_ProgressScope aPS1 (aPS.Next(15), "Shapes", nbShapes);
+ for (i = 1; i <= nbShapes && aPS1.More(); i++, aPS1.Next()) {
const TopoDS_Shape& S = myShapes(i);
// Type
OS << "\n";
OS.precision(prec);
OS.imbue (anOldLocale);
-}
+
+ if (aPS.UserBreak())
+ OS << "Interrupted by the user\n";
+ }
//=======================================================================
//function : ReadShapeEnum
//purpose :
//=======================================================================
-void TopTools_ShapeSet::Read (Standard_IStream& IS, const Handle(Message_ProgressIndicator) &theProgress)
+void TopTools_ShapeSet::Read(Standard_IStream& IS, const Message_ProgressRange& theProgress)
{
// always use C locale for reading shapes
std::locale anOldLocale = IS.imbue (std::locale::classic());
// read the locations
//-----------------------------------------
- //OCC19559
- Message_ProgressSentry aPS(theProgress, "Reading", 0, 10, 3);
- myLocations.Read(IS, theProgress);
- if (!aPS.More())
+ Message_ProgressScope aPS(theProgress, "Reading", 100);
+
+ myLocations.Read(IS, aPS.Next(10));
+
+ if (aPS.UserBreak()) {
+ std::cout << "Interrupted by the user"<<std::endl;
+ // on remet le LC_NUMERIC a la precedente valeur
+ IS.imbue (anOldLocale);
return;
- aPS.Next();
+ }
+
//-----------------------------------------
// read the geometry
//-----------------------------------------
- ReadGeometry(IS, theProgress);
- if (!aPS.More())
+ ReadGeometry(IS, aPS.Next(75));
+
+ if (aPS.UserBreak()) {
+ std::cout << "Interrupted by the user"<<std::endl;
+ IS.imbue(anOldLocale);
return;
- aPS.Next();
+ }
//-----------------------------------------
// read the shapes
IS >> nbShapes;
//OCC19559
-
- Message_ProgressSentry PS(theProgress, "Shapes", 0, nbShapes, 1);
- for (i = 1; i <= nbShapes && PS.More(); i++, PS.Next() ) {
+ Message_ProgressScope aPS1 (aPS.Next(15), "Shapes", nbShapes);
+ for (i = 1; i <= nbShapes && aPS1.More(); i++, aPS1.Next() ) {
TopoDS_Shape S;
//Read type and create empty shape.
myShapes.Add(S);
}
+
// on remet le LC_NUMERIC a la precedente valeur
IS.imbue (anOldLocale);
+
+ if (aPS.UserBreak())
+ std::cout << "Interrupted by the user" << std::endl;
}
//=======================================================================
//purpose :
//=======================================================================
-void TopTools_ShapeSet::Write (const TopoDS_Shape& S, Standard_OStream& OS)const
+void TopTools_ShapeSet::Write(const TopoDS_Shape& S,
+ Standard_OStream& OS)const
{
if (S.IsNull()) OS << "*";
else {
//purpose :
//=======================================================================
-void TopTools_ShapeSet::Read (TopoDS_Shape& S, Standard_IStream& IS)const
+void TopTools_ShapeSet::Read(TopoDS_Shape& S,
+ Standard_IStream& IS)const
{
Read(S,IS,myShapes.Extent());
}
//purpose :
//=======================================================================
-void TopTools_ShapeSet::WriteGeometry (Standard_OStream&,
- const Handle(Message_ProgressIndicator) &)
+void TopTools_ShapeSet::WriteGeometry(Standard_OStream&, const Message_ProgressRange&)
{
}
//purpose :
//=======================================================================
-void TopTools_ShapeSet::ReadGeometry (Standard_IStream&,
- const Handle(Message_ProgressIndicator) &)
+void TopTools_ShapeSet::ReadGeometry(Standard_IStream&, const Message_ProgressRange&)
{
}
//purpose :
//=======================================================================
-void TopTools_ShapeSet::WriteGeometry (const TopoDS_Shape&, Standard_OStream&)const
+void TopTools_ShapeSet::WriteGeometry(const TopoDS_Shape&,
+ Standard_OStream&)const
{
}
//purpose :
//=======================================================================
-void TopTools_ShapeSet::ReadGeometry (const TopAbs_ShapeEnum, Standard_IStream&, TopoDS_Shape&)
+void TopTools_ShapeSet::ReadGeometry(const TopAbs_ShapeEnum,
+ Standard_IStream& ,
+ TopoDS_Shape&)
{
}
//! A ShapeSets contains a Shape and all its
-//! sub-shapes and locations. It can be dumped, written
+//! sub-shapes and locations. It can be dump, write
//! and read.
//!
//! Methods to handle the geometry can be redefined.
DEFINE_STANDARD_ALLOC
+
//! Builds an empty ShapeSet.
Standard_EXPORT TopTools_ShapeSet();
//! Write the type.
//! calls WriteGeometry(S).
//! Write the flags, the subshapes.
- Standard_EXPORT virtual void Write
- (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ Standard_EXPORT virtual void Write (Standard_OStream& OS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads the content of me from the stream <IS>. me
//! is first cleared.
//! Reads the type.
//! calls ReadGeometry(T,S).
//! Reads the flag, the subshapes.
- Standard_EXPORT virtual void Read
- (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ Standard_EXPORT virtual void Read (Standard_IStream& IS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Dumps on <OS> the shape <S>. Dumps the
//! orientation, the index of the TShape and the index
//! Writes the geometry of me on the stream <OS> in a
//! format that can be read back by Read.
- Standard_EXPORT virtual void WriteGeometry
- (Standard_OStream& OS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ Standard_EXPORT virtual void WriteGeometry (Standard_OStream& OS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Reads the geometry of me from the stream <IS>.
- Standard_EXPORT virtual void ReadGeometry
- (Standard_IStream& IS,
- const Handle(Message_ProgressIndicator) &theProgress = NULL);
+ Standard_EXPORT virtual void ReadGeometry (Standard_IStream& IS,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Dumps the geometry of <S> on the stream <OS>.
Standard_EXPORT virtual void DumpGeometry (const TopoDS_Shape& S, Standard_OStream& OS) const;
Standard_EXPORT Standard_Integer NbShapes() const;
private:
-
+
//! Reads from <IS> a shape and returns it in S.
//! <NbShapes> is the number of tshapes in the set.
Standard_EXPORT void Read (TopoDS_Shape& S, Standard_IStream& IS, const Standard_Integer NbShapes) const;
+
TopTools_IndexedMapOfShape myShapes;
TopTools_LocationSet myLocations;
Standard_Integer myFormatNb;
+
};
#endif // _TopTools_ShapeSet_HeaderFile
// commercial license or contractual agreement.
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressScope.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_ClosedShell.hxx>
#include <StepShape_ConnectedFaceSet.hxx>
TopoDSToStep_Builder::TopoDSToStep_Builder
(const TopoDS_Shape& aShape,
- TopoDSToStep_Tool& aTool, const Handle(Transfer_FinderProcess)& FP)
+ TopoDSToStep_Tool& aTool,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False;
- Init(aShape, aTool, FP);
+ Init(aShape, aTool, FP, theProgress);
}
// ============================================================================
void TopoDSToStep_Builder::Init(const TopoDS_Shape& aShape,
TopoDSToStep_Tool& myTool,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
if (myTool.IsBound(aShape)) {
return;
}
- Handle(Message_ProgressIndicator) progress = FP->GetProgress();
-
switch (aShape.ShapeType())
{
case TopAbs_SHELL:
- TopExp_Explorer myExp(myShell, TopAbs_FACE);
+ TopExp_Explorer anExp;
TopoDSToStep_MakeStepFace MkFace;
- for (;myExp.More();myExp.Next()) {
-
- const TopoDS_Face Face = TopoDS::Face(myExp.Current());
+ Standard_Integer nbshapes = 0;
+ for (anExp.Init(myShell, TopAbs_FACE); anExp.More(); anExp.Next())
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+ for (anExp.Init(myShell, TopAbs_FACE); anExp.More() && aPS.More(); anExp.Next(), aPS.Next())
+ {
+ const TopoDS_Face Face = TopoDS::Face(anExp.Current());
- MkFace.Init(Face, myTool, FP);
+ MkFace.Init(Face, myTool, FP);
if (MkFace.IsDone()) {
FS = Handle(StepShape_FaceSurface)::DownCast(MkFace.Value());
// new TransferBRep_ShapeMapper(Face);
// FP->AddWarning(errShape, " a Face from a Shell has not been mapped");
}
- if (!progress.IsNull()) progress->Increment();
}
+ if (!aPS.More())
+ return;
Standard_Integer nbFaces = mySeq.Length();
if ( nbFaces >= 1) {
// FP->AddWarning(errShape, " the Face has not been mapped");
done = Standard_False;
}
- if (!progress.IsNull()) progress->Increment();
break;
}
default: break;
#include <TopoDSToStep_BuilderError.hxx>
#include <TopoDSToStep_Root.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepShape_TopologicalRepresentationItem;
class StdFail_NotDone;
class TopoDS_Shape;
Standard_EXPORT TopoDSToStep_Builder();
- Standard_EXPORT TopoDSToStep_Builder(const TopoDS_Shape& S, TopoDSToStep_Tool& T, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_Builder(const TopoDS_Shape& S,
+ TopoDSToStep_Tool& T,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT void Init (const TopoDS_Shape& S, TopoDSToStep_Tool& T, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT void Init (const TopoDS_Shape& S,
+ TopoDSToStep_Tool& T,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT TopoDSToStep_BuilderError Error() const;
#include <BRepClass3d.hxx>
+#include <Message_ProgressScope.hxx>
#include <MoniTool_DataMapOfShapeTransient.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_BrepWithVoids.hxx>
TopoDSToStep_MakeBrepWithVoids::
TopoDSToStep_MakeBrepWithVoids(const TopoDS_Solid& aSolid,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False ;
TopoDS_Iterator It;
TopoDSToStep_Tool aTool;
if (!aOutShell.IsNull()) {
- It.Initialize(aSolid);
- for ( ; It.More(); It.Next() ) {
+ Standard_Integer nbshapes = 0;
+ for (It.Initialize(aSolid); It.More(); It.Next())
+ if (It.Value().ShapeType() == TopAbs_SHELL)
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+ for (It.Initialize(aSolid); It.More() && aPS.More(); It.Next())
+ {
if (It.Value().ShapeType() == TopAbs_SHELL) {
TopoDS_Shell CurrentShell = TopoDS::Shell(It.Value());
if ( ! aOutShell.IsEqual(CurrentShell) ) //:e0 abv 25 Mar 98: voids should be reversed according to EXPRESS for ABSR
//:d7 abv 16 Mar 98: try to treat 'open' shells as closed since flag
// IsClosed() is often incorrect (taken from MakeManifoldSolid(Solid))
aTool.Init(aMap, Standard_False);
- StepB.Init(CurrentShell, aTool, FP);
+ StepB.Init(CurrentShell, aTool, FP, aPS.Next());
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
aCShell = Handle(StepShape_ClosedShell)::DownCast(StepB.Value());
*/
}
}
+ if (!aPS.More())
+ return;
+
Standard_Integer N = S.Length();
if ( N>=1 ) {
Handle(TCollection_HAsciiString) aName =
#include <Standard_Handle.hxx>
#include <TopoDSToStep_Root.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepShape_BrepWithVoids;
class StdFail_NotDone;
class TopoDS_Solid;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT TopoDSToStep_MakeBrepWithVoids(const TopoDS_Solid& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeBrepWithVoids(const TopoDS_Solid& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const Handle(StepShape_BrepWithVoids)& Value() const;
#include <BRepClass3d.hxx>
+#include <Message_ProgressScope.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_ClosedShell.hxx>
#include <StepShape_FacetedBrep.hxx>
//=============================================================================
TopoDSToStep_MakeFacetedBrep::
TopoDSToStep_MakeFacetedBrep(const TopoDS_Shell& aShell,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False;
if (aShell.Closed()) {
MoniTool_DataMapOfShapeTransient aMap;
TopoDSToStep_Tool aTool(aMap, Standard_True);
- TopoDSToStep_Builder StepB(aShell, aTool, FP);
+ TopoDSToStep_Builder StepB(aShell, aTool, FP, theProgress);
+ if (theProgress.UserBreak())
+ return;
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
TopoDSToStep_MakeFacetedBrep::
TopoDSToStep_MakeFacetedBrep(const TopoDS_Solid& aSolid,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False;
MoniTool_DataMapOfShapeTransient aMap;
TopoDSToStep_Tool aTool(aMap, Standard_True);
- TopoDSToStep_Builder StepB(aOuterShell, aTool, FP);
+ TopoDSToStep_Builder StepB(aOuterShell, aTool, FP, theProgress);
+ if (theProgress.UserBreak())
+ return;
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
#include <Standard_Handle.hxx>
#include <TopoDSToStep_Root.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepShape_FacetedBrep;
class StdFail_NotDone;
class TopoDS_Shell;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT TopoDSToStep_MakeFacetedBrep(const TopoDS_Shell& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeFacetedBrep(const TopoDS_Shell& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT TopoDSToStep_MakeFacetedBrep(const TopoDS_Solid& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeFacetedBrep(const TopoDS_Solid& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const Handle(StepShape_FacetedBrep)& Value() const;
#include <BRepClass3d.hxx>
+#include <Message_ProgressScope.hxx>
#include <MoniTool_DataMapOfShapeTransient.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_ClosedShell.hxx>
//=============================================================================
TopoDSToStep_MakeFacetedBrepAndBrepWithVoids::
TopoDSToStep_MakeFacetedBrepAndBrepWithVoids(const TopoDS_Solid& aSolid,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False;
TopoDS_Iterator It;
TopoDSToStep_Tool aTool;
if (!aOutShell.IsNull()) {
- It.Initialize(aSolid);
- for ( ; It.More(); It.Next() ) {
+ Standard_Integer nbshapes = 0;
+ for (It.Initialize(aSolid); It.More(); It.Next())
+ if (It.Value().ShapeType() == TopAbs_SHELL)
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+ for (It.Initialize(aSolid); It.More() && aPS.More(); It.Next())
+ {
if (It.Value().ShapeType() == TopAbs_SHELL) {
+ Message_ProgressRange aRange = aPS.Next();
TopoDS_Shell CurrentShell = TopoDS::Shell(It.Value());
if (It.Value().Closed()) {
aTool.Init(aMap, Standard_False);
- StepB.Init(CurrentShell, aTool, FP);
+ StepB.Init(CurrentShell, aTool, FP, aRange);
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
}
}
}
+ if (!aPS.More())
+ return;
}
Standard_Integer N = S.Length();
if ( N>=1 ) {
#include <Standard_Handle.hxx>
#include <TopoDSToStep_Root.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepShape_FacetedBrepAndBrepWithVoids;
class StdFail_NotDone;
class TopoDS_Solid;
class Transfer_FinderProcess;
-
//! This class implements the mapping between classes
//! Solid from TopoDS and FacetedBrepAndBrepWithVoids from
//! StepShape. All the topology and geometry comprised
DEFINE_STANDARD_ALLOC
- Standard_EXPORT TopoDSToStep_MakeFacetedBrepAndBrepWithVoids(const TopoDS_Solid& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeFacetedBrepAndBrepWithVoids(const TopoDS_Solid& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const Handle(StepShape_FacetedBrepAndBrepWithVoids)& Value() const;
#include <BRepClass3d.hxx>
+#include <Message_ProgressScope.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_ClosedShell.hxx>
#include <StepShape_HArray1OfFace.hxx>
#include <TransferBRep_ShapeMapper.hxx>
static Handle(StepShape_ManifoldSolidBrep) MakeManifoldSolidBrep (const TopoDS_Shell& aShell,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
Handle(StepShape_ManifoldSolidBrep) theManifoldSolidBrep;
MoniTool_DataMapOfShapeTransient aMap;
TopoDSToStep_Tool aTool(aMap, Standard_False);
- TopoDSToStep_Builder StepB(aShell, aTool, FP);
+ TopoDSToStep_Builder StepB(aShell, aTool, FP, theProgress);
+ if (theProgress.UserBreak())
+ return theManifoldSolidBrep;
TopoDSToStep::AddResult(FP, aTool);
TopoDSToStep_MakeManifoldSolidBrep::
TopoDSToStep_MakeManifoldSolidBrep(const TopoDS_Shell& aShell,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
- theManifoldSolidBrep = MakeManifoldSolidBrep(aShell, FP);
+ theManifoldSolidBrep = MakeManifoldSolidBrep(aShell, FP, theProgress);
done = !theManifoldSolidBrep.IsNull();
- if (!done) {
+ if (!done && !theProgress.UserBreak()) {
Handle(TransferBRep_ShapeMapper) errShape = new TransferBRep_ShapeMapper(aShell);
FP->AddWarning(errShape, " Closed Shell not mapped to ManifoldSolidBrep");
}
TopoDSToStep_MakeManifoldSolidBrep::
TopoDSToStep_MakeManifoldSolidBrep(const TopoDS_Solid& aSolid,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
TopoDS_Shell aOuterShell = BRepClass3d::OuterShell(aSolid);
if (!aOuterShell.IsNull()) {
- theManifoldSolidBrep = MakeManifoldSolidBrep(aOuterShell, FP);
+ theManifoldSolidBrep = MakeManifoldSolidBrep(aOuterShell, FP, theProgress);
done = !theManifoldSolidBrep.IsNull();
- if (!done) {
+ if (!done && !theProgress.UserBreak()) {
Handle(TransferBRep_ShapeMapper) errShape = new TransferBRep_ShapeMapper(aOuterShell);
FP->AddWarning(errShape, " Outer Shell of Solid not mapped to ManifoldSolidBrep");
}
#include <Standard_Handle.hxx>
#include <TopoDSToStep_Root.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepShape_ManifoldSolidBrep;
class StdFail_NotDone;
class TopoDS_Shell;
class Transfer_FinderProcess;
class TopoDS_Solid;
-
//! This class implements the mapping between classes
//! Shell or Solid from TopoDS and ManifoldSolidBrep from
//! StepShape. All the topology and geometry comprised
DEFINE_STANDARD_ALLOC
- Standard_EXPORT TopoDSToStep_MakeManifoldSolidBrep(const TopoDS_Shell& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeManifoldSolidBrep(const TopoDS_Shell& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT TopoDSToStep_MakeManifoldSolidBrep(const TopoDS_Solid& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeManifoldSolidBrep(const TopoDS_Solid& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const Handle(StepShape_ManifoldSolidBrep)& Value() const;
#include <MoniTool_DataMapOfShapeTransient.hxx>
+#include <Message_ProgressScope.hxx>
#include <StdFail_NotDone.hxx>
#include <StepShape_ClosedShell.hxx>
#include <StepShape_ConnectedFaceSet.hxx>
//=============================================================================
TopoDSToStep_MakeShellBasedSurfaceModel::
TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Face& aFace,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False;
MoniTool_DataMapOfShapeTransient aMap;
TopoDSToStep_Tool aTool(aMap, Standard_False);
- TopoDSToStep_Builder StepB(aFace, aTool, FP);
+ TopoDSToStep_Builder StepB(aFace, aTool, FP, theProgress);
+ if (theProgress.UserBreak())
+ return;
TopoDSToStep::AddResult ( FP, aTool );
TopoDSToStep_MakeShellBasedSurfaceModel::
TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Shell& aShell,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False;
StepShape_Shell aShellSelect;
MoniTool_DataMapOfShapeTransient aMap;
TopoDSToStep_Tool aTool(aMap, Standard_False);
- TopoDSToStep_Builder StepB(aShell, aTool, FP);
+ TopoDSToStep_Builder StepB(aShell, aTool, FP, theProgress);
+ if (theProgress.UserBreak())
+ return;
//TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
TopoDSToStep_MakeShellBasedSurfaceModel::
TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Solid& aSolid,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
done = Standard_False;
StepShape_Shell aShellSelect;
MoniTool_DataMapOfShapeTransient aMap;
TColStd_SequenceOfTransient S;
- It.Initialize(aSolid);
- for (; It.More(); It.Next() ) {
+ Standard_Integer nbshapes = 0;
+ for (It.Initialize(aSolid); It.More(); It.Next())
+ if (It.Value().ShapeType() == TopAbs_SHELL)
+ nbshapes++;
+ Message_ProgressScope aPS(theProgress, NULL, nbshapes);
+ for (It.Initialize(aSolid); It.More() && aPS.More(); It.Next())
+ {
if (It.Value().ShapeType() == TopAbs_SHELL) {
aShell = TopoDS::Shell(It.Value());
TopoDSToStep_Tool aTool(aMap, Standard_False);
- TopoDSToStep_Builder StepB(aShell, aTool, FP);
+ TopoDSToStep_Builder StepB(aShell, aTool, FP, aPS.Next());
TopoDSToStep::AddResult ( FP, aTool );
if (StepB.IsDone()) {
}
}
}
+ if (!aPS.More())
+ return;
Standard_Integer N = S.Length();
if ( N >= 1) {
aSbsmBoundary = new StepShape_HArray1OfShell(1,N);
#include <Standard_Handle.hxx>
#include <TopoDSToStep_Root.hxx>
+#include <Message_ProgressRange.hxx>
+
class StepShape_ShellBasedSurfaceModel;
class StdFail_NotDone;
class TopoDS_Face;
DEFINE_STANDARD_ALLOC
- Standard_EXPORT TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Face& F, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Face& F,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Shell& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Shell& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Solid& S, const Handle(Transfer_FinderProcess)& FP);
+ Standard_EXPORT TopoDSToStep_MakeShellBasedSurfaceModel(const TopoDS_Solid& S,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_EXPORT const Handle(StepShape_ShellBasedSurfaceModel)& Value() const;
Handle(Transfer_Binder) Transfer_Actor::Transferring
(const TheStart& /*start*/,
- const Handle(Transfer_TransferProcess)& /*TP*/)
+ const Handle(Transfer_TransferProcess)& /*TP*/,
+ const Message_ProgressRange& /*theProgress*/)
{ return NullResult(); }
Handle(Transfer_Binder) Transfer_ActorDispatch::Transfer
(const Handle(Standard_Transient)& start,
- const Handle(Transfer_TransientProcess)& /*TP*/)
+ const Handle(Transfer_TransientProcess)& /*TP*/,
+ const Message_ProgressRange&)
{
thetool.TransferEntity(start);
return thetool.TransientProcess()->Find(start);
//! Specific action : it calls the method Transfer from CopyTool
//! i.e. the general service Copy, then returns the Binder
//! produced by the TransientProcess
- Standard_EXPORT virtual Handle(Transfer_Binder) Transfer (const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transfer
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
Handle(Transfer_Binder) Transfer_ActorOfFinderProcess::Transfer
(const Handle(Transfer_Finder)& fnd,
- const Handle(Transfer_FinderProcess)& FP)
+ const Handle(Transfer_FinderProcess)& FP,
+ const Message_ProgressRange& theProgress)
{
Handle(Transfer_TransientMapper) tm = Handle(Transfer_TransientMapper)::DownCast (fnd);
if (tm.IsNull()) return NullResult();
- Handle(Standard_Transient) res = TransferTransient (tm->Value(),FP);
+ Handle(Standard_Transient) res = TransferTransient (tm->Value(),FP, theProgress);
if (res.IsNull()) return NullResult();
return TransientResult (res);
}
Handle(Transfer_Binder) Transfer_ActorOfFinderProcess::Transferring
(const Handle(Transfer_Finder)& ent,
- const Handle(Transfer_ProcessForFinder)& TP)
+ const Handle(Transfer_ProcessForFinder)& TP,
+ const Message_ProgressRange& theProgress)
{
- return Transfer(ent,Handle(Transfer_FinderProcess)::DownCast(TP));
+ return Transfer(ent,Handle(Transfer_FinderProcess)::DownCast(TP), theProgress);
}
Handle(Standard_Transient) Transfer_ActorOfFinderProcess::TransferTransient
(const Handle(Standard_Transient)& /*ent*/,
- const Handle(Transfer_FinderProcess)& )
+ const Handle(Transfer_FinderProcess)&,
+ const Message_ProgressRange& )
{
Handle(Standard_Transient) nulres;
return nulres;
//! Returns the Transfer Mode, modifiable
Standard_EXPORT Standard_Integer& ModeTrans();
- Standard_EXPORT virtual Handle(Transfer_Binder) Transferring (const Handle(Transfer_Finder)& start, const Handle(Transfer_ProcessForFinder)& TP) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transferring
+ (const Handle(Transfer_Finder)& start,
+ const Handle(Transfer_ProcessForFinder)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
- Standard_EXPORT virtual Handle(Transfer_Binder) Transfer (const Handle(Transfer_Finder)& start, const Handle(Transfer_FinderProcess)& TP);
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transfer
+ (const Handle(Transfer_Finder)& start,
+ const Handle(Transfer_FinderProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT virtual Handle(Standard_Transient) TransferTransient (const Handle(Standard_Transient)& start, const Handle(Transfer_FinderProcess)& TP);
+ Standard_EXPORT virtual Handle(Standard_Transient) TransferTransient
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_FinderProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
#include <Standard_Transient.hxx>
#include <Transfer_HSequenceOfFinder.hxx>
#include <Transfer_TransferMapOfProcessForFinder.hxx>
+#include <Message_ProgressRange.hxx>
class Standard_DomainError;
class Transfer_Finder;
class Transfer_SimpleBinderOfTransient;
class Standard_Transient;
-
class Transfer_ActorOfProcessForFinder;
DEFINE_STANDARD_HANDLE(Transfer_ActorOfProcessForFinder, Standard_Transient)
//! (Default defined as doing nothing; should be deffered)
//! "mutable" allows the Actor to record intermediate
//! information, in addition to those of TransferProcess
- Standard_EXPORT virtual Handle(Transfer_Binder) Transferring (const Handle(Transfer_Finder)& start, const Handle(Transfer_ProcessForFinder)& TP);
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transferring
+ (const Handle(Transfer_Finder)& start,
+ const Handle(Transfer_ProcessForFinder)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Prepares and Returns a Binder for a Transient Result
//! Returns a Null Handle if <res> is itself Null
#include <TColStd_MapTransientHasher.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <Transfer_TransferMapOfProcessForTransient.hxx>
+#include <Message_ProgressRange.hxx>
class Standard_DomainError;
class Standard_Transient;
class Transfer_Binder;
class Transfer_SimpleBinderOfTransient;
-
class Transfer_ActorOfProcessForTransient;
DEFINE_STANDARD_HANDLE(Transfer_ActorOfProcessForTransient, Standard_Transient)
//! (Default defined as doing nothing; should be deffered)
//! "mutable" allows the Actor to record intermediate
//! information, in addition to those of TransferProcess
- Standard_EXPORT virtual Handle(Transfer_Binder) Transferring (const Handle(Standard_Transient)& start, const Handle(Transfer_ProcessForTransient)& TP);
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transferring
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_ProcessForTransient)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Prepares and Returns a Binder for a Transient Result
//! Returns a Null Handle if <res> is itself Null
Handle(Transfer_Binder) Transfer_ActorOfTransientProcess::Transfer
(const Handle(Standard_Transient)& start,
- const Handle(Transfer_TransientProcess)& TP)
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress)
{
- Handle(Standard_Transient) res = TransferTransient (start,TP);
+ Handle(Standard_Transient) res = TransferTransient (start,TP, theProgress);
if (res.IsNull()) return NullResult();
return TransientResult (res);
}
Handle(Transfer_Binder) Transfer_ActorOfTransientProcess::Transferring
(const Handle(Standard_Transient)& ent,
- const Handle(Transfer_ProcessForTransient)& TP)
+ const Handle(Transfer_ProcessForTransient)& TP,
+ const Message_ProgressRange& theProgress)
{
- return Transfer(ent,Handle(Transfer_TransientProcess)::DownCast(TP));
+ return Transfer(ent,Handle(Transfer_TransientProcess)::DownCast(TP), theProgress);
}
Handle(Standard_Transient) Transfer_ActorOfTransientProcess::TransferTransient
(const Handle(Standard_Transient)& /*ent*/,
- const Handle(Transfer_TransientProcess)& /*TP*/)
+ const Handle(Transfer_TransientProcess)& /*TP*/,
+ const Message_ProgressRange& )
{
Handle(Standard_Transient) nulres;
return nulres;
class Standard_Transient;
class Transfer_ProcessForTransient;
class Transfer_TransientProcess;
-
+class Message_ProgressScope;
class Transfer_ActorOfTransientProcess;
DEFINE_STANDARD_HANDLE(Transfer_ActorOfTransientProcess, Transfer_ActorOfProcessForTransient)
Standard_EXPORT Transfer_ActorOfTransientProcess();
- Standard_EXPORT virtual Handle(Transfer_Binder) Transferring (const Handle(Standard_Transient)& start, const Handle(Transfer_ProcessForTransient)& TP) Standard_OVERRIDE;
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transferring
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_ProcessForTransient)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) Standard_OVERRIDE;
- Standard_EXPORT virtual Handle(Transfer_Binder) Transfer (const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT virtual Handle(Transfer_Binder) Transfer
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
- Standard_EXPORT virtual Handle(Standard_Transient) TransferTransient (const Handle(Standard_Transient)& start, const Handle(Transfer_TransientProcess)& TP);
+ Standard_EXPORT virtual Handle(Standard_Transient) TransferTransient
+ (const Handle(Standard_Transient)& start,
+ const Handle(Transfer_TransientProcess)& TP,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
#include <TColStd_IndexedMapOfInteger.hxx>
#include <Transfer_HSequenceOfFinder.hxx>
#include <Transfer_TransferMapOfProcessForFinder.hxx>
+#include <Message_ProgressRange.hxx>
class Message_Messenger;
class Transfer_Finder;
class Transfer_Binder;
class Transfer_ActorOfProcessForFinder;
-class Message_ProgressIndicator;
class Interface_InterfaceError;
class Transfer_TransferFailure;
class Transfer_FindHasher;
//! the method TransferProduct (see below).
//! Mapping and Roots are managed : nothing is done if a Result is
//! already Bound, an exception is raised in case of error.
- Standard_EXPORT Handle(Transfer_Binder) Transferring (const Handle(Transfer_Finder)& start);
+ Standard_EXPORT Handle(Transfer_Binder) Transferring (const Handle(Transfer_Finder)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Same as Transferring but does not return the Binder.
//! Simply returns True in case of success (for user call)
- Standard_EXPORT Standard_Boolean Transfer (const Handle(Transfer_Finder)& start);
+ Standard_EXPORT Standard_Boolean Transfer (const Handle(Transfer_Finder)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Allows controls if exceptions will be handled
//! Transfer Operations
//! a check or a check-list
//! By default, returns 0; can be redefined
Standard_EXPORT virtual Standard_Integer CheckNum (const Handle(Transfer_Finder)& start) const;
-
- //! Sets Progress indicator
- Standard_EXPORT void SetProgress (const Handle(Message_ProgressIndicator)& theProgress);
-
- //! Gets Progress indicator
- Standard_EXPORT Handle(Message_ProgressIndicator) GetProgress() const;
//! until a Non Null Binder is produced.
//! But keep in mind that a Null Binder can allways be returned
//! if a Starting Entity has not been recognized at all.
- Standard_EXPORT Handle(Transfer_Binder) TransferProduct (const Handle(Transfer_Finder)& start);
+ Standard_EXPORT Handle(Transfer_Binder) TransferProduct (const Handle(Transfer_Finder)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_Boolean theerrh;
Standard_Integer thetrace;
Standard_Integer theindex;
Handle(Transfer_ActorOfProcessForFinder) theactor;
Transfer_TransferMapOfProcessForFinder themap;
- Handle(Message_ProgressIndicator) myProgress;
};
#include <Transfer_Finder.hxx>
#include <Transfer_Binder.hxx>
#include <Transfer_ActorOfProcessForFinder.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <Interface_InterfaceError.hxx>
#include <Transfer_TransferFailure.hxx>
#include <Transfer_FindHasher.hxx>
#include <Transfer_TransferMapOfProcessForTransient.hxx>
#include <TColStd_MapTransientHasher.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
+#include <Message_ProgressRange.hxx>
class Message_Messenger;
class Transfer_Binder;
class Transfer_ActorOfProcessForTransient;
-class Message_ProgressIndicator;
class Interface_InterfaceError;
class Transfer_TransferFailure;
class Transfer_IteratorOfProcessForTransient;
//! the method TransferProduct (see below).
//! Mapping and Roots are managed : nothing is done if a Result is
//! already Bound, an exception is raised in case of error.
- Standard_EXPORT Handle(Transfer_Binder) Transferring (const Handle(Standard_Transient)& start);
+ Standard_EXPORT Handle(Transfer_Binder) Transferring (const Handle(Standard_Transient)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Same as Transferring but does not return the Binder.
//! Simply returns True in case of success (for user call)
- Standard_EXPORT Standard_Boolean Transfer (const Handle(Standard_Transient)& start);
+ Standard_EXPORT Standard_Boolean Transfer (const Handle(Standard_Transient)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Allows controls if exceptions will be handled
//! Transfer Operations
//! a check or a check-list
//! By default, returns 0; can be redefined
Standard_EXPORT virtual Standard_Integer CheckNum (const Handle(Standard_Transient)& start) const;
-
- //! Sets Progress indicator
- Standard_EXPORT void SetProgress (const Handle(Message_ProgressIndicator)& theProgress);
-
- //! Gets Progress indicator
- Standard_EXPORT Handle(Message_ProgressIndicator) GetProgress() const;
-
//! until a Non Null Binder is produced.
//! But keep in mind that a Null Binder can allways be returned
//! if a Starting Entity has not been recognized at all.
- Standard_EXPORT Handle(Transfer_Binder) TransferProduct (const Handle(Standard_Transient)& start);
+ Standard_EXPORT Handle(Transfer_Binder) TransferProduct (const Handle(Standard_Transient)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
Standard_Boolean theerrh;
Standard_Integer thetrace;
Standard_Integer theindex;
Handle(Transfer_ActorOfProcessForTransient) theactor;
Transfer_TransferMapOfProcessForTransient themap;
- Handle(Message_ProgressIndicator) myProgress;
};
#include <Standard_Transient.hxx>
#include <Transfer_Binder.hxx>
#include <Transfer_ActorOfProcessForTransient.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <Interface_InterfaceError.hxx>
#include <Transfer_TransferFailure.hxx>
#include <Transfer_TransferMapOfProcessForTransient.hxx>
#include <Transfer_TransferFailure.hxx>
#include <Transfer_TransferOutput.hxx>
#include <Transfer_TransientProcess.hxx>
+#include <Message_ProgressScope.hxx>
Transfer_TransferOutput::Transfer_TransferOutput (const Handle(Transfer_ActorOfTransientProcess)& actor,
const Handle(Interface_InterfaceModel)& amodel)
Handle(Transfer_TransientProcess) Transfer_TransferOutput::TransientProcess () const
{ return theproc; }
-void Transfer_TransferOutput::Transfer (const Handle(Standard_Transient)& obj)
+void Transfer_TransferOutput::Transfer (const Handle(Standard_Transient)& obj,
+ const Message_ProgressRange& theProgress)
{
if (themodel->Number(obj) == 0) throw Transfer_TransferFailure("TransferOutput : Transfer, entities do not come from same initial model");
// Standard_Integer scope = 0;
//:1 modified by ABV 5 Nov 97
//:1 if (!theproc->Transfer(obj)) return; // auparavant, traitement Undefined
// Standard_Boolean ok =
- theproc->Transfer ( obj );
+ theproc->Transfer ( obj, theProgress );
// if (scope > 0) theproc->EndScope (scope);
// if ( ! ok ) return;
// Pour transferer tout simplement toutes les racines d'un modele d'interface
// Chacune est notee "Root" dans le Process final
-void Transfer_TransferOutput::TransferRoots ()
-{ TransferRoots(Interface_Protocol::Active()); }
+void Transfer_TransferOutput::TransferRoots (const Message_ProgressRange& theProgress)
+{ TransferRoots(Interface_Protocol::Active(), theProgress); }
-void Transfer_TransferOutput::TransferRoots (const Handle(Interface_Protocol)& protocol)
+void Transfer_TransferOutput::TransferRoots (const Handle(Interface_Protocol)& protocol,
+ const Message_ProgressRange& theProgress)
{
theproc->SetRootManagement (Standard_False);
Interface_ShareFlags tool(themodel,protocol);
Interface_EntityIterator list = tool.RootEntities();
- for (list.Start(); list.More(); list.Next()) {
+ Message_ProgressScope aPS(theProgress, NULL, list.NbEntities());
+ for (list.Start(); list.More() && aPS.More(); list.Next()) {
Handle(Standard_Transient) ent = list.Value();
// Standard_Integer scope = 0;
// if (thescope) scope = theproc->NewScope (ent);
- if (theproc->Transfer(ent)) theproc->SetRoot(ent);
+ if (theproc->Transfer (ent, aPS.Next())) theproc->SetRoot(ent);
// if (scope > 0) theproc->EndScope (scope);
}
}
-void Transfer_TransferOutput::TransferRoots (const Interface_Graph& G)
+void Transfer_TransferOutput::TransferRoots (const Interface_Graph& G,
+ const Message_ProgressRange& theProgress)
{
theproc->SetRootManagement (Standard_False);
Interface_ShareFlags tool(G);
theproc->SetModel (G.Model());
Interface_EntityIterator list = tool.RootEntities();
- for (list.Start(); list.More(); list.Next()) {
+ Message_ProgressScope aPS(theProgress, NULL, list.NbEntities());
+ for (list.Start(); list.More() && aPS.More(); list.Next()) {
Handle(Standard_Transient) ent = list.Value();
// Standard_Integer scope = 0;
// if (thescope) scope = theproc->NewScope (ent);
- if (theproc->Transfer(ent)) theproc->SetRoot(ent);
+ if (theproc->Transfer (ent, aPS.Next())) theproc->SetRoot(ent);
// if (scope > 0) theproc->EndScope (scope);
}
}
#include <Standard.hxx>
#include <Standard_DefineAlloc.hxx>
#include <Standard_Handle.hxx>
-
#include <Standard_Boolean.hxx>
+#include <Message_ProgressRange.hxx>
+
class Transfer_TransientProcess;
class Interface_InterfaceModel;
class Standard_NoSuchObject;
class Interface_Graph;
class Interface_EntityIterator;
-
//! A TransferOutput is a Tool which manages the transfer of
//! entities created by an Interface, stored in an InterfaceModel,
//! into a set of Objects suitable for an Application
//! Transfer checks that all taken Entities come from the same
//! Model, then calls Transfer from TransientProcess
- Standard_EXPORT void Transfer (const Handle(Standard_Transient)& obj);
+ Standard_EXPORT void Transfer (const Handle(Standard_Transient)& obj,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Runs transfer on the roots of the Interface Model
//! The Roots are computed with a ShareFlags created from a
//! Protocol given as Argument
- Standard_EXPORT void TransferRoots (const Handle(Interface_Protocol)& protocol);
+ Standard_EXPORT void TransferRoots (const Handle(Interface_Protocol)& protocol,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Runs transfer on the roots defined by a Graph of dependences
//! (which detains also a Model and its Entities)
//! Roots are computed with a ShareFlags created from the Graph
- Standard_EXPORT void TransferRoots (const Interface_Graph& G);
+ Standard_EXPORT void TransferRoots (const Interface_Graph& G,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Runs transfer on the roots of the Interface Model
//! Remark : the Roots are computed with a ShareFlags created
//! from the Active Protocol
- Standard_EXPORT void TransferRoots();
+ Standard_EXPORT void TransferRoots(const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns the list of Starting Entities with these criteria :
//! - <normal> False, gives the entities bound with ABNORMAL STATUS
#include <Message_Messenger.hxx>
#include <Message_Msg.hxx>
#include <Message.hxx>
+#include <Message_ProgressScope.hxx>
#include <Transfer_VoidBinder.hxx>
#include <Transfer_SimpleBinderOfTransient.hxx>
//purpose :
//=======================================================================
-Handle(Transfer_Binder) Transfer_TransferProcess::Transferring(const TheStart& start)
+Handle(Transfer_Binder) Transfer_TransferProcess::Transferring(const TheStart& start,
+ const Message_ProgressRange& theProgress)
{
// Map deja alimentee ?
Handle(Transfer_Binder) former = FindAndMask(start);
Standard_Integer oldlev = thelevel;
try {
OCC_CATCH_SIGNALS
- binder = TransferProduct(start);
+ binder = TransferProduct(start, theProgress);
}
// ... Exceptions a Rattraper : elles ne se ressemblent pas toutes ... !
}
// Transfert non protege (ainsi, dbx a la main en cas de plantage par Raise)
- else binder = TransferProduct(start);
+ else binder = TransferProduct(start, theProgress);
+
+ if (theProgress.UserBreak())
+ return Handle(Transfer_Binder)();
// .... Conclusion : Noter dans la Map ....
// ## ## TransferProduct : Action proprement dite ## ##
Handle(Transfer_Binder) Transfer_TransferProcess::TransferProduct
- (const TheStart& start)
+ (const TheStart& start,
+ const Message_ProgressRange& theProgress)
{
thelevel ++; // si decremente et == 0, transfert racine
Handle(Transfer_Binder) binder;
Handle(Transfer_Actor) actor = theactor;
// On balaie les Next jusqu a avoir un Resultat
+ Message_ProgressScope aScope (theProgress, NULL, 1, true);
while (!actor.IsNull()) {
- if (actor->Recognize (start)) binder = actor->Transferring(start,this);
+ if (actor->Recognize (start)) binder = actor->Transferring(start,this, aScope.Next());
else binder.Nullify();
if (!binder.IsNull()) break;
actor = actor->Next();
}
+ if (aScope.UserBreak())
+ return Handle(Transfer_Binder)();
+
if (binder.IsNull()) {
// if (thetrace) {
// aSender << "Transfer has produced no Result" <<endl;
//purpose :
//=======================================================================
-Standard_Boolean Transfer_TransferProcess::Transfer(const TheStart& start)
+Standard_Boolean Transfer_TransferProcess::Transfer(const TheStart& start,
+ const Message_ProgressRange& theProgress)
{
- Handle(Transfer_Binder) binder = Transferring(start);
+ Handle(Transfer_Binder) binder = Transferring(start, theProgress);
return (!binder.IsNull());
}
return 0;
}
-
-//=======================================================================
-//function : SetProgress
-//purpose : Sets Progress indicator
-//=======================================================================
-
-void Transfer_TransferProcess::SetProgress(const Handle(Message_ProgressIndicator)& theProgress)
-{
- myProgress = theProgress;
-}
-
-//=======================================================================
-//function : GetProgress
-//purpose : Returns Progress indicator
-//=======================================================================
-
-Handle(Message_ProgressIndicator) Transfer_TransferProcess::GetProgress() const
-{
- return myProgress;
-}
#include <Interface_Macros.hxx>
#include <Interface_Protocol.hxx>
#include <Message_Messenger.hxx>
+#include <Message_ProgressScope.hxx>
#include <Standard_OutOfRange.hxx>
#include <Standard_Transient.hxx>
#include <TopoDS_Compound.hxx>
void TransferBRep_Reader::PrepareTransfer () { }
- void TransferBRep_Reader::TransferRoots ()
+ void TransferBRep_Reader::TransferRoots (const Message_ProgressRange& theProgress)
{
Clear();
if (!BeginTransfer()) return;
Transfer_TransferOutput TP (theProc,theModel);
- TP.TransferRoots(theProto);
+ TP.TransferRoots(theProto, theProgress);
EndTransfer();
}
- Standard_Boolean TransferBRep_Reader::Transfer (const Standard_Integer num)
+ Standard_Boolean TransferBRep_Reader::Transfer (const Standard_Integer num,
+ const Message_ProgressRange& theProgress)
{
if (!BeginTransfer()) return Standard_False;
if (num <= 0 || num > theModel->NbEntities()) return Standard_False;
theModel->Print (ent, sout);
sout<<std::endl;
}
- TP.Transfer(ent);
+ TP.Transfer(ent, theProgress);
theProc->SetRoot(ent);
EndTransfer();
return Standard_True;
}
void TransferBRep_Reader::TransferList
- (const Handle(TColStd_HSequenceOfTransient)& list)
+ (const Handle(TColStd_HSequenceOfTransient)& list,
+ const Message_ProgressRange& theProgress)
{
if (!BeginTransfer()) return;
if (list.IsNull()) return;
if (theProc->TraceLevel() > 1)
sout<<"-- Transfer(Read-List) : "<<nb<<" Items"<<std::endl;
- for (i = 1; i <= nb; i ++) {
+ Message_ProgressScope aPS(theProgress, NULL, nb);
+ for (i = 1; i <= nb && aPS.More(); i++) {
+ Message_ProgressRange aRange = aPS.Next();
Handle(Standard_Transient) ent = list->Value(i);
if (theModel->Number(ent) == 0) continue;
theModel->Print (ent, sout);
sout<<std::endl;
}
- TP.Transfer(ent);
+ TP.Transfer (ent, aRange);
theProc->SetRoot(ent);
}
EndTransfer();
#include <Standard_Boolean.hxx>
#include <TopTools_HSequenceOfShape.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
+#include <Message_ProgressRange.hxx>
+
class Interface_Protocol;
class Transfer_ActorOfTransientProcess;
class Interface_InterfaceModel;
class TopoDS_Shape;
class Standard_Transient;
-
//! This class offers a simple, easy to call, way of transferring
//! data from interface files to Shapes from CasCade
//! It must be specialized according to each norm/protocol, by :
//! The result will be a list of Shapes.
//! This method calls user redefinable PrepareTransfer
//! Remark : former result is cleared
- Standard_EXPORT virtual void TransferRoots();
+ Standard_EXPORT virtual void TransferRoots(const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers an Entity given its rank in the Model (Root or not)
//! Returns True if it is recognized as Geom-Topol.
//! (But it can have failed : see IsDone)
- Standard_EXPORT virtual Standard_Boolean Transfer (const Standard_Integer num);
+ Standard_EXPORT virtual Standard_Boolean Transfer (const Standard_Integer num,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers a list of Entities (only the ones also in the Model)
//! Remark : former result is cleared
- Standard_EXPORT virtual void TransferList (const Handle(TColStd_HSequenceOfTransient)& list);
+ Standard_EXPORT virtual void TransferList (const Handle(TColStd_HSequenceOfTransient)& list,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns True if the LAST Transfer/TransferRoots was a success
Standard_EXPORT Standard_Boolean IsDone() const;
#include <Image_AlienPixMap.hxx>
#include <Image_Diff.hxx>
#include <Image_VideoRecorder.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
+#include <Message_ProgressRange.hxx>
#include <NCollection_DataMap.hxx>
#include <NCollection_List.hxx>
#include <NCollection_LocalArray.hxx>
// Manage frame-rated animation here
Standard_Real aPts = aPlayStartTime;
int64_t aNbFrames = 0;
- Message_ProgressSentry aPSentry (aProgress, "Video recording, sec", 0, Max (1, Standard_Integer(aPlayDuration / aPlaySpeed)), 1);
+ Message_ProgressScope aPS(Message_ProgressIndicator::Start(aProgress),
+ "Video recording, sec", Max(1, Standard_Integer(aPlayDuration / aPlaySpeed)));
Standard_Integer aSecondsProgress = 0;
- for (; aPts <= anUpperPts && aPSentry.More();)
+ for (; aPts <= anUpperPts && aPS.More();)
{
const Standard_Real aRecPts = aPlaySpeed * ((Standard_Real(aRecParams.FpsDen) / Standard_Real(aRecParams.FpsNum)) * Standard_Real(aNbFrames));
aPts = aPlayStartTime + aRecPts;
while (aSecondsProgress < Standard_Integer(aRecPts / aPlaySpeed))
{
- aPSentry.Next();
+ aPS.Next();
++aSecondsProgress;
}
}
class Standard_GUID;
class TCollection_AsciiString;
class TCollection_ExtendedString;
-class TColStd_HArray1OfByte;
+#include <TColStd_HArray1OfByte.hxx>
class TDF_RelocationTable;
class XCAFDoc_Note;
class XCAFDoc_AssemblyItemId;
#include <Message_ListIteratorOfListOfMsg.hxx>
#include <Message_ListOfMsg.hxx>
#include <Message_Msg.hxx>
-#include <Message_ProgressIndicator.hxx>
#include <Resource_Manager.hxx>
#include <ShapeAlgo.hxx>
#include <ShapeAlgo_AlgoContainer.hxx>
const Standard_CString prscfile,
const Standard_CString pseq,
Handle(Standard_Transient)& info,
- const Handle(Message_ProgressIndicator)& progress,
+ const Message_ProgressRange& theProgress,
const Standard_Boolean NonManifold) const
{
if ( shape.IsNull() ) return shape;
rscfile = prscfile;
context = new ShapeProcess_ShapeContext(shape, rscfile);
context->SetDetalisation(TopAbs_EDGE);
- if ( !progress.IsNull() )
- context->SetProgress(progress);
}
context->SetNonManifold(NonManifold);
info = context;
sfs->SetMaxTolerance ( maxTol );
sfs->FixFaceTool()->FixWireTool()->FixSameParameterMode() = Standard_False;
sfs->FixSolidTool()->CreateOpenSolidMode() = Standard_False;
- sfs->Perform(progress);
+ sfs->Perform(theProgress);
TopoDS_Shape S = sfs->Shape();
if ( ! S.IsNull() && S != shape ) {
rsc->SetResource ( "Runtime.Tolerance", Prec );
rsc->SetResource ( "Runtime.MaxTolerance", maxTol );
- if ( !ShapeProcess::Perform(context, seq) )
+ if ( !ShapeProcess::Perform(context, seq, theProgress) )
return shape; // return original shape
return context->Result();
#include <Standard_CString.hxx>
#include <Standard_Boolean.hxx>
#include <Standard_Integer.hxx>
+#include <Message_ProgressRange.hxx>
+
class XSAlgo_ToolContainer;
class TopoDS_Shape;
class Standard_Transient;
-class Message_ProgressIndicator;
class TopoDS_Edge;
class TopoDS_Face;
class Transfer_TransientProcess;
Standard_EXPORT virtual TopoDS_Shape ProcessShape (
const TopoDS_Shape& shape, const Standard_Real Prec, const Standard_Real MaxTol,
const Standard_CString rscfile, const Standard_CString seq, Handle(Standard_Transient)& info,
- const Handle(Message_ProgressIndicator)& progress = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange(),
const Standard_Boolean NonManifold = Standard_False) const;
//! Checks quality of pcurve of the edge on the given face,
const Handle(Transfer_Finder)& theMapper,
const Handle(Transfer_FinderProcess)& theFP,
const Handle(Interface_InterfaceModel)& theModel,
- const Standard_Integer theModeTrans)
+ const Standard_Integer theModeTrans,
+ const Message_ProgressRange& theProgress)
{
if (theActor.IsNull()) return IFSelect_RetError;
if (theModel.IsNull()) return IFSelect_RetError;
theActor->ModeTrans() = theModeTrans;
theFP->SetModel (theModel);
theFP->SetActor (theActor);
- theFP->Transfer (theMapper);
+ theFP->Transfer (theMapper, theProgress);
IFSelect_ReturnStatus stat = IFSelect_RetFail;
Handle(Transfer_Binder) binder = theFP->Find (theMapper);
(const Handle(Standard_Transient)& theObj,
const Handle(Transfer_FinderProcess)& theFP,
const Handle(Interface_InterfaceModel)& theModel,
- const Standard_Integer theModeTrans) const
+ const Standard_Integer theModeTrans,
+ const Message_ProgressRange& theProgress) const
{
if (theObj.IsNull()) return IFSelect_RetVoid;
return TransferFinder
- (myAdaptorWrite,new Transfer_TransientMapper(theObj),theFP,theModel,theModeTrans);
+ (myAdaptorWrite,new Transfer_TransientMapper(theObj),theFP,theModel,theModeTrans, theProgress);
}
//=======================================================================
(const TopoDS_Shape& shape,
const Handle(Transfer_FinderProcess)& FP,
const Handle(Interface_InterfaceModel)& model,
- const Standard_Integer modetrans) const
+ const Standard_Integer modetrans,
+ const Message_ProgressRange& theProgress) const
{
if (shape.IsNull()) return IFSelect_RetVoid;
IFSelect_ReturnStatus theReturnStat = TransferFinder
- (myAdaptorWrite,new TransferBRep_ShapeMapper(shape),FP,model,modetrans);
+ (myAdaptorWrite,new TransferBRep_ShapeMapper(shape),FP,model,modetrans, theProgress);
return theReturnStat;
}
#include <Standard_Transient.hxx>
#include <NCollection_DataMap.hxx>
#include <TCollection_AsciiString.hxx>
+#include <Message_ProgressRange.hxx>
+
class IFSelect_WorkLibrary;
class Interface_Protocol;
class IFSelect_Signature;
class TopoDS_Shape;
class Interface_CheckIterator;
-
class XSControl_Controller;
DEFINE_STANDARD_HANDLE(XSControl_Controller, Standard_Transient)
//! 0 OK , 1 No Result , 2 Fail (e.g. exception raised)
//! -1 bad conditions , -2 bad model or null model
//! For type of object not recognized : should return 1
- Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteTransient (const Handle(Standard_Transient)& obj, const Handle(Transfer_FinderProcess)& FP, const Handle(Interface_InterfaceModel)& model, const Standard_Integer modetrans = 0) const;
+ Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteTransient
+ (const Handle(Standard_Transient)& obj,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(Interface_InterfaceModel)& model,
+ const Standard_Integer modetrans = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Tells if a shape is valid for a transfer to a model
//! Asks the ActorWrite (through a ShapeMapper)
//! Returned value is a status, as follows :
//! Done OK , Void : No Result , Fail : Fail (e.g. exception)
//! Error : bad conditions , bad model or null model
- Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteShape (const TopoDS_Shape& shape, const Handle(Transfer_FinderProcess)& FP, const Handle(Interface_InterfaceModel)& model, const Standard_Integer modetrans = 0) const;
+ Standard_EXPORT virtual IFSelect_ReturnStatus TransferWriteShape
+ (const TopoDS_Shape& shape,
+ const Handle(Transfer_FinderProcess)& FP,
+ const Handle(Interface_InterfaceModel)& model,
+ const Standard_Integer modetrans = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange()) const;
//! Records a Session Item, to be added for customisation of the Work Session.
//! It must have a specific name.
#include <Interface_Static.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <ShapeExtend_Explorer.hxx>
#include <Standard_Transient.hxx>
#include <TopoDS_Compound.hxx>
//purpose :
//=======================================================================
-Standard_Boolean XSControl_Reader::TransferOneRoot(const Standard_Integer num)
+Standard_Boolean XSControl_Reader::TransferOneRoot(const Standard_Integer num,
+ const Message_ProgressRange& theProgress)
{
- return TransferEntity (RootForTransfer (num));
+ return TransferEntity (RootForTransfer (num), theProgress);
}
//purpose :
//=======================================================================
-Standard_Boolean XSControl_Reader::TransferOne(const Standard_Integer num)
+Standard_Boolean XSControl_Reader::TransferOne(const Standard_Integer num,
+ const Message_ProgressRange& theProgress)
{
- return TransferEntity (thesession->StartingEntity (num));
+ return TransferEntity (thesession->StartingEntity (num), theProgress);
}
//=======================================================================
Standard_Boolean XSControl_Reader::TransferEntity
- (const Handle(Standard_Transient)& start)
+ (const Handle(Standard_Transient)& start, const Message_ProgressRange& theProgress)
{
if (start.IsNull()) return Standard_False;
const Handle(XSControl_TransferReader) &TR = thesession->TransferReader();
TR->BeginTransfer();
- if (TR->TransferOne (start) == 0) return Standard_False;
+ if (TR->TransferOne (start, Standard_True, theProgress) == 0) return Standard_False;
TopoDS_Shape sh = TR->ShapeResult(start);
//ShapeExtend_Explorer STU;
//SMH May 00: allow empty shapes (STEP CAX-IF, external references)
//=======================================================================
Standard_Integer XSControl_Reader::TransferList
- (const Handle(TColStd_HSequenceOfTransient)& list)
+ (const Handle(TColStd_HSequenceOfTransient)& list,
+ const Message_ProgressRange& theProgress)
{
if (list.IsNull()) return 0;
Standard_Integer nbt = 0;
TR->BeginTransfer();
ClearShapes();
ShapeExtend_Explorer STU;
- for (i = 1; i <= nb; i ++) {
+ Message_ProgressScope PS(theProgress, NULL, nb);
+ for (i = 1; i <= nb && PS.More(); i++) {
Handle(Standard_Transient) start = list->Value(i);
- if (TR->TransferOne (start) == 0) continue;
+ if (TR->TransferOne (start, Standard_True, PS.Next()) == 0) continue;
TopoDS_Shape sh = TR->ShapeResult(start);
if (STU.ShapeType(sh,Standard_True) == TopAbs_SHAPE) continue; // nulle-vide
theshapes.Append(sh);
//purpose :
//=======================================================================
-Standard_Integer XSControl_Reader::TransferRoots ()
+Standard_Integer XSControl_Reader::TransferRoots (const Message_ProgressRange& theProgress)
{
NbRootsForTransfer();
Standard_Integer nbt = 0;
TR->BeginTransfer();
ClearShapes();
ShapeExtend_Explorer STU;
- const Handle(Transfer_TransientProcess) &proc = thesession->TransferReader()->TransientProcess();
- Message_ProgressSentry PS ( proc->GetProgress(), "Root", 0, nb, 1 );
- for (i = 1; i <= nb && PS.More(); i ++,PS.Next()) {
+ Message_ProgressScope PS (theProgress, "Root", nb);
+ for (i = 1; i <= nb && PS.More(); i ++) {
Handle(Standard_Transient) start = theroots.Value(i);
- if (TR->TransferOne (start) == 0) continue;
+ if (TR->TransferOne (start, Standard_True, PS.Next()) == 0) continue;
TopoDS_Shape sh = TR->ShapeResult(start);
if (STU.ShapeType(sh,Standard_True) == TopAbs_SHAPE) continue; // nulle-vide
theshapes.Append(sh);
#include <TColStd_HSequenceOfTransient.hxx>
#include <Standard_Integer.hxx>
#include <IFSelect_PrintCount.hxx>
+#include <Message_ProgressRange.hxx>
+
class XSControl_WorkSession;
class Interface_InterfaceModel;
class Standard_Transient;
class TopoDS_Shape;
-
//! A groundwork to convert a shape to data which complies
//! with a particular norm. This data can be that of a whole
//! model or that of a specific list of entities in the model.
//! Translates a root identified by the rank num in the model.
//! false is returned if no shape is produced.
- Standard_EXPORT Standard_Boolean TransferOneRoot (const Standard_Integer num = 1);
+ Standard_EXPORT Standard_Boolean TransferOneRoot (const Standard_Integer num = 1,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Translates an IGES or STEP
//! entity identified by the rank num in the model.
//! false is returned if no shape is produced.
- Standard_EXPORT Standard_Boolean TransferOne (const Standard_Integer num);
+ Standard_EXPORT Standard_Boolean TransferOne (const Standard_Integer num,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Translates an IGES or STEP
//! entity in the model. true is returned if a shape is
//! produced; otherwise, false is returned.
- Standard_EXPORT Standard_Boolean TransferEntity (const Handle(Standard_Transient)& start);
+ Standard_EXPORT Standard_Boolean TransferEntity (const Handle(Standard_Transient)& start,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Translates a list of entities.
//! Returns the number of IGES or STEP entities that were
//! successfully translated. The list can be produced with GiveList.
//! Warning - This function does not clear the existing output shapes.
- Standard_EXPORT Standard_Integer TransferList (const Handle(TColStd_HSequenceOfTransient)& list);
+ Standard_EXPORT Standard_Integer TransferList (const Handle(TColStd_HSequenceOfTransient)& list,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Translates all translatable
//! roots and returns the number of successful translations.
//! Warning - This function clears existing output shapes first.
- Standard_EXPORT Standard_Integer TransferRoots();
+ Standard_EXPORT Standard_Integer TransferRoots(const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Clears the list of shapes that
//! may have accumulated in calls to TransferOne or TransferRoot.C
#include <Interface_SignLabel.hxx>
#include <Interface_Static.hxx>
#include <Message_Messenger.hxx>
+#include <Message_ProgressScope.hxx>
#include <ShapeFix.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
//=======================================================================
Standard_Integer XSControl_TransferReader::TransferOne
- (const Handle(Standard_Transient)& ent, const Standard_Boolean rec)
+ (const Handle(Standard_Transient)& ent,
+ const Standard_Boolean rec,
+ const Message_ProgressRange& theProgress)
{
if (myActor.IsNull() || myModel.IsNull()) return 0;
// seule difference entre TransferRoots et TransferOne
Standard_Integer res = 0;
Handle(Standard_Transient) obj = ent;
- TP.Transfer (obj);
+ TP.Transfer (obj, theProgress);
+ if (theProgress.UserBreak())
+ return res;
myTP->SetRoot (obj);
// Resultat ...
//=======================================================================
Standard_Integer XSControl_TransferReader::TransferList
- (const Handle(TColStd_HSequenceOfTransient)& list, const Standard_Boolean rec)
+ (const Handle(TColStd_HSequenceOfTransient)& list,
+ const Standard_Boolean rec,
+ const Message_ProgressRange& theProgress)
{
if (myActor.IsNull() || myModel.IsNull()) return 0;
Standard_Integer res = 0;
nb = list->Length();
Handle(Standard_Transient) obj;
-
- for (i = 1; i <= nb; i ++) {
+ Message_ProgressScope aPS(theProgress, NULL, nb);
+ for (i = 1; i <= nb && aPS.More(); i++) {
obj = list->Value(i);
- TP.Transfer (obj);
+ TP.Transfer (obj, aPS.Next());
myTP->SetRoot (obj);
// Resultat ...
//purpose :
//=======================================================================
-Standard_Integer XSControl_TransferReader::TransferRoots(const Interface_Graph& G)
+Standard_Integer XSControl_TransferReader::TransferRoots(const Interface_Graph& G,
+ const Message_ProgressRange& theProgress)
{
if (myModel != G.Model()) return -1;
if (!BeginTransfer()) return -1;
sout<<"\n*******************************************************************\n";
}
- TP.TransferRoots (G);
+ TP.TransferRoots (G, theProgress);
+ if (theProgress.UserBreak())
+ return -1;
// Les entites transferees sont notees "asmain"
Standard_Integer i,n = myTP->NbMapped();
#include <Standard_Transient.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
#include <Interface_CheckStatus.hxx>
+#include <Message_ProgressRange.hxx>
+
class XSControl_Controller;
class Interface_InterfaceModel;
class Interface_HGraph;
class Interface_CheckIterator;
class Interface_Graph;
-
class XSControl_TransferReader;
DEFINE_STANDARD_HANDLE(XSControl_TransferReader, Standard_Transient)
//! Imagine, using the selected Actor for Read
//! Returns count of transferred entities, ok or with fails (0/1)
//! If <rec> is True (D), the result is recorded by RecordResult
- Standard_EXPORT Standard_Integer TransferOne (const Handle(Standard_Transient)& theEnt, const Standard_Boolean theRec = Standard_True);
+ Standard_EXPORT Standard_Integer TransferOne (const Handle(Standard_Transient)& theEnt,
+ const Standard_Boolean theRec = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Commands the transfer on reading for a list of entities to
//! data for Imagine, using the selected Actor for Read
//! Returns count of transferred entities, ok or with fails (0/1)
//! If <rec> is True (D), the results are recorded by RecordResult
- Standard_EXPORT Standard_Integer TransferList (const Handle(TColStd_HSequenceOfTransient)& theList, const Standard_Boolean theRec = Standard_True);
+ Standard_EXPORT Standard_Integer TransferList (const Handle(TColStd_HSequenceOfTransient)& theList,
+ const Standard_Boolean theRec = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Transfers the content of the current Interface Model to
//! data handled by Imagine, starting from its Roots (determined
//! by the Graph <G>), using the selected Actor for Read
//! Returns the count of performed root transfers (i.e. 0 if none)
//! or -1 if no actor is defined
- Standard_EXPORT Standard_Integer TransferRoots (const Interface_Graph &theGraph);
+ Standard_EXPORT Standard_Integer TransferRoots (const Interface_Graph &theGraph,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Clears the results attached to an entity
//! if <ents> equates the starting model, clears all results
IFSelect_ReturnStatus XSControl_TransferWriter::TransferWriteTransient
(const Handle(Interface_InterfaceModel)& model,
- const Handle(Standard_Transient)& obj)
+ const Handle(Standard_Transient)& obj,
+ const Message_ProgressRange& theProgress)
{
IFSelect_ReturnStatus status = IFSelect_RetVoid;
if (myController.IsNull()) return IFSelect_RetError;
sout << "****** Transferring Transient, CDL Type = ";
sout<<obj->DynamicType()->Name()<<" ******"<<std::endl;
status = myController->TransferWriteTransient
- (obj,myTransferWriter,model,myTransferMode);
+ (obj,myTransferWriter,model, myTransferMode, theProgress);
}
catch(Standard_Failure const& anException) {
sout<<"**** **** TransferWriteShape, EXCEPTION : ";
IFSelect_ReturnStatus XSControl_TransferWriter::TransferWriteShape
(const Handle(Interface_InterfaceModel)& theModel,
- const TopoDS_Shape& theShape)
+ const TopoDS_Shape& theShape,
+ const Message_ProgressRange& theProgress)
{
IFSelect_ReturnStatus status = IFSelect_RetVoid;
if (myController.IsNull()) return IFSelect_RetError;
sout << "****** Transferring Shape, ShapeType = " << aShape.ShapeType();
sout<<" ******"<<std::endl;
status = myController->TransferWriteShape
- (aShape,myTransferWriter,theModel,myTransferMode);
+ (aShape,myTransferWriter, theModel, myTransferMode, theProgress);
}
catch(Standard_Failure const& anException) {
sout<<"**** **** TransferWriteShape, EXCEPTION : ";
//! Works by calling the Controller
//! Returns status : =0 if OK, >0 if error during transfer, <0 if
//! transfer badly initialised
- Standard_EXPORT IFSelect_ReturnStatus TransferWriteTransient (const Handle(Interface_InterfaceModel)& theModel, const Handle(Standard_Transient)& theObj);
+ Standard_EXPORT IFSelect_ReturnStatus TransferWriteTransient
+ (const Handle(Interface_InterfaceModel)& theModel,
+ const Handle(Standard_Transient)& theObj,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Tells if a Shape is valid for a transfer to a model
//! Asks the Controller (RecognizeWriteShape)
//! Works by calling the Controller
//! Returns status : =0 if OK, >0 if error during transfer, <0 if
//! transfer badly initialised
- Standard_EXPORT IFSelect_ReturnStatus TransferWriteShape (const Handle(Interface_InterfaceModel)& theModel, const TopoDS_Shape& theShape);
+ Standard_EXPORT IFSelect_ReturnStatus TransferWriteShape
+ (const Handle(Interface_InterfaceModel)& theModel,
+ const TopoDS_Shape& theShape,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns the check-list of last transfer (write), i.e. the
//! check-list currently recorded in the FinderProcess
#include <Interface_IntVal.hxx>
#include <Interface_Macros.hxx>
#include <Message_Messenger.hxx>
+#include <Message_ProgressScope.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <TColStd_HSequenceOfTransient.hxx>
//purpose :
//=======================================================================
-Standard_Integer XSControl_WorkSession::TransferReadOne (const Handle(Standard_Transient)& ent)
+Standard_Integer XSControl_WorkSession::TransferReadOne (const Handle(Standard_Transient)& ent,
+ const Message_ProgressRange& theProgress)
{
Handle(Interface_InterfaceModel) model = Model();
- if (ent == model) return TransferReadRoots();
+ if (ent == model) return TransferReadRoots(theProgress);
Handle(TColStd_HSequenceOfTransient) list = GiveList(ent);
- if (list->Length() == 1) return myTransferReader->TransferOne(list->Value(1));
- else return myTransferReader->TransferList (list);
+ if (list->Length() == 1)
+ return myTransferReader->TransferOne(list->Value(1), Standard_True, theProgress);
+ else
+ return myTransferReader->TransferList (list, Standard_True, theProgress);
}
//purpose :
//=======================================================================
-Standard_Integer XSControl_WorkSession::TransferReadRoots ()
+Standard_Integer XSControl_WorkSession::TransferReadRoots (const Message_ProgressRange& theProgress)
{
- return myTransferReader->TransferRoots(Graph());
+ return myTransferReader->TransferRoots(Graph(), theProgress);
}
//purpose :
//=======================================================================
-IFSelect_ReturnStatus XSControl_WorkSession::TransferWriteShape (const TopoDS_Shape& shape, const Standard_Boolean compgraph)
+IFSelect_ReturnStatus XSControl_WorkSession::TransferWriteShape (const TopoDS_Shape& shape,
+ const Standard_Boolean compgraph,
+ const Message_ProgressRange& theProgress)
{
IFSelect_ReturnStatus status;
if (myController.IsNull()) return IFSelect_RetError;
return IFSelect_RetVoid;
}
- status = myTransferWriter->TransferWriteShape (model,shape);
+ status = myTransferWriter->TransferWriteShape(model, shape, theProgress);
+ if (theProgress.UserBreak())
+ return IFSelect_RetStop;
// qui s occupe de tout, try/catch inclus
//skl insert param compgraph for XDE writing 10.12.2003
//! - <ents> a HSequenceOfTransient : this list
//! - <ents> the Model : in this specific case, all the roots,
//! with no cumulation of former transfers (TransferReadRoots)
- Standard_EXPORT Standard_Integer TransferReadOne (const Handle(Standard_Transient)& theEnts);
+ Standard_EXPORT Standard_Integer TransferReadOne (const Handle(Standard_Transient)& theEnts,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Commands the transfer of all the root entities of the model
//! i.e. calls TransferRoot from the TransferReader with the Graph
//! No cumulation with former calls to TransferReadOne
- Standard_EXPORT Standard_Integer TransferReadRoots();
+ Standard_EXPORT Standard_Integer TransferReadRoots(const Message_ProgressRange& theProgress = Message_ProgressRange());
//! produces and returns a new Model well conditionned
//! It is produced by the Norm Controller
//! according to the last call to SetModeWriteShape
//! Returns status :Done if OK, Fail if error during transfer,
//! Error if transfer badly initialised
- Standard_EXPORT IFSelect_ReturnStatus TransferWriteShape (const TopoDS_Shape& theShape, const Standard_Boolean theCompGraph = Standard_True);
+ Standard_EXPORT IFSelect_ReturnStatus TransferWriteShape
+ (const TopoDS_Shape& theShape,
+ const Standard_Boolean theCompGraph = Standard_True,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns the check-list of last transfer (write)
//! It is recorded in the FinderProcess, but it must be bound with
}
IFSelect_ReturnStatus XSControl_Writer::TransferShape
- (const TopoDS_Shape& sh, const Standard_Integer mode)
+ (const TopoDS_Shape& sh, const Standard_Integer mode, const Message_ProgressRange& theProgress)
{
thesession->TransferWriter()->SetTransferMode (mode);
- return thesession->TransferWriteShape (sh);
+ return thesession->TransferWriteShape (sh, Standard_True, theProgress);
}
IFSelect_ReturnStatus XSControl_Writer::WriteFile
#include <Standard_Boolean.hxx>
#include <IFSelect_ReturnStatus.hxx>
#include <Standard_Integer.hxx>
+#include <Message_ProgressRange.hxx>
+
class XSControl_WorkSession;
class Interface_InterfaceModel;
class TopoDS_Shape;
-
//! This class gives a simple way to create then write a
//! Model compliant to a given norm, from a Shape
//! The model can then be edited by tools by other appropriate tools
Standard_EXPORT Handle(Interface_InterfaceModel) Model (const Standard_Boolean newone = Standard_False);
//! Transfers a Shape according to the mode
- Standard_EXPORT IFSelect_ReturnStatus TransferShape (const TopoDS_Shape& sh, const Standard_Integer mode = 0);
+ Standard_EXPORT IFSelect_ReturnStatus TransferShape (const TopoDS_Shape& sh,
+ const Standard_Integer mode = 0,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Writes the produced model
Standard_EXPORT IFSelect_ReturnStatus WriteFile (const Standard_CString filename);
#include <Interface_Static.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Standard_ErrorHandler.hxx>
#include <Standard_Failure.hxx>
#include <TCollection_AsciiString.hxx>
// Progress indicator
Handle(Draw_ProgressIndicator) progress = new Draw_ProgressIndicator ( di, 1 );
- progress->SetScale ( 0, 100, 1 );
- progress->Show();
+ Message_ProgressScope aPSRoot (progress->Start(), "Reading", 100);
IGESControl_Reader Reader (XSDRAW::Session(),Standard_False);
Standard_Boolean aFullMode = Standard_True;
// Reading the file
- progress->NewScope ( 20, "Loading" ); // On average loading takes 20%
- progress->Show();
+ aPSRoot.SetName("Loading");
+ progress->Show(aPSRoot);
if (modfic) readstat = Reader.ReadFile (fnom.ToCString());
else if (XSDRAW::Session()->NbStartingEntities() > 0) readstat = IFSelect_RetDone;
- progress->EndScope();
- progress->Show();
+ aPSRoot.Next(20); // On average loading takes 20%
+ if (aPSRoot.UserBreak())
+ return 1;
if (readstat != IFSelect_RetDone) {
if (modfic) di<<"Could not read file "<<fnom.ToCString()<<" , abandon\n";
Handle(XSControl_WorkSession) thesession = Reader.WS();
thesession->ClearContext();
XSDRAW::SetTransferProcess (thesession->TransferReader()->TransientProcess());
- progress->NewScope ( 80, "Translation" );
- progress->Show();
- thesession->TransferReader()->TransientProcess()->SetProgress ( progress );
+
+ aPSRoot.SetName("Translation");
+ progress->Show(aPSRoot);
if (modepri == 1) Reader.SetReadVisible (Standard_True);
- Reader.TransferRoots();
+ Reader.TransferRoots(aPSRoot.Next(80));
- thesession->TransferReader()->TransientProcess()->SetProgress ( 0 );
- progress->EndScope();
- progress->Show();
+ if (aPSRoot.UserBreak())
+ return 1;
+
// result in only one shape for all the roots
// or in one shape for one root.
di<<"Count of shapes produced : "<<Reader.NbShapes()<<"\n";
std::cout << " give the number of the Entity : " << std::flush;
nent = XSDRAW::GetEntityNumber();
- if (!Reader.TransferOne (nent)) di<<"Transfer entity n0 "<<nent<<" : no result\n";
+ if (!Reader.TransferOne (nent))
+ di<<"Transfer entity n0 "<<nent<<" : no result\n";
else {
nbs = Reader.NbShapes();
char shname[30]; Sprintf (shname,"%s_%d",rnom.ToCString(),nent);
Handle(XSControl_WorkSession) thesession = Reader.WS();
thesession->ClearContext();
XSDRAW::SetTransferProcess (thesession->TransferReader()->TransientProcess());
- progress->NewScope ( 80, "Translation" );
- progress->Show();
- thesession->TransferReader()->TransientProcess()->SetProgress ( progress );
+
+ aPSRoot.SetName("Translation");
+ progress->Show(aPSRoot);
Reader.SetReadVisible (Standard_True);
- Reader.TransferRoots();
+ Reader.TransferRoots(aPSRoot.Next(80));
- thesession->TransferReader()->TransientProcess()->SetProgress ( 0 );
- progress->EndScope();
- progress->Show();
-
+ if (aPSRoot.UserBreak())
+ return 1;
+
// result in only one shape for all the roots
TopoDS_Shape shape = Reader.OneShape();
// save the shape
Handle(XSControl_WorkSession) thesession = Reader.WS();
XSDRAW::SetTransferProcess (thesession->TransferReader()->TransientProcess());
- progress->NewScope ( 80, "Translation" );
- progress->Show();
- thesession->TransferReader()->TransientProcess()->SetProgress ( progress );
+ aPSRoot.SetName("Translation");
+ progress->Show(aPSRoot);
- Message_ProgressSentry PSentry ( progress, "Root", 0, nbl, 1 );
- for (Standard_Integer ill = 1; ill <= nbl && PSentry.More(); ill ++, PSentry.Next()) {
-
+ Message_ProgressScope aPS(aPSRoot.Next(80), "Root", nbl);
+ for (Standard_Integer ill = 1; ill <= nbl && aPS.More(); ill++)
+ {
nent = Reader.Model()->Number(list->Value(ill));
if (nent == 0) continue;
- if (!Reader.TransferOne(nent)) di<<"Transfer entity n0 "<<nent<<" : no result\n";
+ if (!Reader.TransferOne(nent, aPS.Next()))
+ di<<"Transfer entity n0 "<<nent<<" : no result\n";
else {
nbs = Reader.NbShapes();
char shname[30]; Sprintf (shname,"%s_%d",rnom.ToCString(),nbs);
nbt++;
}
}
- thesession->TransferReader()->TransientProcess()->SetProgress ( 0 );
- progress->EndScope();
- progress->Show();
- di<<"Nb Shapes successfully produced : "<<nbt<<"\n";
+ if (aPSRoot.UserBreak())
+ return 1;
+ di<<"Nb Shapes successfully produced : "<<nbt<<"\n";
answer = 0; // on ne reboucle pas
}
}
Standard_Integer npris = 0;
Handle(Draw_ProgressIndicator) progress = new Draw_ProgressIndicator ( di, 1 );
- progress->NewScope(90,"Translating");
- progress->Show();
- ICW.TransferProcess()->SetProgress(progress);
+ Message_ProgressScope aPSRoot (progress->Start(), "Translating", 100);
+ progress->Show(aPSRoot);
- for ( Standard_Integer i = 1; i < n; i++) {
+ Message_ProgressScope aPS(aPSRoot.Next(90), NULL, n);
+ for ( Standard_Integer i = 1; i < n && aPS.More(); i++) {
const char* nomvar = a[i];
if (a[i][0] == '+') nomvar = &(a[i])[1];
else if (i > 1) { nomfic = a[i]; break; }
TopoDS_Shape Shape = DBRep::Get(nomvar);
- if (ICW.AddShape (Shape)) npris ++;
+ if (ICW.AddShape (Shape, aPS.Next())) npris ++;
else if (ICW.AddGeom (DrawTrSurf::GetCurve (nomvar)) ) npris ++;
else if (ICW.AddGeom (DrawTrSurf::GetSurface (nomvar)) ) npris ++;
}
XSDRAW::SetModel(ICW.Model());
XSDRAW::SetTransferProcess (ICW.TransferProcess());
- ICW.TransferProcess()->SetProgress(0);
- progress->EndScope();
- progress->Show();
- progress->NewScope(10,"Writing");
- progress->Show();
+ if (aPSRoot.UserBreak())
+ return 1;
+ aPSRoot.SetName("Writing");
+ progress->Show(aPSRoot);
di<<npris<<" Shapes written, giving "<<XSDRAW::Model()->NbEntities()<<" Entities\n";
if (! ICW.Write(nomfic)) di<<" Error: could not write file " << nomfic;
else di<<" File " << nomfic << " written";
- progress->EndScope();
- progress->Show();
-
return 0;
}
#include <Interface_Static.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <STEPControl_ActorWrite.hxx>
#include <STEPControl_Controller.hxx>
#include <STEPControl_Reader.hxx>
//purpose :
//=======================================================================
-static Standard_Integer stepread (Draw_Interpretor& di/*theCommands*/, Standard_Integer argc, const char** argv)
+static Standard_Integer stepread (Draw_Interpretor& di, Standard_Integer argc, const char** argv)
{
if (argc < 3) {
di << "Use: stepread [file] [f or r (type of model full or reduced)]\n";
// Progress indicator
Handle(Draw_ProgressIndicator) progress = new Draw_ProgressIndicator ( di, 1 );
- progress->SetScale ( 0, 100, 1 );
- progress->Show();
+ Message_ProgressScope aPSRoot (progress->Start(), "Reading", 100);
STEPControl_Reader sr (XSDRAW::Session(),Standard_False);
TCollection_AsciiString fnom,rnom;
di<<" -- Names of variables BREP-DRAW prefixed by : "<<rnom.ToCString()<<"\n";
IFSelect_ReturnStatus readstat = IFSelect_RetVoid;
- progress->NewScope ( 20, "Loading" ); // On average loading takes 20%
- progress->Show();
+ aPSRoot.SetName("Loading");
+ progress->Show(aPSRoot);
Standard_Boolean fromtcl = Standard_False;
Standard_Boolean aFullMode = Standard_False;
if (modfic) readstat = sr.ReadFile (fnom.ToCString());
else if (XSDRAW::Session()->NbStartingEntities() > 0) readstat = IFSelect_RetDone;
- progress->EndScope();
- progress->Show();
+ aPSRoot.Next(20); // On average loading takes 20%
+ if (aPSRoot.UserBreak())
+ return 1;
if (readstat != IFSelect_RetDone) {
if (modfic) di<<"Could not read file "<<fnom.ToCString()<<" , abandon\n";
return 1;
}
-
// nom = "." -> fichier deja lu
Standard_Integer i, num, nbs, modepri = 1;
if (fromtcl) modepri = 4;
if (modepri == 2) {
std::cout<<"Root N0 : "<<std::flush; std::cin>>num;
}
+ aPSRoot.SetName("Translation");
+ progress->Show(aPSRoot);
- progress->NewScope ( 80, "Translation" );
- progress->Show();
- sr.WS()->TransferReader()->TransientProcess()->SetProgress ( progress );
-
- if (!sr.TransferRoot (num)) di<<"Transfer root n0 "<<num<<" : no result\n";
+ if (!sr.TransferRoot (num, aPSRoot.Next(80)))
+ di<<"Transfer root n0 "<<num<<" : no result\n";
else {
nbs = sr.NbShapes();
char shname[30]; Sprintf (shname,"%s_%d",rnom.ToCString(),nbs);
TopoDS_Shape sh = sr.Shape(nbs);
DBRep::Set (shname,sh);
}
-
- sr.WS()->TransferReader()->TransientProcess()->SetProgress ( 0 );
- progress->EndScope();
- progress->Show();
+ if (aPSRoot.UserBreak())
+ return 1;
}
else if (modepri == 3) {
std::cout<<"Entity : "<<std::flush; num = XSDRAW::GetEntityNumber();
- if (!sr.TransferOne (num)) di<<"Transfer entity n0 "<<num<<" : no result\n";
+ if (!sr.TransferOne (num))
+ di<<"Transfer entity n0 "<<num<<" : no result\n";
else {
nbs = sr.NbShapes();
char shname[30]; Sprintf (shname,"%s_%d",rnom.ToCString(),num);
di<<"Nb entities selected : "<<nbl<<"\n";
if (nbl == 0) continue;
- progress->NewScope ( 80, "Translation" );
- progress->Show();
- sr.WS()->TransferReader()->TransientProcess()->SetProgress ( progress );
+ aPSRoot.SetName("Translation");
+ progress->Show(aPSRoot);
- Message_ProgressSentry PSentry ( progress, "Root", 0, nbl, 1 );
- for (ill = 1; ill <= nbl && PSentry.More(); ill ++, PSentry.Next()) {
+ Message_ProgressScope aPS(aPSRoot.Next(80), "Root", nbl);
+ for (ill = 1; ill <= nbl && aPS.More(); ill++) {
num = sr.Model()->Number(list->Value(ill));
if (num == 0) continue;
- if (!sr.TransferOne(num)) di<<"Transfer entity n0 "<<num<<" : no result\n";
+ if (!sr.TransferOne(num, aPS.Next()))
+ di<<"Transfer entity n0 "<<num<<" : no result\n";
else {
nbs = sr.NbShapes();
char shname[30]; Sprintf (shname,"%s_%d",rnom.ToCString(),nbs);
DBRep::Set (shname,sh);
}
}
- sr.WS()->TransferReader()->TransientProcess()->SetProgress ( 0 );
- progress->EndScope();
- progress->Show();
+ if (aPSRoot.UserBreak())
+ return 1;
}
else di<<"Unknown mode n0 "<<modepri<<"\n";
}
Standard_Integer nbavant = (stepmodel.IsNull() ? 0 : stepmodel->NbEntities());
Handle(Draw_ProgressIndicator) progress = new Draw_ProgressIndicator ( di, 1 );
- progress->NewScope(90,"Translating");
- progress->Show();
- sw.WS()->TransferWriter()->FinderProcess()->SetProgress(progress);
+ Message_ProgressScope aPSRoot (progress->Start(), "Translating", 100);
+ progress->Show(aPSRoot);
- Standard_Integer stat = sw.Transfer (shape,mode);
+ Standard_Integer stat = sw.Transfer (shape, mode, Standard_True, aPSRoot.Next(90));
if (stat == IFSelect_RetDone)
{
di << "Translation: OK\n";
di << "Error: translation failed, status = " << stat << "\n";
}
- sw.WS()->TransferWriter()->FinderProcess()->SetProgress(0);
- progress->EndScope();
- progress->Show();
- progress->NewScope(10,"Writing");
- progress->Show();
+ if (aPSRoot.UserBreak())
+ return 1;
+ aPSRoot.SetName("Writing");
+ progress->Show(aPSRoot);
// Que s est-il passe
stepmodel = sw.Model();
default : di<<"Error: File "<<nomfic<<" written with fail messages\n"; break;
}
- progress->EndScope();
- progress->Show();
-
return 0;
}
//=======================================================================
}
else
{
- aReader.Perform (aFilePath, aProgress);
+ aReader.Perform (aFilePath, aProgress->Start());
if (isNoDoc)
{
DBRep::Set (aDestName.ToCString(), aReader.SingleShape());
aWriter.SetForcedUVExport (toForceUVExport);
aWriter.ChangeCoordinateSystemConverter().SetInputLengthUnit (aSystemUnitFactor);
aWriter.ChangeCoordinateSystemConverter().SetInputCoordinateSystem (RWMesh_CoordinateSystem_Zup);
- aWriter.Perform (aDoc, aFileInfo, aProgress);
+ aWriter.Perform (aDoc, aFileInfo, aProgress->Start());
return 0;
}
}
StlAPI_Writer aWriter;
aWriter.ASCIIMode() = isASCIIMode;
- Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator(di, 1);
- Standard_Boolean isOK = aWriter.Write (aShape, argv[2], aProgress);
+ Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (di);
+ Standard_Boolean isOK = aWriter.Write (aShape, argv[2], aProgress->Start());
if (!isOK)
di << "** Error **: Mesh writing has been failed.\n";
}
{
// Read STL file to the triangulation.
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (theDI, 1);
- Handle(Poly_Triangulation) aTriangulation = RWStl::ReadFile (aFilePath.ToCString(), aProgress);
+ Handle(Poly_Triangulation) aTriangulation = RWStl::ReadFile (aFilePath.ToCString(), aProgress->Start());
TopoDS_Face aFace;
BRep_Builder aB;
aSimpleReader.SetSinglePrecision (isSinglePrecision);
aSimpleReader.SetCreateShapes (Standard_False);
aSimpleReader.SetTransformation (aReader.CoordinateSystemConverter());
- aSimpleReader.Read (aFilePath.ToCString(), aProgress);
+ aSimpleReader.Read (aFilePath.ToCString(), aProgress->Start());
Handle(Poly_Triangulation) aTriangulation = aSimpleReader.GetTriangulation();
TopoDS_Face aFace;
}
else
{
- aReader.Perform (aFilePath, aProgress);
+ aReader.Perform (aFilePath, aProgress->Start());
if (isNoDoc)
{
DBRep::Set (aDestName.ToCString(), aReader.SingleShape());
// Progress indicator
OSD_Path aFile( argv[2] );
Handle(Draw_ProgressIndicator) aProgress = new Draw_ProgressIndicator (di, 1);
- Handle(Poly_Triangulation) aSTLMesh = RWStl::ReadFile (aFile, aProgress);
+ Handle(Poly_Triangulation) aSTLMesh = RWStl::ReadFile (aFile, aProgress->Start());
di << "Reading OK...\n";
Handle( XSDRAWSTLVRML_DataSource ) aDS = new XSDRAWSTLVRML_DataSource( aSTLMesh );
//purpose : Implementation of ReadShapeSection
//=======================================================================
Handle(XmlMDF_ADriver) XmlDrivers_DocumentRetrievalDriver::ReadShapeSection(
- const XmlObjMgt_Element& theElement,
+ const XmlObjMgt_Element& theElement,
const Handle(Message_Messenger)& theMsgDriver,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
if (myDrivers.IsNull()) myDrivers = AttributeDrivers (theMsgDriver);
Handle(XmlMDF_ADriver) aDriver;
{
Handle(XmlMNaming_NamedShapeDriver) aNamedShapeDriver =
Handle(XmlMNaming_NamedShapeDriver)::DownCast (aDriver);
- aNamedShapeDriver->ReadShapeSection (theElement, theProgress);
+ aNamedShapeDriver->ReadShapeSection (theElement, theRange);
}
return aDriver;
}
Standard_EXPORT virtual Handle(XmlMDF_ADriver) ReadShapeSection
(const XmlObjMgt_Element& thePDoc,
const Handle(Message_Messenger)& theMsgDriver,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual void ShapeSetCleaning
(const Handle(XmlMDF_ADriver)& theDriver) Standard_OVERRIDE;
//=======================================================================
Standard_Boolean XmlDrivers_DocumentStorageDriver::WriteShapeSection
(XmlObjMgt_Element& theElement,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Standard_Boolean isShape(Standard_False);
Handle(XmlMDF_ADriver) aDriver;
{
Handle(XmlMNaming_NamedShapeDriver) aNamedShapeDriver =
Handle(XmlMNaming_NamedShapeDriver)::DownCast (aDriver);
- aNamedShapeDriver->WriteShapeSection (theElement, theProgress);
+ aNamedShapeDriver->WriteShapeSection (theElement, theRange);
isShape = Standard_True;
}
return isShape;
Standard_EXPORT virtual Standard_Boolean WriteShapeSection
(XmlObjMgt_Element& thePDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
DEFINE_STANDARD_RTTIEXT(XmlDrivers_DocumentStorageDriver,XmlLDrivers_DocumentStorageDriver)
#include <CDM_Application.hxx>
#include <CDM_Document.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <CDM_MetaData.hxx>
#include <LDOM_DocumentType.hxx>
#include <LDOM_LDOMImplementation.hxx>
(const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
myReaderStatus = PCDM_RS_DriverFailure;
myFileName = theFileName;
if (aFileStream.is_open() && aFileStream.good())
{
- Read (aFileStream, NULL, theNewDocument, theApplication, theProgress);
+ Read (aFileStream, NULL, theNewDocument, theApplication, theRange);
}
else
{
const Handle(Storage_Data)& /*theStorageData*/,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Handle(Message_Messenger) aMessageDriver = theApplication -> MessageDriver();
::take_time (~0, " +++++ Start RETRIEVE procedures ++++++", aMessageDriver);
const XmlObjMgt_Element anElement= aParser.getDocument().getDocumentElement();
::take_time (0, " +++++ Fin parsing XML : ", aMessageDriver);
- ReadFromDomDocument (anElement, theNewDocument, theApplication, theProgress);
+ ReadFromDomDocument (anElement, theNewDocument, theApplication, theRange);
}
//=======================================================================
(const XmlObjMgt_Element& theElement,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
const Handle(Message_Messenger) aMsgDriver =
theApplication -> MessageDriver();
}
}
}
- Message_ProgressSentry aPS(theProgress, "Reading document", 0, 2, 1);
+ Message_ProgressScope aPS(theRange, "Reading document", 2);
// 2. Read Shapes section
if (myDrivers.IsNull()) myDrivers = AttributeDrivers (aMsgDriver);
- const Handle(XmlMDF_ADriver) aNSDriver = ReadShapeSection(theElement, aMsgDriver, theProgress);
+ const Handle(XmlMDF_ADriver) aNSDriver = ReadShapeSection(theElement, aMsgDriver, aPS.Next());
if(!aNSDriver.IsNull())
::take_time (0, " +++++ Fin reading Shapes : ", aMsgDriver);
myReaderStatus = PCDM_RS_UserBreak;
return;
}
- aPS.Next();
// 2.1. Keep document format version in RT
Handle(Storage_HeaderData) aHeaderData = new Storage_HeaderData();
TCollection_ExtendedString aMessage ("PasteDocument");
aMsgDriver ->Send (aMessage.ToExtString(), Message_Trace);
#endif
- if (!MakeDocument(theElement, theNewDocument, theProgress))
+ if (!MakeDocument(theElement, theNewDocument, aPS.Next()))
myReaderStatus = PCDM_RS_MakeFailure;
else
myReaderStatus = PCDM_RS_OK;
myReaderStatus = PCDM_RS_UserBreak;
return;
}
- aPS.Next();
// Wipe off the shapes written to the <shapes> section
ShapeSetCleaning(aNSDriver);
Standard_Boolean XmlLDrivers_DocumentRetrievalDriver::MakeDocument
(const XmlObjMgt_Element& theElement,
const Handle(CDM_Document)& theTDoc,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
Standard_Boolean aResult = Standard_False;
Handle(TDocStd_Document) TDOC = Handle(TDocStd_Document)::DownCast(theTDoc);
if (!TDOC.IsNull())
{
Handle(TDF_Data) aTDF = new TDF_Data();
- aResult = XmlMDF::FromTo (theElement, aTDF, myRelocTable, myDrivers, theProgress);
+ aResult = XmlMDF::FromTo (theElement, aTDF, myRelocTable, myDrivers, theRange);
if (aResult) {
TDOC->SetData (aTDF);
TDocStd_Owner::SetDocument (aTDF, TDOC);
Handle(XmlMDF_ADriver) XmlLDrivers_DocumentRetrievalDriver::ReadShapeSection(
const XmlObjMgt_Element& /*theElement*/,
const Handle(Message_Messenger)& /*aMsgDriver*/,
- const Handle(Message_ProgressIndicator)& /*theProgress*/)
+ const Message_ProgressRange& /*theRange*/)
{
Handle(XmlMDF_ADriver) aDriver;
//empty; to be redefined
Standard_EXPORT virtual void Read (const TCollection_ExtendedString& theFileName,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual void Read (Standard_IStream& theIStream,
const Handle(Storage_Data)& theStorageData,
const Handle(CDM_Document)& theDoc,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange= Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(XmlMDF_ADriverTable) AttributeDrivers (const Handle(Message_Messenger)& theMsgDriver);
Standard_EXPORT virtual void ReadFromDomDocument (const XmlObjMgt_Element& theDomElement,
const Handle(CDM_Document)& theNewDocument,
const Handle(CDM_Application)& theApplication,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT virtual Standard_Boolean MakeDocument (const XmlObjMgt_Element& thePDoc,
const Handle(CDM_Document)& theTDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT virtual Handle(XmlMDF_ADriver) ReadShapeSection
(const XmlObjMgt_Element& thePDoc,
const Handle(Message_Messenger)& theMsgDriver,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT virtual void ShapeSetCleaning (const Handle(XmlMDF_ADriver)& theDriver);
#include <CDM_Document.hxx>
#include <Message.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <LDOM_DocumentType.hxx>
#include <LDOM_LDOMImplementation.hxx>
#include <LDOM_XmlWriter.hxx>
//=======================================================================
void XmlLDrivers_DocumentStorageDriver::Write (const Handle(CDM_Document)& theDocument,
const TCollection_ExtendedString& theFileName,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
myFileName = theFileName;
if (aFileStream.is_open() && aFileStream.good())
{
- Write (theDocument, aFileStream, theProgress);
+ Write (theDocument, aFileStream, theRange);
}
else
{
//function : Write
//purpose :
//=======================================================================
-void XmlLDrivers_DocumentStorageDriver::Write (const Handle(CDM_Document)& theDocument,
- Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress)
+void XmlLDrivers_DocumentStorageDriver::Write (const Handle(CDM_Document)& theDocument,
+ Standard_OStream& theOStream,
+ const Message_ProgressRange& theRange)
{
Handle(Message_Messenger) aMessageDriver = theDocument->Application()->MessageDriver();
::take_time (~0, " +++++ Start STORAGE procedures ++++++", aMessageDriver);
// Fill the document with data
XmlObjMgt_Element anElement = aDOMDoc.getDocumentElement();
- if (WriteToDomDocument (theDocument, anElement, theProgress) == Standard_False) {
+ if (WriteToDomDocument (theDocument, anElement, theRange) == Standard_False) {
LDOM_XmlWriter aWriter;
aWriter.SetIndentation(1);
Standard_Boolean XmlLDrivers_DocumentStorageDriver::WriteToDomDocument
(const Handle(CDM_Document)& theDocument,
XmlObjMgt_Element& theElement,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
SetIsError(Standard_False);
Handle(Message_Messenger) aMessageDriver =
aCommentsElem.appendChild (aCItem);
XmlObjMgt::SetExtendedString (aCItem, aComments(i));
}
- Message_ProgressSentry aPS(theProgress, "Writing", 0, 2, 1);
+ Message_ProgressScope aPS(theRange, "Writing", 2);
// 2a. Write document contents
Standard_Integer anObjNb = 0;
{
try
{
OCC_CATCH_SIGNALS
- anObjNb = MakeDocument(theDocument, theElement, theProgress);
+ anObjNb = MakeDocument(theDocument, theElement, aPS.Next());
if (!aPS.More())
{
SetIsError(Standard_True);
SetStoreStatus(PCDM_SS_UserBreak);
return IsError();
}
- aPS.Next();
}
catch (Standard_Failure const& anException)
{
myRelocTable.Clear();
// 4. Write Shapes section
- if (WriteShapeSection(theElement, theProgress))
+ if (WriteShapeSection(theElement, aPS.Next()))
::take_time (0, " +++ Fin DOM data for Shapes : ", aMessageDriver);
if (!aPS.More())
{
SetStoreStatus(PCDM_SS_UserBreak);
return IsError();
}
- aPS.Next();
return IsError();
}
//purpose :
//=======================================================================
Standard_Integer XmlLDrivers_DocumentStorageDriver::MakeDocument
- (const Handle(CDM_Document)& theTDoc,
- XmlObjMgt_Element& theElement,
- const Handle(Message_ProgressIndicator)& theProgress)
+ (const Handle(CDM_Document)& theTDoc,
+ XmlObjMgt_Element& theElement,
+ const Message_ProgressRange& theRange)
{
TCollection_ExtendedString aMessage;
Handle(TDocStd_Document) TDOC = Handle(TDocStd_Document)::DownCast(theTDoc);
if (myDrivers.IsNull()) myDrivers = AttributeDrivers (aMessageDriver);
// Retrieve from DOM_Document
- XmlMDF::FromTo (aTDF, theElement, myRelocTable, myDrivers, theProgress);
+ XmlMDF::FromTo (aTDF, theElement, myRelocTable, myDrivers, theRange);
#ifdef OCCT_DEBUGXML
aMessage = "First step successfull";
aMessageDriver -> Send (aMessage.ToExtString(), Message_Warning);
//purpose : defines WriteShapeSection
//=======================================================================
Standard_Boolean XmlLDrivers_DocumentStorageDriver::WriteShapeSection
- (XmlObjMgt_Element& /*theElement*/,
- const Handle(Message_ProgressIndicator)& /*theProgress*/)
+ (XmlObjMgt_Element& /*theElement*/,
+ const Message_ProgressRange& /*theRange*/)
{
// empty; should be redefined in subclasses
return Standard_False;
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& theDocument,
const TCollection_ExtendedString& theFileName,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual void Write (const Handle(CDM_Document)& theDocument,
Standard_OStream& theOStream,
- const Handle(Message_ProgressIndicator)& theProgress = NULL) Standard_OVERRIDE;
+ const Message_ProgressRange& theRange = Message_ProgressRange()) Standard_OVERRIDE;
Standard_EXPORT virtual Handle(XmlMDF_ADriverTable) AttributeDrivers (const Handle(Message_Messenger)& theMsgDriver);
Standard_EXPORT virtual Standard_Boolean WriteToDomDocument
(const Handle(CDM_Document)& theDocument,
XmlObjMgt_Element& thePDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT virtual Standard_Integer MakeDocument
(const Handle(CDM_Document)& theDocument,
XmlObjMgt_Element& thePDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT void AddNamespace (const TCollection_AsciiString& thePrefix,
const TCollection_AsciiString& theURI);
Standard_EXPORT virtual Standard_Boolean WriteShapeSection
(XmlObjMgt_Element& thePDoc,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Handle(XmlMDF_ADriverTable) myDrivers;
XmlObjMgt_SRelocationTable myRelocTable;
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <Storage_Schema.hxx>
#include <TColStd_MapOfTransient.hxx>
#include <TDF_Attribute.hxx>
XmlObjMgt_Element& theElement,
XmlObjMgt_SRelocationTable& theRelocTable,
const Handle(XmlMDF_ADriverTable)& theDrivers,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
UnsuppTypesMap().Clear();
// Standard_Integer count =
- WriteSubTree(theData->Root(), theElement, theRelocTable, theDrivers, theProgress);
+ WriteSubTree(theData->Root(), theElement, theRelocTable, theDrivers, theRange);
UnsuppTypesMap().Clear();
}
XmlObjMgt_Element& theElement,
XmlObjMgt_SRelocationTable& theRelocTable,
const Handle(XmlMDF_ADriverTable)& theDrivers,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
XmlObjMgt_Document aDoc = theElement.getOwnerDocument();
{
}
itr2.Initialize(theLabel);
- Message_ProgressSentry aPS(theProgress, "Writing sub-tree", 0, child_count, 1);
- for ( ; itr2.More() && aPS.More(); itr2.Next(), aPS.Next())
+ Message_ProgressScope aPS(theRange, "Writing sub-tree", child_count, true);
+ for ( ; itr2.More() && aPS.More(); itr2.Next())
{
const TDF_Label& aChildLab = itr2.Value();
- count += WriteSubTree(aChildLab, aLabElem, theRelocTable, theDrivers, theProgress);
+ count += WriteSubTree(aChildLab, aLabElem, theRelocTable, theDrivers, aPS.Next());
}
if (count > 0 || TDocStd_Owner::GetDocument(theLabel.Data())->EmptyLabelsSavingMode())
//function : FromTo
//purpose : Paste data from DOM_Element into transient document
//=======================================================================
-Standard_Boolean XmlMDF::FromTo (const XmlObjMgt_Element& theElement,
- Handle(TDF_Data)& theData,
- XmlObjMgt_RRelocationTable& theRelocTable,
+Standard_Boolean XmlMDF::FromTo (const XmlObjMgt_Element& theElement,
+ Handle(TDF_Data)& theData,
+ XmlObjMgt_RRelocationTable& theRelocTable,
const Handle(XmlMDF_ADriverTable)& theDrivers,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
TDF_Label aRootLab = theData->Root();
XmlMDF_MapOfDriver aDriverMap;
if ( anElem.getNodeName().equals (::LabelString()) )
{
Standard_Integer subcount =
- ReadSubTree(anElem, aRootLab, theRelocTable, aDriverMap, theProgress);
+ ReadSubTree(anElem, aRootLab, theRelocTable, aDriverMap, theRange);
// check for error
if (subcount < 0)
return Standard_False;
//function : ReadSubTree
//purpose :
//=======================================================================
-Standard_Integer XmlMDF::ReadSubTree (const XmlObjMgt_Element& theElement,
- const TDF_Label& theLabel,
- XmlObjMgt_RRelocationTable& theRelocTable,
- const XmlMDF_MapOfDriver& theDriverMap,
- const Handle(Message_ProgressIndicator)& theProgress)
+Standard_Integer XmlMDF::ReadSubTree (const XmlObjMgt_Element& theElement,
+ const TDF_Label& theLabel,
+ XmlObjMgt_RRelocationTable& theRelocTable,
+ const XmlMDF_MapOfDriver& theDriverMap,
+ const Message_ProgressRange& theRange)
{
// Extraction of the driver subset.
Standard_Integer count = 0;
//XmlObjMgt_Element anElem = (const XmlObjMgt_Element &) theElement.getFirstChild();
LDOM_Node theNode = theElement.getFirstChild();
XmlObjMgt_Element anElem = (const XmlObjMgt_Element &) theNode;
- Message_ProgressSentry aPS(theProgress, "Reading sub-tree", 0, 2, 1, true);
+ Message_ProgressScope aPS(theRange, "Reading sub-tree", 2, true);
while ( !anElem.isNull() )
{
if ( anElem.getNodeType() == LDOM_Node::ELEMENT_NODE )
// read sub-tree
Standard_Integer subcount =
- ReadSubTree(anElem, aLab, theRelocTable, theDriverMap, theProgress);
+ ReadSubTree(anElem, aLab, theRelocTable, theDriverMap, aPS.Next());
// check for error
if (subcount == -1)
return -1;
anElem = (const XmlObjMgt_Element &) theNode1;
if (!aPS.More())
- return -1;
- aPS.Next();
+ return -1;
}
// AfterRetrieval
#include <XmlObjMgt_RRelocationTable.hxx>
#include <XmlMDF_MapOfDriver.hxx>
-#include <Message_ProgressIndicator.hxx>
+#include <Message_ProgressRange.hxx>
class TDF_Data;
class XmlMDF_ADriverTable;
XmlObjMgt_Element& aTarget,
XmlObjMgt_SRelocationTable& aReloc,
const Handle(XmlMDF_ADriverTable)& aDrivers,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Translates a persistent <aSource> into a transient
//! <aTarget>.
(const XmlObjMgt_Element& aSource,
Handle(TDF_Data)& aTarget, XmlObjMgt_RRelocationTable& aReloc,
const Handle(XmlMDF_ADriverTable)& aDrivers,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Adds the attribute storage drivers to <aDriverSeq>.
Standard_EXPORT static void AddDrivers (const Handle(XmlMDF_ADriverTable)& aDriverTable,
XmlObjMgt_Element& theElement,
XmlObjMgt_SRelocationTable& aReloc,
const Handle(XmlMDF_ADriverTable)& aDrivers,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT static Standard_Integer ReadSubTree
(const XmlObjMgt_Element& theElement,
const TDF_Label& theLabel,
XmlObjMgt_RRelocationTable& aReloc,
const XmlMDF_MapOfDriver& aDrivers,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
Standard_EXPORT static void CreateDrvMap (const Handle(XmlMDF_ADriverTable)& aDriverTable,
XmlMDF_MapOfDriver& anAsciiDriverMap);
#include <BRepTools.hxx>
#include <Message_Messenger.hxx>
-#include <Message_ProgressSentry.hxx>
+#include <Message_ProgressScope.hxx>
#include <LDOM_OSStream.hxx>
#include <LDOM_Text.hxx>
#include <Standard_SStream.hxx>
//=======================================================================
void XmlMNaming_NamedShapeDriver::ReadShapeSection (const XmlObjMgt_Element& theElement,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
XmlObjMgt_Element anElement =
XmlObjMgt::FindChildByName (theElement, ::ShapesString());
LDOMString aData = aNode.getNodeValue();
std::stringstream aStream (std::string(aData.GetString()));
myShapeSet.Clear();
- myShapeSet.Read (aStream, theProgress);
+ myShapeSet.Read (aStream, theRange);
break;
}
}
//=======================================================================
void XmlMNaming_NamedShapeDriver::WriteShapeSection (XmlObjMgt_Element& theElement,
- const Handle(Message_ProgressIndicator)& theProgress)
+ const Message_ProgressRange& theRange)
{
// Create "shapes" element and append it as child
XmlObjMgt_Document aDoc = theElement.getOwnerDocument();
LDOM_OSStream aStream (16 * 1024);
// ostrstream aStream;
// aStream.rdbuf() -> setbuf (0, 16380);
- Message_ProgressSentry aPS(theProgress, "Writing shape section", 0, 2, 1);
- myShapeSet.Write (aStream, theProgress);
+ Message_ProgressScope aPS(theRange, "Writing shape section", 2);
+ myShapeSet.Write (aStream, aPS.Next());
if (!aPS.More())
return;
- aPS.Next();
+
aStream << std::ends;
char * aStr = (char *)aStream.str();
LDOM_Text aText = aDoc.createTextNode (aStr);
//! Input the shapes from DOM element
Standard_EXPORT void ReadShapeSection (const XmlObjMgt_Element& anElement,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Output the shapes into DOM element
Standard_EXPORT void WriteShapeSection (XmlObjMgt_Element& anElement,
- const Handle(Message_ProgressIndicator)& theProgress = NULL);
+ const Message_ProgressRange& theRange = Message_ProgressRange());
//! Clear myShapeSet
Standard_EXPORT void Clear();
math_Gauss::math_Gauss(const math_Matrix& A,
const Standard_Real MinPivot,
- const Handle(Message_ProgressIndicator) & aProgress)
-: LU (1, A.RowNumber(), 1, A.ColNumber()),
+ const Message_ProgressRange& theProgress)
+ : LU (1, A.RowNumber(), 1, A.ColNumber()),
Index(1, A.RowNumber()),
D (0.0),
Done (Standard_False)
Index,
D,
MinPivot,
- aProgress);
+ theProgress);
if(!Error) {
Done = Standard_True;
}
#include <Standard_Real.hxx>
#include <math_Vector.hxx>
#include <Standard_OStream.hxx>
+#include <Message_ProgressRange.hxx>
class math_NotSquare;
class Standard_DimensionError;
class StdFail_NotDone;
class math_Matrix;
-class Message_ProgressIndicator;
//! This class implements the Gauss LU decomposition (Crout algorithm)
//! with partial pivoting (rows interchange) of a square matrix and
//! Exception NotSquare is raised if A is not a square matrix.
Standard_EXPORT math_Gauss(const math_Matrix& A,
const Standard_Real MinPivot = 1.0e-20,
- const Handle(Message_ProgressIndicator) & aProgress = Handle(Message_ProgressIndicator)());
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
//! Returns true if the computations are successful, otherwise returns false
Standard_Boolean IsDone() const { return Done; }
#include <Standard_Failure.hxx>
#include <Standard_NotImplemented.hxx>
-#include <Message_ProgressSentry.hxx>
#include <math_Vector.hxx>
#include <math_IntegerVector.hxx>
#include <math_Matrix.hxx>
+#include <Message_ProgressScope.hxx>
namespace {
static inline Standard_Real PYTHAG (const Standard_Real a, const Standard_Real b)
Standard_Real& d,
math_Vector& vv,
Standard_Real TINY,
- const Handle(Message_ProgressIndicator) & aProgress) {
+ const Message_ProgressRange& theProgress) {
Standard_Integer i, imax=0, j, k;
Standard_Real big, dum, sum, temp;
Standard_Integer n = a.RowNumber();
d = 1.0;
- Message_ProgressSentry aPSentry(aProgress, "", 0, n, 1);
+ Message_ProgressScope aPS(theProgress, "", n);
for(i = 1; i <= n; i++) {
big = 0.0;
vv(i) = 1.0 / big;
}
- for(j = 1; j <= n && aPSentry.More(); j++, aPSentry.Next()) {
+ for(j = 1; j <= n && aPS.More(); j++, aPS.Next()) {
for(i = 1; i < j; i++) {
sum = a(i,j);
for(k = 1; k < i; k++)
math_IntegerVector& indx,
Standard_Real& d,
Standard_Real TINY,
- const Handle(Message_ProgressIndicator) & aProgress) {
+ const Message_ProgressRange& theProgress) {
math_Vector vv(1, a.RowNumber());
- return LU_Decompose(a, indx, d, vv, TINY, aProgress);
+ return LU_Decompose(a, indx, d, vv, TINY, theProgress);
}
void LU_Solve(const math_Matrix& a,
#include <Standard_Integer.hxx>
#include <Standard_Real.hxx>
#include <Standard_Handle.hxx>
+#include <Message_ProgressRange.hxx>
class math_IntegerVector;
class math_Vector;
class math_Matrix;
-class Message_ProgressIndicator;
const Standard_Integer math_Status_UserAborted = -1;
const Standard_Integer math_Status_OK = 0;
const Standard_Integer math_Status_NoConvergence = 3;
Standard_EXPORT Standard_Integer LU_Decompose(math_Matrix& a,
- math_IntegerVector& indx,
- Standard_Real& d,
- Standard_Real TINY = 1.0e-20,
- const Handle(Message_ProgressIndicator) & aProgress = Handle(Message_ProgressIndicator)());
+ math_IntegerVector& indx,
+ Standard_Real& d,
+ Standard_Real TINY = 1.0e-20,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
// Given a matrix a(1..n, 1..n), this routine computes its LU decomposition,
// The matrix a is replaced by this LU decomposition and the vector indx(1..n)
// interchanges was even or odd.
Standard_EXPORT Standard_Integer LU_Decompose(math_Matrix& a,
- math_IntegerVector& indx,
- Standard_Real& d,
- math_Vector& vv,
- Standard_Real TINY = 1.0e-30,
- const Handle(Message_ProgressIndicator) & aProgress = Handle(Message_ProgressIndicator)());
+ math_IntegerVector& indx,
+ Standard_Real& d,
+ math_Vector& vv,
+ Standard_Real TINY = 1.0e-30,
+ const Message_ProgressRange& theProgress = Message_ProgressRange());
// Idem to the previous LU_Decompose function. But the input Vector vv(1..n) is
// used internally as a scratch area.
puts "# Test output of progress indicator in text mode"
pload QAcommands
+
+XProgress +t
+
set out [OCC28478 3 2]
set expected {
- {Progress: 0% Outer: 0 / 3}
+ {Progress: 0%}
{Progress: 17% Outer: 1 / 3 Inner: 1 / 2}
{Progress: 33% Outer: 1 / 3 Inner: 2 / 2}
{Progress: 50% Outer: 2 / 3 Inner: 1 / 2}
puts "# Test output of progress indicator in text mode (infinite scale)"
pload QAcommands
+
+XProgress +t
+
set out [OCC28478 3 2 -inf]
set expected {
- {Progress: 0% Outer: 0 / 3}
+ {Progress: 0%}
{Progress: 11% Outer: 1 / 3 Inner: 1}
{Progress: 17% Outer: 1 / 3 Inner: 2}
{Progress: 20% Outer: 1 / 3 Inner: 3}
+ {Progress: 22% Outer: 1 / 3 Inner: 4}
{Progress: 33% Outer: 1 / 3 Inner: finished}
{Progress: 44% Outer: 2 / 3 Inner: 1}
{Progress: 50% Outer: 2 / 3 Inner: 2}
{Progress: 53% Outer: 2 / 3 Inner: 3}
+ {Progress: 56% Outer: 2 / 3 Inner: 4}
{Progress: 67% Outer: 2 / 3 Inner: finished}
{Progress: 78% Outer: 3 / 3 Inner: 1}
{Progress: 83% Outer: 3 / 3 Inner: 2}
{Progress: 87% Outer: 3 / 3 Inner: 3}
+ {Progress: 89% Outer: 3 / 3 Inner: 4}
{Progress: 100% Outer: 3 / 3 Inner: finished}
}
restore [locate_data_file OCC22765.brep] a
vinit
-XProgress -tclOutput
XProgress -t
set List1 [sewing result 0.1 a]
if { [string compare $List1 ""] != 0 } {
- puts "Error: XProgress should not have any output in this mode"
+ puts "Error: XProgress should not have any DRAW output in this mode"
} else {
puts "Mode -t works properly"
}
catch { pload XSDRAW }
vinit
-XProgress -tclOutput
XProgress -t
set List1 [meshfromstl result [locate_data_file bearing.stl]]
puts "----------------------"
catch { pload XSDRAW }
restore [locate_data_file OCC22746-om.brep] a
vinit
-XProgress -tclOutput
XProgress -t
set List1 [fixshape result a]
puts "----------------------"
catch { pload XSDRAW }
restore [locate_data_file OCC22746-trampafus-notfixed.brep] a
vinit
-XProgress -tclOutput
XProgress -t
set List1 [fixshape result a]
puts "----------------------"
restore [locate_data_file OCC22761-TransmissionTestModel5-notfixed.brep] a
vinit
-XProgress -tclOutput
XProgress -t
set List1 [fixshape result a]
puts "----------------------"
puts "caf009-A1"
# Configurate XProgress
-XProgress -g +t -tcloutput
+XProgress +t
# Create binary document
NewDocument Doc BinOcaf
puts "caf009-A2"
# Configurate XProgress
-XProgress -g +t -tcloutput
+XProgress +t
# Create binary document
NewDocument Doc XmlOcaf
# Test data
set ctr { "0%" "Writing sub-tree" "Writing shape section"
- "Writing Shapes" "Writing geometry" "2D Curves" "3D Curves" "Surfaces" "100%" }
+ "Writing" "Geometry" "2D Curves" "3D Curves"
+ "Polygons On Triangulation" "Surfaces"
+ "3D Polygons" "Triangulations" "100%" "Shapes" }
foreach data ${ctr} {
if ![regexp $data $output] {
set bDoc [CreateBinDoc]
# Configurate XProgress
-XProgress -g +t -tcloutput
+XProgress +t
# Open binary document
if {${bDoc} == "" } {
set xDoc [CreateXmlDoc]
# Configurate XProgress
-XProgress -g +t -tcloutput
+XProgress +t
# Open xml document
if {${xDoc} == "" } {
Close Doc
# Test data
-set ctr {"0%" "Reading document" "Reading geometry" "3D Curves"
- "Surfaces" "Shapes" "Reading sub-tree" "100%" }
+set ctr { "0%" "Reading document" "Reading" "3D Curves" "2D Curves"
+ "3D Polygons" "Polygons On Triangulation" "Shapes"
+ "Triangulations" "Surfaces" "Reading sub-tree" "100%" }
foreach data ${ctr} {
if ![regexp $data $output] {
SetShape Doc 0:2 b
# Configurate XProgress
-XProgress -g +t -tcloutput
+XProgress +t
# Save
set output [Save Doc]
SetShape Doc 0:2 b
# Configurate XProgress
-XProgress -g +t -tcloutput
+XProgress +t
# Save
set output [Save Doc]
Close Doc
# Test data
-set ctr { "0%" "Writing sub-tree" "Writing shape section"
- "Writing Shapes" "Writing geometry" "2D Curves" "3D Curves" "Surfaces" "100%" }
+set ctr { "0%" "Writing sub-tree" "Writing shape section" "Polygons On Triangulation"
+ "3D Polygons" "Locations" "Writing" "Geometry" "2D Curves"
+ "Triangulations" "3D Curves" "Surfaces" "Shapes" "100%" }
foreach data ${ctr} {
if ![regexp $data $output] {
sphere s 10
tessellate result s 100 100
-XProgress -tclOutput
XProgress +t
set out [writestl result s.stl]
set expected {
- {Progress: 0% Triangles: 0 / 20000}
- {Progress: 5% Triangles: 1001 / 20000}
- {Progress: 10% Triangles: 2001 / 20000}
- {Progress: 15% Triangles: 3001 / 20000}
- {Progress: 20% Triangles: 4001 / 20000}
- {Progress: 25% Triangles: 5001 / 20000}
- {Progress: 30% Triangles: 6001 / 20000}
- {Progress: 35% Triangles: 7001 / 20000}
- {Progress: 40% Triangles: 8001 / 20000}
- {Progress: 45% Triangles: 9001 / 20000}
- {Progress: 50% Triangles: 10001 / 20000}
- {Progress: 55% Triangles: 11001 / 20000}
- {Progress: 60% Triangles: 12001 / 20000}
- {Progress: 65% Triangles: 13001 / 20000}
- {Progress: 70% Triangles: 14001 / 20000}
- {Progress: 75% Triangles: 15001 / 20000}
- {Progress: 80% Triangles: 16001 / 20000}
- {Progress: 85% Triangles: 17001 / 20000}
- {Progress: 90% Triangles: 18001 / 20000}
- {Progress: 95% Triangles: 19001 / 20000}
+ {Progress: 0%}
+ {Progress: 5% Triangles: 1000 / 20000}
+ {Progress: 10% Triangles: 2000 / 20000}
+ {Progress: 15% Triangles: 3000 / 20000}
+ {Progress: 20% Triangles: 4000 / 20000}
+ {Progress: 25% Triangles: 5000 / 20000}
+ {Progress: 30% Triangles: 6000 / 20000}
+ {Progress: 35% Triangles: 7000 / 20000}
+ {Progress: 40% Triangles: 8000 / 20000}
+ {Progress: 45% Triangles: 9000 / 20000}
+ {Progress: 50% Triangles: 10000 / 20000}
+ {Progress: 55% Triangles: 11000 / 20000}
+ {Progress: 60% Triangles: 12000 / 20000}
+ {Progress: 65% Triangles: 13000 / 20000}
+ {Progress: 70% Triangles: 14000 / 20000}
+ {Progress: 75% Triangles: 15000 / 20000}
+ {Progress: 80% Triangles: 16000 / 20000}
+ {Progress: 85% Triangles: 17000 / 20000}
+ {Progress: 90% Triangles: 18000 / 20000}
+ {Progress: 95% Triangles: 19000 / 20000}
{Progress: 100% Triangles: 20000 / 20000}
}
--- /dev/null
+puts "# ========"
+puts "# 0025748: Parallel version of progress indicator"
+puts "# ========"
+puts ""
+
+pload QAcommands
+
+XProgress +t
+
+set out [OCC25748 -niter 10000 -matsize 100 -parallel -progr]
+if {[llength [split $out \n]] != 103} {
+ puts "Error: unexpected number of lines in the output, must be 103"
+}
projects / occt.git / commitdiff