#include "CurveCreator_Utils.h"
#include <AIS_Shape.hxx>
+#include <AIS_InteractiveObject.hxx>
#include <Geom_CartesianPoint.hxx>
#include <gp_Pnt.hxx>
#include <gp_Lin.hxx>
myNbUndos (0),
myNbRedos (0),
myUndoDepth (-1),
- myOpLevel(0)
+ myOpLevel(0),
+ mySkipSorting(false)
{
}
void CurveCreator_Curve::redisplayCurve()
{
if( myDisplayer ) {
- myDisplayer->erase( false );
+ myDisplayer->eraseAll( false );
myAISShape = NULL;
- myDisplayer->display( constructWire(), true );
+
+ myDisplayer->display( getAISObject( true ), true );
}
}
const int theNewIndex)
{
bool res = false;
- if (theISection != theNewIndex) {
- CurveCreator_Section *aSection = mySections.at(theISection);
+ int aMovedSectionId = theISection >= 0 ? theISection : mySections.size()-1;
+
+ if (aMovedSectionId != theNewIndex) {
+ CurveCreator_Section *aSection = mySections.at(aMovedSectionId);
// Remove section
- CurveCreator::Sections::iterator anIter = mySections.begin() + theISection;
+ CurveCreator::Sections::iterator anIter = mySections.begin() + aMovedSectionId;
mySections.erase(anIter);
return res;
}
-void CurveCreator_Curve::convert( const SectionToPointList& thePoints,
- std::map< int, std::list<int> >& theConvPoints )
-{
- theConvPoints.clear();
-
- SectionToPointList::const_iterator anIt = thePoints.begin(), aLast = thePoints.end();
- std::list<int> aPoints;
- int aSectionId, aPointId;
- for ( ; anIt != aLast; anIt++ ) {
- aSectionId = anIt->first;
- aPointId = anIt->second;
- aPoints.clear();
- if ( theConvPoints.find( aSectionId ) != theConvPoints.end() )
- aPoints = theConvPoints[aSectionId];
- aPoints.push_back( aPointId );
- theConvPoints[aSectionId] = aPoints;
- }
-}
-
/************ Implementation of INTERFACE methods ************/
/***********************************************/
{
// erase curve from the viewer
if( myDisplayer ) {
- myDisplayer->erase( true );
+ myDisplayer->eraseAll( true );
myAISShape = NULL;
}
// Delete all allocated data.
startOperation();
// Set the difference.
if (addEmptyDiff()) {
- myListDiffs.back().init(this, CurveCreator_Operation::Clear);
+ myListDiffs.back().init(this);
}
res = clearInternal();
finishOperation();
}
//! For internal use only! Undo/Redo are not used here.
-bool CurveCreator_Curve::joinInternal( const int theISectionTo,
- const int theISectionFrom )
+bool CurveCreator_Curve::joinInternal( const std::list<int>& theSections )
{
bool res = false;
- CurveCreator_Section *aSection1 = mySections.at(theISectionTo);
- CurveCreator_Section *aSection2 = mySections.at(theISectionFrom);
-
- aSection1->myPoints.insert(aSection1->myPoints.end(),
- aSection2->myPoints.begin(),
- aSection2->myPoints.end());
+ if ( theSections.empty() )
+ return res;
+
+ int anISectionMain = theSections.front();
+ CurveCreator_Section* aSectionMain = mySections.at( anISectionMain );
+ std::list <int> aSectionsToJoin = theSections;
+ aSectionsToJoin.erase( aSectionsToJoin.begin() ); // skip the main section
+ // it is important to sort and reverse the section ids in order to correctly remove them
+ aSectionsToJoin.sort();
+ aSectionsToJoin.reverse();
+
+ std::list<int>::const_iterator anIt = aSectionsToJoin.begin(), aLast = aSectionsToJoin.end();
+ CurveCreator_Section* aSection;
+ for (; anIt != aLast; anIt++) {
+ aSection = mySections.at(*anIt);
+ aSectionMain->myPoints.insert(aSectionMain->myPoints.end(), aSection->myPoints.begin(),
+ aSection->myPoints.end());
+ res = removeSectionInternal(*anIt);
+ if ( !res )
+ break;
+ }
- res = removeSection(theISectionFrom);
redisplayCurve();
return res;
}
-//! Join range of sections to one section (join all sections if -1 is passed in theISectionFrom argument)
-bool CurveCreator_Curve::join( const int theISectionTo,
- const int theISectionFrom )
+bool CurveCreator_Curve::join( const std::list<int>& theSections )
{
- //TODO
bool res = false;
- if ( theISectionTo != theISectionFrom ) {
+
+ if ( !theSections.empty() )
+ {
startOperation();
if (addEmptyDiff())
- myListDiffs.back().init(this, CurveCreator_Operation::Join, theISectionTo, theISectionFrom);
+ myListDiffs.back().init(this, CurveCreator_Operation::Join, theSections);
- res = joinInternal( theISectionTo, theISectionFrom );
+ res = joinInternal( theSections );
finishOperation();
}
return aNbCoords/myDimension;
}
+void CurveCreator_Curve::setSkipSorting( const bool theIsToSkip )
+{
+ mySkipSorting = theIsToSkip;
+}
+
+bool CurveCreator_Curve::canPointsBeSorted()
+{
+ return false;
+}
+
+/**
+ * Saves points coordinates difference.
+ * \param theOldCoords the old points coordinates
+ */
+void CurveCreator_Curve::saveCoordDiff( const SectionToPointCoordsList &theOldCoords )
+{
+ // Set the difference.
+ startOperation();
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this, theOldCoords);
+ }
+ finishOperation();
+}
+
//! Get "closed" flag of the specified section
bool CurveCreator_Curve::isClosed( const int theISection ) const
{
}
//! Set coordinates of specified points from different sections
-bool CurveCreator_Curve::setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords)
+bool CurveCreator_Curve::setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords,
+ const bool theIsToSaveDiff )
{
bool res = false;
// Set the difference.
startOperation();
- if (addEmptyDiff()) {
+ if (theIsToSaveDiff && addEmptyDiff()) {
myListDiffs.back().init(this, CurveCreator_Operation::SetCoordinates,
theSectionToPntCoords);
}
//! For internal use only! Undo/Redo are not used here.
bool CurveCreator_Curve::removePointsInternal( const SectionToPointList &thePoints )
{
- bool res = false;
+ bool aRes = false;
std::map<int, std::list<int> > aConvPoints;
convert( thePoints, aConvPoints );
std::map<int, std::list<int> >::const_iterator anIt = aConvPoints.begin(),
aLast = aConvPoints.end();
- CurveCreator_Section *aSection = 0;
for ( ; anIt != aLast; anIt++ ) {
int aSectionId = anIt->first;
- aSection = mySections.at(aSectionId);
- if( aSection ) {
- std::list<int> aSectionPoints = anIt->second;
- aSectionPoints.sort();
- std::list<int>::const_reverse_iterator aPntIt = aSectionPoints.rbegin();
- for( ; aPntIt != aSectionPoints.rend(); aPntIt++ ){
- int aPntIndx = *aPntIt;
- CurveCreator::Coordinates::iterator aFirstPosition;
- if(aPntIndx == -1)
- aFirstPosition = aSection->myPoints.end() - getDimension();
- else
- aFirstPosition = aSection->myPoints.begin() + toICoord(aPntIndx);
- aSection->myPoints.erase( aFirstPosition, aFirstPosition + getDimension() );
- res = true;
- }
- }
+ aRes = removeSectionPoints(aSectionId, anIt->second);
}
- if(res)
+ if( aRes)
redisplayCurve();
- return res;
+
+ return aRes;
}
//! Remove point with given id
bool res = false;
// Set the difference.
startOperation();
+ SectionToPointList aListOfSectionsToPoints;
+ aListOfSectionsToPoints.push_back(std::make_pair(theISection, theIPnt));
if (addEmptyDiff()) {
myListDiffs.back().init(this, CurveCreator_Operation::RemovePoints,
- theISection, theIPnt);
+ aListOfSectionsToPoints);
}
- SectionToPointList aListOfSectionsToPoints;
- aListOfSectionsToPoints.push_back(std::make_pair(theISection, theIPnt));
res = removePointsInternal( aListOfSectionsToPoints );
finishOperation();
return res;
return aCoords;
}
-
-/***********************************************/
-/*** Presentation methods ***/
-/***********************************************/
-std::vector<Handle_AIS_InteractiveObject> CurveCreator_Curve::constructWire()
+void CurveCreator_Curve::constructAISObject()
{
- std::vector<Handle_AIS_InteractiveObject> aCurveRepresentation;
-
TopoDS_Shape aShape;
CurveCreator_Utils::constructShape( this, aShape );
myAISShape = new AIS_Shape( aShape );
- aCurveRepresentation.push_back( myAISShape );
- return aCurveRepresentation;
}
-//=======================================================================
-// function: getAISObject
-// purpose:
-//=======================================================================
-Handle_AIS_InteractiveObject CurveCreator_Curve::getAISObject() const
+Handle(AIS_InteractiveObject) CurveCreator_Curve::getAISObject( const bool theNeedToBuild ) const
{
+ if ( !myAISShape && theNeedToBuild ) {
+ CurveCreator_Curve* aCurve = (CurveCreator_Curve*)this;
+ aCurve->constructAISObject();
+ }
return myAISShape;
-}
\ No newline at end of file
+}
+
+bool CurveCreator_Curve::removeSectionPoints( const int theSectionId,
+ const std::list<int>& thePointIds )
+{
+ bool aRes = false;
+
+ CurveCreator_Section *aSection = mySections.at( theSectionId );
+ if ( !aSection )
+ return aRes;
+
+ std::list<int> aSectionPoints = thePointIds;
+ aSectionPoints.sort();
+ std::list<int>::const_reverse_iterator aPntIt = aSectionPoints.rbegin();
+ for ( ; aPntIt != aSectionPoints.rend(); aPntIt++ ) {
+ int aPntIndx = *aPntIt;
+ CurveCreator::Coordinates::iterator aFirstPosition;
+ if ( aPntIndx == -1 )
+ aFirstPosition = aSection->myPoints.end() - getDimension();
+ else
+ aFirstPosition = aSection->myPoints.begin() + toICoord( aPntIndx );
+ aSection->myPoints.erase( aFirstPosition, aFirstPosition + getDimension() );
+ aRes = true;
+ }
+ return aRes;
+}
+
+void CurveCreator_Curve::convert( const SectionToPointList& thePoints,
+ std::map< int, std::list<int> >& theConvPoints )
+{
+ theConvPoints.clear();
+
+ SectionToPointList::const_iterator anIt = thePoints.begin(), aLast = thePoints.end();
+ std::list<int> aPoints;
+ int aSectionId, aPointId;
+ for ( ; anIt != aLast; anIt++ ) {
+ aSectionId = anIt->first;
+ aPointId = anIt->second;
+ aPoints.clear();
+ if ( theConvPoints.find( aSectionId ) != theConvPoints.end() )
+ aPoints = theConvPoints[aSectionId];
+ aPoints.push_back( aPointId );
+ theConvPoints[aSectionId] = aPoints;
+ }
+}