//=======================================================================
std::string CurveCreator_Curve::getUniqSectionName() const
{
+ CurveCreator_Section* aSection;
for( int i = 0 ; i < 1000000 ; i++ ){
char aBuffer[255];
sprintf( aBuffer, "Section_%d", i+1 );
std::string aName(aBuffer);
int j;
for( j = 0 ; j < mySections.size() ; j++ ){
- if( mySections[j]->myName == aName )
+ aSection = getSection( j );
+ if ( aSection && aSection->myName == aName )
break;
}
if( j == mySections.size() )
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 = getSection( aMovedSectionId );
// Remove section
- CurveCreator::Sections::iterator anIter = mySections.begin() + theISection;
+ CurveCreator::Sections::iterator anIter = mySections.begin() + aMovedSectionId;
mySections.erase(anIter);
int i = 0;
const int aNbSections = getNbSections();
+ CurveCreator_Section* aSection;
for (; i < aNbSections; i++) {
- delete mySections[i];
+ aSection = getSection( i );
+ if ( aSection )
+ delete aSection;
}
mySections.clear();
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 = getSection( 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 = getSection( *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();
}
{
int aNbCoords = 0;
+ CurveCreator_Section* aSection;
if (theISection == -1) {
int i = 0;
const int aNbSections = getNbSections();
for (; i < aNbSections; i++) {
- aNbCoords += mySections[i]->myPoints.size();
+ aSection = getSection( i );
+ if ( aSection )
+ aNbCoords += aSection->myPoints.size();
}
} else {
- if ( ( theISection >= 0 ) && ( theISection < mySections.size() ) )
- aNbCoords = mySections.at(theISection)->myPoints.size();
+ aSection = getSection( theISection );
+ if ( aSection )
+ aNbCoords = aSection->myPoints.size();
}
return aNbCoords/myDimension;
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
{
- return mySections.at(theISection)->myIsClosed;
+ CurveCreator_Section* aSection = getSection( theISection );
+ return aSection ? aSection->myIsClosed : false;
}
//! For internal use only! Undo/Redo are not used here.
bool CurveCreator_Curve::setClosedInternal( const int theISection,
const bool theIsClosed )
{
+ CurveCreator_Section* aSection = 0;
if (theISection == -1) {
int aSize = mySections.size();
int i;
for (i = 0; i < aSize; i++) {
- mySections[i]->myIsClosed = theIsClosed;
- redisplayCurve();
+ aSection = getSection( i );
+ if( aSection ) {
+ aSection->myIsClosed = theIsClosed;
+ redisplayCurve();
+ }
}
} else {
- mySections.at(theISection)->myIsClosed = theIsClosed;
- redisplayCurve();
+ aSection = getSection( theISection );
+ if ( aSection ) {
+ aSection->myIsClosed = theIsClosed;
+ redisplayCurve();
+ }
}
return true;
}
//! Returns specified section name
std::string CurveCreator_Curve::getSectionName( const int theISection ) const
{
- if( ( theISection >= 0 ) && ( theISection < mySections.size() ))
- return mySections.at(theISection)->myName;
- return "";
+ CurveCreator_Section* aSection = getSection( theISection );
+ return aSection ? aSection->myName : "";
}
//! For internal use only! Undo/Redo are not used here.
const std::string& theName )
{
bool res = false;
- if( ( theISection >= 0 ) && ( theISection < mySections.size() )){
- mySections.at(theISection)->myName = theName;
+ CurveCreator_Section* aSection = getSection( theISection );
+ if( aSection ) {
+ aSection->myName = theName;
res = true;
}
return res;
CurveCreator::SectionType CurveCreator_Curve::getSectionType
( const int theISection ) const
{
- return mySections.at(theISection)->myType;
+ CurveCreator_Section* aSection = getSection( theISection );
+ return aSection ? aSection->myType : CurveCreator::Polyline;
}
//! For internal use only! Undo/Redo are not used here.
bool CurveCreator_Curve::setSectionTypeInternal( const int theISection,
const CurveCreator::SectionType theType )
{
+ CurveCreator_Section* aSection;
if (theISection == -1) {
int i = 0;
const int aNbSections = getNbSections();
for (; i < aNbSections; i++) {
- mySections[i]->myType = theType;
+ aSection = getSection( i );
+ if ( aSection )
+ aSection->myType = theType;
}
redisplayCurve();
} else {
- if( mySections.at(theISection)->myType != theType ){
- mySections.at(theISection)->myType = theType;
+ aSection = getSection( theISection );
+ if ( aSection && aSection->myType != theType ){
+ aSection->myType = theType;
redisplayCurve();
}
}
CurveCreator_Section *aSection = 0;
for ( ; anIt != theSectionsMap.end(); anIt++ ) {
int anISection = anIt->first;
- aSection = mySections.at(anISection);
+ aSection = getSection( anISection );
if( aSection ) {
CurveCreator::PosPointsList aSectionPoints = anIt->second;
CurveCreator::PosPointsList::const_iterator aPntIt = aSectionPoints.begin();
CurveCreator_Section *aSection = 0;
for ( ; anIt != theSectionsMap.end(); anIt++ ) {
int anISection = anIt->first;
- aSection = mySections.at(anISection);
+ aSection = getSection( anISection );
if( aSection ) {
CurveCreator::PosPointsList aSectionPoints = anIt->second;
CurveCreator::PosPointsList::const_iterator aPntIt = aSectionPoints.begin();
}
//! 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);
}
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;
CurveCreator::Coordinates CurveCreator_Curve::getPoint( const int theISection,
const int theIPnt) const
{
- CurveCreator_Section *aSection = mySections.at(theISection);
+ CurveCreator_Section* aSection = getSection( theISection );
CurveCreator::Coordinates::const_iterator
anIter = aSection->myPoints.begin() + toICoord(theIPnt);
CurveCreator::Coordinates aResult(anIter, anIter + myDimension);
//=======================================================================
CurveCreator::Coordinates CurveCreator_Curve::getPoints( const int theISection ) const
{
- CurveCreator::Coordinates aCoords;
- if ( ( theISection >= 0 ) && ( theISection < mySections.size() ) )
- {
- aCoords = mySections.at(theISection)->myPoints;
- }
- return aCoords;
+ CurveCreator_Section* aSection = getSection( theISection );
+ return aSection ? aSection->myPoints : CurveCreator::Coordinates();
}
void CurveCreator_Curve::constructAISObject()
myAISShape = new AIS_Shape( aShape );
}
+CurveCreator_Section* CurveCreator_Curve::getSection( const int theSectionId ) const
+{
+ CurveCreator_Section *aSection = 0;
+ if ( theSectionId >= 0 && theSectionId < mySections.size() )
+ aSection = mySections.at( theSectionId );
+
+ return aSection;
+}
+
Handle(AIS_InteractiveObject) CurveCreator_Curve::getAISObject( const bool theNeedToBuild ) const
{
if ( !myAISShape && theNeedToBuild ) {
{
bool aRes = false;
- CurveCreator_Section *aSection = mySections.at( theSectionId );
+ CurveCreator_Section* aSection = getSection( theSectionId );
if ( !aSection )
return aRes;
