X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FHYDROCurveCreator%2FCurveCreator_Curve.cxx;h=129520136437240ed6e21fce61cf9ae439a34aad;hb=8edd427af3997521bda72ca3c416cc1d490565d5;hp=83b4c68fc98176050c5a92a258b2ceed92c66f12;hpb=66eed78107ad562c2846807c99978fe5a212cca4;p=modules%2Fhydro.git diff --git a/src/HYDROCurveCreator/CurveCreator_Curve.cxx b/src/HYDROCurveCreator/CurveCreator_Curve.cxx index 83b4c68f..12952013 100644 --- a/src/HYDROCurveCreator/CurveCreator_Curve.cxx +++ b/src/HYDROCurveCreator/CurveCreator_Curve.cxx @@ -23,11 +23,25 @@ #include "CurveCreator_Curve.hxx" #include "CurveCreator.hxx" +#include "CurveCreator_PosPoint.hxx" #include "CurveCreator_Section.hxx" -#include "CurveCreator_Listener.hxx" +#include "CurveCreator_Displayer.h" +#include "CurveCreator_Utils.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include #include +//#define AIS_CURVE_DISPLAY + //======================================================================= // function: Constructor // purpose: @@ -35,12 +49,15 @@ CurveCreator_Curve::CurveCreator_Curve( const CurveCreator::Dimension theDimension ) : myIsLocked (false), myDimension (theDimension), - myListener(NULL), + myDisplayer (NULL), myNbUndos (0), myNbRedos (0), myUndoDepth (-1), myOpLevel(0) { +#ifdef AIS_CURVE_DISPLAY + myAISCurve = new CurveCreator_AISCurve( this ); +#endif } //======================================================================= @@ -84,21 +101,34 @@ std::string CurveCreator_Curve::getUniqSectionName() const } //======================================================================= -// function: setListener -// purpose: set curve changes listener +// function: setDisplayer +// purpose: set curve changes Displayer //======================================================================= -void CurveCreator_Curve::setListener( CurveCreator_Listener* theListener ) +void CurveCreator_Curve::setDisplayer( CurveCreator_Displayer* theDisplayer ) { - myListener = theListener; + myDisplayer = theDisplayer; + +#ifdef AIS_CURVE_DISPLAY + myDisplayer->displayAIS( myAISCurve, false ); +#endif } //======================================================================= -// function: removeListener -// purpose: remove the attached listener +// function: getDisplayer +// purpose: get curve changes Displayer //======================================================================= -void CurveCreator_Curve::removeListener() +CurveCreator_Displayer* CurveCreator_Curve::getDisplayer() { - myListener = NULL; + return myDisplayer; +} + +//======================================================================= +// function: removeDisplayer +// purpose: remove the attached Displayer +//======================================================================= +void CurveCreator_Curve::removeDisplayer() +{ + myDisplayer = NULL; } //======================================================================= @@ -152,6 +182,20 @@ int CurveCreator_Curve::toICoord(const int theIPnt) const return theIPnt * myDimension; } +std::vector CurveCreator_Curve::constructSection( int theISection ) const +{ + std::vector aSectionRepresentation; + + TopoDS_Shape aShape; + CurveCreator_Utils::constructShape( this, theISection, aShape, aSectionRepresentation ); + + AIS_Shape* anAISShape = new AIS_Shape( aShape ); + //aShape->SetSelectionMode( AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_VERTEX ) ); + aSectionRepresentation.push_back( anAISShape ); + + return aSectionRepresentation; +} + //======================================================================= // function: setUndoDepth // purpose: @@ -210,6 +254,134 @@ int CurveCreator_Curve::getUndoDepth() const return myUndoDepth; } +Handle_AIS_Point CurveCreator_Curve::getAISPoint( int theISection, int theIPoint ) const +{ + double anX, anY, aZ; + getCoordinates( theISection, theIPoint, anX, anY, aZ ); + gp_Pnt aPoint( anX, anY, aZ); + + AIS_Point* aPnt = new AIS_Point( new Geom_CartesianPoint(aPoint)); + return aPnt; +} + +Handle_AIS_Line CurveCreator_Curve::getAISLine( int theISection, int theIPoint1, int theIPoint2 ) const +{ + double anX, anY, aZ; + getCoordinates( theISection, theIPoint1, anX, anY, aZ ); + gp_Pnt aPoint1( anX, anY, aZ); + + double anX2, anY2, aZ2; + getCoordinates( theISection, theIPoint2, anX2, anY2, aZ2 ); +//MTN to avoid crash during line construction + if( ( anX == anX2 ) && ( anY == anY2 ) && (aZ == aZ2 ) ){ + aZ2 += 1e-7; + } + + gp_Pnt aPoint2( anX2, anY2, aZ2 ); + + AIS_Line* aLine = new AIS_Line( new Geom_CartesianPoint(aPoint1), new Geom_CartesianPoint(aPoint2) ); + return aLine; +} + +void CurveCreator_Curve::getCoordinates( int theISection, int theIPoint, double& theX, double& theY, double& theZ ) const +{ + CurveCreator::Coordinates aCoords = getPoint( theISection, theIPoint ); + theX = aCoords[0]; + theY = aCoords[1]; + theZ = 0.; + if( getDimension() == CurveCreator::Dim3d ){ + theZ = aCoords[2]; + } +} + +//#define USE_COMPOUND +void CurveCreator_Curve::redisplayCurve() +{ + if( myDisplayer ) { +#ifdef AIS_CURVE_DISPLAY + myDisplayer->redisplayAIS(myAISCurve, false); +#else + myDisplayer->erase( false ); +//#ifndef USE_COMPOUND + myDisplayer->display( constructWire(), true ); +//#else + /*std::vector anAISObjects = constructWire(); + int aSelMode = AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_VERTEX ); + Handle(AIS_InteractiveContext) aContext = myDisplayer->getAISContext(); + for( int i = 0 ; i < anAISObjects.size() ; i++ ){ + Handle_AIS_InteractiveObject anAISObject = anAISObjects[i]; + //anAISObject->SetSelectionMode( aSelMode ); + aContext->Display( anAISObject, Standard_False ); + //aContext->Display( anAISObject, 0, aSelMode, Standard_False, Standard_True ); + } + aContext->UpdateCurrentViewer(); + */ +//#endif +#endif + } +} + +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::moveSectionInternal(const int theISection, + const int theNewIndex) +{ + bool res = false; + if (theISection != theNewIndex) { + CurveCreator_Section *aSection = mySections.at(theISection); + + // Remove section + CurveCreator::Sections::iterator anIter = mySections.begin() + theISection; + + mySections.erase(anIter); + + // Insert section. + anIter = mySections.begin() + theNewIndex; + mySections.insert(anIter, aSection); + res = true; + } + return res; +} + +//======================================================================= +// function: moveSection +// purpose: +//======================================================================= +bool CurveCreator_Curve::moveSection(const int theISection, + const int theNewIndex) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::MoveSection, + theISection, theNewIndex); + } + + // Update the curve. + res = moveSectionInternal(theISection, theNewIndex); + finishOperation(); + return res; +} + +void CurveCreator_Curve::convert( const SectionToPointList& thePoints, + std::map< int, std::list >& theConvPoints ) +{ + theConvPoints.clear(); + + SectionToPointList::const_iterator anIt = thePoints.begin(), aLast = thePoints.end(); + std::list 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 ************/ /***********************************************/ @@ -259,12 +431,12 @@ bool CurveCreator_Curve::redo() /***********************************************/ /*** Section methods ***/ /***********************************************/ -//======================================================================= -// function: clear -// purpose: -//======================================================================= -bool CurveCreator_Curve::clear() +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::clearInternal() { + // erase curve from the viewer + if( myDisplayer ) + myDisplayer->erase( true ); // Delete all allocated data. int i = 0; const int aNbSections = getNbSections(); @@ -274,36 +446,60 @@ bool CurveCreator_Curve::clear() } mySections.clear(); - if( myListener ) - myListener->curveChanged(); return true; } -//! Join range of sections to one section (join all sections if -1 is passed in one of arguments) +//======================================================================= +// function: clear +// purpose: +//======================================================================= +bool CurveCreator_Curve::clear() +{ + bool res = false; + startOperation(); + // Set the difference. + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::Clear); + } + res = clearInternal(); + finishOperation(); + return res; +} + +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::joinInternal( const int theISectionTo, + const int theISectionFrom ) +{ + 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()); + + 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 ) + const int theISectionFrom ) { - if (theISectionTo != theISectionFrom) { + //TODO + bool res = false; + if ( theISectionTo != theISectionFrom ) { startOperation(); if (addEmptyDiff()) myListDiffs.back().init(this, CurveCreator_Operation::Join, theISectionTo, theISectionFrom); - CurveCreator_Section *aSection1 = mySections.at(theISectionTo); - CurveCreator_Section *aSection2 = mySections.at(theISectionFrom); - - aSection1->myPoints.insert(aSection1->myPoints.end(), - aSection2->myPoints.begin(), - aSection2->myPoints.end()); - - removeSection(theISectionFrom); - if( myListener ) - myListener->curveChanged(); + res = joinInternal( theISectionTo, theISectionFrom ); finishOperation(); - return true; } - return false; + return res; } //! Get number of sections @@ -312,6 +508,26 @@ int CurveCreator_Curve::getNbSections() const return mySections.size(); } +//! For internal use only! Undo/Redo are not used here. +int CurveCreator_Curve::addSectionInternal + (const std::string& theName, const CurveCreator::SectionType theType, + const bool theIsClosed, const CurveCreator::Coordinates &thePoints) +{ + CurveCreator_Section *aSection = new CurveCreator_Section; + + std::string aName = theName; + if( aName.empty() ){ + aName = getUniqSectionName(); + } + aSection->myName = aName; + aSection->myType = theType; + aSection->myIsClosed = theIsClosed; + aSection->myPoints = thePoints; + mySections.push_back(aSection); + redisplayCurve(); + return mySections.size()-1; +} + //======================================================================= // function: addSection // purpose: adds an empty section @@ -323,26 +539,16 @@ int CurveCreator_Curve::addSection int resISection = -1; // Set the difference. startOperation(); + CurveCreator::Coordinates aCoords; //empty list if (addEmptyDiff()) { - CurveCreator::Coordinates aCoords; //empty list myListDiffs.back().init(this, CurveCreator_Operation::AddSection, theName, aCoords, theType, theIsClosed); } - CurveCreator_Section *aSection = new CurveCreator_Section; - std::string aName = theName; - if( aName.empty() ){ - aName = getUniqSectionName(); - } - aSection->myName = aName; - aSection->myType = theType; - aSection->myIsClosed = theIsClosed; - mySections.push_back(aSection); - if( myListener ) - myListener->sectionAdded( -1 ); + resISection = addSectionInternal(theName, theType, theIsClosed, aCoords); finishOperation(); - return mySections.size()-1; + return resISection; } //======================================================================= // function: addSection @@ -353,33 +559,22 @@ int CurveCreator_Curve::addSection const bool theIsClosed, const CurveCreator::Coordinates &thePoints) { int resISection = -1; - //// Set the difference. - //startOperation(); - //if (addEmptyDiff()) { - // myListDiffs.back().init(this, CurveCreator_Operation::AddSection, - // theName, thePoints, theType, theIsClosed); - //} - - // create an empty section - resISection = addSection(theName, theType, theIsClosed); - if( resISection != -1 ) { - // attach the given points to created section - CurveCreator_Section *aSection = mySections.at(resISection); - aSection->myPoints = thePoints; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::AddSection, + theName, thePoints, theType, theIsClosed); } - - //finishOperation(); + + resISection = addSectionInternal(theName, theType, theIsClosed, thePoints); + + finishOperation(); return resISection; } -//! Removes the given sections. -bool CurveCreator_Curve::removeSection( const int theISection ) +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::removeSectionInternal( const int theISection ) { - // Set the difference. - startOperation(); - if (addEmptyDiff()) - myListDiffs.back().init(this, CurveCreator_Operation::RemoveSection, theISection); - if (theISection == -1) { delete mySections.back(); mySections.pop_back(); @@ -389,11 +584,23 @@ bool CurveCreator_Curve::removeSection( const int theISection ) delete *anIterRm; mySections.erase(anIterRm); } - if( myListener ) - myListener->sectionRemoved(theISection); + redisplayCurve(); + return true; +} + +//! Removes the given sections. +bool CurveCreator_Curve::removeSection( const int theISection ) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) + myListDiffs.back().init(this, CurveCreator_Operation::RemoveSection, theISection); + + res = removeSectionInternal( theISection ); finishOperation(); - return true; + return res; } /** @@ -412,7 +619,8 @@ int CurveCreator_Curve::getNbPoints( const int theISection ) const aNbCoords += mySections[i]->myPoints.size(); } } else { - aNbCoords = mySections.at(theISection)->myPoints.size(); + if ( ( theISection >= 0 ) && ( theISection < mySections.size() ) ) + aNbCoords = mySections.at(theISection)->myPoints.size(); } return aNbCoords/myDimension; @@ -424,12 +632,9 @@ bool CurveCreator_Curve::isClosed( const int theISection ) const return mySections.at(theISection)->myIsClosed; } -/** - * Set "closed" flag of the specified section (all sections if - * \a theISection is -1). - */ -bool CurveCreator_Curve::setClosed( const int theISection, - const bool theIsClosed ) +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::setClosedInternal( const int theISection, + const bool theIsClosed ) { if (theISection == -1) { int aSize = mySections.size(); @@ -437,20 +642,35 @@ bool CurveCreator_Curve::setClosed( const int theISection, for (i = 0; i < aSize; i++) { mySections[i]->myIsClosed = theIsClosed; - if( myListener ){ - myListener->sectionClosed( theISection, theIsClosed ); - } + redisplayCurve(); } } else { mySections.at(theISection)->myIsClosed = theIsClosed; - if( myListener ){ - myListener->sectionClosed( theISection, theIsClosed ); - } + redisplayCurve(); } return true; } -//! Returns specifyed section name +/** + * Set "closed" flag of the specified section (all sections if + * \a theISection is -1). + */ +bool CurveCreator_Curve::setClosed( const int theISection, + const bool theIsClosed ) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::SetClosed, + theIsClosed, theISection); + } + res = setClosedInternal( theISection, theIsClosed ); + finishOperation(); + return res; +} + +//! Returns specified section name std::string CurveCreator_Curve::getSectionName( const int theISection ) const { if( ( theISection >= 0 ) && ( theISection < mySections.size() )) @@ -458,15 +678,32 @@ std::string CurveCreator_Curve::getSectionName( const int theISection ) const return ""; } -/** Set name of the specified section */ -bool CurveCreator_Curve::setSectionName - ( const int theISection, const std::string& theName ) +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::setSectionNameInternal( const int theISection, + const std::string& theName ) { + bool res = false; if( ( theISection >= 0 ) && ( theISection < mySections.size() )){ mySections.at(theISection)->myName = theName; - return true; + res = true; + } + return res; +} + +/** Set name of the specified section */ +bool CurveCreator_Curve::setSectionName( const int theISection, + const std::string& theName ) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::RenameSection, + theName, theISection); } - return false; + res = setSectionNameInternal( theISection, theName ); + finishOperation(); + return res; } //! Get type of the specified section @@ -476,12 +713,9 @@ CurveCreator::SectionType CurveCreator_Curve::getSectionType return mySections.at(theISection)->myType; } -/** - * Set type of the specified section (or all sections - * if \a theISection is -1). - */ -bool CurveCreator_Curve::setSectionType( const int theISection, - const CurveCreator::SectionType theType ) +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::setSectionTypeInternal( const int theISection, + const CurveCreator::SectionType theType ) { if (theISection == -1) { int i = 0; @@ -490,23 +724,75 @@ bool CurveCreator_Curve::setSectionType( const int theISection, for (; i < aNbSections; i++) { mySections[i]->myType = theType; } - if( myListener ) - myListener->curveChanged(); + redisplayCurve(); } else { if( mySections.at(theISection)->myType != theType ){ mySections.at(theISection)->myType = theType; - if( myListener ) - myListener->sectionTypeChanged(theISection); + redisplayCurve(); } } return true; } +/** + * Set type of the specified section (or all sections + * if \a theISection is -1). + */ +bool CurveCreator_Curve::setSectionType( const int theISection, + const CurveCreator::SectionType theType ) +{ + bool res = false; + startOperation(); + // Set the difference. + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::SetType, + theType, theISection); + } + + res = setSectionTypeInternal( theISection, theType ); + + finishOperation(); + return res; +} + /***********************************************/ /*** Point methods ***/ /***********************************************/ +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::addPointsInternal( const CurveCreator::SectionsMap &theSectionsMap ) +{ + bool res = false; + CurveCreator::SectionsMap::const_iterator anIt = theSectionsMap.begin(); + CurveCreator_Section *aSection = 0; + for ( ; anIt != theSectionsMap.end(); anIt++ ) { + int anISection = anIt->first; + aSection = mySections.at(anISection); + if( aSection ) { + CurveCreator::PosPointsList aSectionPoints = anIt->second; + CurveCreator::PosPointsList::const_iterator aPntIt = aSectionPoints.begin(); + for( ; aPntIt != aSectionPoints.end(); aPntIt++ ){ + int anIPnt = (*aPntIt)->myID; + CurveCreator::Coordinates aCoords = (*aPntIt)->myCoords; + CurveCreator::Coordinates::iterator anIterPosition; + if(anIPnt == -1) + anIterPosition = aSection->myPoints.end(); + else + anIterPosition = aSection->myPoints.begin() + toICoord(anIPnt); + CurveCreator::Coordinates::const_iterator aFirstPosition = + aCoords.begin(); + aSection->myPoints.insert(anIterPosition, + aCoords.begin(), aCoords.end()); + } + res = true; + } + } + if(res) + redisplayCurve(); + return res; +} + /** * Add one point to the specified section starting from the given theIPnt index * (or at the end of points if \a theIPnt is -1). @@ -520,59 +806,147 @@ bool CurveCreator_Curve::addPoints( const CurveCreator::Coordinates& theCoords, // Set the difference. startOperation(); if (addEmptyDiff()) { - myListDiffs.back().init(this, CurveCreator_Operation::AddPoints, - theCoords, theISection); - } - CurveCreator_Section *aSection = - (theISection == -1 ? mySections.back() : mySections.at(theISection)); - - if( aSection ) { - int anICoord = ( theIPnt == -1 ? 0 : toICoord(theIPnt) ); - CurveCreator::Coordinates::iterator anIterPosition = aSection->myPoints.end(); - if( theIPnt != -1 ) - anIterPosition = aSection->myPoints.begin() + toICoord(theIPnt); - aSection->myPoints.insert(anIterPosition, - theCoords.begin(), theCoords.end()); - if( myListener ) - myListener->pointInserted( theISection, -1 ); - res = true; + CurveCreator_ICurve::SectionToPointCoordsList aList; + aList.push_back(std::make_pair(std::make_pair(theISection, theIPnt), theCoords)); + myListDiffs.back().init(this, CurveCreator_Operation::InsertPoints, + aList); } + CurveCreator::SectionsMap aSectionsMap; + CurveCreator::PosPointsList aPoints; + CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( theIPnt, theCoords ); + aPoints.push_back( aPosPoint ); + aSectionsMap[theISection] = aPoints; + + res = addPointsInternal( aSectionsMap ); + finishOperation(); return res; } - //! Set coordinates of specified point +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::setPointInternal( const CurveCreator::SectionsMap &theSectionsMap ) +{ + bool res = false; + // Update the curve. + CurveCreator::SectionsMap::const_iterator anIt = theSectionsMap.begin(); + CurveCreator_Section *aSection = 0; + for ( ; anIt != theSectionsMap.end(); anIt++ ) { + int anISection = anIt->first; + aSection = mySections.at(anISection); + if( aSection ) { + CurveCreator::PosPointsList aSectionPoints = anIt->second; + CurveCreator::PosPointsList::const_iterator aPntIt = aSectionPoints.begin(); + for( ; aPntIt != aSectionPoints.end(); aPntIt++ ){ + int anIPnt = (*aPntIt)->myID; + CurveCreator::Coordinates aCoords = (*aPntIt)->myCoords; + for ( int i = 0; i < myDimension; i++) + aSection->myPoints.at(toICoord(anIPnt) + i) = aCoords[i]; + } + res = true; + } + } + if(res) + redisplayCurve(); + + return res; +} + +//! Set coordinates of specified point bool CurveCreator_Curve::setPoint( const int theISection, const int theIPnt, const CurveCreator::Coordinates& theNewCoords ) { + bool res = false; // Set the difference. startOperation(); if (addEmptyDiff()) { + CurveCreator_ICurve::SectionToPointCoordsList aList; + aList.push_back(std::make_pair(std::make_pair(theISection, theIPnt), theNewCoords)); myListDiffs.back().init(this, CurveCreator_Operation::SetCoordinates, - theNewCoords, theISection, theIPnt); + aList); } + CurveCreator::SectionsMap aSectionsMap; + CurveCreator::PosPointsList aPoints; + CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( theIPnt, theNewCoords ); + aPoints.push_back( aPosPoint ); + aSectionsMap[theISection] = aPoints; - bool res = false; + int aSize1 = getNbPoints( theISection ); + res = setPointInternal( aSectionsMap ); + int aSize2 = getNbPoints( theISection ); - // Update the curve. - if (theNewCoords.size() == myDimension) { - CurveCreator_Section *aSection = mySections.at(theISection); - int i; - for (i = 0; i < myDimension; i++) { - aSection->myPoints.at(toICoord(theIPnt) + i) = theNewCoords[i]; - } - if( myListener ) - myListener->pointChanged( theISection, theIPnt ); + finishOperation(); + + return res; +} + +//! Set coordinates of specified points from different sections +bool CurveCreator_Curve::setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::SetCoordinates, + theSectionToPntCoords); + } + CurveCreator::SectionsMap aSectionsMap; + CurveCreator::PosPointsList aPosPoints; + CurveCreator_ICurve::SectionToPointCoordsList::const_iterator anIt = + theSectionToPntCoords.begin(), aLast = theSectionToPntCoords.end(); + int aSectionId, aPointId; + for ( ; anIt != aLast; anIt++ ) { + aPosPoints.clear(); + aSectionId = anIt->first.first; + aPointId = anIt->first.second; + CurveCreator::Coordinates aNewCoords = anIt->second; + CurveCreator_PosPoint* aPosPoint = + new CurveCreator_PosPoint( aPointId, aNewCoords ); + if( aSectionsMap.find(aSectionId) != aSectionsMap.end() ) + aPosPoints = aSectionsMap[aSectionId]; + aPosPoints.push_back( aPosPoint ); + aSectionsMap[aSectionId] = aPosPoints; - res = true; } - + res = setPointInternal( aSectionsMap ); finishOperation(); return res; } +//! For internal use only! Undo/Redo are not used here. +bool CurveCreator_Curve::removePointsInternal( const SectionToPointList &thePoints ) +{ + bool res = false; + std::map > aConvPoints; + convert( thePoints, aConvPoints ); + std::map >::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 aSectionPoints = anIt->second; + aSectionPoints.sort(); + std::list::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; + } + } + } + if(res) + redisplayCurve(); + return res; +} + //! Remove point with given id bool CurveCreator_Curve::removePoint( const int theISection, const int theIPnt ) { @@ -581,22 +955,31 @@ bool CurveCreator_Curve::removePoint( const int theISection, const int theIPnt ) startOperation(); if (addEmptyDiff()) { myListDiffs.back().init(this, CurveCreator_Operation::RemovePoints, - theISection, theIPnt, 0); + theISection, theIPnt); } - CurveCreator_Section *aSection = mySections.at(theISection); - if( aSection ) { - CurveCreator::Coordinates::iterator anIterPosition = - aSection->myPoints.begin() + toICoord(theIPnt); - aSection->myPoints.erase( anIterPosition ); - if( myListener ) - myListener->pointRemoved( theISection, theIPnt ); - res = true; + SectionToPointList aListOfSectionsToPoints; + aListOfSectionsToPoints.push_back(std::make_pair(theISection, theIPnt)); + res = removePointsInternal( aListOfSectionsToPoints ); + finishOperation(); + return res; +} + +//! Remove several points from different sections with given ids +bool CurveCreator_Curve::removeSeveralPoints( const SectionToPointList &theSectionToPntIDs) +{ + bool res = false; + // Set the difference. + startOperation(); + if (addEmptyDiff()) { + myListDiffs.back().init(this, CurveCreator_Operation::RemovePoints, + theSectionToPntIDs); } + res = removePointsInternal( theSectionToPntIDs ); finishOperation(); return res; } -//======================================================================= + //======================================================================= // function: getCoordinates // purpose: //======================================================================= @@ -617,13 +1000,35 @@ CurveCreator::Coordinates CurveCreator_Curve::getPoint( const int theISection, //======================================================================= CurveCreator::Coordinates CurveCreator_Curve::getPoints( const int theISection ) const { - return mySections.at(theISection)->myPoints; + CurveCreator::Coordinates aCoords; + if ( ( theISection >= 0 ) && ( theISection < mySections.size() ) ) + { + aCoords = mySections.at(theISection)->myPoints; + } + return aCoords; } /***********************************************/ /*** Presentation methods ***/ /***********************************************/ -/* TopoDS_Wire CurveCreator_Curve::constructWire() const +std::vector CurveCreator_Curve::constructWire() const +{ + std::vector aCurveRepresentation; + std::vector aSectionObjects; + for( int iSection = 0 ; iSection < getNbSections() ; iSection++ ){ + aSectionObjects = constructSection( iSection ); + for( int iObject = 0 ; iObject < aSectionObjects.size() ; iObject++ ){ + aCurveRepresentation.push_back( aSectionObjects.at(iObject) ); + } + } + return aCurveRepresentation; +} + +void CurveCreator_Curve::getPoint( const int theISection, const int theIPoint, + gp_Pnt& thePoint ) const { -}*/ + double anX, anY, aZ; + getCoordinates( theISection, theIPoint, anX, anY, aZ ); + thePoint = gp_Pnt( anX, anY, aZ); +}