OPTION(SALOME_BUILD_GUI "Enable GUI" ON)
CMAKE_DEPENDENT_OPTION(SALOME_GEOM_USE_OPENCV "Enable shape recognition from picture" OFF
"SALOME_BUILD_GUI" OFF)
-CMAKE_DEPENDENT_OPTION(SALOME_GEOM_BUILD_CC "Enable curve creator (experimental)" OFF
- "SALOME_BUILD_GUI" OFF)
-MARK_AS_ADVANCED(SALOME_BUILD_GUI SALOME_GEOM_USE_OPENCV SALOME_GEOM_BUILD_CC)
-
-# Debug options (!!! FOR DEVELOPERS ONLY !!! TO BE REMOVED LATER !!!)
-IF(CMAKE_BUILD_TYPE MATCHES "^Debug$")
- CMAKE_DEPENDENT_OPTION(SALOME_GEOM_DEBUG_CC "Debug curve creator" OFF
- "SALOME_GEOM_BUILD_CC" OFF)
- MARK_AS_ADVANCED(SALOME_GEOM_DEBUG_CC)
-
- IF(SALOME_GEOM_DEBUG_CC)
- ADD_DEFINITIONS(-DDEBUG_CURVE_CREATOR)
- ENDIF(SALOME_GEOM_DEBUG_CC)
-ENDIF()
+MARK_AS_ADVANCED(SALOME_BUILD_GUI SALOME_GEOM_USE_OPENCV)
# Prerequisites
# =============
)
IF(SALOME_BUILD_GUI)
LIST(APPEND _${PROJECT_NAME}_exposed_targets
- AdvancedGUI BasicGUI BlocksGUI BooleanGUI BuildGUI DisplayGUI DlgRef EntityGUI GEOMBase
+ AdvancedGUI BasicGUI BlocksGUI BooleanGUI BuildGUI DisplayGUI DlgRef CurveCreator EntityGUI GEOMBase
GEOMFiltersSelection GEOM GEOMToolsGUI GenerationGUI GroupGUI Material MeasureGUI GEOMObject
OperationGUI PrimitiveGUI RepairGUI TransformationGUI ImportExportGUI
)
)
ENDIF(SALOME_GEOM_USE_OPENCV)
-IF(SALOME_GEOM_BUILD_CC)
- LIST(APPEND _${PROJECT_NAME}_exposed_targets
- CurveCreator
- )
-ENDIF(SALOME_GEOM_BUILD_CC)
-
# Add all targets to the build-tree export set
EXPORT(TARGETS ${_${PROJECT_NAME}_exposed_targets}
FILE ${PROJECT_BINARY_DIR}/${PROJECT_NAME}Targets.cmake)
AdvancedEngine OCC2VTK VTKExport
)
-##
-# Curve creator
-##
-IF(SALOME_GEOM_BUILD_CC)
- SET(SUBDIRS_CC
- CurveCreator
- )
-ENDIF()
-
##
# OPENCV
##
SET(SUBDIRS_GUI
OBJECT DlgRef GEOMFiltersSelection Material GEOMGUI
GEOMBase GEOMToolsGUI DisplayGUI BasicGUI PrimitiveGUI GenerationGUI
- EntityGUI BuildGUI BooleanGUI TransformationGUI OperationGUI
+ CurveCreator EntityGUI BuildGUI BooleanGUI TransformationGUI OperationGUI
RepairGUI MeasureGUI GroupGUI BlocksGUI AdvancedGUI ImportExportGUI
GEOM_SWIG_WITHIHM
)
# header files / to be processed by moc
SET(_moc_HEADERS
CurveCreator_NewSectionDlg.h
- CurveCreator_NewPointDlg.h
+ CurveCreator_TableView.h
CurveCreator_TreeView.h
-# CurveCreator_UndoOptsDlg.h
CurveCreator_Widget.h
)
ENDIF(SALOME_BUILD_GUI)
SET(_other_HEADERS
CurveCreator.hxx
CurveCreator_Curve.hxx
- CurveCreator_CurveEditor.hxx
CurveCreator_Diff.hxx
+ CurveCreator_Displayer.hxx
CurveCreator_ICurve.hxx
- CurveCreator_Listener.hxx
CurveCreator_Macro.hxx
CurveCreator_Operation.hxx
+ CurveCreator_PosPoint.hxx
CurveCreator_Section.hxx
+ CurveCreator_UtilsICurve.hxx
+ CurveCreator_Utils.hxx
)
# header files / to install
# sources / static
SET(_other_SOURCES
CurveCreator_Curve.cxx
- CurveCreator_CurveEditor.cxx
CurveCreator_Diff.cxx
- CurveCreator_ICurve.cxx
+ CurveCreator_Displayer.cxx
CurveCreator_Operation.cxx
+ CurveCreator_Utils.cxx
+ CurveCreator_UtilsICurve.cxx
)
IF(SALOME_BUILD_GUI)
LIST(APPEND _other_SOURCES
- CurveCreator_NewPointDlg.cxx
CurveCreator_NewSectionDlg.cxx
+ CurveCreator_TableView.cxx
CurveCreator_TreeView.cxx
-# CurveCreator_UndoOptsDlg.cxx
CurveCreator_Widget.cxx
)
ENDIF(SALOME_BUILD_GUI)
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#define _CurveCreator_HeaderFile
#include <deque>
+#include <map>
+#include <list>
+
+struct CurveCreator_Section;
+struct CurveCreator_PosPoint;
namespace CurveCreator
{
-
- //! Dimension of the curve
- enum Dimension
- {
- Dim2d = 2,
- Dim3d = 3
- };
-
- //! Type of the section
- enum Type
- {
- Polyline,
- BSpline
- };
-
//! Points coordinates
typedef float TypeCoord;
+ /** List of coordinates in format depends on section dimension:
+ * 2D: [x1, y1, x2, y2, x3, y3, ..]
+ * 3D: [x1, y1, z1, x2, y2, z2, x3, y3, z3, ..]
+ */
typedef std::deque<TypeCoord> Coordinates;
+ //! List of sections
+ typedef std::deque<CurveCreator_Section *> Sections;
+
+ // List of positioned points (points with coordinates)
+ typedef std::list<CurveCreator_PosPoint*> PosPointsList;
+ //! Map of sections with positioned points
+ typedef std::map<int,PosPointsList> SectionsMap;
};
#endif
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// Author: Sergey KHROMOV
#include "CurveCreator_Curve.hxx"
+
+#include "CurveCreator.hxx"
+#include "CurveCreator_PosPoint.hxx"
#include "CurveCreator_Section.hxx"
-#include "CurveCreator_Listener.hxx"
+#include "CurveCreator_Displayer.hxx"
+#include "CurveCreator_Utils.hxx"
+
+#include <AIS_Shape.hxx>
+#include <AIS_InteractiveObject.hxx>
+#include <Geom_CartesianPoint.hxx>
+#include <gp_Pnt.hxx>
+#include <gp_Lin.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Face.hxx>
+#include <TopoDS_Wire.hxx>
#include <stdio.h>
// function: Constructor
// purpose:
//=======================================================================
-CurveCreator_Curve::CurveCreator_Curve
- (const CurveCreator::Dimension theDimension)
-: CurveCreator_ICurve(theDimension)
+CurveCreator_Curve::CurveCreator_Curve( const CurveCreator::Dimension theDimension )
+: myIsLocked (false),
+ myDimension (theDimension),
+ myDisplayer (NULL),
+ myAISShape (NULL),
+ myNbUndos (0),
+ myNbRedos (0),
+ myUndoDepth (-1),
+ myOpLevel(0),
+ mySkipSorting(false)
+{
+}
+
+//=======================================================================
+// function: Destructor
+// purpose:
+//=======================================================================
+CurveCreator_Curve::~CurveCreator_Curve()
+{
+ // Delete all allocated data.
+ clear();
+}
+
+//=======================================================================
+// function: getDimension
+// purpose:
+//=======================================================================
+CurveCreator::Dimension CurveCreator_Curve::getDimension() const
+{
+ return myDimension;
+}
+
+//=======================================================================
+// function: getUniqSectionName
+// purpose: return unique section name
+//=======================================================================
+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++ ){
+ aSection = getSection( j );
+ if ( aSection && aSection->myName == aName )
+ break;
+ }
+ if( j == mySections.size() )
+ return aName;
+ }
+ return "";
+}
+
+//=======================================================================
+// function: setDisplayer
+// purpose: set curve changes Displayer
+//=======================================================================
+void CurveCreator_Curve::setDisplayer( CurveCreator_Displayer* theDisplayer )
+{
+ myDisplayer = theDisplayer;
+}
+
+//=======================================================================
+// function: getDisplayer
+// purpose: get curve changes Displayer
+//=======================================================================
+CurveCreator_Displayer* CurveCreator_Curve::getDisplayer()
+{
+ return myDisplayer;
+}
+
+//=======================================================================
+// function: removeDisplayer
+// purpose: remove the attached Displayer
+//=======================================================================
+void CurveCreator_Curve::removeDisplayer()
{
+ myDisplayer = NULL;
}
//=======================================================================
-// function: addPoints
+// function: addDiff
// purpose:
//=======================================================================
-void CurveCreator_Curve::addPoints
- (const CurveCreator::Coordinates &thePoints, const int theISection)
+bool CurveCreator_Curve::addEmptyDiff()
+{
+ bool isEnabled = false;
+
+ if (myUndoDepth != 0) {
+ // Forget all Redos after the current one.
+ if (myNbRedos > 0) {
+ myNbRedos = 0;
+ myListDiffs.erase(myCurrenPos, myListDiffs.end());
+ }
+
+ if (myUndoDepth == -1 || myNbUndos < myUndoDepth) {
+ // Increase the number of undos.
+ myNbUndos++;
+ } else {
+ // If there are too many differences, remove the first one.
+ myListDiffs.pop_front();
+ }
+
+ // Add new difference.
+ myListDiffs.push_back(CurveCreator_Diff());
+ myCurrenPos = myListDiffs.end();
+ isEnabled = true;
+ }
+
+ return isEnabled;
+}
+
+void CurveCreator_Curve::startOperation()
+{
+ myOpLevel++;
+}
+
+void CurveCreator_Curve::finishOperation()
+{
+ myOpLevel--;
+}
+
+//=======================================================================
+// function: toICoord
+// purpose:
+//=======================================================================
+int CurveCreator_Curve::toICoord(const int theIPnt) const
+{
+ return theIPnt * myDimension;
+}
+
+//=======================================================================
+// function: setUndoDepth
+// purpose:
+//=======================================================================
+void CurveCreator_Curve::setUndoDepth(const int theDepth)
+{
+ if (theDepth == 0) {
+ // Reset all undo/redo data.
+ myNbUndos = 0;
+ myNbRedos = 0;
+ myListDiffs.clear();
+ myCurrenPos = myListDiffs.end();
+ myUndoDepth = 0;
+ } else if (theDepth == -1) {
+ // There is nothing to do as the depth become unlimited.
+ myUndoDepth = -1;
+ } else if (theDepth > 0) {
+ // The new "real" depth is set.
+ if (theDepth < myNbRedos) {
+ // The new depth is less then number of redos. Remove the latest redos.
+ int aShift = (myNbRedos - theDepth);
+ ListDiff::iterator aFromPos = myListDiffs.end();
+
+ while (aShift--) {
+ aFromPos--;
+ }
+
+ myListDiffs.erase(aFromPos, myListDiffs.end());
+ myNbRedos = theDepth;
+ }
+
+ if (theDepth < myNbUndos + myNbRedos) {
+ // The new depth is less then the total number of differences.
+ // Remove the first undos.
+ int aShift = (myNbUndos + myNbRedos - theDepth);
+ ListDiff::iterator aToPos = myListDiffs.begin();
+
+ while (aShift--) {
+ aToPos++;
+ }
+
+ myListDiffs.erase(myListDiffs.begin(), aToPos);
+ myNbUndos = theDepth - myNbRedos;
+ }
+
+ myUndoDepth = theDepth;
+ }
+}
+
+//=======================================================================
+// function: getUndoDepth
+// purpose:
+//=======================================================================
+int CurveCreator_Curve::getUndoDepth() const
+{
+ return myUndoDepth;
+}
+
+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];
+ }
+}
+
+void CurveCreator_Curve::redisplayCurve()
+{
+ if( myDisplayer ) {
+ myDisplayer->eraseAll( false );
+ myAISShape = NULL;
+
+ myDisplayer->display( getAISObject( true ), true );
+ }
+}
+
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::moveSectionInternal(const int theISection,
+ const int theNewIndex)
+{
+ bool res = false;
+ int aMovedSectionId = theISection >= 0 ? theISection : mySections.size()-1;
+
+ if (aMovedSectionId != theNewIndex) {
+ CurveCreator_Section* aSection = getSection( aMovedSectionId );
+
+ // Remove section
+ CurveCreator::Sections::iterator anIter = mySections.begin() + aMovedSectionId;
+
+ 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;
+}
+
+/************ Implementation of INTERFACE methods ************/
+
+/***********************************************/
+/*** Undo/Redo methods ***/
+/***********************************************/
+
+//! Get number of available undo operations
+int CurveCreator_Curve::getNbUndo() const
+{
+ return myNbUndos;
+}
+
+//! Undo previous operation
+bool CurveCreator_Curve::undo()
+{
+ bool res = false;
+ if (myNbUndos > 0) {
+ myNbUndos--;
+ myNbRedos++;
+ myCurrenPos--;
+ myCurrenPos->applyUndo(this);
+ res = true;
+ }
+ return res;
+}
+
+//! Get number of available redo operations
+int CurveCreator_Curve::getNbRedo() const
+{
+ return myNbRedos;
+}
+
+//! Redo last previously "undone" operation
+bool CurveCreator_Curve::redo()
+{
+ bool res = false;
+ if (myNbRedos > 0) {
+ myCurrenPos->applyRedo(this);
+ myCurrenPos++;
+ myNbRedos--;
+ myNbUndos++;
+ res = true;
+ }
+ return res;
+}
+
+/***********************************************/
+/*** Section methods ***/
+/***********************************************/
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::clearInternal()
+{
+ // erase curve from the viewer
+ if( myDisplayer ) {
+ myDisplayer->eraseAll( true );
+ myAISShape = NULL;
+ }
+ // Delete all allocated data.
+ int i = 0;
+ const int aNbSections = getNbSections();
+
+ CurveCreator_Section* aSection;
+ for (; i < aNbSections; i++) {
+ aSection = getSection( i );
+ if ( aSection )
+ delete aSection;
+ }
+
+ mySections.clear();
+
+ return true;
+}
+
+//=======================================================================
+// function: clear
+// purpose:
+//=======================================================================
+bool CurveCreator_Curve::clear()
+{
+ bool res = false;
+ startOperation();
+ // Set the difference.
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this);
+ }
+ res = clearInternal();
+ finishOperation();
+ return res;
+}
+
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::joinInternal( const std::list<int>& theSections )
+{
+ bool res = false;
+ 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;
+ }
+
+ redisplayCurve();
+ return res;
+}
+
+bool CurveCreator_Curve::join( const std::list<int>& theSections )
+{
+ bool res = false;
+
+ if ( !theSections.empty() )
+ {
+ startOperation();
+ if (addEmptyDiff())
+ myListDiffs.back().init(this, CurveCreator_Operation::Join, theSections);
+
+ res = joinInternal( theSections );
+
+ finishOperation();
+ }
+ return res;
+}
+
+//! Get number of sections
+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
+//=======================================================================
+int CurveCreator_Curve::addSection
+ (const std::string& theName, const CurveCreator::SectionType theType,
+ const bool theIsClosed)
+{
+ int resISection = -1;
+ // Set the difference.
+ startOperation();
+ CurveCreator::Coordinates aCoords; //empty list
+ if (addEmptyDiff()) {
+ myListDiffs.back().init(this, CurveCreator_Operation::AddSection,
+ theName, aCoords, theType, theIsClosed);
+ }
+
+ resISection = addSectionInternal(theName, theType, theIsClosed, aCoords);
+
+ finishOperation();
+ return resISection;
+}
+//=======================================================================
+// function: addSection
+// purpose: adds a section with the given points
+//=======================================================================
+int CurveCreator_Curve::addSection
+ (const std::string& theName, const CurveCreator::SectionType theType,
+ 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);
+ }
+
+ resISection = addSectionInternal(theName, theType, theIsClosed, thePoints);
+
+ finishOperation();
+ return resISection;
+}
+
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::removeSectionInternal( const int theISection )
+{
+ if (theISection == -1) {
+ delete mySections.back();
+ mySections.pop_back();
+ } else {
+ CurveCreator::Sections::iterator anIterRm = mySections.begin() + theISection;
+
+ delete *anIterRm;
+ mySections.erase(anIterRm);
+ }
+ 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 res;
+}
+
+/**
+ * Get number of points in specified section or (the total number of points
+ * in Curve if theISection is equal to -1).
+ */
+int CurveCreator_Curve::getNbPoints( const int theISection ) const
+{
+ int aNbCoords = 0;
+
+ CurveCreator_Section* aSection;
+ if (theISection == -1) {
+ int i = 0;
+ const int aNbSections = getNbSections();
+
+ for (; i < aNbSections; i++) {
+ aSection = getSection( i );
+ if ( aSection )
+ aNbCoords += aSection->myPoints.size();
+ }
+ } else {
+ aSection = getSection( theISection );
+ if ( aSection )
+ aNbCoords = aSection->myPoints.size();
+ }
+
+ 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
+{
+ 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++) {
+ aSection = getSection( i );
+ if( aSection ) {
+ aSection->myIsClosed = theIsClosed;
+ redisplayCurve();
+ }
+ }
+ } else {
+ aSection = getSection( theISection );
+ if ( aSection ) {
+ aSection->myIsClosed = theIsClosed;
+ redisplayCurve();
+ }
+ }
+ return true;
+}
+
+/**
+ * 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
+{
+ CurveCreator_Section* aSection = getSection( theISection );
+ return aSection ? aSection->myName : "";
+}
+
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::setSectionNameInternal( const int theISection,
+ const std::string& theName )
+{
+ bool res = false;
+ CurveCreator_Section* aSection = getSection( theISection );
+ if( aSection ) {
+ aSection->myName = theName;
+ 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);
+ }
+ res = setSectionNameInternal( theISection, theName );
+ finishOperation();
+ return res;
+}
+
+//! Get type of the specified section
+CurveCreator::SectionType CurveCreator_Curve::getSectionType
+ ( const int theISection ) const
+{
+ 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++) {
+ aSection = getSection( i );
+ if ( aSection )
+ aSection->myType = theType;
+ }
+ redisplayCurve();
+ } else {
+ aSection = getSection( theISection );
+ if ( aSection && aSection->myType != theType ){
+ aSection->myType = theType;
+ 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 = getSection( 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).
+ */
+bool CurveCreator_Curve::addPoints( const CurveCreator::Coordinates& theCoords,
+ const int theISection,
+ const int theIPnt )
+{
+ bool res = false;
+ CurveCreator::Coordinates aCoords = theCoords;
+ // Set the difference.
+ startOperation();
+ if (addEmptyDiff()) {
+ 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;
+}
+
+//! 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 = getSection( 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,
+ aList);
+ }
+ CurveCreator::SectionsMap aSectionsMap;
+ CurveCreator::PosPointsList aPoints;
+ CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( theIPnt, theNewCoords );
+ aPoints.push_back( aPosPoint );
+ aSectionsMap[theISection] = aPoints;
+
+ int aSize1 = getNbPoints( theISection );
+ res = setPointInternal( aSectionsMap );
+ int aSize2 = getNbPoints( theISection );
+
+ finishOperation();
+
+ return res;
+}
+
+//! Set coordinates of specified points from different sections
+bool CurveCreator_Curve::setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords,
+ const bool theIsToSaveDiff )
+{
+ bool res = false;
+ // Set the difference.
+ startOperation();
+ if (theIsToSaveDiff && 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 = setPointInternal( aSectionsMap );
+ finishOperation();
+
+ return res;
+}
+
+//! For internal use only! Undo/Redo are not used here.
+bool CurveCreator_Curve::removePointsInternal( const SectionToPointList &thePoints )
+{
+ 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();
+ for ( ; anIt != aLast; anIt++ ) {
+ int aSectionId = anIt->first;
+ aRes = removeSectionPoints(aSectionId, anIt->second);
+ }
+ if( aRes)
+ redisplayCurve();
+
+ return aRes;
+}
+
+//! Remove point with given id
+bool CurveCreator_Curve::removePoint( const int theISection, const int theIPnt )
+{
+ 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,
+ aListOfSectionsToPoints);
+ }
+ 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:
+//=======================================================================
+CurveCreator::Coordinates CurveCreator_Curve::getPoint( const int theISection,
+ const int theIPnt) const
+{
+ CurveCreator_Section* aSection = getSection( theISection );
+ CurveCreator::Coordinates::const_iterator
+ anIter = aSection->myPoints.begin() + toICoord(theIPnt);
+ CurveCreator::Coordinates aResult(anIter, anIter + myDimension);
+
+ return aResult;
+}
+
+//=======================================================================
+// function: getPoints
+// purpose:
+//=======================================================================
+CurveCreator::Coordinates CurveCreator_Curve::getPoints( const int theISection ) const
+{
+ CurveCreator_Section* aSection = getSection( theISection );
+ return aSection ? aSection->myPoints : CurveCreator::Coordinates();
+}
+
+void CurveCreator_Curve::constructAISObject()
+{
+ TopoDS_Shape aShape;
+ CurveCreator_Utils::constructShape( this, aShape );
+
+ 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 ) {
+ CurveCreator_Curve* aCurve = (CurveCreator_Curve*)this;
+ aCurve->constructAISObject();
+ }
+ return myAISShape;
+}
+
+bool CurveCreator_Curve::removeSectionPoints( const int theSectionId,
+ const std::list<int>& thePointIds )
+{
+ bool aRes = false;
+
+ CurveCreator_Section* aSection = getSection( 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 )
{
- CurveCreator_Section *aSection =
- (theISection == -1 ? mySections.back() : mySections.at(theISection));
+ theConvPoints.clear();
- aSection->myPoints.insert(aSection->myPoints.end(),
- thePoints.begin(), thePoints.end());
- if( myListener )
- myListener->pointInserted( theISection, -1 );
+ 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;
+ }
}
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#ifndef _CurveCreator_Curve_HeaderFile
#define _CurveCreator_Curve_HeaderFile
-#include "CurveCreator.hxx"
#include "CurveCreator_ICurve.hxx"
+
#include "CurveCreator_Macro.hxx"
-#include "CurveCreator_Operation.hxx"
+#include "CurveCreator.hxx"
+#include "CurveCreator_Diff.hxx"
-class CurveCreator_Section;
-class CurveCreator_Listener;
+#include <list>
+#include <map>
+
+struct CurveCreator_Section;
+class CurveCreator_Displayer;
+class AIS_Shape;
+class Handle_AIS_InteractiveObject;
/**
* The CurveCreator_Curve object is represented as one or more sets of
* connected points; thus CurveCreator_Curve object can contain several
* not connected curves (polylines or b-splines), each such curve has two
- * only ends � start and end points � in other words non-manifold curves
+ * only ends "start and end points" in other words non-manifold curves
* are not supported.
*/
class CURVECREATOR_EXPORT CurveCreator_Curve : public CurveCreator_ICurve
{
+protected:
+ typedef std::list<CurveCreator_Diff> ListDiff;
+
public:
//! Constructor of the curve.
/** The dimension is explicitly specified in the constructor
*/
CurveCreator_Curve(const CurveCreator::Dimension theDimension);
- /** Add points to the specified section (or last section
+ //! Destructor.
+ virtual ~CurveCreator_Curve();
+
+ //! Get the dimension.
+ virtual CurveCreator::Dimension getDimension() const;
+
+ //! Return unique section name
+ virtual std::string getUniqSectionName() const;
+
+ //! Set curve creator Displayer object
+ virtual void setDisplayer( CurveCreator_Displayer* theDisplayer );
+
+ //! Return curve creator Displayer object
+ CurveCreator_Displayer* getDisplayer();
+
+ //! Remove curve creator Displayer object
+ virtual void removeDisplayer();
+
+ /** Set depth of undo operations (unlimited if \a theDepth is -1
+ * or disabled if \a theDepth is 0)
+ */
+ virtual void setUndoDepth(const int theDepth = -1);
+
+ //! Get depth of undo operations.
+ virtual int getUndoDepth() const;
+
+ virtual void startOperation();
+ virtual void finishOperation();
+
+ /**
+ * This method converts the point index to the index in
+ * an array of coordinates.
+ */
+ virtual int toICoord(const int theIPnt) const;
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool moveSectionInternal(const int theISection,
+ const int theNewIndex);
+ //! Move section to new position in list
+ virtual bool moveSection(const int theISection,
+ const int theNewIndex);
+
+protected:
+ /** This method updates all undo/redo information required to be updated
+ * after curve modification operation. It returns false if undo/redo
+ * is disabled and true otherwise.
+ */
+ virtual bool addEmptyDiff();
+
+public: // TODO: remove public
+ void getCoordinates( int theISection, int theIPoint, double& theX, double& theY, double& theZ ) const;
+protected: // TODO: remove public
+ void redisplayCurve();
+
+public:
+ /************ Implementation of INTERFACE methods ************/
+
+ /***********************************************/
+ /*** Undo/Redo methods ***/
+ /***********************************************/
+
+ //! Get number of available undo operations
+ virtual int getNbUndo() const;
+
+ //! Undo previous operation
+ virtual bool undo();
+
+ //! Get number of available redo operations
+ virtual int getNbRedo() const;
+
+ //! Redo last previously "undone" operation
+ virtual bool redo();
+
+
+ /***********************************************/
+ /*** Section methods ***/
+ /***********************************************/
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool clearInternal();
+ //! Clear the polyline (remove all sections)
+ virtual bool clear();
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool joinInternal( const std::list<int>& theSections );
+
+ //! Join list of sections to one section (join all if the list is empty)
+ // The first section in the list is a leader, another sections are joined to it
+ virtual bool join( const std::list<int>& theSections );
+
+ //! Get number of sections
+ virtual int getNbSections() const;
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual int addSectionInternal( const std::string &theName,
+ const CurveCreator::SectionType theType,
+ const bool theIsClosed,
+ const CurveCreator::Coordinates &thePoints);
+ //! Add a new section.
+ virtual int addSection( const std::string &theName,
+ const CurveCreator::SectionType theType,
+ const bool theIsClosed );
+ //! Add a new section.
+ virtual int addSection( const std::string &theName,
+ const CurveCreator::SectionType theType,
+ const bool theIsClosed,
+ const CurveCreator::Coordinates &thePoints);
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool removeSectionInternal( const int theISection );
+ //! Removes the given sections.
+ virtual bool removeSection( const int theISection );
+
+ //! Get "closed" flag of the specified section
+ virtual bool isClosed( const int theISection ) const;
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool setClosedInternal( const int theISection,
+ const bool theIsClosed );
+ /**
+ * Set "closed" flag of the specified section (all sections if
+ * \a theISection is -1).
+ */
+ virtual bool setClosed( const int theISection,
+ const bool theIsClosed );
+
+ //! Returns specifyed section name
+ virtual std::string getSectionName( const int theISection ) const;
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool setSectionNameInternal( const int theISection,
+ const std::string& theName );
+ /** Set name of the specified section */
+ virtual bool setSectionName( const int theISection,
+ const std::string& theName );
+
+ //! Get type of the specified section
+ virtual CurveCreator::SectionType getSectionType( const int theISection ) const;
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool setSectionTypeInternal( const int theISection,
+ const CurveCreator::SectionType theType );
+ /**
+ * Set type of the specified section (or all sections
* if \a theISection is -1).
*/
- virtual void addPoints
- (const CurveCreator::Coordinates &thePoints, const int theISection = -1);
+ virtual bool setSectionType( const int theISection,
+ const CurveCreator::SectionType theType );
+
+
+ /***********************************************/
+ /*** Point methods ***/
+ /***********************************************/
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool addPointsInternal( const CurveCreator::SectionsMap &theSectionsMap );
+ /**
+ * Add one point to the specified section starting from the given theIPnt index
+ * (or at the end of points if \a theIPnt is -1).
+ */
+ virtual bool addPoints( const CurveCreator::Coordinates &theCoords,
+ const int theISection,
+ const int theIPnt = -1 );
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool setPointInternal( const CurveCreator::SectionsMap &theSectionsMap );
+ //! Set coordinates of specified point
+ virtual bool setPoint( const int theISection,
+ const int theIPnt,
+ const CurveCreator::Coordinates& theNewCoords );
+
+ //! Set coordinates of specified points from different sections
+ virtual bool setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords,
+ const bool theIsToSaveDiff = true );
+
+ //! For internal use only! Undo/Redo are not used here.
+ virtual bool removePointsInternal( const SectionToPointList &thePoints );
+ /** Remove point with given id */
+ virtual bool removePoint( const int theISection, const int theIPnt = -1 );
+
+ //! Remove several points from different sections with given ids
+ virtual bool removeSeveralPoints( const SectionToPointList &theSectionToPntIDs);
+
+ //! Get coordinates of specified point
+ virtual CurveCreator::Coordinates getPoint( const int theISection,
+ const int theIPnt ) const;
+
+ /**
+ * Get points of a section (the total points in Curve if theISection is equal to -1)..
+ */
+ virtual CurveCreator::Coordinates getPoints( const int theISection = -1 ) const;
+
+
+ /**
+ * Get number of points in specified section or (the total number of points
+ * in Curve if theISection is equal to -1).
+ */
+ virtual int getNbPoints( const int theISection ) const;
+
+ /**
+ * Set skip sorting flag. If the flag is true - points sorting will be skipped.
+ */
+ virtual void setSkipSorting( const bool theIsToSkip );
+
+ /**
+ * Indicates whether the points can be sorted.
+ */
+ virtual bool canPointsBeSorted();
+
+ /**
+ * Saves points coordinates difference.
+ * \param theOldCoords the old points coordinates
+ */
+ virtual void saveCoordDiff( const SectionToPointCoordsList &theOldCoords );
+
+ /***********************************************/
+ /*** Presentation methods ***/
+ /***********************************************/
+ /**
+ * Get the curve AIS object
+ */
+ virtual Handle_AIS_InteractiveObject getAISObject( const bool theNeedToBuild = false ) const;
+
+protected:
+ /**
+ * Removes the points from the section. It sortes the points and remove them
+ * in the decreasing order
+ * \param theSectionId a section index
+ * \param thePointIds a list of section points
+ */
+ bool removeSectionPoints( const int theSectionId,
+ const std::list<int>& thePointIds );
+ /**
+ * Converts the list of pairs of section to point into map of a section to list of points
+ * \param thePoints an source list
+ * \param theConvPoints a converted map
+ */
+ void convert( const SectionToPointList &thePoints,
+ std::map<int, std::list<int> > &theConvPoints );
+
+protected:
+ virtual void constructAISObject();
+ /**
+ * Returns the section by the section index or NULL if the index is out of the section
+ * list range
+ * \param theSectionId the section index
+ */
+ CurveCreator_Section* getSection( const int theSectionId ) const;
+
+protected:
+ bool mySkipSorting;
+
+public:
+ bool myIsLocked;
+ CurveCreator::Sections mySections; //!< curve data
+ CurveCreator::Dimension myDimension; //!< curve dimension
+ CurveCreator_Displayer* myDisplayer; //!< curve displayer
- friend class CurveCreator_CurveEditor;
- friend class CurveCreator_Operation;
+private:
+ int myNbUndos;
+ int myNbRedos;
+ ListDiff::iterator myCurrenPos;
+ ListDiff myListDiffs;
+ int myUndoDepth;
+ int myOpLevel;
+ AIS_Shape* myAISShape; //!< AIS shape
};
#endif
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// function: init
// purpose:
//=======================================================================
-bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
- const CurveCreator_Operation::Type theType)
+bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve)
{
+ CurveCreator_Operation::Type aType = CurveCreator_Operation::Clear;
bool isOK = false;
if (theCurve != NULL) {
// Set redo.
myPRedo = new CurveCreator_Operation;
- if (myPRedo->init(theType)) {
+ if (myPRedo->init(aType)) {
isOK = true;
const int aNbSections = theCurve->getNbSections();
- if (theType == CurveCreator_Operation::Clear) {
- // Construct undo for Clear command.
- if (aNbSections > 0) {
- setNbUndos(aNbSections);
+ // Construct undo for Clear command.
+ if (aNbSections > 0) {
+ setNbUndos(aNbSections);
- for (int i = 0; i < aNbSections && isOK; i++) {
- // Add AddSection command.
- isOK = addSectionToUndo(theCurve, i, myPUndo[i]);
- }
- }
- } else { // theType == CurveCreator_Operation::Join
- // Construct undo for Join command.
- if (aNbSections > 1) {
- // Add the RemovePoints command to remove points of
- // the second section fron the first one.
- const int aNbPoints = theCurve->getNbPoints(0);
-
- setNbUndos(aNbSections);
- isOK = myPUndo[0].init(CurveCreator_Operation::RemovePoints,
- 0, aNbPoints, -1);
-
- for (int i = 1; i < aNbSections && isOK; i++) {
- // Add AddSection command.
- isOK = addSectionToUndo(theCurve, i, myPUndo[i]);
- }
+ for (int i = 0; i < aNbSections && isOK; i++) {
+ // Add AddSection command.
+ isOK = addSectionToUndo(theCurve, i, myPUndo[i]);
}
}
}
setNbUndos(1);
isOK = myPUndo[0].init(theType, theIntParam2, theIntParam1);
break;
- case CurveCreator_Operation::Join:
- {
- // If the last section is removed, one AddSection command is
- // enough. If not last section is removed, two commands are
- // requred: AddSection and MoveSection.
- const int aLastIndex = theCurve->getNbSections() - 1;
- const int aNbPoints = theCurve->getNbPoints(theIntParam1);
-
- if (theIntParam2 == aLastIndex) {
- setNbUndos(2);
- } else {
- setNbUndos(3);
- }
-
- isOK = myPUndo[0].init(CurveCreator_Operation::RemovePoints,
- theIntParam1, aNbPoints, -1);
-
- if (isOK) {
- isOK = addSectionToUndo(theCurve, theIntParam2, myPUndo[1]);
-
- if (isOK && theIntParam2 != aLastIndex) {
- isOK = myPUndo[2].init(CurveCreator_Operation::MoveSection,
- aLastIndex, theIntParam2);
- }
- }
- }
- break;
default:
break;
}
//=======================================================================
bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
const CurveCreator_Operation::Type theType,
- const int theIntParam1,
- const int theIntParam2,
- const int theIntParam3)
+ const std::list<int>& theParams)
{
bool isOK = false;
- if (theCurve != NULL) {
+ if (theCurve != NULL || theParams.empty()) {
clear();
// Set redo.
myPRedo = new CurveCreator_Operation;
- if (myPRedo->init(theType, theIntParam1, theIntParam2, theIntParam3)) {
- // Construct undo for RemovePoints command.
- const CurveCreator::Dimension aDim = theCurve->getDimension();
- const CurveCreator::Coordinates &aPoints =
- theCurve->getPoints(theIntParam1);
- CurveCreator::Coordinates::const_iterator anIterBegin =
- aPoints.begin() + (aDim*theIntParam2);
- CurveCreator::Coordinates::const_iterator anIterEnd;
-
- if (theIntParam3 == -1) {
- anIterEnd = aPoints.end();
- } else {
- anIterEnd = anIterBegin + (aDim*theIntParam3);
- }
-
- CurveCreator::Coordinates aPointsToAdd;
-
- setNbUndos(1);
- aPointsToAdd.insert(aPointsToAdd.end(), anIterBegin, anIterEnd);
- isOK = myPUndo[0].init(CurveCreator_Operation::InsertPoints,
- aPointsToAdd, theIntParam1, theIntParam2);
- }
-
- if (!isOK) {
- clear();
- }
- }
-
- return isOK;
-}
-
-//=======================================================================
-// function: init
-// purpose:
-//=======================================================================
-bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
- const CurveCreator_Operation::Type theType,
- const CurveCreator::Coordinates &theCoords,
- const int theIntParam)
-{
- bool isOK = false;
-
- if (theCurve != NULL) {
- clear();
-
- // Set redo.
- myPRedo = new CurveCreator_Operation;
+ if (myPRedo->init(theType, theParams)) {
+ // Construct undo for different commands.
+ switch (theType) {
+ case CurveCreator_Operation::Join:
+ {
+ int aSectionMain = theParams.front();
+ const int aNbPointsMain = theCurve->getNbPoints(aSectionMain);
+
+ std::list<int> aSectionsToJoin = theParams;
+ aSectionsToJoin.erase( aSectionsToJoin.begin() );
+ // it is important to sort the section indices in order to correct perform undo
+ // for the move sections to the previous positions
+ aSectionsToJoin.sort();
+ // 1rst undo for remove points from the main and n-1 undoes to contain joined sections
+ int aSectionsToJoinNb = aSectionsToJoin.size();
+ int aNbUndos = 2*aSectionsToJoinNb + 1;
+ setNbUndos( aNbUndos );
+
+ // Add joined sections to undo
+ std::list<int>::const_iterator anIt = aSectionsToJoin.begin(),
+ aLast = aSectionsToJoin.end();
+ anIt = aSectionsToJoin.begin();
+ int aLastSectionId = -1;
+ for (int i = 0; anIt != aLast && i < aSectionsToJoinNb; anIt++, i++) {
+ int anISection = *anIt;
+ isOK = addSectionToUndo( theCurve, anISection, myPUndo[i*2] );
+ if (isOK) {
+ isOK = myPUndo[i*2+1].init(CurveCreator_Operation::MoveSection,
+ aLastSectionId, anISection);
+ if (!isOK)
+ break;
+ }
+ }
+ // Construct undo for RemovePoints command.
+ if (isOK) {
+ int aNbPointsInJoined = 0;
+ anIt = aSectionsToJoin.begin();
+ for ( ; anIt != aLast; anIt++ )
+ aNbPointsInJoined += theCurve->getNbPoints( *anIt );
- if (myPRedo->init(theType, theCoords, theIntParam)) {
- // Construct undo for AddPoints command.
- const int aSectionInd = getSectionIndex(theCurve, theIntParam);
- const CurveCreator::Dimension aDim = theCurve->getDimension();
- const CurveCreator::Coordinates &aPoints =
- theCurve->getPoints(aSectionInd);
- const int aNbPoints = (aPoints.size()/aDim);
+ int aJoinedSize = aNbPointsMain + aNbPointsInJoined;
+ CurveCreator_ICurve::SectionToPointList aSectionToPointList;
+ for (int anIPoint = aNbPointsMain; anIPoint < aJoinedSize; anIPoint++)
+ aSectionToPointList.push_back(std::make_pair(aSectionMain, anIPoint));
- setNbUndos(1);
- isOK = myPUndo[0].init(CurveCreator_Operation::RemovePoints,
- aSectionInd, aNbPoints, -1);
+ isOK = myPUndo[aNbUndos-1].init(CurveCreator_Operation::RemovePoints, aSectionToPointList);
+ }
+ }
+ break;
+ default:
+ break;
+ }
}
if (!isOK) {
return isOK;
}
-//=======================================================================
-// function: init
-// purpose:
-//=======================================================================
bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
const CurveCreator_Operation::Type theType,
- const CurveCreator::Coordinates &theCoords,
- const int theIntParam1,
- const int theIntParam2)
+ const std::string &theName,
+ const int theIntParam1 )
+{
+ bool isOK = false;
+ myPRedo = new CurveCreator_Operation;
+
+ if (myPRedo->init(theType, theName, theIntParam1 )) {
+ // Construct undo for different commands.
+ switch (theType) {
+ case CurveCreator_Operation::RenameSection:
+ setNbUndos(1);
+ isOK = myPUndo[0].init(CurveCreator_Operation::RenameSection,
+ theCurve->getSectionName(theIntParam1), theIntParam1);
+ break;
+ }
+ }
+ if( !isOK ){
+ clear();
+ }
+ return isOK;
+}
+
+bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
+ const CurveCreator_Operation::Type theType,
+ const CurveCreator_ICurve::SectionToPointList &theParamList1)
{
bool isOK = false;
// Set redo.
myPRedo = new CurveCreator_Operation;
- if (myPRedo->init(theType, theCoords, theIntParam1, theIntParam2)) {
+ if (myPRedo->init(theType, theParamList1)) {
// Construct undo for different commands.
switch (theType) {
- case CurveCreator_Operation::InsertPoints:
+ case CurveCreator_Operation::RemovePoints:
{
+ // Construct undo for RemovePoints command.
+ CurveCreator_ICurve::SectionToPointCoordsList aSectionToPointCoords;
+ CurveCreator::Coordinates aPointsToAdd;
const CurveCreator::Dimension aDim = theCurve->getDimension();
- const int aNbPoints = (theCoords.size()/aDim);
- const int aSectionInd = getSectionIndex(theCurve, theIntParam1);
- int aPointInd;
-
- if (theIntParam2 == -1) {
- aPointInd = theCurve->getNbPoints(aSectionInd);
- } else {
- aPointInd = theIntParam2;
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = theParamList1.begin(), aLast = theParamList1.end();
+ std::list<int> aPoints;
+ int aSectionId, aPointId;
+ for ( ; anIt != aLast; anIt++ ) {
+ aPointsToAdd.clear();
+ aSectionId = anIt->first;
+ aPointId = anIt->second;
+ const CurveCreator::Coordinates &aPoints =
+ theCurve->getPoints(aSectionId);
+ CurveCreator::Coordinates::const_iterator anIterBegin =
+ aPoints.begin() + (aDim*aPointId);
+ CurveCreator::Coordinates::const_iterator anIterEnd =
+ anIterBegin + aDim;
+ aPointsToAdd.insert(aPointsToAdd.end(), anIterBegin, anIterEnd);
+ aSectionToPointCoords.push_back(std::make_pair(*anIt, aPointsToAdd));
}
+ setNbUndos(1);
+ isOK = myPUndo[0].init(CurveCreator_Operation::InsertPoints,
+ aSectionToPointCoords);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (!isOK) {
+ clear();
+ }
+ }
+ return isOK;
+}
+
+bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
+ const CurveCreator_Operation::Type theType,
+ const CurveCreator_ICurve::SectionToPointCoordsList &theParamList1)
+{
+ bool isOK = false;
+
+ if (theCurve != NULL) {
+ clear();
+
+ // Set redo.
+ myPRedo = new CurveCreator_Operation;
+
+ if (myPRedo->init(theType, theParamList1)) {
+ // Construct undo for different commands.
+ switch (theType) {
+ case CurveCreator_Operation::InsertPoints:
+ {
+ // Construct undo for RemovePoints command.
+ CurveCreator_ICurve::SectionToPointList aSectionToPointList;
+ CurveCreator_ICurve::SectionToPointCoordsList::const_iterator anIt = theParamList1.begin(), aLast = theParamList1.end();
+ for ( ; anIt != aLast; anIt++ ) {
+ aSectionToPointList.push_back(anIt->first);
+ }
setNbUndos(1);
isOK = myPUndo[0].init(CurveCreator_Operation::RemovePoints,
- aSectionInd, aPointInd, aNbPoints);
+ aSectionToPointList);
}
break;
case CurveCreator_Operation::SetCoordinates:
{
- const CurveCreator::Coordinates anOldCoords =
- theCurve->getCoordinates(theIntParam1, theIntParam2);
+ // Construct undo for SetCoordinates command.
+ CurveCreator_ICurve::SectionToPointCoordsList aSectionToPointOldCoords;
+ CurveCreator_ICurve::SectionToPointCoordsList::const_iterator anIt = theParamList1.begin(), aLast = theParamList1.end();
+ for ( ; anIt != aLast; anIt++ ) {
+ CurveCreator::Coordinates anOldCoords = theCurve->getPoint(anIt->first.first, anIt->first.second);
+ aSectionToPointOldCoords.push_back(std::make_pair(anIt->first, anOldCoords));
+ }
setNbUndos(1);
isOK = myPUndo[0].init(CurveCreator_Operation::SetCoordinates,
- anOldCoords, theIntParam1, theIntParam2);
+ aSectionToPointOldCoords);
}
break;
default:
}
bool CurveCreator_Diff::init(const CurveCreator_Curve *theCurve,
- const CurveCreator_Operation::Type theType,
- const std::string &theName,
- const int theIntParam1 )
+ const CurveCreator_ICurve::SectionToPointCoordsList &theOldParamList)
{
bool isOK = false;
- myPRedo = new CurveCreator_Operation;
- if (myPRedo->init(theType, theName, theIntParam1 )) {
- // Construct undo for different commands.
- switch (theType) {
- case CurveCreator_Operation::RenameSection:
- setNbUndos(1);
- isOK = myPUndo[0].init(CurveCreator_Operation::RenameSection,
- theCurve->getSectionName(theIntParam1), theIntParam1);
- break;
- }
- }
- if( !isOK ){
+ if (theCurve != NULL && theOldParamList.size() > 0) {
clear();
+
+ // Set redo.
+ myPRedo = new CurveCreator_Operation;
+
+ // Construct redo for SetCoordinates command.
+ CurveCreator_ICurve::SectionToPointCoordsList aSectionToPointActualCoords;
+ CurveCreator_ICurve::SectionToPointCoordsList::const_iterator anIt =
+ theOldParamList.begin(), aLast = theOldParamList.end();
+ for ( ; anIt != aLast; anIt++ ) {
+ CurveCreator::Coordinates anActualCoords = theCurve->getPoint(anIt->first.first, anIt->first.second);
+ aSectionToPointActualCoords.push_back(std::make_pair(anIt->first, anActualCoords));
+ }
+
+ if (myPRedo->init(CurveCreator_Operation::SetCoordinates, aSectionToPointActualCoords)) {
+ // Undo for SetCoordinates command.
+ setNbUndos(1);
+ isOK = myPUndo[0].init(CurveCreator_Operation::SetCoordinates,
+ theOldParamList);
+ }
+
+ if (!isOK) {
+ clear();
+ }
}
+
return isOK;
}
const int theIndex,
CurveCreator_Operation &theOperation) const
{
+ const std::string aName = theCurve->getSectionName(theIndex);
const CurveCreator::Coordinates &aPnts = theCurve->getPoints(theIndex);
- const CurveCreator::Type aType = theCurve->getType(theIndex);
+ const CurveCreator::SectionType aType = theCurve->getSectionType(theIndex);
const bool isClosed = theCurve->isClosed(theIndex);
bool isOK = theOperation.init(CurveCreator_Operation::AddSection,
- aPnts, aType, isClosed);
+ aName, aPnts, aType, isClosed);
return isOK;
}
// Get sections to be modified.
for (i = 0; i < aNbSections; i++) {
if (isSetType) {
- aValue = theCurve->getType(i);
+ aValue = theCurve->getSectionType(i);
} else {
aValue = theCurve->isClosed(i);
}
// There is only particular section modified.
// Check if there is a real modification required.
if (isSetType) {
- aValue = theCurve->getType(theIntParam2);
+ aValue = theCurve->getSectionType(theIntParam2);
} else {
aValue = theCurve->isClosed(theIntParam2);
}
std::list<int>::iterator anIter = aListOfInd.begin();
if (isSetType) {
- aValue = theCurve->getType(*anIter);
+ aValue = theCurve->getSectionType(*anIter);
} else {
aValue = theCurve->isClosed(*anIter);
}
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
* parameters. It is applicable to the following operations:
* <UL>
* <LI>Clear</LI>
- * <LI>Join (without arguments)</LI>
* </UL>
*/
- bool init(const CurveCreator_Curve *theCurve,
- const CurveCreator_Operation::Type theType);
+ bool init(const CurveCreator_Curve *theCurve);
/**
* This method initializes the difference with an operation with one integer
* <LI>SetType</LI>
* <LI>SetClosed</LI>
* <LI>MoveSection</LI>
- * <LI>Join (with 2 int arguments)</LI>
* </UL>
*/
bool init(const CurveCreator_Curve *theCurve,
const int theIntParam1,
const int theIntParam2);
- /**
- * This method initializes the difference with an operation with three
- * integer parameters. It is applicable to the following operations:
+ /**
+ * This method initializes the difference with an operation with two integer
+ * parameters. It is applicable to the following operations:
* <UL>
- * <LI>RemovePoints</LI>
+ * <LI>Join (with a list of int arguments)</LI>
* </UL>
*/
bool init(const CurveCreator_Curve *theCurve,
const CurveCreator_Operation::Type theType,
- const int theIntParam1,
- const int theIntParam2,
- const int theIntParam3);
+ const std::list<int>& theParams);
/**
* This method initializes the difference with an operation with one
- * CurveCreator::Coordinates parameter and one integer parameter.
+ * Name, one CurveCreator::Coordinates parameter and two integer parameters.
* It is applicable to the following operations:
* <UL>
- * <LI>AddPoints</LI>
+ * <LI>AddSection</LI>
* </UL>
*/
bool init(const CurveCreator_Curve *theCurve,
const CurveCreator_Operation::Type theType,
+ const std::string& theName,
const CurveCreator::Coordinates &theCoords,
- const int theIntParam);
+ const int theIntParam1,
+ const int theIntParam2);
/**
* This method initializes the difference with an operation with one
- * CurveCreator::Coordinates parameter and two integer parameters.
+ * string and one integer parameters.
* It is applicable to the following operations:
* <UL>
- * <LI>InsertPoints</LI>
- * <LI>SetCoordinates</LI>
+ * <LI>RenameSection</LI>
* </UL>
*/
bool init(const CurveCreator_Curve *theCurve,
const CurveCreator_Operation::Type theType,
- const CurveCreator::Coordinates &theCoords,
- const int theIntParam1,
- const int theIntParam2);
+ const std::string &theName,
+ const int theIntParam1 );
/**
- * This method initializes the difference with an operation with one
- * Name, one CurveCreator::Coordinates parameter and two integer parameters.
+ * This method initializes the difference with an operation with
+ * list of pairs of integer parameters.
* It is applicable to the following operations:
* <UL>
- * <LI>AddSection</LI>
+ * <LI>RemovePoints</LI>
* </UL>
*/
bool init(const CurveCreator_Curve *theCurve,
const CurveCreator_Operation::Type theType,
- const std::string& theName,
- const CurveCreator::Coordinates &theCoords,
- const int theIntParam1,
- const int theIntParam2);
+ const CurveCreator_ICurve::SectionToPointList &theParamList);
/**
- * This method initializes the difference with an operation with one
- * string and one integer parameters.
+ * This method initializes the difference with an operation with
+ * list of pairs of integer parameters with point coordinates.
* It is applicable to the following operations:
* <UL>
- * <LI>RenameSection</LI>
+ * <LI>RemovePoints</LI>
* </UL>
*/
bool init(const CurveCreator_Curve *theCurve,
const CurveCreator_Operation::Type theType,
- const std::string &theName,
- const int theIntParam1 );
+ const CurveCreator_ICurve::SectionToPointCoordsList &theParamList);
+
+ /**
+ * This method initializes the difference with an operation with
+ * list of pairs of integer parameters with point coordinates.
+ * \param theCurve the modified curve
+ * \param theOldParamList the old parameters (to be saved for undo)
+ */
+ bool init(const CurveCreator_Curve *theCurve,
+ const CurveCreator_ICurve::SectionToPointCoordsList &theOldParamList);
/**
* This method applies undo operation to theCurve.
--- /dev/null
+#include "CurveCreator_Displayer.hxx"
+
+CurveCreator_Displayer::CurveCreator_Displayer( Handle_AIS_InteractiveContext theContext,
+ const int theZLayer ) :
+ myContext( theContext ), myZLayer( theZLayer )
+{
+ myObjects.clear();
+}
+
+CurveCreator_Displayer::~CurveCreator_Displayer(void)
+{
+ eraseAll( true );
+ for( int i = 0 ; i < myObjects.size() ; i++ ){
+ myObjects[i].Nullify();
+ }
+ myObjects.clear();
+}
+
+void CurveCreator_Displayer::display( const Handle(AIS_InteractiveObject)& theObject, bool isUpdate )
+{
+ if ( theObject.IsNull() )
+ return;
+
+ myObjects.push_back( theObject );
+ myContext->Display( theObject, Standard_False );
+
+ if ( myZLayer >= 0 )
+ myContext->SetZLayer( theObject, myZLayer );
+
+ if( isUpdate )
+ myContext->UpdateCurrentViewer();
+}
+
+void CurveCreator_Displayer::eraseAll( bool isUpdate )
+{
+ if(myObjects.empty())
+ return;
+ for( int i = 0 ; i < myObjects.size() ; i++ ){
+ myContext->Erase(myObjects[i], Standard_False);
+ }
+ myObjects.clear();
+ if( isUpdate )
+ myContext->UpdateCurrentViewer();
+}
+
+Quantity_Color CurveCreator_Displayer::getActiveColor( bool isHL )
+{
+ if( isHL ){
+ return Quantity_Color( 1., 0., 0., Quantity_TOC_RGB );
+ }
+ return Quantity_Color( 0., 1., 0., Quantity_TOC_RGB );
+}
+
+/*void CurveCreator_Displayer::highlight( const AISObjectsList& theObjects, bool isHL )
+{
+ return;
+ //TODO:
+ Quantity_Color aColor = getActiveColor( isHL );
+ for( int i = 0 ; i < theObjects.size() ; i++ ){
+ theObjects[i]->SetColor(aColor);
+ myContext->Display(theObjects[i], Standard_False);
+ }
+ myContext->UpdateCurrentViewer();
+}*/
--- /dev/null
+#ifndef CURVECREATOR_DISPLAYER_H
+#define CURVECREATOR_DISPLAYER_H
+
+#include "CurveCreator_Macro.hxx"
+
+#include <AIS_InteractiveObject.hxx>
+#include <AIS_InteractiveContext.hxx>
+
+#include <vector>
+
+class CURVECREATOR_EXPORT CurveCreator_Displayer
+{
+typedef std::vector<Handle_AIS_InteractiveObject> AISObjectsList;
+
+public:
+ CurveCreator_Displayer( Handle_AIS_InteractiveContext theContext,
+ const int theZLayer = -1 );
+ ~CurveCreator_Displayer(void);
+
+ void display( const Handle_AIS_InteractiveObject& theObject, bool isUpdate );
+ void eraseAll( bool isUpdate );
+ //void highlight( const AISObjectsList& theObjects, bool isHL );
+
+protected:
+ Quantity_Color getActiveColor( bool isHL );
+
+private:
+ Handle_AIS_InteractiveContext myContext;
+ AISObjectsList myObjects;
+ int myZLayer;
+};
+
+#endif
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
-// File: CurveCreator_Curve.hxx
-// Author: Sergey KHROMOV
+// File: CurveCreator_ICurve.hxx
+// Author: Alexander KOVALEV and Alexander SOLOVYOV
#ifndef _CurveCreator_ICurve_HeaderFile
#define _CurveCreator_ICurve_HeaderFile
-#include "CurveCreator.hxx"
#include "CurveCreator_Macro.hxx"
-#include "CurveCreator_Operation.hxx"
+#include <deque>
+#include <vector>
+#include <string>
+#include <list>
-class CurveCreator_Section;
-class CurveCreator_Listener;
+class Handle_AIS_InteractiveObject;
+
+namespace CurveCreator
+{
+ //! Type of the section
+ enum SectionType
+ {
+ Polyline,
+ Spline,
+ };
+
+ //! Dimension of the curve
+ enum Dimension
+ {
+ Dim2d = 2,
+ Dim3d = 3
+ };
+
+};
/**
* The CurveCreator_ICurve object is represented as one or more sets of
* connected points; thus CurveCreator_ICurve object can contain several
* not connected curves (polylines or b-splines), each such curve has two
- * only ends � start and end points � in other words non-manifold curves
+ * only ends "start and end points" in other words non-manifold curves
* are not supported.
*/
class CURVECREATOR_EXPORT CurveCreator_ICurve
{
+public:
+ typedef std::pair<int,int> SectionToPoint;
+ typedef std::deque<SectionToPoint> SectionToPointList;
- //! List of curves
- typedef std::deque<CurveCreator_Section *> Sections;
+ typedef std::deque< std::pair< SectionToPoint,std::deque< float > > > SectionToPointCoordsList;
public:
- //! Constructor of the curve.
- /** The dimension is explicitly specified in the constructor
- * and cannot be changed later.
- */
- CurveCreator_ICurve(const CurveCreator::Dimension theDimension);
+ /***********************************************/
+ /*** Undo/Redo methods ***/
+ /***********************************************/
- //! Destructor.
- virtual ~CurveCreator_ICurve();
+ //! Get number of available undo operations
+ virtual int getNbUndo() const = 0;
- //! Returns true if this curve is locked by a curve editor.
- virtual bool isLocked() const;
+ //! Undo previous operation
+ virtual bool undo() = 0;
- //! Get the dimension.
- virtual CurveCreator::Dimension getDimension() const;
+ //! Get number of available redo operations
+ virtual int getNbRedo() const = 0;
- //! Get number of sections.
- virtual int getNbSections() const;
+ //! Redo last previously "undone" operation
+ virtual bool redo() = 0;
- /** Get number of points in specified section or (the total number of points
- * in Curve if theISection is equal to -1).
- */
- virtual int getNbPoints(const int theISection = -1) const;
- //! Get coordinates of specified point
- virtual CurveCreator::Coordinates getCoordinates
- (const int theISection, const int theIPnt) const;
+ /***********************************************/
+ /*** Section methods ***/
+ /***********************************************/
- //! Get points of a section.
- virtual const CurveCreator::Coordinates &getPoints(const int theISection) const;
+ //! Clear the polyline (remove all sections)
+ virtual bool clear() = 0;
- //! Get type of the specified section
- virtual CurveCreator::Type getType(const int theISection) const;
+ //! Join list of sections to one section (join all if the list is empty)
+ // The first section in the list is a leader, another sections are joined to it
+ virtual bool join( const std::list<int>& theSections ) = 0;
- //! Get �closed� flag of the specified section
- virtual bool isClosed(const int theISection) const;
+ //! Get number of sections
+ virtual int getNbSections() const = 0;
- //! Returns specifyed section name
- virtual std::string getSectionName(const int theISection) const;
+ //! Add a new section.
+ virtual int addSection( const std::string& theName,
+ const CurveCreator::SectionType theType,
+ const bool theIsClosed ) = 0;
- /**
- * Return unic section name
- */
- virtual std::string getUnicSectionName();
+ //! Removes the given sections.
+ virtual bool removeSection( const int theISection ) = 0;
- /**
- * Set curve creator listener object
- */
- virtual void setListener( CurveCreator_Listener* myWatcher );
+ //! Get "closed" flag of the specified section
+ virtual bool isClosed( const int theISection ) const = 0;
/**
- * Remove curve creator listener object
+ * Set "closed" flag of the specified section (all sections if
+ * \a theISection is -1).
*/
- virtual void removeListener();
+ virtual bool setClosed( const int theISection,
+ const bool theIsClosed ) = 0;
-protected:
+ //! Returns specifyed section name
+ virtual std::string getSectionName( const int theISection ) const = 0;
- /** Set type of the specified section (or all sections
- * if \a theISection is -1).
- */
- virtual void setType(const CurveCreator::Type theType, const int theISection = -1);
+ /** Set name of the specified section */
+ virtual bool setSectionName( const int theISection,
+ const std::string& theName ) = 0;
- /** Add points to the specified section (or last section
+ //! Get type of the specified section
+ virtual CurveCreator::SectionType getSectionType( const int theISection ) const = 0;
+
+ /**
+ * Set type of the specified section (or all sections
* if \a theISection is -1).
*/
- virtual void addPoints
- (const CurveCreator::Coordinates &thePoints, const int theISection = -1) = 0;
-
- //! Add a new section.
- virtual void addSection (const std::string &theName, const CurveCreator::Type theType,
- const bool theIsClosed,
- const CurveCreator::Coordinates &thePoints);
+ virtual bool setSectionType( const int theISection,
+ const CurveCreator::SectionType theType ) = 0;
- //! Removes the section. If theISection equals -1, removes the last section.
- virtual void removeSection(const int theISection = -1);
- /** Insert points in the given position (add to the end of list
- * if \a theIPnt parameter is -1) of the specified section
- * (or last section if \a theISection parameter is -1).
- */
- virtual void insertPoints(const CurveCreator::Coordinates &thePoints,
- const int theISection = -1,
- const int theIPnt = -1);
+ /***********************************************/
+ /*** Point methods ***/
+ /***********************************************/
- /** Remove \a nbPoints points from given \a theISection,
- * starting from given \a theIPnt (of all points up to the end of
- * section if \a theNbPoints is -1).
- */
- virtual void removePoints(const int theISection,
- const int theIPnt,
- const int theNbPoints = -1);
+ //! Get the dimension.
+ virtual CurveCreator::Dimension getDimension() const = 0;
- /** Move specified point within section to new position
+ /**
+ * Insert one or several points to the specified section starting from the given theIPnt index
+ * (or add these at the end of section points if \a theIPnt is -1).
*/
- virtual void movePoint(const int theISection,
- const int theIPointFrom,
- const int theNewIndex);
-
- //! Remove all sections.
- virtual void clear();
+ virtual bool addPoints( const std::deque<float>& theCoords,
+ const int theISection,
+ const int theIPnt = -1 ) = 0;
//! Set coordinates of specified point
- virtual void setCoordinates(const CurveCreator::Coordinates &theCoords,
- const int theISection,
- const int theIPnt);
+ virtual bool setPoint( const int theISection,
+ const int theIPnt,
+ const std::deque<float>& theNewCoords ) = 0;
+
+ //! Set coordinates of specified points from different sections
+ virtual bool setSeveralPoints( const SectionToPointCoordsList &theSectionToPntCoords,
+ const bool theIsToSaveDiff = true ) = 0;
+
+ //! Remove point with given id
+ virtual bool removePoint( const int theISection, const int theIPnt = -1 ) = 0;
+ //! Remove several points from different sections
+ virtual bool removeSeveralPoints( const SectionToPointList &theSectionToPntIDs) = 0;
- /** Set �closed� flag of the specified section (all sections if
- * \a theISection is -1).
- */
- virtual void setClosed(const bool theIsClosed, const int theISection = -1);
+ //! Get coordinates of specified point
+ virtual std::deque<float> getPoint( const int theISection,
+ const int theIPnt ) const = 0;
- /** Set name of the specified section.
+ /**
+ * Get points of a section (the total points in Curve if theISection is equal to -1)..
*/
- virtual void setName( const std::string& theName, const int theISection );
+ virtual std::deque<float> getPoints( const int theISection = -1 ) const = 0;
- /** Move specified \a theISection to the specified position
- * in the sections list.
+ /**
+ * Get number of points in specified section or (the total number of points
+ * in Curve if theISection is equal to -1).
*/
- virtual void moveSection(const int theISection, const int theNewIndex);
+ virtual int getNbPoints( const int theISection ) const = 0;
- //! Join two sections to one section
- virtual void join(const int theISectionTo, const int theISectionFrom);
+ /**
+ * Set skip sorting flag. If the flag is true - points sorting will be skipped.
+ */
+ virtual void setSkipSorting( const bool ) = 0;
- //! Join all sections to the single curve
- virtual void join();
+ /**
+ * Indicates whether the points can be sorted.
+ */
+ virtual bool canPointsBeSorted() = 0;
/**
- * This method converts the point index to the index in
- * an array of coordinates.
+ * Saves points coordinates difference.
+ * \param theOldCoords the old points coordinates
*/
- virtual int toICoord(const int theIPnt) const;
+ virtual void saveCoordDiff( const SectionToPointCoordsList &theOldCoords ) = 0;
-public:
+ /***********************************************/
+ /*** Presentation methods ***/
+ /***********************************************/
- bool myIsLocked;
- Sections mySections; //!< curve data
- CurveCreator::Dimension myDimension; //!< curve dimension
- CurveCreator_Listener* myListener; //!< listener
+ virtual Handle_AIS_InteractiveObject getAISObject( const bool theNeedToBuild = false ) const = 0;
+
+protected:
+ virtual void constructAISObject() = 0;
};
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
//
#include "CurveCreator_NewSectionDlg.h"
-#include "CurveCreator_Curve.hxx"
+//#include "CurveCreator_Curve.hxx"
#include <SUIT_Session.h>
#include <SUIT_ResourceMgr.h>
#include <QDialogButtonBox>
#include <QPushButton>
-CurveCreator_NewSectionDlg::CurveCreator_NewSectionDlg( QWidget *parent ) :
- QWidget(parent)
+CurveCreator_NewSectionDlg::CurveCreator_NewSectionDlg( QWidget *parent, bool enableClosed ) :
+ QWidget(parent), myIsEnableClosed( enableClosed )
{
+ QVBoxLayout* aMainLayout = new QVBoxLayout( this );
+ aMainLayout->setMargin( 0 );
+
QFrame* aFrame = new QFrame( this );
+ aMainLayout->addWidget( aFrame );
+
QVBoxLayout* aLayout = new QVBoxLayout( aFrame );
+ aLayout->setMargin( 0 );
QFrame* aCoordFrame = new QFrame( aFrame );
QGridLayout* aCoordLayout = new QGridLayout( aCoordFrame );
myIsClosed = new QCheckBox(this);
aCoordLayout->addWidget(aLbl, 2, 0);
aCoordLayout->addWidget(myIsClosed, 2, 1);
+ if ( !myIsEnableClosed ) {
+ aLbl->hide();
+ myIsClosed->hide();
+ }
myBtnFrame = new QFrame( aFrame );
QHBoxLayout* aBtnsLayout = new QHBoxLayout( myBtnFrame );
aLayout->addWidget( myBtnFrame, 1 );
}
-void CurveCreator_NewSectionDlg::setSectionParameters( const QString& theName, bool isClosed, CurveCreator::Type theType )
+void CurveCreator_NewSectionDlg::setSectionParameters( const QString& theName, bool isClosed, CurveCreator::SectionType theType )
{
myName->setText(theName);
myIsClosed->setChecked(isClosed);
return myIsClosed->isChecked();
}
-CurveCreator::Type CurveCreator_NewSectionDlg::getSectionType() const
+CurveCreator::SectionType CurveCreator_NewSectionDlg::getSectionType() const
{
if( myLineType->currentIndex() == 0 )
return CurveCreator::Polyline;
else
- return CurveCreator::BSpline;
+ return CurveCreator::Spline;
}
void CurveCreator_NewSectionDlg::updateTitle()
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#define CURVECREATOR_NEWSECTION_H
#include "CurveCreator.hxx"
+#include "CurveCreator_ICurve.hxx"
#include <QDockWidget>
-class CurveCreator_Curve;
+//class CurveCreator_Curve;
class QLineEdit;
class QComboBox;
{
Q_OBJECT
public:
- explicit CurveCreator_NewSectionDlg(QWidget *parent = 0);
+ explicit CurveCreator_NewSectionDlg(QWidget *parent = 0, bool enableClosed = true );
QString getName() const;
bool isClosed() const;
- CurveCreator::Type getSectionType() const;
+ CurveCreator::SectionType getSectionType() const;
- void setSectionParameters( const QString& theName, bool isClosed, CurveCreator::Type theType );
+ void setSectionParameters( const QString& theName, bool isClosed, CurveCreator::SectionType theType );
void setSectionName(const QString& theName );
void clear();
void setEditMode( bool isEdit );
+ bool isEnableClosed() const { return myIsEnableClosed; }
signals:
void addSection();
QComboBox* myLineType;
QCheckBox* myIsClosed;
bool myIsEdit;
+ bool myIsEnableClosed;
QPushButton* myAddBtn;
QPushButton* myCancelBtn;
};
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "CurveCreator_Operation.hxx"
#include "CurveCreator_Curve.hxx"
+#include "CurveCreator.hxx"
#include <string>
#include <stdlib.h>
clear();
}
+bool compId(CurveCreator_PosPoint* p1, CurveCreator_PosPoint* p2)
+{
+ return p1->myID < p2->myID;
+}
+
//=======================================================================
// function: Constructor
// purpose:
{
bool isOK = false;
- if (theType == CurveCreator_Operation::Clear ||
- theType == CurveCreator_Operation::Join) {
+ if (theType == CurveCreator_Operation::Clear) {
clear();
myType = theType;
isOK = true;
// function: Constructor
// purpose:
//=======================================================================
-bool CurveCreator_Operation::init(const CurveCreator_Operation::Type theType,
- const int theIntParam1,
- const int theIntParam2,
- const int theIntParam3)
+bool CurveCreator_Operation::init(const Type theType, const std::list<int> theParamList)
{
bool isOK = false;
- if (theType == CurveCreator_Operation::RemovePoints) {
- int *pData = (int *)allocate(3*sizeof(int));
-
- pData[0] = theIntParam1;
- pData[1] = theIntParam2;
- pData[2] = theIntParam3;
- myType = theType;
- isOK = true;
- }
-
- return isOK;
-}
-
-//=======================================================================
-// function: Constructor
-// purpose:
-//=======================================================================
-bool CurveCreator_Operation::init(const CurveCreator_Operation::Type theType,
- const CurveCreator::Coordinates &theCoords,
- const int theIntParam)
-{
- bool isOK = false;
+ if (theType == CurveCreator_Operation::Join)
+ {
+ const int aNbPoints = theParamList.size();
- if (theType == CurveCreator_Operation::AddPoints) {
- const int aNbCoords = theCoords.size();
const size_t aSize =
- 2*sizeof(theIntParam) + aNbCoords*sizeof(CurveCreator::TypeCoord);
- int *pIntData = (int *)allocate(aSize);
-
- *pIntData++ = theIntParam;
- *pIntData++ = aNbCoords;
+ sizeof(aNbPoints) +
+ aNbPoints * (sizeof(int));
- CurveCreator::TypeCoord *pRealData = (CurveCreator::TypeCoord *)pIntData;
- int i = 0;
+ int *pIntData = (int *)allocate(aSize);
- for (; i < aNbCoords; i++) {
- *pRealData++ = theCoords[i];
- }
+ *pIntData++ = aNbPoints;
+ std::list<int>::const_iterator anIt = theParamList.begin(), aLast = theParamList.end();
+ for ( ; anIt != aLast; anIt++ )
+ *pIntData++ = *anIt;
- myType = theType;
+ myType = theType;
isOK = true;
}
-
return isOK;
}
//=======================================================================
bool CurveCreator_Operation::init(const CurveCreator_Operation::Type theType,
const CurveCreator::Coordinates &theCoords,
- const int theIntParam1,
- const int theIntParam2)
+ const int theIntParam)
{
bool isOK = false;
- if (theType == CurveCreator_Operation::AddSection ||
- theType == CurveCreator_Operation::InsertPoints ||
- theType == CurveCreator_Operation::SetCoordinates) {
+ if (theType == CurveCreator_Operation::AddPoints) {
const int aNbCoords = theCoords.size();
const size_t aSize =
- 3*sizeof(theIntParam1) + aNbCoords*sizeof(CurveCreator::TypeCoord);
+ 2*sizeof(theIntParam) + aNbCoords*sizeof(CurveCreator::TypeCoord);
int *pIntData = (int *)allocate(aSize);
- *pIntData++ = theIntParam1;
- *pIntData++ = theIntParam2;
+ *pIntData++ = theIntParam;
*pIntData++ = aNbCoords;
CurveCreator::TypeCoord *pRealData = (CurveCreator::TypeCoord *)pIntData;
pIntData = (int*)aStrPtr;
*pIntData++ = aNbCoords;
- CurveCreator::TypeCoord *pRealData = (CurveCreator::TypeCoord *)aStrPtr;
+ CurveCreator::TypeCoord *pRealData = (CurveCreator::TypeCoord *)pIntData;
int i = 0;
for (; i < aNbCoords; i++) {
return false;
}
+bool CurveCreator_Operation::init(const CurveCreator_Operation::Type theType,
+ const CurveCreator_ICurve::SectionToPointCoordsList &theParamList1)
+{
+ bool isOK = false;
+
+ if (theType == CurveCreator_Operation::InsertPoints ||
+ theType == CurveCreator_Operation::SetCoordinates ) {
+
+ const int aNbPoints = theParamList1.size();
+
+ CurveCreator_ICurve::SectionToPointCoordsList::const_iterator anIt =
+ theParamList1.begin();
+ const int aNbCoords = anIt->second.size();
+
+ const size_t aSize =
+ sizeof(aNbPoints) + sizeof(aNbCoords) +
+ aNbPoints * (3*sizeof(int) + aNbCoords*sizeof(CurveCreator::TypeCoord));
+ int *pIntData = (int *)allocate(aSize);
+
+ *pIntData++ = aNbPoints;
+ *pIntData++ = aNbCoords;
+ int aSectionId, aPointId;
+ for ( ; anIt != theParamList1.end(); anIt++ ) {
+ aSectionId = anIt->first.first;
+ aPointId = anIt->first.second;
+
+ *pIntData++ = aSectionId;
+ *pIntData++ = aPointId;
+ *pIntData++ = aNbCoords;
+
+ const CurveCreator::Coordinates &aCoords = anIt->second;
+ CurveCreator::TypeCoord *pRealData = (CurveCreator::TypeCoord *)pIntData;
+ for (int i = 0; i < aNbCoords; i++) {
+ *pRealData++ = aCoords[i];
+ }
+ pIntData = (int *)pRealData;
+ }
+
+ myType = theType;
+ isOK = true;
+ }
+
+ return isOK;
+}
+
+bool CurveCreator_Operation::init(const CurveCreator_Operation::Type theType,
+ const CurveCreator_ICurve::SectionToPointList &theParamList1)
+{
+ bool isOK = false;
+
+ if (theType == CurveCreator_Operation::RemovePoints) {
+ const int aNbPoints = theParamList1.size();
+
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt =
+ theParamList1.begin();
+
+ const size_t aSize =
+ sizeof(aNbPoints) +
+ aNbPoints * (2*sizeof(int));
+ int *pIntData = (int *)allocate(aSize);
+
+ *pIntData++ = aNbPoints;
+ int aSectionId, aPointId;
+ for ( ; anIt != theParamList1.end(); anIt++ ) {
+ aSectionId = anIt->first;
+ aPointId = anIt->second;
+
+ *pIntData++ = aSectionId;
+ *pIntData++ = aPointId;
+ }
+
+ myType = theType;
+ isOK = true;
+ }
+
+ return isOK;
+}
+
//=======================================================================
// function: apply
// purpose:
switch (myType) {
case CurveCreator_Operation::AddPoints:
+ case CurveCreator_Operation::InsertPoints:
+ case CurveCreator_Operation::SetCoordinates:
{
+ int aSectionId, aPointId;
+ CurveCreator::SectionsMap aSectionsMap;
+ CurveCreator::PosPointsList aPoints;
CurveCreator::Coordinates aCoords;
- getCoords(&pInt[1], aCoords);
- theCurve->addPoints(aCoords, pInt[0]);
+ int nbPoints = pInt[0];
+ int nbCoords = pInt[1];
+ int nbParams = 3+nbCoords;
+ for (int i = 0; i < nbPoints*nbParams; i=i+nbParams) {
+ aCoords.clear();
+ aPoints.clear();
+ getCoords(&pInt[4+i], aCoords);
+ aSectionId = pInt[2+i];
+ aPointId = pInt[3+i];
+ if ( aSectionsMap.find( aSectionId ) != aSectionsMap.end() )
+ aPoints = aSectionsMap[aSectionId];
+ CurveCreator_PosPoint* aPosPoint = new CurveCreator_PosPoint( aPointId, aCoords );
+ aPoints.push_back( aPosPoint );
+ aPoints.sort(compId);
+ aSectionsMap[aSectionId] = aPoints;
+ }
+ switch (myType) {
+ case CurveCreator_Operation::AddPoints:
+ case CurveCreator_Operation::InsertPoints:
+ theCurve->addPointsInternal( aSectionsMap );
+ break;
+ case CurveCreator_Operation::SetCoordinates:
+ theCurve->setPointInternal( aSectionsMap );
+ break;
+ }
}
break;
case CurveCreator_Operation::RemovePoints:
- theCurve->removePoints(pInt[0], pInt[1], pInt[2]);
- break;
- case CurveCreator_Operation::InsertPoints:
{
- CurveCreator::Coordinates aCoords;
-
- getCoords(&pInt[2], aCoords);
- theCurve->insertPoints(aCoords, pInt[0], pInt[1]);
+ CurveCreator_ICurve::SectionToPointList aListOfSectionsToPoints;
+ int nbPoints = pInt[0];
+ for (int i = 1; i < nbPoints*2; i=i+2) {
+ aListOfSectionsToPoints.push_back(std::make_pair(pInt[i], pInt[i+1]));
+ }
+ theCurve->removePointsInternal(aListOfSectionsToPoints);
}
break;
case CurveCreator_Operation::SetType:
{
- const CurveCreator::Type aType = (CurveCreator::Type) pInt[0];
+ const CurveCreator::SectionType aType = (CurveCreator::SectionType) pInt[0];
- theCurve->setType(aType, pInt[1]);
+ theCurve->setSectionTypeInternal( pInt[1], aType );
}
break;
case CurveCreator_Operation::Clear:
- theCurve->clear();
- break;
- case CurveCreator_Operation::SetCoordinates:
- {
- CurveCreator::Coordinates aCoords;
-
- getCoords(&pInt[2], aCoords);
- theCurve->setCoordinates(aCoords, pInt[0], pInt[1]);
- }
+ theCurve->clearInternal();
break;
case CurveCreator_Operation::SetClosed:
- theCurve->setClosed((pInt[0] != 0), pInt[1]);
+ theCurve->setClosedInternal(pInt[1], (pInt[0] != 0));
break;
case CurveCreator_Operation::MoveSection:
- theCurve->moveSection(pInt[0], pInt[1]);
+ theCurve->moveSectionInternal(pInt[0], pInt[1]);
break;
case CurveCreator_Operation::Join:
- if (myPData == NULL) {
- theCurve->join();
- } else {
- theCurve->join(pInt[0], pInt[1]);
+ if (myPData != NULL)
+ {
+ std::list<int> aListOfSections;
+ int nbSections = pInt[0];
+ for (int i = 1; i < nbSections+1; i++) {
+ aListOfSections.push_back(pInt[i]);
+ }
+ theCurve->joinInternal(aListOfSections);
}
break;
case CurveCreator_Operation::AddSection:
{
- const CurveCreator::Type aType = (CurveCreator::Type) pInt[0];
+ const CurveCreator::SectionType aType = (CurveCreator::SectionType) pInt[0];
std::string aName = std::string((char*)&pInt[2]);
char* aPtr = ((char*)&pInt[2]);
aPtr += (aName.length()) + 1;
getCoords((int*)aPtr, aCoords);
- theCurve->addSection(aName, aType, (pInt[1] != 0), aCoords);
+ theCurve->addSectionInternal(aName, aType, (pInt[1] != 0), aCoords);
}
break;
case CurveCreator_Operation::RemoveSection:
- theCurve->removeSection(pInt[0]);
+ theCurve->removeSectionInternal(pInt[0]);
break;
case CurveCreator_Operation::RenameSection:
{
std::string aName = std::string((char*)&pInt[1]);
- theCurve->setName(aName, pInt[0]);
+ theCurve->setSectionNameInternal(pInt[0], aName);
}
break;
default:
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#define _CurveCreator_Operation_HeaderFile
#include "CurveCreator.hxx"
+#include "CurveCreator_ICurve.hxx"
+#include "CurveCreator_PosPoint.hxx"
#include <string>
+#include <vector>
class CurveCreator_Curve;
* It is applicable to the following operations:
* <UL>
* <LI>Clear</LI>
- * <LI>Join (without arguments)</LI>
* </UL>
* @return true in case of success; false otherwise.
*/
const int theIntParam2);
/**
- * This method initializes the object with an operation with three integer
+ * This method initializes the object with an operation with two integer
* parameters. It is applicable to the following operations:
* <UL>
+ * <LI>Join (with a list of int arguments)</LI>
+ * </UL>
+ * @return true in case of success; false otherwise.
+ */
+ bool init(const Type theType, const std::list<int> theParamList);
+
+ /**
+ * This method initializes the object with an operation with
+ * list of pairs of integer parameters.
+ * It is applicable to the following operations:
+ * <UL>
* <LI>RemovePoints</LI>
* </UL>
* @return true in case of success; false otherwise.
*/
- bool init(const Type theType, const int theIntParam1,
- const int theIntParam2, const int theIntParam3);
+ bool init(const Type theType,
+ const CurveCreator_ICurve::SectionToPointList &theParamList1);
/**
* This method initializes the object with an operation with one
const int theIntParam);
/**
- * This method initializes the object with an operation with one
- * CurveCreator::Coordinates parameter and two integer parameters.
+ * This method initializes the object with an operation with
+ * list of pairs of integer parameters and CurveCreator::Coordinates parameters.
* It is applicable to the following operations:
* <UL>
- * <LI>AddSection</LI>
* <LI>InsertPoints</LI>
- * <LI>SetCoordinates</LI>
* </UL>
* @return true in case of success; false otherwise.
*/
- bool init(const Type theType, const CurveCreator::Coordinates &theCoords,
- const int theIntParam1, const int theIntParam2);
+ bool init(const Type theType,
+ const CurveCreator_ICurve::SectionToPointCoordsList &theParamList1);
/**
* This method initializes the object with an operation with one
--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+// File: CurveCreator_PosPoint.hxx
+// Author: Alexander KOVALEV
+
+#ifndef _CurveCreator_PosPoint_HeaderFile
+#define _CurveCreator_PosPoint_HeaderFile
+
+#include "CurveCreator.hxx"
+
+struct CurveCreator_PosPoint
+{
+public:
+ CurveCreator_PosPoint( int theID, CurveCreator::Coordinates theCoords )
+ : myID( theID ), myCoords( theCoords )
+ { };
+
+ ////! Overloaded operator to use sorting.
+ //bool operator < (CurveCreator_PosPoint const & thePosPoint) const
+ //{
+ // return myID < thePosPoint.myID;
+ //}
+
+ int myID; // point ID
+ CurveCreator::Coordinates myCoords; // point coordinates
+
+};
+
+#endif
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
std::string myName; //!< section name
CurveCreator::Coordinates myPoints; //!< points coordinates
- CurveCreator::Type myType; //!< type of the section
+ CurveCreator::SectionType myType; //!< type of the section
bool myIsClosed; //!< closed or not
};
--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "CurveCreator_TableView.h"
+#include "CurveCreator_UtilsICurve.hxx"
+
+#include <gp_Pnt.hxx>
+
+#include <QTableWidget>
+#include <QTableWidgetItem>
+
+#include <QtxDoubleSpinBox.h>
+
+const double DBL_MINIMUM = -10000000.;
+const double DBL_MAXIMUM = 10000000.;
+
+const int SECTION_NAME_COLUMN_WIDTH = 75;
+const int POINT_INDEX_COLUMN_WIDTH = 40;
+
+const double LOCAL_SELECTION_TOLERANCE = 0.0001;
+
+CurveCreator_TableItemDelegate::CurveCreator_TableItemDelegate( QObject* theParent )
+: QItemDelegate( theParent )
+{
+}
+
+/**
+ * Creates an editor for the cell
+ */
+QWidget* CurveCreator_TableItemDelegate::createEditor( QWidget* theParent,
+ const QStyleOptionViewItem& theOption,
+ const QModelIndex& theIndex ) const
+{
+ QWidget* anEditor = 0;
+
+ int aColumnId = theIndex.column();
+ if ( aColumnId == 2 || aColumnId == 3 ) {
+ QDoubleSpinBox* aSpin = new QtxDoubleSpinBox( theParent );
+ aSpin->setDecimals( 2 );
+ aSpin->setRange( DBL_MINIMUM, DBL_MAXIMUM );
+ anEditor = aSpin;
+ }
+ else
+ anEditor = QItemDelegate::createEditor( theParent, theOption, theIndex );
+
+ return anEditor;
+}
+
+void CurveCreator_TableItemDelegate::setEditorData( QWidget* theEditor,
+ const QModelIndex& theIndex ) const
+{
+ int aColumnId = theIndex.column();
+ if ( aColumnId == 2 || aColumnId == 3 ) {
+ QDoubleSpinBox* aDblSpin = dynamic_cast<QDoubleSpinBox*>( theEditor );
+ if ( aDblSpin ) {
+ double aValue = theIndex.model()->data( theIndex, Qt::EditRole ).toDouble();
+ aDblSpin->setValue( aValue );
+ }
+ }
+ else
+ QItemDelegate::setEditorData( theEditor, theIndex );
+}
+
+void CurveCreator_TableItemDelegate::setModelData( QWidget* theEditor,
+ QAbstractItemModel* theModel,
+ const QModelIndex& theIndex ) const
+{
+ int aColumnId = theIndex.column();
+ if ( aColumnId == 2 || aColumnId == 3 ) {
+ QDoubleSpinBox* aDblSpin = dynamic_cast<QDoubleSpinBox*>( theEditor );
+ if ( aDblSpin ) {
+ double aValue = aDblSpin->value();
+ theModel->setData( theIndex, aValue, Qt::UserRole);
+ }
+ }
+ else
+ QItemDelegate::setModelData( theEditor, theModel, theIndex );
+}
+
+CurveCreator_TableView::CurveCreator_TableView( CurveCreator_ICurve* theCurve,
+ QWidget* theParent,
+ const QStringList& theCoordTitles )
+: QTableWidget( theParent ), myCurve( theCurve )
+{
+ setItemDelegate( new CurveCreator_TableItemDelegate( this ) );
+ setVisible( false );
+ setColumnCount( 4 );
+ setColumnWidth( 0, SECTION_NAME_COLUMN_WIDTH );
+ setColumnWidth( 1, POINT_INDEX_COLUMN_WIDTH );
+ QStringList aLabels;
+ QString aCoord1 = theCoordTitles.size() > 0 ? theCoordTitles[0] : tr( "X" ); // tr( "X_POSITION_LBL" )
+ QString aCoord2 = theCoordTitles.size() > 1 ? theCoordTitles[1] : tr( "Y" ); // tr( "Y_POSITION_LBL" )
+ //aLabels << tr( "SECTION_LABEL" ) << tr( "IDENTIFIER_LABEL" ) << aCoord1 << aCoord2;
+ aLabels << tr( "Section" ) << "Index" << aCoord1 << aCoord2;
+ setHorizontalHeaderLabels( aLabels );
+}
+
+void CurveCreator_TableView::setCurve( CurveCreator_ICurve* theCurve )
+{
+ myCurve = theCurve;
+}
+
+void CurveCreator_TableView::setLocalPointsToTable(
+ const CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ setRowCount( thePoints.size() );
+
+ int aRowId = 0;
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = thePoints.begin(),
+ aLast = thePoints.end();
+ for ( ; anIt != aLast; anIt++ ) {
+ CurveCreator_ICurve::SectionToPoint aSPoint = *anIt;
+ int anISection = aSPoint.first;
+ int anIPoint = aSPoint.second;
+
+ QTableWidgetItem* anItem;
+ anItem = new QTableWidgetItem( myCurve->getSectionName( anISection ).c_str() );
+ anItem->setFlags( anItem->flags() & ~Qt::ItemIsEnabled );
+ anItem->setData( Qt::UserRole, anISection );
+ setItem( aRowId, 0, anItem );
+
+ anItem = new QTableWidgetItem( QString::number( anIPoint + 1 ) );
+ anItem->setFlags( anItem->flags() & ~Qt::ItemIsEnabled );
+ anItem->setData( Qt::UserRole, anIPoint );
+ setItem( aRowId, 1, anItem );
+
+ gp_Pnt aPoint;
+ CurveCreator_UtilsICurve::getPoint( myCurve, anISection, anIPoint, aPoint );
+
+ anItem = item( aRowId, 2 );
+ if ( !anItem ) {
+ anItem = new QTableWidgetItem();
+ setItem( aRowId, 2, anItem );
+ }
+ anItem->setData( Qt::UserRole, aPoint.X() );
+ anItem->setData( Qt::DisplayRole, QString::number( aPoint.X(), 'f', 2 ) );
+
+ anItem = item( aRowId, 3 );
+ if ( !anItem ) {
+ anItem = new QTableWidgetItem();
+ setItem( aRowId, 3, anItem );
+ }
+ anItem->setData( Qt::UserRole, aPoint.Y() );
+ anItem->setData( Qt::DisplayRole, QString::number( aPoint.Y(), 'f', 2 ) );
+
+ aRowId++;
+ }
+}
+
+int CurveCreator_TableView::getSectionId( const int theRowId ) const
+{
+ return item( theRowId, 0 )->data( Qt::UserRole ).toInt();
+}
+
+/**
+ * Returns a point index from the table
+ * \param theRowId a table row
+ */
+int CurveCreator_TableView::getPointId( const int theRowId ) const
+{
+ return item( theRowId, 1 )->data( Qt::UserRole ).toInt();
+}
--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef CURVECREATOR_TABLEVIEW_H
+#define CURVECREATOR_TABLEVIEW_H
+
+#include "CurveCreator_ICurve.hxx"
+
+#include <QItemDelegate>
+#include <QTableWidget>
+
+class CurveCreator_TableItemDelegate : public QItemDelegate
+{
+public:
+ CurveCreator_TableItemDelegate( QObject* theParent );
+ ~CurveCreator_TableItemDelegate() {}
+
+ virtual QWidget* createEditor( QWidget* theParent,
+ const QStyleOptionViewItem& theOption,
+ const QModelIndex& theIndex ) const;
+ virtual void setEditorData( QWidget* theEditor, const QModelIndex& theIndex ) const;
+ virtual void setModelData( QWidget* theEditor, QAbstractItemModel* theModel,
+ const QModelIndex& theIndex ) const;
+};
+
+class CurveCreator_TableView : public QTableWidget
+{
+public:
+ CurveCreator_TableView( CurveCreator_ICurve* theCurve, QWidget* theParent = 0,
+ const QStringList& theCoordTitles = QStringList() );
+ ~CurveCreator_TableView() {};
+
+ void setCurve( CurveCreator_ICurve* theCurve );
+
+ void setLocalPointsToTable( const CurveCreator_ICurve::SectionToPointList& thePoints );
+
+ /**
+ * Returns a section index from the table
+ * \param theRowId a table row
+ */
+ int getSectionId( const int theRowId ) const;
+ /**
+ * Returns a point index from the table
+ * \param theRowId a table row
+ */
+ int getPointId( const int theRowId ) const;
+
+private:
+ CurveCreator_ICurve* myCurve;
+
+};
+
+#endif // CURVECREATOR_TABLEVIEW_H
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
//
#include "CurveCreator_TreeView.h"
-#include "CurveCreator_Curve.hxx"
+#include "CurveCreator_ICurve.hxx"
#include <SUIT_Session.h>
#include <SUIT_ResourceMgr.h>
#define ID_SECTION -1
-CurveCreator_TreeViewModel::CurveCreator_TreeViewModel( CurveCreator_Curve* theCurve, QObject* parent ) :
+CurveCreator_TreeViewModel::CurveCreator_TreeViewModel( CurveCreator_ICurve* theCurve, QObject* parent ) :
QAbstractItemModel(parent), myCurve(theCurve)
{
SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
}
else if( role == Qt::DecorationRole ){
if( aColumn == 0 ){
- CurveCreator::Type aSectionType = myCurve->getType(aRow);
+ CurveCreator::SectionType aSectionType = myCurve->getSectionType(aRow);
if( aSectionType == CurveCreator::Polyline ){
if( myCurve->isClosed(aRow) ){
return myCachedIcons[ICON_CLOSED_POLYLINE];
int aRowCnt = 0;
if( myCurve != NULL ){
if( !parent.isValid() ){
- //Points level
+ //Section level
aRowCnt = myCurve->getNbSections();
}
else{
- //Section level
if( parent.internalId() == ID_SECTION ){
+ //Points level
aRowCnt = myCurve->getNbPoints(parent.row());
}
}
return theIndx.row();
}
-void CurveCreator_TreeViewModel::setCurve( CurveCreator_Curve* theCurve )
+void CurveCreator_TreeViewModel::setCurve( CurveCreator_ICurve* theCurve )
{
myCurve = theCurve;
reset();
}
/*****************************************************************************************/
-CurveCreator_TreeView::CurveCreator_TreeView( CurveCreator_Curve* theCurve, QWidget *parent) :
+CurveCreator_TreeView::CurveCreator_TreeView( CurveCreator_ICurve* theCurve, QWidget *parent) :
QTreeView(parent)
{
header()->hide();
aSect << aModel->getSection( anIndxs[i] );
}
}
- qSort(aSect.begin(), aSect.end());
return aSect;
}
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
- rowsInserted(QModelIndex(), theSection, theSection );
+ int nbRows = aModel->rowCount();
+ int aSection = (theSection == -1 ? (nbRows==0 ? 0 : nbRows-1) : theSection);
+ rowsInserted(QModelIndex(), aSection, aSection );
+ QModelIndex aSectIndx = aModel->sectionIndex(aSection);
+ selectionModel()->select(aSectIndx, QItemSelectionModel::Rows | QItemSelectionModel::ClearAndSelect);
}
}
}
}
-void CurveCreator_TreeView::pointsSwapped( int theSection, int thePointNum, int theOffset )
-{
- CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
- if( aModel ){
- QModelIndex aFirstIndex = aModel->pointIndex( theSection, thePointNum );
- QModelIndex aSecondIndex = aModel->pointIndex( theSection, thePointNum + theOffset );
- swapIndexes( aFirstIndex, aSecondIndex );
- }
-}
-
void CurveCreator_TreeView::setSelectedSections( const QList<int>& theList )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
selectionModel()->clearSelection();
for( int i = 0 ; i < theList.size() ; i++ ){
QModelIndex aSectIndx = aModel->sectionIndex(theList[i]);
- selectionModel()->select(aSectIndx, QItemSelectionModel::Select );
- }
- }
-}
-
-void CurveCreator_TreeView::setSelectedPoints( const QList< QPair<int, int> >& thePointsList )
-{
- CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
- if( aModel ){
- selectionModel()->clearSelection();
- for( int i = 0 ; i < thePointsList.size() ; i++ ){
- QModelIndex aSectIndx = aModel->pointIndex( thePointsList[i].first, thePointsList[i].second );
- selectionModel()->select(aSectIndx, QItemSelectionModel::Select );
+ selectionModel()->select(aSectIndx, QItemSelectionModel::Select | QItemSelectionModel::Rows );
}
}
}
return s1.second < s2.second;
}
-QList< QPair< int, int > > CurveCreator_TreeView::getSelectedPoints() const
-{
- QList< QPair< int, int > > aPoints;
- CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
- if( !aModel )
- return aPoints;
- QModelIndexList anIndxs = selectionModel()->selectedIndexes();
- for( int i = 0 ; i < anIndxs.size() ; i++ ){
- if( !aModel->isSection( anIndxs[i] ) ){
- int aSect = aModel->getSection(anIndxs[i]);
- int aPointNum = aModel->getPoint(anIndxs[i]);
- QPair< int, int > aPoint = QPair<int,int>( aSect, aPointNum );
- aPoints.push_back( aPoint );
- }
- }
- qSort( aPoints.begin(), aPoints.end(), pointLessThan );
- return aPoints;
-}
-
CurveCreator_TreeView::SelectionType CurveCreator_TreeView::getSelectionType() const
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
int aSect = aModel->getSection(theIndx);
if( aModel->isSection(theIndx) ){
emit sectionEntered( aSect );
- return;
}
- int aPointNum = aModel->getPoint( theIndx );
- emit pointEntered( aSect, aPointNum );
}
-void CurveCreator_TreeView::setCurve( CurveCreator_Curve* theCurve )
+void CurveCreator_TreeView::setCurve( CurveCreator_ICurve* theCurve )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel )
aModel->setCurve(theCurve);
reset();
}
+
+void CurveCreator_TreeView::reset()
+{
+ QList<int> aSelSections = getSelectedSections();
+ QTreeView::reset();
+ setSelectedSections(aSelSections);
+}
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include <QTreeView>
#include <QAbstractItemModel>
-class CurveCreator_Curve;
+class CurveCreator_ICurve;
class CurveCreator_TreeViewModel : public QAbstractItemModel
{
public:
- CurveCreator_TreeViewModel( CurveCreator_Curve* theCurve, QObject* parent );
+ CurveCreator_TreeViewModel( CurveCreator_ICurve* theCurve, QObject* parent );
virtual int columnCount(const QModelIndex & parent = QModelIndex()) const;
virtual int rowCount(const QModelIndex & parent = QModelIndex()) const;
virtual QVariant data(const QModelIndex & index, int role = Qt::DisplayRole) const;
int getSection( const QModelIndex& theIndx ) const;
int getPoint( const QModelIndex& theIndx ) const;
- void setCurve( CurveCreator_Curve* theCurve );
+ void setCurve( CurveCreator_ICurve* theCurve );
private:
enum IconType{ ICON_POLYLINE, ICON_SPLINE, ICON_CLOSED_SPLINE, ICON_CLOSED_POLYLINE, ICON_POINT };
private:
- CurveCreator_Curve* myCurve;
+ CurveCreator_ICurve* myCurve;
QMap<IconType, QPixmap> myCachedIcons;
};
public:
enum SelectionType{ ST_NOSEL, ST_POINTS, ST_POINTS_ONE_SECTION, ST_SECTIONS, ST_MIXED };
public:
- explicit CurveCreator_TreeView( CurveCreator_Curve* theCurve, QWidget *parent = 0);
+ explicit CurveCreator_TreeView( CurveCreator_ICurve* theCurve, QWidget *parent = 0);
SelectionType getSelectionType() const;
QList<int> getSelectedSections() const;
- QList< QPair< int, int > > getSelectedPoints() const;
void pointsAdded( int theSection, int thePoint, int thePointsCnt=1 );
void pointDataChanged( int theSection, int thePoint );
void pointsRemoved(int theSection, int thePoint, int thePointsCnt=1 );
- void pointsSwapped( int theSection, int thePointNum, int theOffset );
void sectionAdded( int theSection );
void sectionChanged(int theSection , int aSectCnt = 1);
void sectionsSwapped( int theSection, int theOffset );
void setSelectedSections( const QList<int>& theList );
- void setSelectedPoints( const QList< QPair<int, int> >& thePointsList );
- void setCurve( CurveCreator_Curve* theCurve );
+ void setCurve( CurveCreator_ICurve* theCurve );
+
+ void reset();
signals:
void selectionChanged();
void sectionEntered(int);
- void pointEntered(int,int);
-public slots:
+
protected slots:
void onActivated( QModelIndex theIndx );
protected:
--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "CurveCreator_Utils.hxx"
+#include "CurveCreator.hxx"
+#include "CurveCreator_UtilsICurve.hxx"
+
+#include <GEOMUtils.hxx>
+
+#include <gp_Pln.hxx>
+
+#include <TopoDS.hxx>
+#include <TopoDS_Vertex.hxx>
+#include <TopoDS_Wire.hxx>
+#include <TopoDS_Edge.hxx>
+#include <TopoDS_Compound.hxx>
+
+#include <AIS_ListOfInteractive.hxx>
+#include <AIS_ListIteratorOfListOfInteractive.hxx>
+#include <AIS_Shape.hxx>
+#include <AIS_Line.hxx>
+#include <AIS_Trihedron.hxx>
+#include <AIS_LocalContext.hxx>
+
+#include <Geom_Point.hxx>
+#include <Geom_BSplineCurve.hxx>
+#include <Geom_Line.hxx>
+
+#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
+#include <GeomAPI_ProjectPointOnCurve.hxx>
+#include <SelectMgr_EntityOwner.hxx>
+#include <SelectMgr_Selection.hxx>
+#include <Select3D_SensitivePoint.hxx>
+
+#include <BRep_Tool.hxx>
+#include <BRep_Builder.hxx>
+#include <BRepBuilderAPI_MakeVertex.hxx>
+#include <BRepBuilderAPI_MakeEdge.hxx>
+#include <BRepBuilderAPI_MakeWire.hxx>
+
+#include <TColgp_HArray1OfPnt.hxx>
+#include <TColStd_HArray1OfBoolean.hxx>
+#include <TColgp_Array1OfVec.hxx>
+#include <GeomAPI_Interpolate.hxx>
+
+#include <ProjLib.hxx>
+#include <ElSLib.hxx>
+
+#include <math.h>
+
+#include "CurveCreator_ICurve.hxx"
+
+const double LOCAL_SELECTION_TOLERANCE = 0.0001;
+const int SCENE_PIXEL_PROJECTION_TOLERANCE = 10;
+const int SCENE_PIXEL_POINT_TOLERANCE = 5;
+
+//=======================================================================
+// function : ConvertClickToPoint()
+// purpose : Returns the point clicked in 3D view
+//=======================================================================
+void CurveCreator_Utils::ConvertPointToClick( const gp_Pnt& thePoint,
+ Handle(V3d_View) theView,
+ int& x, int& y )
+{
+ theView->Convert(thePoint.X(), thePoint.Y(), thePoint.Z(), x, y );
+}
+
+
+//=======================================================================
+// function : ConvertClickToPoint()
+// purpose : Returns the point clicked in 3D view
+//=======================================================================
+gp_Pnt CurveCreator_Utils::ConvertClickToPoint( int x, int y, Handle(V3d_View) aView )
+{
+ // the 3D point, that is a projection of the pixels to the XYZ view plane
+ //return GEOMUtils::ConvertClickToPoint( x, y, aView );
+
+ // we need the projection to the XOY plane
+ // 1. find a point in the plane of the eye and the normal to the plane
+ Standard_Real X, Y, Z;
+ Quantity_Parameter Vx, Vy, Vz;
+ aView->ConvertWithProj( x, y, X, Y, Z, Vx, Vy, Vz );
+
+ // 2. build a ray from the point by the normal to the XOY plane and intersect it
+ // The ray equation is the following : p(x,y,z) = p0(x,y,z) + t*V(x,y,z)
+ // X,Y,Z - defines p0(x,y,z), Vx,Vy,Vz - defines V(x,y,z)
+ // p(x,y,z) - is a searched point, t - should to be calculated by the condition of XOY plane
+ // The system of equations is the following:
+ // p(x) = p0(x)+t*V(x)
+ // p(y) = p0(y)+t*V(y)
+ // p(z) = p0(z)+t*V(z)
+ // p(z) = 0
+
+ Standard_Real aXp, aYp, aZp;
+ //It is not possible to use Precision::Confusion(), because it is e-0.8, but V is sometimes e-6
+ Standard_Real aPrec = LOCAL_SELECTION_TOLERANCE;
+ if ( fabs( Vz ) > aPrec ) {
+ Standard_Real aT = -Z/Vz;
+ aXp = X + aT*Vx;
+ aYp = Y + aT*Vy;
+ aZp = Z + aT*Vz;
+ }
+ else { // Vz = 0 - the eyed plane is orthogonal to Z plane - XOZ, or YOZ
+ aXp = aYp = aZp = 0;
+ if ( fabs( Vy ) < aPrec ) // Vy = 0 - the YOZ plane
+ aYp = Y;
+ else if ( fabs( Vx ) < aPrec ) // Vx = 0 - the XOZ plane
+ aXp = X;
+ }
+ /*std::cout << "ConvertClickToPoint: " << std::endl
+ << "XYZ1 = (" << X << ", " << Y << ", " << Z << "); " << std::endl
+ << "Vxyz = (" << Vx << ", " << Vy << ", " << Vz << "); " << std::endl
+ << "Resp = (" << aXp << ", " << aYp << ", " << aZp << "); " << std::endl;*/
+
+ gp_Pnt ResultPoint( aXp, aYp, aZp );
+ return ResultPoint;
+}
+
+void CurveCreator_Utils::constructShape( const CurveCreator_ICurve* theCurve,
+ TopoDS_Shape& theShape )
+{
+ BRep_Builder aBuilder;
+ TopoDS_Compound aComp;
+ aBuilder.MakeCompound( aComp );
+ for( int iSection = 0 ; iSection < theCurve->getNbSections() ; iSection++ )
+ {
+ int theISection = iSection;
+
+ CurveCreator::SectionType aSectType = theCurve->getSectionType( theISection );
+ int aPointSize = theCurve->getNbPoints( theISection );
+ if ( aPointSize == 0 )
+ continue;
+
+ bool aSectIsClosed = theCurve->isClosed( theISection );
+ bool isPolyline = aSectType == CurveCreator::Polyline;
+
+ int iPoint = 0;
+ gp_Pnt aPrevPoint, aPoint;
+ // filters the curve points to skip equal points
+ std::vector<gp_Pnt> aPoints;
+ CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+ aPoints.push_back( aPoint );
+ aPrevPoint = aPoint;
+ iPoint++;
+ for( ; iPoint < aPointSize; iPoint++ ) {
+ CurveCreator_UtilsICurve::getPoint( theCurve, theISection, iPoint, aPoint );
+ if ( !isEqualPoints( aPrevPoint, aPoint ) )
+ aPoints.push_back( aPoint );
+ aPrevPoint = aPoint;
+ }
+ int aNbPoints = aPoints.size();
+
+ if ( aNbPoints == 1 ) {
+ aPoint = aPoints.front();
+ TopoDS_Vertex aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
+ aBuilder.Add( aComp, aVertex );
+ }
+ else if ( aNbPoints > 1 ) {
+ Handle(TColgp_HArray1OfPnt) aHCurvePoints = new TColgp_HArray1OfPnt(1, aNbPoints);
+ TColgp_Array1OfVec aTangents(1, aNbPoints);
+ Handle(TColStd_HArray1OfBoolean) aTangentFlags = new TColStd_HArray1OfBoolean(1, aNbPoints);
+ gp_Vec aNullVec(0, 0, 0);
+
+ TopoDS_Edge aPointEdge;
+ TopoDS_Vertex aVertex;
+
+ std::vector<gp_Pnt>::const_iterator aPointIt = aPoints.begin(), aPointLast = aPoints.end();
+ aPoint = *aPointIt;
+
+ int aHIndex = 1;
+ aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
+ aBuilder.Add( aComp, aVertex );
+ if ( !isPolyline ) {
+ aHCurvePoints->SetValue( aHIndex, aPoint );
+ aTangents.SetValue( aHIndex, aNullVec );
+ aTangentFlags->SetValue( aHIndex, Standard_False );
+ aHIndex++;
+ }
+
+ aPrevPoint = aPoint;
+ aPointIt++;
+ for( ; aPointIt != aPointLast; aPointIt++ ) {
+ aPoint = *aPointIt;
+ aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
+ aBuilder.Add( aComp, aVertex );
+ if ( isPolyline ) {
+ TopoDS_Edge aPointEdge = BRepBuilderAPI_MakeEdge( aPrevPoint, aPoint ).Edge();
+ aBuilder.Add( aComp, aPointEdge );
+ }
+ else {
+ aHCurvePoints->SetValue( aHIndex, aPoint );
+ aTangents.SetValue( aHIndex, aNullVec );
+ aTangentFlags->SetValue( aHIndex, Standard_False );
+ aHIndex++;
+ }
+ aPrevPoint = aPoint;
+ }
+ if( aSectIsClosed && ( aNbPoints > 2 ) ) {
+ aPoint = aPoints.front();
+ aVertex = BRepBuilderAPI_MakeVertex( aPoint ).Vertex();
+ aBuilder.Add( aComp, aVertex );
+ if ( isPolyline ) {
+ aPointEdge = BRepBuilderAPI_MakeEdge( aPrevPoint, aPoint ).Edge();
+ aBuilder.Add( aComp, aPointEdge );
+ }
+ }
+ if( !isPolyline ) {
+ // compute BSpline
+ Handle(Geom_BSplineCurve) aBSplineCurve;
+ GeomAPI_Interpolate aGBC(aHCurvePoints, aSectIsClosed, gp::Resolution());
+ // correct the spline degree to be as 3 for non-periodic spline if number of points
+ // less than 3. It is need to have a knot in each spline point. This knots are used
+ // to found a neighbour points when a new point is inserted between two existing.
+ if (!aSectIsClosed ) {
+ if (aHCurvePoints->Length() == 3)
+ aGBC.Load(aTangents, aTangentFlags);
+ }
+
+ aGBC.Perform();
+ if ( aGBC.IsDone() )
+ aBSplineCurve = aGBC.Curve();
+ TopoDS_Edge anEdge = BRepBuilderAPI_MakeEdge( aBSplineCurve ).Edge();
+ TopoDS_Wire aWire = BRepBuilderAPI_MakeWire( anEdge ).Wire();
+ aBuilder.Add( aComp, aWire );
+ }
+ }
+ }
+ theShape = aComp;
+}
+
+class CompareSectionToPoint
+{
+public:
+ CompareSectionToPoint( const int theISection = -1, const int theIPoint = -1 )
+ : mySectionId( theISection ), myPointId( theIPoint ) {};
+ ~CompareSectionToPoint() {}
+
+ bool operator < ( const CompareSectionToPoint& theOther ) const
+ {
+ bool isLess = mySectionId < theOther.mySectionId;
+ if ( !isLess && mySectionId == theOther.mySectionId )
+ isLess = myPointId < theOther.myPointId;
+ return isLess;
+ }
+
+private:
+ int mySectionId;
+ int myPointId;
+};
+
+
+void CurveCreator_Utils::getSelectedPoints( Handle(AIS_InteractiveContext) theContext,
+ const CurveCreator_ICurve* theCurve,
+ CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ thePoints.clear();
+
+ std::list<float> aSelectedPoints;
+ gp_Pnt aPnt;
+ std::map<CompareSectionToPoint, int> aPointsMap;
+
+ CurveCreator_ICurve::SectionToPointList aPoints;
+ for ( theContext->InitSelected(); theContext->MoreSelected(); theContext->NextSelected() ) {
+ TopoDS_Vertex aVertex;
+ TopoDS_Shape aShape = theContext->SelectedShape();
+ if ( !aShape.IsNull() && aShape.ShapeType() == TopAbs_VERTEX )
+ aVertex = TopoDS::Vertex( theContext->SelectedShape() );
+
+ if ( aVertex.IsNull() )
+ continue;
+ aPnt = BRep_Tool::Pnt( aVertex );
+
+ CurveCreator_UtilsICurve::findSectionsToPoints( theCurve, aPnt.X(), aPnt.Y(), aPoints );
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = aPoints.begin(),
+ aLast = aPoints.end();
+ CompareSectionToPoint aPoint;
+ for ( ; anIt != aLast; anIt++ ) {
+ aPoint = CompareSectionToPoint( (*anIt).first, (*anIt).second );
+ if ( aPointsMap.find( aPoint ) != aPointsMap.end() )
+ continue;
+ aPointsMap[aPoint] = 0;
+
+ thePoints.push_back( *anIt );
+ }
+ }
+}
+
+void CurveCreator_Utils::setSelectedPoints( Handle(AIS_InteractiveContext) theContext,
+ const CurveCreator_ICurve* theCurve,
+ const CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ if ( !theCurve )
+ return;
+
+ Handle(AIS_InteractiveObject) anAIS = theCurve->getAISObject();
+ if ( anAIS.IsNull() )
+ return;
+ Handle(AIS_Shape) anAISShape = Handle(AIS_Shape)::DownCast( anAIS );
+ if ( anAISShape.IsNull() )
+ return;
+
+ //ASL: we convert list of point indices to list of points coordinates
+ int aSize = thePoints.size();
+ std::vector<gp_Pnt> aPntsToSelect( aSize );
+
+ CurveCreator_ICurve::SectionToPointList::const_iterator
+ aPIt = thePoints.begin(), aPLast = thePoints.end();
+ CurveCreator_ICurve::SectionToPoint aSToPoint;
+ for( int i=0; aPIt != aPLast; aPIt++, i++ )
+ {
+ gp_Pnt aPntToSelect;
+ CurveCreator_UtilsICurve::getPoint( theCurve, aPIt->first, aPIt->second, aPntToSelect );
+ aPntsToSelect[i] = aPntToSelect;
+ }
+
+ theContext->ClearSelected( Standard_False );
+ //ASL: we switch off automatic highlight to improve performance of selection
+ theContext->SetAutomaticHilight( Standard_False );
+
+ Handle_SelectMgr_Selection aSelection = anAISShape->Selection( AIS_Shape::SelectionMode( TopAbs_VERTEX ) );
+ for( aSelection->Init(); aSelection->More(); aSelection->Next() )
+ {
+ Handle_SelectBasics_SensitiveEntity aSenEntity = aSelection->Sensitive();
+ Handle_Select3D_SensitivePoint aSenPnt = Handle_Select3D_SensitivePoint::DownCast( aSenEntity );
+
+ gp_Pnt anOwnerPnt = aSenPnt->Point();
+ Handle_SelectMgr_EntityOwner anOwner = Handle_SelectMgr_EntityOwner::DownCast( aSenPnt->OwnerId() );
+
+
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = thePoints.begin(),
+ aLast = thePoints.end();
+ bool isFound = false;
+ for( int i=0; i<aSize; i++ )
+ {
+ bool isIntersect = fabs( aPntsToSelect[i].X() - anOwnerPnt.X() ) < LOCAL_SELECTION_TOLERANCE &&
+ fabs( aPntsToSelect[i].Y() - anOwnerPnt.Y() ) < LOCAL_SELECTION_TOLERANCE;
+ if( isIntersect )
+ {
+ theContext->AddOrRemoveSelected( anOwner, Standard_False );
+ break;
+ }
+ }
+ }
+
+ //ASL: we switch on again automatic highlight (otherwise selection will not be shown)
+ // and call HilightPicked to draw selected owners
+ theContext->SetAutomaticHilight( Standard_True );
+ theContext->LocalContext()->HilightPicked( Standard_True );
+}
+
+//=======================================================================
+// function : setLocalPointContext
+// purpose : Open/close the viewer local context
+//=======================================================================
+void CurveCreator_Utils::setLocalPointContext( const CurveCreator_ICurve* theCurve,
+ Handle(AIS_InteractiveContext) theContext,
+ const bool theOpen )
+{
+ if ( !theContext )
+ return;
+
+ if ( theOpen ) {
+ // Open local context if there is no one
+ if ( !theContext->HasOpenedContext() ) {
+ theContext->ClearCurrents( false );
+ theContext->OpenLocalContext( false/*use displayed objects*/, true/*allow shape decomposition*/ );
+ }
+ // load the curve AIS object to the local context with the point selection
+ Handle(AIS_InteractiveObject) anAIS = theCurve->getAISObject();
+ if ( !anAIS.IsNull() )
+ {
+ if ( anAIS->IsKind( STANDARD_TYPE( AIS_Shape ) ) )
+ {
+ theContext->Load( anAIS, -1/*selection mode*/, true/*allow decomposition*/ );
+ theContext->Activate( anAIS, AIS_Shape::SelectionMode( (TopAbs_ShapeEnum)TopAbs_VERTEX ) );
+ }
+ }
+ }
+ else {
+ if ( theContext->HasOpenedContext() )
+ theContext->CloseAllContexts();
+ }
+}
+
+bool CurveCreator_Utils::pointOnObject( Handle(V3d_View) theView,
+ Handle(AIS_InteractiveObject) theObject,
+ const int theX, const int theY,
+ gp_Pnt& thePoint,
+ gp_Pnt& thePoint1, gp_Pnt& thePoint2 )
+{
+ bool isFullFound = false;
+
+ if ( theObject.IsNull() || theView.IsNull() )
+ return isFullFound;
+ Handle(AIS_Shape) aShape = Handle(AIS_Shape)::DownCast( theObject );
+ if ( aShape.IsNull() )
+ return isFullFound;
+ const TopoDS_Compound& aCompound = TopoDS::Compound( aShape->Shape() );
+ if ( aCompound.IsNull() )
+ return isFullFound;
+
+ gp_Pnt aCurPoint, aCurPoint1, aCurPoint2;
+ gp_Pnt aFoundPoint, aFoundPnt1, aFoundPnt2;
+ Standard_Real aParameter;
+ bool isFound = false;
+ int aDelta, aMinDelta = 2*SCENE_PIXEL_PROJECTION_TOLERANCE*SCENE_PIXEL_PROJECTION_TOLERANCE;
+ TopExp_Explorer anExp( aCompound, TopAbs_EDGE );
+ for ( ; anExp.More(); anExp.Next())
+ {
+ const TopoDS_Edge& anEdge = TopoDS::Edge(anExp.Current());
+ if ( anEdge.IsNull() )
+ continue;
+ Standard_Real aFirst, aLast;
+ Handle(Geom_Curve) aCurve = BRep_Tool::Curve( anEdge, aFirst, aLast );
+ if ( aCurve->IsKind( STANDARD_TYPE(Geom_BSplineCurve) ) ) {
+ Handle(Geom_BSplineCurve) aBSplineCurve =
+ Handle(Geom_BSplineCurve)::DownCast( aCurve );
+ if ( !aBSplineCurve.IsNull() ) {
+ isFound = hasProjectPointOnCurve( theView, theX, theY, aBSplineCurve,
+ aParameter, aDelta );
+ if ( isFound ) {
+ aCurPoint = aBSplineCurve->Value( aParameter );
+ Standard_Integer anI1, anI2;
+ aBSplineCurve->LocateU( aParameter, LOCAL_SELECTION_TOLERANCE, anI1, anI2 );
+ aCurPoint1 = aBSplineCurve->Value( aBSplineCurve->Knot( anI1 ) );
+ aCurPoint2 = aBSplineCurve->Value( aBSplineCurve->Knot( anI2 ) );
+ }
+ }
+ }
+ else { // a curve built on a polyline edge
+ Handle(Geom_Line) aGLine = Handle(Geom_Line)::DownCast( aCurve );
+ if ( aGLine.IsNull() )
+ continue;
+ isFound = hasProjectPointOnCurve( theView, theX, theY, aGLine, aParameter,
+ aDelta );
+ if ( isFound ) {
+ aCurPoint = aGLine->Value( aParameter );
+ TopoDS_Vertex V1, V2;
+ TopExp::Vertices( anEdge, V1, V2, Standard_True );
+ if ( V1.IsNull() || V2.IsNull() )
+ continue;
+ aCurPoint1 = BRep_Tool::Pnt(V1);
+ aCurPoint2 = BRep_Tool::Pnt(V2);
+
+ // check that the projected point is on the bounded curve
+ gp_Vec aVec1( aCurPoint1, aCurPoint );
+ gp_Vec aVec2( aCurPoint2, aCurPoint );
+ isFound = fabs( aVec1.Angle( aVec2 ) - M_PI ) < LOCAL_SELECTION_TOLERANCE;
+ }
+ }
+ if ( isFound && aMinDelta >= aDelta ) {
+ aMinDelta = aDelta;
+
+ isFullFound = true;
+ aFoundPnt1 = aCurPoint1;
+ aFoundPnt2 = aCurPoint2;
+ aFoundPoint = aCurPoint;
+ }
+ }
+ if ( isFullFound ) {
+ int aX, anY, aX1, anY1, aX2, anY2;
+ int aDelta;
+ CurveCreator_Utils::ConvertPointToClick( aFoundPoint, theView, aX, anY );
+ CurveCreator_Utils::ConvertPointToClick( aFoundPnt1, theView, aX1, anY1 );
+ CurveCreator_Utils::ConvertPointToClick( aFoundPnt2, theView, aX2, anY2 );
+
+ isFullFound = !isEqualPixels( aX, anY, aX1, anY1, SCENE_PIXEL_POINT_TOLERANCE, aDelta ) &&
+ !isEqualPixels( aX, anY, aX2, anY2, SCENE_PIXEL_POINT_TOLERANCE, aDelta );
+ if ( isFullFound ) {
+ thePoint = aFoundPoint;
+ thePoint1 = aFoundPnt1;
+ thePoint2 = aFoundPnt2;
+ }
+ }
+ return isFullFound;
+}
+
+bool CurveCreator_Utils::hasProjectPointOnCurve( Handle(V3d_View) theView,
+ const int theX, const int theY,
+ const Handle(Geom_Curve)& theCurve,
+ Standard_Real& theParameter,
+ int& theDelta )
+{
+ bool isFound = false;
+ if ( theView.IsNull() )
+ return isFound;
+
+ gp_Pnt aPoint = CurveCreator_Utils::ConvertClickToPoint( theX, theY, theView );
+
+ GeomAPI_ProjectPointOnCurve aProj( aPoint, theCurve );
+ Standard_Integer aNbPoint = aProj.NbPoints();
+ if (aNbPoint > 0) {
+ for (Standard_Integer j = 1; j <= aNbPoint && !isFound; j++) {
+ gp_Pnt aNewPoint = aProj.Point( j );
+ theParameter = aProj.Parameter( j );
+
+ int aX, anY;
+ CurveCreator_Utils::ConvertPointToClick( aNewPoint, theView, aX, anY );
+
+ isFound = isEqualPixels( aX, anY, theX, theY, SCENE_PIXEL_PROJECTION_TOLERANCE, theDelta );
+ }
+ }
+ return isFound;
+}
+
+bool CurveCreator_Utils::isEqualPixels( const int theX, const int theY, const int theOtherX,
+ const int theOtherY, const double theTolerance, int& theDelta )
+{
+ int aXDelta = abs( theX - theOtherX );
+ int anYDelta = abs( theY - theOtherY );
+
+ theDelta = aXDelta*aXDelta + anYDelta*anYDelta;
+
+ return aXDelta < theTolerance && anYDelta < theTolerance;
+}
+
+bool CurveCreator_Utils::isEqualPoints( const gp_Pnt& thePoint, const gp_Pnt& theOtherPoint )
+{
+ return theOtherPoint.IsEqual( thePoint, LOCAL_SELECTION_TOLERANCE );
+}
--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef CURVECREATOR_UTILS_H
+#define CURVECREATOR_UTILS_H
+
+#include "CurveCreator_Macro.hxx"
+#include "CurveCreator_ICurve.hxx"
+
+#include <AIS_InteractiveContext.hxx>
+#include <AIS_InteractiveObject.hxx> // TODO: remove
+#include <V3d_View.hxx>
+#include <gp_Pnt.hxx>
+#include <Geom_Curve.hxx>
+#include <TopoDS_Shape.hxx>
+
+#include <list>
+#include <vector> // TODO: remove
+
+
+class CurveCreator_Utils
+{
+public:
+
+ /*!
+ * \brief Returns the point clicked in 3D view.
+ *
+ * \param x The X coordinate in the view.
+ * \param y The Y coordinate in the view.
+ * \param theView View where the given point takes place.
+ * \retval gp_Pnt Returns the point clicked in 3D view
+ */
+ CURVECREATOR_EXPORT static void ConvertPointToClick( const gp_Pnt& thePoint,
+ Handle(V3d_View) theView,
+ int& x, int& y );
+
+ /*!
+ * \brief Returns the point clicked in 3D view.
+ *
+ * \param x The X coordinate in the view.
+ * \param y The Y coordinate in the view.
+ * \param theView View where the given point takes place.
+ * \retval gp_Pnt Returns the point clicked in 3D view
+ */
+ CURVECREATOR_EXPORT static gp_Pnt ConvertClickToPoint( int x, int y,
+ Handle(V3d_View) theView );
+
+ /**
+ * Generates shape on the curve
+ * \param theCurve a curve object, that contains data
+ * \param theShape a generated shape
+ */
+ CURVECREATOR_EXPORT static void constructShape( const CurveCreator_ICurve* theCurve,
+ TopoDS_Shape& theShape );
+
+ /**
+ * Find selected points in the context
+ * \param theContext the viewer context
+ * \param theCurve a curve object, that contains data
+ */
+ CURVECREATOR_EXPORT static void getSelectedPoints( Handle(AIS_InteractiveContext) theContext,
+ const CurveCreator_ICurve* theCurve,
+ CurveCreator_ICurve::SectionToPointList& thePoints );
+
+ /**
+ * Set selected points to the context
+ * \param theContext the viewer context
+ * \param theCurve a curve object, that contains data
+ * \param thePoints the curve point indices to be selected in the context
+ */
+ CURVECREATOR_EXPORT static void setSelectedPoints(
+ Handle(AIS_InteractiveContext) theContext,
+ const CurveCreator_ICurve* theCurve,
+ const CurveCreator_ICurve::SectionToPointList& thePoints =
+ CurveCreator_ICurve::SectionToPointList() );
+
+ /*!
+ * \brief Sets the local point context for the 3D viewer.
+ * \param theCurve a curve object, that contains data
+ * \param theContext the viewer context
+ * \param theOpen The flag to open or close the local context.
+ */
+ CURVECREATOR_EXPORT static void setLocalPointContext(
+ const CurveCreator_ICurve* theCurve,
+ Handle(AIS_InteractiveContext) theContext,
+ const bool theOpen );
+
+ /**
+ * Checks whether the point belongs to the OCC object
+ * \param theObject a line or shape with a bspline inside
+ * \param theX the X coordinate in the view.
+ * \param theY the Y coordinate in the view.
+ * \param thePoint the output point to be append to the model curve
+ * \param thePoint1 the output point to bound the line where a new point should be inserted
+ * \param thePoint2 the output point to bound the line where a new point should be inserted
+ */
+ CURVECREATOR_EXPORT static bool pointOnObject( Handle(V3d_View) theView,
+ Handle(AIS_InteractiveObject) theObject,
+ const int theX, const int theY,
+ gp_Pnt& thePoint, gp_Pnt& thePoint1,
+ gp_Pnt& thePoint2 );
+
+protected:
+ /*
+ * Returns whether the clicked point belong to the curve or has a very near projection
+ * \param theX the X coordinate of a point clicked in the OCC viewer
+ * \param theY the Y coordinate of a point clicked in the OCC viewer
+ * \param theCurve a geometry curve
+ * \param theOutPoint a found projected point on the curve
+ */
+ CURVECREATOR_EXPORT static bool hasProjectPointOnCurve(
+ Handle(V3d_View) theView,
+ const int theX, const int theY,
+ const Handle(Geom_Curve)& theCurve,
+ Standard_Real& theParameter,
+ int& theDelta );
+
+ /*
+ * Returns whether the X and Y coordinates is in the pixel tolerance
+ * \param theX the X coordinate of the first point
+ * \param theY the Y coordinate of the first point
+ * \param theOtherX the X coordinate of the second point
+ * \param theOtherY the Y coordinate of the second point
+ * \param theTolerance the tolerance to compare
+ * \param theDelta the sum of the a square of X and a square of Y
+ * \returns whether the points are provide to the pixel tolerance
+ */
+ CURVECREATOR_EXPORT static bool isEqualPixels( const int theX, const int theY,
+ const int theOtherX, const int theOtherY,
+ const double theTolerance, int& theDelta );
+
+
+ /*
+ * Returns whether the points are the same
+ * \param thePoint the first point
+ * \param theOtherPoint the second point
+ * \returns whether the points are provide to the pixel tolerance
+ */
+ CURVECREATOR_EXPORT static bool isEqualPoints( const gp_Pnt& thePoint,
+ const gp_Pnt& theOtherPoint );
+};
+
+#endif // CURVECREATOR_UTILS_H
--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "CurveCreator_UtilsICurve.hxx"
+
+#include "CurveCreator.hxx"
+#include <gp_Pnt.hxx>
+
+const double LOCAL_SELECTION_TOLERANCE = 0.0001;
+
+int CurveCreator_UtilsICurve::findLocalPointIndex( const CurveCreator_ICurve* theCurve,
+ int theSectionId, float theX, float theY )
+{
+ int aPntIndex = -1;
+ if ( !theCurve )
+ return aPntIndex;
+
+ CurveCreator::Coordinates aCoords;
+ for ( int i = 0, aNb = theCurve->getNbPoints( theSectionId ); i < aNb && aPntIndex < 0; i++ ) {
+ aCoords = theCurve->getPoint( theSectionId, i );
+ if ( aCoords.size() < 2 )
+ continue;
+ if ( fabs( aCoords[0] - theX ) < LOCAL_SELECTION_TOLERANCE &&
+ fabs( aCoords[1] - theY ) < LOCAL_SELECTION_TOLERANCE )
+ aPntIndex = i;
+ }
+
+ return aPntIndex;
+}
+
+void CurveCreator_UtilsICurve::findSectionsToPoints( const CurveCreator_ICurve* theCurve,
+ const double theX, const double theY,
+ CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ thePoints.clear();
+
+ int aPointId = -1;
+ for ( int i = 0, aNb = theCurve->getNbSections(); i < aNb; i++ ) {
+ aPointId = CurveCreator_UtilsICurve::findLocalPointIndex( theCurve, i, theX, theY );
+ if ( aPointId < 0 )
+ continue;
+ CurveCreator_ICurve::SectionToPoint aPoint = std::make_pair( i, aPointId );
+ if ( !CurveCreator_UtilsICurve::contains( thePoints, aPoint ) )
+ thePoints.push_back( aPoint );
+ }
+}
+
+void CurveCreator_UtilsICurve::convert( const CurveCreator_ICurve::SectionToPointList& thePoints,
+ QMap<int, QList<int> >& theConvPoints )
+{
+ theConvPoints.clear();
+
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = thePoints.begin(),
+ aLast = thePoints.end();
+ QList<int> aPoints;
+ int aSectionId, aPointId;
+ for ( ; anIt != aLast; anIt++ ) {
+ aSectionId = anIt->first;
+ aPointId = anIt->second;
+ aPoints.clear();
+ if ( theConvPoints.contains( aSectionId ) )
+ aPoints = theConvPoints[aSectionId];
+ if ( aPoints.contains( aPointId ) )
+ continue;
+ aPoints.append( aPointId );
+ theConvPoints[aSectionId] = aPoints;
+ }
+}
+
+#include "CurveCreator_Curve.hxx" // TODO
+void CurveCreator_UtilsICurve::getPoint( const CurveCreator_ICurve* theCurve, const int theISection,
+ const int theIPoint, gp_Pnt& thePoint )
+{
+ double anX, anY, aZ;
+ // TODO
+ const CurveCreator_Curve* aCurve = dynamic_cast<const CurveCreator_Curve*>( theCurve );
+ if ( aCurve )
+ aCurve->getCoordinates( theISection, theIPoint, anX, anY, aZ );
+ thePoint = gp_Pnt( anX, anY, aZ);
+}
+
+std::string CurveCreator_UtilsICurve::getUniqSectionName( CurveCreator_ICurve* theCurve )
+{
+ 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 < theCurve->getNbSections() ; j++ ){
+ if( theCurve->getSectionName(j) == aName )
+ break;
+ }
+ if( j == theCurve->getNbSections() )
+ return aName;
+ }
+ return "";
+}
+
+bool CurveCreator_UtilsICurve::contains( const CurveCreator_ICurve::SectionToPointList& theList,
+ const CurveCreator_ICurve::SectionToPoint& theValue )
+{
+ bool isFound = false;
+
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = theList.begin(),
+ aLast = theList.end();
+ for ( ; anIt != aLast && !isFound; anIt++ )
+ isFound = anIt->first == theValue.first && anIt->second == theValue.second;
+
+ return isFound;
+}
--- /dev/null
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef CURVECREATOR_UTILS_ICURVE_H
+#define CURVECREATOR_UTILS_ICURVE_H
+
+#include "CurveCreator_Macro.hxx"
+
+#include "CurveCreator_ICurve.hxx"
+
+#include <gp_Pnt.hxx>
+
+#include <QMap>
+#include <QList>
+
+class CurveCreator_UtilsICurve
+{
+public:
+
+ /*!
+ * Returns a point index in the model curve by the point coordinates in the viewer
+ * \param theX the X coordinate of the point
+ * \param theY the Y coordinate of the point
+ */
+ CURVECREATOR_EXPORT static int findLocalPointIndex( const CurveCreator_ICurve* theCurve,
+ int theSectionId, float theX, float theY );
+
+ CURVECREATOR_EXPORT static void findSectionsToPoints( const CurveCreator_ICurve* theCurve,
+ const double theX, const double theY,
+ CurveCreator_ICurve::SectionToPointList& thePoints );
+ CURVECREATOR_EXPORT static void convert( const CurveCreator_ICurve::SectionToPointList& thePoints,
+ QMap<int, QList<int> >& theConvPoints );
+
+ CURVECREATOR_EXPORT static void getPoint( const CurveCreator_ICurve* theCurve, const int theISection,
+ const int theIPoint, gp_Pnt& thePoint );
+
+ /*!
+ * Returns a unique section name
+ * \param theCurve a curve interface
+ */
+ CURVECREATOR_EXPORT static std::string getUniqSectionName(
+ CurveCreator_ICurve* theCurve );
+
+ /**
+ * Returns whethe the container has the value
+ * \param theList a container of values
+ * \param theValue a value
+ */
+ CURVECREATOR_EXPORT static bool contains( const CurveCreator_ICurve::SectionToPointList& theList,
+ const CurveCreator_ICurve::SectionToPoint& theValue );
+};
+
+#endif // CURVECREATOR_UTILS_ICURVE_H
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#include "CurveCreator_Widget.h"
#include "CurveCreator_TreeView.h"
-#include "CurveCreator_Curve.hxx"
-#include "CurveCreator_CurveEditor.hxx"
+#include "CurveCreator_ICurve.hxx"
#include "CurveCreator.hxx"
-#include "CurveCreator_NewPointDlg.h"
#include "CurveCreator_NewSectionDlg.h"
-
-#include <GEOMUtils.hxx>
+#include "CurveCreator_Utils.hxx"
+#include "CurveCreator_UtilsICurve.hxx"
+#include "CurveCreator_TableView.h"
#include <SUIT_Session.h>
#include <SUIT_Desktop.h>
#include <OCCViewer_ViewWindow.h>
#include <OCCViewer_ViewManager.h>
#include <OCCViewer_ViewPort3d.h>
-
-#include <BRep_Tool.hxx>
-#include <TopoDS.hxx>
+#include <OCCViewer_Utilities.h>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QMenu>
#include <QMouseEvent>
#include <QApplication>
+#include <QTableWidget>
+#include <QTime>
+
+//#define MEASURE_TIME
+
+#ifdef MEASURE_TIME
+
+ #define START_MEASURE_TIME \
+ QTime aTimer; \
+ aTimer.start(); \
+
+ #define END_MEASURE_TIME( theMsg ) \
+ double aTime = aTimer.elapsed() * 0.001; \
+ FILE* aFile = fopen( "performance", "a" ); \
+ fprintf( aFile, "%s = %.3lf sec\n", theMsg, aTime ); \
+ fclose( aFile ); \
+
+#else
+
+ #define START_MEASURE_TIME
+ #define END_MEASURE_TIME( theMsg )
+
+#endif
+
+
+
+
+
CurveCreator_Widget::CurveCreator_Widget(QWidget* parent,
- CurveCreator_Curve *theCurve,
- Qt::WindowFlags fl) :
- QWidget(parent), myNewPointEditor(NULL), myNewSectionEditor(NULL), myEdit(NULL), myCurve(theCurve)
-{
- if( myCurve )
- myEdit = new CurveCreator_CurveEditor( myCurve );
-
- CurveCreator::Dimension aDim = CurveCreator::Dim2d;
- if( myCurve )
- aDim = myCurve->getDimension();
- myNewPointEditor = new CurveCreator_NewPointDlg( aDim, this );
- myNewPointEditor->hide();
-// connect( myNewPointEditor, SIGNAL(addPoint()), this, SLOT(onAddNewPoint()) );
- connect( myNewPointEditor, SIGNAL(modifyPoint()), this, SLOT(onModifyPoint()) );
- connect( myNewPointEditor, SIGNAL(cancelPoint()), this, SLOT(onCancelPoint()) );
-
- myNewSectionEditor = new CurveCreator_NewSectionDlg( this );
- myNewSectionEditor->hide();
- connect( myNewSectionEditor, SIGNAL(addSection()), this, SLOT(onAddNewSection()) );
- connect( myNewSectionEditor, SIGNAL(modifySection()), this, SLOT(onModifySection()) );
- connect( myNewSectionEditor, SIGNAL(cancelSection()), this, SLOT(onCancelSection()) );
-
- QGroupBox* aSectionGroup = new QGroupBox(tr("Sections"),this);
-
- mySectionView = new CurveCreator_TreeView(myCurve, aSectionGroup);
- connect( mySectionView, SIGNAL(selectionChanged()), this, SLOT( onSelectionChanged() ) );
- connect( mySectionView, SIGNAL(pointEntered(int,int)), this, SLOT(onEditPoint(int,int)) );
- connect( mySectionView, SIGNAL(sectionEntered(int)), this, SLOT(onEditSection(int)) );
- connect( mySectionView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(onContextMenu(QPoint)) );
- QToolBar* aTB = new QToolBar(tr("TOOL_BAR_TLT"), aSectionGroup);
+ CurveCreator_ICurve *theCurve,
+ const int theActionFlags,
+ const QStringList& theCoordTitles,
+ Qt::WindowFlags fl,
+ int theLocalPointRowLimit )
+: QWidget(parent), myNewSectionEditor(NULL), myCurve(theCurve), mySection(0),
+ myDragStarted( false ), myDragInteractionStyle( SUIT_ViewModel::STANDARD ),
+ myOCCViewer( 0 ), myLocalPointRowLimit( theLocalPointRowLimit )
+{
+ bool isToEnableClosed = !( theActionFlags & DisableClosedSection );
+ myNewSectionEditor = new CurveCreator_NewSectionDlg( this, isToEnableClosed );
+ myNewSectionEditor->hide();
+ connect( myNewSectionEditor, SIGNAL(addSection()), this, SLOT(onAddNewSection()) );
+ connect( myNewSectionEditor, SIGNAL(modifySection()), this, SLOT(onModifySection()) );
+ connect( myNewSectionEditor, SIGNAL(cancelSection()), this, SLOT(onCancelSection()) );
+
+ QGroupBox* aSectionGroup = new QGroupBox(tr("Sections"),this);
+
+ mySectionView = new CurveCreator_TreeView(myCurve, aSectionGroup);
+ mySectionView->setSelectionMode( QTreeView::ExtendedSelection );
+ connect( mySectionView, SIGNAL(selectionChanged()), this, SLOT( onSelectionChanged() ) );
+ connect( mySectionView, SIGNAL(sectionEntered(int)), this, SLOT(onEditSection(int)) );
+ connect( mySectionView, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(onContextMenu(QPoint)) );
+
+ myLocalPointView = new CurveCreator_TableView( myCurve, this, theCoordTitles );
+ connect( myLocalPointView, SIGNAL( cellChanged( int, int ) ),
+ this, SLOT( onCellChanged( int, int ) ) );
+
+ QToolBar* aTB = new QToolBar(tr("TOOL_BAR_TLT"), aSectionGroup);
// QToolButton* anUndoBtn = new QToolButton(aTB);
- SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
- QPixmap anUndoPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_UNDO")));
- QPixmap aRedoPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_REDO")));
- QPixmap aNewSectionPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_NEW_SECTION")));
- QPixmap aNewPointPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_NEW_POINT")));
- QPixmap anEditPointsPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_EDIT_POINTS")));
- QPixmap aDetectPointsPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_EDIT_POINTS")));
- QPixmap aPolylinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
- QPixmap aSplinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
- QPixmap aRemovePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_DELETE")));
- QPixmap aJoinPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_JOIN")));
- QPixmap aStepUpPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_UP")));
- QPixmap aStepDownPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_DOWN")));
-
-/* QPixmap anUndoPixmap = QPixmap(tr(":images/ICON_UNDO"));
- QPixmap aRedoPixmap = QPixmap(tr(":images/ICON_REDO"));
- QPixmap aNewSectionPixmap = QPixmap(tr(":images/ICON_NEW_SECTION"));
- QPixmap aNewPointPixmap = QPixmap(tr(":images/ICON_NEW_POINT"));
- QPixmap aPolylinePixmap = QPixmap(tr(":images/ICON_POLYLINE"));
- QPixmap aSplinePixmap = QPixmap(tr(":images/ICON_SPLINE"));
- QPixmap aRemovePixmap = QPixmap(tr(":images/ICON_REMOVE"));
- QPixmap aJoinPixmap = QPixmap(tr(":images/ICON_JOIN"));
- QPixmap aStepUpPixmap = QPixmap(tr(":images/ICON_STEP_UP"));
- QPixmap aStepDownPixmap = QPixmap(tr(":images/ICON_STEP_DOWN"));*/
-
- QAction* anAct = createAction( UNDO_ID, tr("UNDO"), anUndoPixmap, tr("UNDO_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_Z) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onUndo()) );
+ SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
+ QPixmap anUndoPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_UNDO")));
+ QPixmap aRedoPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_REDO")));
+ QPixmap aNewSectionPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_NEW_SECTION")));
+ QPixmap aNewPointPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_NEW_POINT")));
+ QPixmap anEditPointsPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_EDIT_POINTS")));
+ QPixmap aDetectPointsPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_EDIT_POINTS")));
+ QPixmap aPolylinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
+ QPixmap aSplinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
+ QPixmap aRemovePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_DELETE")));
+ QPixmap aJoinPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_JOIN")));
+ QPixmap aStepUpPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_UP")));
+ QPixmap aStepDownPixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_ARROW_DOWN")));
+
+ QAction* anAct = createAction( UNDO_ID, tr("UNDO"), anUndoPixmap, tr("UNDO_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_Z) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onUndo()) );
+ aTB->addAction(anAct);
+
+ anAct = createAction( REDO_ID, tr("REDO"), aRedoPixmap, tr("REDO_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_Y) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onRedo()) );
+ aTB->addAction(anAct);
+
+ aTB->addSeparator();
+
+ anAct = createAction( NEW_SECTION_ID, tr("NEW_SECTION"), aNewSectionPixmap, tr("NEW_SECTION_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_N) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onNewSection()) );
+ if ( !(theActionFlags & DisableNewSection) ) {
aTB->addAction(anAct);
+ aTB->addSeparator();
+ }
- anAct = createAction( REDO_ID, tr("REDO"), aRedoPixmap, tr("REDO_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_Y) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onRedo()) );
+ anAct = createAction( ADDITION_MODE_ID, tr("ADDITION_MODE"), aNewPointPixmap, tr("ADDITION_MODE_TLT"),
+ QKeySequence() );
+ anAct->setCheckable(true);
+ connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onAdditionMode(bool)) );
+ connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
+ aTB->addAction(anAct);
+
+ anAct = createAction( MODIFICATION_MODE_ID, tr("MODIFICATION_MODE"), anEditPointsPixmap, tr("MODIFICATION_MODE_TLT"),
+ QKeySequence() );
+ anAct->setCheckable(true);
+ connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onModificationMode(bool)) );
+ connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
+ aTB->addAction(anAct);
+
+ anAct = createAction( DETECTION_MODE_ID, tr("DETECTION_MODE"), aDetectPointsPixmap, tr("DETECTION_MODE_TLT"),
+ QKeySequence() );
+ anAct->setCheckable(true);
+ connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onDetectionMode(bool)) );
+ connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
+ if ( !(theActionFlags & DisableDetectionMode) ) {
aTB->addAction(anAct);
+ }
+
+ anAct = createAction( CLOSE_SECTIONS_ID, tr("CLOSE_SECTIONS"), QPixmap(), tr("CLOSE_SECTIONS_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_W) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onCloseSections()) );
+
+ anAct = createAction( UNCLOSE_SECTIONS_ID, tr("UNCLOSE_SECTIONS"), QPixmap(),
+ tr("UNCLOSE_SECTIONS_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_S) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onUncloseSections()) );
+
+ anAct = createAction( SET_SECTIONS_POLYLINE_ID, tr("SET_SECTIONS_POLYLINE"),
+ aPolylinePixmap, tr("SET_POLYLINE_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_E) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onSetPolyline()) );
+
+ anAct = createAction( SET_SECTIONS_SPLINE_ID, tr("SET_SECTIONS_SPLINE"), aSplinePixmap,
+ tr("SET_SPLINE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_R) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onSetSpline()) );
+
+ anAct = createAction( REMOVE_ID, tr("REMOVE"), aRemovePixmap, tr("REMOVE_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_Delete ) );
+ connect(anAct, SIGNAL(triggered()), this, SLOT(onRemove()) );
+ aTB->addAction(anAct);
+
+ aTB->addSeparator();
+
+ anAct = createAction( JOIN_ID, tr("JOIN"), aJoinPixmap, tr("JOIN_TLT"),
+ QKeySequence(Qt::ControlModifier|Qt::Key_Plus ) );
+ connect( anAct, SIGNAL(triggered()), this, SLOT(onJoin()) );
+ aTB->addAction(anAct);
+
+ anAct = createAction( CLEAR_ALL_ID, tr("CLEAR_ALL"), QPixmap(), tr("CLEAR_ALL_TLT"),
+ QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Delete ) );
+ connect( anAct, SIGNAL(triggered()), this, SLOT( onClearAll()) );
+
+ anAct = createAction( JOIN_ALL_ID, tr("JOIN_ALL"), QPixmap(), tr("JOIN_ALL_TLT"),
+ QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Plus ) );
+ connect( anAct, SIGNAL(triggered()), this, SLOT(onJoinAll()) );
+
+ QVBoxLayout* aSectLayout = new QVBoxLayout();
+ aSectLayout->setMargin( 5 );
+ aSectLayout->setSpacing( 5 );
+ aSectLayout->addWidget(aTB);
+ aSectLayout->addWidget(mySectionView);
+ aSectLayout->addWidget( myLocalPointView );
+ aSectionGroup->setLayout(aSectLayout);
+ QVBoxLayout* aLay = new QVBoxLayout();
+ aLay->setMargin( 0 );
+ aLay->setSpacing( 5 );
+// aLay->addLayout(aNameLayout);
+ aLay->addWidget(aSectionGroup);
+ setLayout(aLay);
- aTB->addSeparator();
+ updateActionsStates();
+ updateUndoRedo();
+}
- anAct = createAction( NEW_SECTION_ID, tr("NEW_SECTION"), aNewSectionPixmap, tr("NEW_SECTION_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_N) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onNewSection()) );
- aTB->addAction(anAct);
- aTB->addSeparator();
+/**
+ * Set an OCC viewer
+ */
+void CurveCreator_Widget::setOCCViewer( OCCViewer_Viewer* theViewer )
+{
+ if ( myOCCViewer == theViewer )
+ return;
- anAct = createAction( INSERT_SECTION_BEFORE_ID, tr("INSERT_SECTION_BEFORE"), QPixmap(),
- tr("INSERT_SECTION_BEFORE_TLT"),
- QKeySequence(Qt::ControlModifier | Qt::Key_Insert ) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onInsertSectionBefore()) );
-
- anAct = createAction( INSERT_SECTION_AFTER_ID, tr("INSERT_SECTION_AFTER"), QPixmap(),
- tr("INSERT_SECTION_AFTER_TLT"),
- QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Insert ) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onInsertSectionAfter()) );
-
- anAct = createAction( ADDITION_MODE_ID, tr("ADDITION_MODE"), aNewPointPixmap, tr("ADDITION_MODE_TLT"),
- QKeySequence() );
- anAct->setCheckable(true);
- connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onAdditionMode(bool)) );
- connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
- aTB->addAction(anAct);
+ if ( myOCCViewer ) {
+ OCCViewer_ViewManager* aViewManager = dynamic_cast<OCCViewer_ViewManager*>
+ ( myOCCViewer->getViewManager() );
+ disconnect( aViewManager, SIGNAL( mousePress( SUIT_ViewWindow*, QMouseEvent* ) ),
+ this, SLOT( onMousePress( SUIT_ViewWindow*, QMouseEvent* ) ) );
+ disconnect( aViewManager, SIGNAL( mouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ),
+ this, SLOT( onMouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ) );
+ disconnect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ),
+ this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) );
+ disconnect( aViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
+ this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
+ // restore normal mode in the viewer
+ OCCViewer_Utilities::setViewer2DMode( myOCCViewer, OCCViewer_ViewWindow::No2dMode );
+ // all local contexts should be closed if the viewer is not more used
+ setLocalPointContext( false, true );
+ }
+
+ myOCCViewer = theViewer;
+ if ( myOCCViewer ) {
+ OCCViewer_ViewManager* aViewManager = dynamic_cast<OCCViewer_ViewManager*>
+ ( myOCCViewer->getViewManager() );
+ connect( aViewManager, SIGNAL( mousePress( SUIT_ViewWindow*, QMouseEvent* ) ),
+ this, SLOT( onMousePress( SUIT_ViewWindow*, QMouseEvent* ) ) );
+ connect( aViewManager, SIGNAL( mouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ),
+ this, SLOT( onMouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ) );
+ connect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ),
+ this, SLOT( onMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) );
+ connect( aViewManager, SIGNAL( lastViewClosed( SUIT_ViewManager* ) ),
+ this, SLOT( onLastViewClosed( SUIT_ViewManager* ) ) );
+ OCCViewer_Utilities::setViewer2DMode( myOCCViewer, OCCViewer_ViewWindow::XYPlane );
+ }
+}
+
+/**
+ * Returns current OCC viewer
+ */
+OCCViewer_Viewer* CurveCreator_Widget::getOCCViewer()
+{
+ return myOCCViewer;
+}
+
+/**
+ * Returns OCC viewer context
+ */
+Handle(AIS_InteractiveContext) CurveCreator_Widget::getAISContext()
+{
+ Handle(AIS_InteractiveContext) aContext;
+ OCCViewer_Viewer* aViewer = getOCCViewer();
+ if ( aViewer )
+ aContext = aViewer->getAISContext();
+
+ return aContext;
+}
+
+/**
+ * Returns OCC viewer view port
+ */
+OCCViewer_ViewPort3d* CurveCreator_Widget::getViewPort()
+{
+ OCCViewer_ViewPort3d* aViewPort = 0;
+ OCCViewer_Viewer* aViewer = getOCCViewer();
+ if ( aViewer )
+ aViewPort = ((OCCViewer_ViewWindow*)aViewer->getViewManager()->getActiveView())->getViewPort();
- anAct = createAction( MODIFICATION_MODE_ID, tr("MODIFICATION_MODE"), anEditPointsPixmap, tr("MODIFICATION_MODE_TLT"),
- QKeySequence() );
- anAct->setCheckable(true);
- connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onModificationMode(bool)) );
- connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
- aTB->addAction(anAct);
+ return aViewPort;
+}
- anAct = createAction( DETECTION_MODE_ID, tr("DETECTION_MODE"), aDetectPointsPixmap, tr("DETECTION_MODE_TLT"),
- QKeySequence() );
- anAct->setCheckable(true);
- connect(anAct, SIGNAL(triggered(bool)), this, SLOT(onDetectPoints(bool)) );
- connect(anAct, SIGNAL(toggled(bool)), this, SLOT(onModeChanged(bool)) );
- aTB->addAction(anAct);
+/**
+ * Set interaction style in the OCC viewer
+ * \param theStyle a new style
+ * \return the previous style
+ */
+int CurveCreator_Widget::changeInteractionStyle( int theStyle )
+{
+ OCCViewer_Viewer* aViewer = getOCCViewer();
+ if ( !aViewer )
+ return -1;
- anAct = createAction( INSERT_POINT_BEFORE_ID, tr("INSERT_POINT_BEFORE"), QPixmap(),
- tr("INSERT_POINT_BEFORE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_B) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onInsertPointBefore()) );
-
- anAct = createAction( INSERT_POINT_AFTER_ID, tr("INSERT_POINT_AFTER"), QPixmap(),
- tr("INSERT_POINT_AFTER_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_M) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onInsertPointAfter()) );
-
- anAct = createAction( CLOSE_SECTIONS_ID, tr("CLOSE_SECTIONS"), QPixmap(), tr("CLOSE_SECTIONS_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_W) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onCloseSections()) );
-
- anAct = createAction( UNCLOSE_SECTIONS_ID, tr("UNCLOSE_SECTIONS"), QPixmap(),
- tr("UNCLOSE_SECTIONS_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_S) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onUncloseSections()) );
-
- anAct = createAction( SET_SECTIONS_POLYLINE_ID, tr("SET_SECTIONS_POLYLINE"),
- aPolylinePixmap, tr("SET_POLYLINE_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_E) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onSetPolyline()) );
-
- anAct = createAction( SET_SECTIONS_SPLINE_ID, tr("SET_SECTIONS_SPLINE"), aSplinePixmap,
- tr("SET_SPLINE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_R) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onSetSpline()) );
-
- anAct = createAction( REMOVE_ID, tr("REMOVE"), aRemovePixmap, tr("REMOVE_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_Delete ) );
- connect(anAct, SIGNAL(triggered()), this, SLOT(onRemove()) );
- aTB->addAction(anAct);
- aTB->addSeparator();
+ int aPrevStyle = aViewer->interactionStyle();
+ aViewer->setInteractionStyle( theStyle );
- anAct = createAction( JOIN_ID, tr("JOIN"), aJoinPixmap, tr("JOIN_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_Plus ) );
- connect( anAct, SIGNAL(triggered()), this, SLOT(onJoin()) );
- aTB->addAction(anAct);
- aTB->addSeparator();
+ return aPrevStyle;
+}
- anAct = createAction( UP_ID, tr("STEP_UP"), aStepUpPixmap, tr("STEP_UP_TLT"),
- QKeySequence(Qt::ControlModifier|Qt::Key_Up ) );
- connect( anAct, SIGNAL(triggered()), this, SLOT(onMoveUp()) );
-
- anAct = createAction( DOWN_ID, tr("STEP_DOWN"), aStepDownPixmap, tr("STEP_DOWN"),
- QKeySequence(Qt::ControlModifier|Qt::Key_Down ) );
- connect( anAct, SIGNAL(triggered()), this, SLOT(onMoveDown()) );
-
- anAct = createAction( CLEAR_ALL_ID, tr("CLEAR_ALL"), QPixmap(), tr("CLEAR_ALL_TLT"),
- QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Delete ) );
- connect( anAct, SIGNAL(triggered()), this, SLOT( onClearAll()) );
-
- anAct = createAction( JOIN_ALL_ID, tr("JOIN_ALL"), QPixmap(), tr("JOIN_ALL_TLT"),
- QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Plus ) );
- connect( anAct, SIGNAL(triggered()), this, SLOT(onJoinAll()) );
-
- QVBoxLayout* aSectLayout = new QVBoxLayout();
- aSectLayout->setMargin( 5 );
- aSectLayout->setSpacing( 5 );
- aSectLayout->addWidget(aTB);
- aSectLayout->addWidget(mySectionView);
- aSectionGroup->setLayout(aSectLayout);
- QVBoxLayout* aLay = new QVBoxLayout();
- aLay->setMargin( 0 );
- aLay->setSpacing( 5 );
-// aLay->addLayout(aNameLayout);
- aLay->addWidget(aSectionGroup);
- setLayout(aLay);
- onSelectionChanged();
+//=======================================================================
+// function: reset
+// purpose: reset the widget viewer, close local context, clear selection
+//=======================================================================
+void CurveCreator_Widget::reset()
+{
}
-void CurveCreator_Widget::setCurve( CurveCreator_Curve* theCurve )
+void CurveCreator_Widget::setCurve( CurveCreator_ICurve* theCurve )
{
- if( myEdit != NULL ){
- delete myEdit;
- myEdit = NULL;
- }
myCurve = theCurve;
- mySectionView->setCurve(myCurve);
- if( myCurve != NULL ){
- myEdit = new CurveCreator_CurveEditor(myCurve);
- }
- onSelectionChanged();
+ mySectionView->setCurve( myCurve );
+ myLocalPointView->setCurve( myCurve );
+ updateActionsStates();
updateUndoRedo();
}
void CurveCreator_Widget::onSelectionChanged()
+{
+ updateActionsStates();
+ updateUndoRedo();
+ emit selectionChanged();
+}
+
+void CurveCreator_Widget::updateActionsStates()
{
QList<ActionId> anEnabledAct;
if( myCurve ){
- anEnabledAct << NEW_SECTION_ID;
+ anEnabledAct << NEW_SECTION_ID << MODIFICATION_MODE_ID;
+ if ( removeEnabled() )
+ anEnabledAct << REMOVE_ID;
QList<int> aSelSections = mySectionView->getSelectedSections();
- QList< QPair< int, int > > aSelPoints = mySectionView->getSelectedPoints();
CurveCreator_TreeView::SelectionType aSelType = mySectionView->getSelectionType();
switch( aSelType ){
case CurveCreator_TreeView::ST_NOSEL:{
anEnabledAct << UP_ID;
}*/
if( aSelSections.size() == 1 ){
- anEnabledAct << ADDITION_MODE_ID << MODIFICATION_MODE_ID << DETECTION_MODE_ID;
+ anEnabledAct << ADDITION_MODE_ID << DETECTION_MODE_ID;
}
- if (myActionMap[ADDITION_MODE_ID]->isChecked()) {
- mySection = -1;
- myPointNum = -1;
- QList<int> aSelSection = mySectionView->getSelectedSections();
- if( aSelSection.size() > 0 ){
- mySection = aSelSection[0];
- myPointNum = myCurve->getNbPoints(mySection);
+ switch ( getActionMode() ) {
+ case AdditionMode: {
+ mySection = -1;
+ myPointNum = -1;
+ QList<int> aSelSection = mySectionView->getSelectedSections();
+ if( aSelSection.size() > 0 ){
+ mySection = aSelSection[0];
+ myPointNum = myCurve->getNbPoints(mySection);
+ }
}
- } else if (myActionMap[MODIFICATION_MODE_ID]->isChecked()) {
- anEnabledAct << REMOVE_ID;
- anEnabledAct << CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID << SET_SECTIONS_SPLINE_ID;
- int aSectCnt = myCurve->getNbSections();
- if( aSectCnt > 0 )
- anEnabledAct << CLEAR_ALL_ID;
- if( aSectCnt > 1 )
- anEnabledAct << JOIN_ALL_ID;
- if( aSelSections.size() > 1 ){
- anEnabledAct << JOIN_ID;
+ break;
+ case ModificationMode: {
+ if ( myNewSectionEditor->isEnableClosed() )
+ anEnabledAct << CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID;
+ anEnabledAct << SET_SECTIONS_POLYLINE_ID << SET_SECTIONS_SPLINE_ID;
+ int aSectCnt = myCurve->getNbSections();
+ if( aSectCnt > 0 )
+ anEnabledAct << CLEAR_ALL_ID;
+ if( aSectCnt > 1 )
+ anEnabledAct << JOIN_ALL_ID;
+ if( aSelSections.size() > 1 ){
+ anEnabledAct << JOIN_ID;
+ }
}
- } else if (myActionMap[DETECTION_MODE_ID]->isChecked()) {
- } else { //no active mode
+ break;
+ case DetectionMode: {
+ }
+ break;
+ case NoneMode:
+ {
+ int aSectCnt = myCurve->getNbSections();
+ if( aSectCnt > 1 )
+ anEnabledAct << JOIN_ALL_ID;
+ if( aSelSections.size() > 1 )
+ anEnabledAct << JOIN_ID;
+ }
+ break;
+ default:
+ break;
}
/*if( aSelSections[ aSelSections.size() - 1 ] < ( myCurve->getNbSections() - 1 ) ){
anEnabledAct << DOWN_ID;
}
}
}
- emit selectionChanged();
}
void CurveCreator_Widget::onAdditionMode(bool checked)
{
- if( !myEdit )
+ if (!checked)
return;
- SUIT_ViewWindow* aViewWindow = 0;
- SUIT_Study* activeStudy = SUIT_Session::session()->activeApplication()->activeStudy();
- if ( activeStudy )
- aViewWindow = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
- if ( aViewWindow == 0 )
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+ if( !myCurve || aContext.IsNull() )
return;
- SUIT_ViewManager* aViewManager = aViewWindow->getViewManager();
-
- if ( aViewManager->getType() == OCCViewer_Viewer::Type() ) {
- if (checked) {
- connect( aViewManager, SIGNAL( mousePress( SUIT_ViewWindow*, QMouseEvent* ) ),
- this, SLOT( onGetPointByClick( SUIT_ViewWindow*, QMouseEvent* ) ) );
- } else {
- disconnect( aViewManager, SIGNAL( mousePress( SUIT_ViewWindow*, QMouseEvent* ) ),
- this, SLOT( onGetPointByClick( SUIT_ViewWindow*, QMouseEvent* ) ) );
- return;
- }
- }
mySection= -1;
myPointNum = -1;
if( aSelSection.size() > 0 ){
mySection = aSelSection[0];
}
- else{
- QList< QPair<int,int> > aSelPoints = mySectionView->getSelectedPoints();
- if( aSelPoints.size() > 0 ){
- mySection = aSelPoints[0].first;
- myPointNum = aSelPoints[0].second + 1;
- }
- }
-/*
- QString aSectName;
- if( mySection < 0 ){
- mySection = myCurve->getNbSections() - 1;
- }
- aSectName = QString::fromStdString( myCurve->getSectionName(mySection));
- if( myPointNum < 0 ){
- myPointNum = myCurve->getNbPoints(mySection);
- }
- myNewPointEditor->clear();
- myNewPointEditor->setEditMode(false);
- myNewPointEditor->setSectionName(aSectName);
- myNewPointEditor->setDimension(myCurve->getDimension());
-*/
// emit subOperationStarted( myNewPointEditor );
}
void CurveCreator_Widget::onModificationMode(bool checked)
{
- SUIT_ViewWindow* aViewWindow = 0;
- SUIT_Study* activeStudy = SUIT_Session::session()->activeApplication()->activeStudy();
- if ( activeStudy )
- aViewWindow = SUIT_Session::session()->activeApplication()->desktop()->activeWindow();
- if ( aViewWindow == 0 )
- return;
- SUIT_ViewManager* aViewManager = aViewWindow->getViewManager();
- if ( aViewManager->getType() == OCCViewer_Viewer::Type() ) {
- if (checked) {
-// connect( aViewManager, SIGNAL( mouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ),
-// this, SLOT( onPointSelect( SUIT_ViewWindow*, QMouseEvent* ) ) );
- connect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ),
- this, SLOT( onPointDrag( SUIT_ViewWindow*, QMouseEvent* ) ) );
- }
- else {
-// disconnect( aViewManager, SIGNAL( mouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ),
-// this, SLOT( onPointSelect( SUIT_ViewWindow*, QMouseEvent* ) ) );
- disconnect( aViewManager, SIGNAL( mouseMove( SUIT_ViewWindow*, QMouseEvent* ) ),
- this, SLOT( onPointDrag( SUIT_ViewWindow*, QMouseEvent* ) ) );
- return;
- }
- }
+ myLocalPointView->setVisible( checked );
}
-void CurveCreator_Widget::onDetectPoints(bool checked)
+void CurveCreator_Widget::onDetectionMode(bool checked)
{
}
void CurveCreator_Widget::onModeChanged(bool checked)
{
+ ActionMode aMode = NoneMode;
if (checked) {
QAction* anAction = (QAction*)sender();
switch(myActionMap.key(anAction)) {
case ADDITION_MODE_ID:
+ aMode = AdditionMode;
if (myActionMap[MODIFICATION_MODE_ID]->isChecked())
myActionMap[MODIFICATION_MODE_ID]->trigger();
else if (myActionMap[DETECTION_MODE_ID]->isChecked())
myActionMap[DETECTION_MODE_ID]->trigger();
break;
case MODIFICATION_MODE_ID:
+ aMode = ModificationMode;
if (myActionMap[ADDITION_MODE_ID]->isChecked())
myActionMap[ADDITION_MODE_ID]->trigger();
else if (myActionMap[DETECTION_MODE_ID]->isChecked())
myActionMap[DETECTION_MODE_ID]->trigger();
break;
case DETECTION_MODE_ID:
+ aMode = DetectionMode;
if (myActionMap[ADDITION_MODE_ID]->isChecked())
myActionMap[ADDITION_MODE_ID]->trigger();
else if (myActionMap[MODIFICATION_MODE_ID]->isChecked())
break;
}
}
- onSelectionChanged();
-}
-
-void CurveCreator_Widget::onAddNewPoint(const CurveCreator::Coordinates& theCoords)
-{
- if( !myEdit )
- return;
-// CurveCreator::Coordinates aCoords = myNewPointEditor->getCoordinates();
- myEdit->insertPoints(theCoords, mySection, myPointNum );
- mySectionView->pointsAdded( mySection, myPointNum );
-// myNewPointEditor->clear();
- myPointNum++;
- onSelectionChanged();
+ updateActionsStates();
updateUndoRedo();
+ setLocalPointContext( aMode == ModificationMode, true );
}
void CurveCreator_Widget::onNewSection()
{
- if( !myEdit )
+ if( !myCurve )
return;
+
+ stopActionMode();
myNewSectionEditor->clear();
myNewSectionEditor->setEditMode(false);
- QString aSectName = QString( myCurve->getUnicSectionName().c_str() );
+ QString aSectName = QString( CurveCreator_UtilsICurve::getUniqSectionName( myCurve ).c_str() );
myNewSectionEditor->setSectionParameters(aSectName, true, CurveCreator::Polyline );
- emit subOperationStarted( myNewSectionEditor );
+ emit subOperationStarted( myNewSectionEditor, false );
}
void CurveCreator_Widget::onAddNewSection()
{
- if( !myEdit )
+ if( !myCurve )
return;
- CurveCreator::Coordinates aCoords;
- myEdit->addSection( myNewSectionEditor->getName().toStdString(), myNewSectionEditor->getSectionType(),
- myNewSectionEditor->isClosed(), aCoords );
- mySectionView->sectionAdded( mySection );
- QString aNewName = QString(myCurve->getUnicSectionName().c_str());
+ myCurve->addSection( myNewSectionEditor->getName().toStdString(),
+ myNewSectionEditor->getSectionType(),
+ myNewSectionEditor->isClosed() );
+ mySectionView->sectionAdded( -1 ); // add a new section to the end of list
+ QString aNewName = QString( CurveCreator_UtilsICurve::getUniqSectionName( myCurve ).c_str() );
myNewSectionEditor->setSectionName(aNewName);
- mySection++;
- onSelectionChanged();
+ updateActionsStates();
updateUndoRedo();
onCancelSection();
}
-void CurveCreator_Widget::onCancelPoint()
-{
- emit subOperationFinished( myNewPointEditor );
-}
-
void CurveCreator_Widget::onCancelSection()
{
emit subOperationFinished( myNewSectionEditor );
return anAct;
}
-QAction* CurveCreator_Widget::getAction(ActionId theId)
+QAction* CurveCreator_Widget::getAction( ActionId theId )
{
if( myActionMap.contains(theId) )
return myActionMap[theId];
return NULL;
}
+QAction* CurveCreator_Widget::getAction( ActionMode theMode )
+{
+ ActionId anActionId = NONE_ID;
+ switch ( theMode ) {
+ case AdditionMode:
+ anActionId = ADDITION_MODE_ID;
+ break;
+ case ModificationMode:
+ anActionId = MODIFICATION_MODE_ID;
+ break;
+ case DetectionMode:
+ anActionId = DETECTION_MODE_ID;
+ break;
+ default:
+ break;
+ }
+ QAction* anAction = 0;
+ if ( anActionId != NONE_ID && myActionMap.contains( anActionId ) )
+ anAction = myActionMap[anActionId];
+ return anAction;
+}
+
void CurveCreator_Widget::onEditSection( int theSection )
{
- if( !myEdit )
+ if( !myCurve )
return;
+
+ stopActionMode();
mySection = theSection;
QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
bool isClosed = myCurve->isClosed(theSection);
- CurveCreator::Type aType = myCurve->getType(theSection);
+ CurveCreator::SectionType aType = myCurve->getSectionType(theSection);
myNewSectionEditor->setEditMode(true);
myNewSectionEditor->setSectionParameters( aSectName, isClosed, aType );
- emit subOperationStarted( myNewSectionEditor );
+ emit subOperationStarted( myNewSectionEditor, true );
}
void CurveCreator_Widget::onModifySection()
{
- if( !myEdit )
+ if( !myCurve )
return;
QString aName = myNewSectionEditor->getName();
bool isClosed = myNewSectionEditor->isClosed();
- CurveCreator::Type aSectType = myNewSectionEditor->getSectionType();
- myEdit->startOperation();
- myEdit->setClosed( isClosed, mySection );
- myEdit->setName( aName.toStdString(), mySection );
- myEdit->setType( aSectType, mySection );
- myEdit->finishOperation();
- mySectionView->sectionChanged(mySection);
- updateUndoRedo();
- onCancelSection();
-}
+ CurveCreator::SectionType aSectType = myNewSectionEditor->getSectionType();
+ if( myCurve->getSectionName(mySection) != aName.toStdString() )
+ myCurve->setSectionName( mySection , aName.toStdString() );
-void CurveCreator_Widget::onEditPoint( int theSection, int thePoint )
-{
- if( !myNewPointEditor || !myEdit )
- return;
- mySection = theSection;
- myPointNum = thePoint;
- QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
- myNewPointEditor->setEditMode(true);
- myNewPointEditor->setSectionName(aSectName);
- myNewPointEditor->setDimension( myCurve->getDimension() );
- CurveCreator::Coordinates aCoords = myCurve->getCoordinates(theSection,thePoint);
- myNewPointEditor->setCoordinates(aCoords);
- emit subOperationStarted( myNewPointEditor );
-}
+ if( myCurve->getSectionType(mySection) != aSectType )
+ myCurve->setSectionType( mySection, aSectType );
-void CurveCreator_Widget::onModifyPoint()
-{
- if( !myEdit )
- return;
- CurveCreator::Coordinates aCoords = myNewPointEditor->getCoordinates();
- myEdit->setCoordinates( aCoords, mySection, myPointNum );
- mySectionView->pointDataChanged( mySection, myPointNum );
+ if( myCurve->isClosed(mySection) != isClosed )
+ myCurve->setClosed( mySection, isClosed );
+ mySectionView->sectionChanged(mySection);
updateUndoRedo();
- onCancelPoint();
+ onCancelSection();
}
void CurveCreator_Widget::onJoin()
{
- if( !myEdit )
+ if( !myCurve )
return;
QList<int> aSections = mySectionView->getSelectedSections();
if( aSections.size() == 0 ){
return;
}
- int aMainSect = aSections[0];
- int aMainSectSize = myCurve->getNbPoints(aMainSect);
- myEdit->startOperation();
- for( int i = 1 ; i < aSections.size() ; i++ ){
- int aSectNum = aSections[i] - (i-1);
- myEdit->join( aMainSect, aSectNum );
- mySectionView->sectionsRemoved( aSectNum );
+ stopActionMode();
+
+ std::list<int> aSectionsToJoin;
+ for( int i = 0; i < aSections.size() ; i++ ){
+ aSectionsToJoin.push_back( aSections[i] );
+ }
+ //int aMainSect = aSectionsToJoin.front();
+ //int aMainSectSize = myCurve->getNbPoints(aMainSect);
+ if ( myCurve->join( aSectionsToJoin ) )
+ {
+ std::list<int>::const_iterator anIt = aSectionsToJoin.begin(),
+ aLast = aSectionsToJoin.end();
+ // the first section should be skipped. It is not removed, but is modified
+ anIt++;
+ for ( ; anIt != aLast; anIt++ )
+ mySectionView->sectionsRemoved( *anIt );
}
- myEdit->finishOperation();
+
+ /* The update for the points of the main section
int aNewSectSize = myCurve->getNbPoints(aMainSect);
if( aNewSectSize != aMainSectSize )
- mySectionView->pointsAdded( aMainSect, aMainSectSize, aNewSectSize-aMainSectSize );
+ mySectionView->pointsAdded( aMainSect, aMainSectSize, aNewSectSize-aMainSectSize );*/
updateUndoRedo();
}
void CurveCreator_Widget::onRemove()
{
- if( !myEdit )
+ if( !myCurve )
return;
- QList< QPair<int,int> > aSelPoints = mySectionView->getSelectedPoints();
- int aCurrSect=-1;
- int aRemoveCnt = 0;
- myEdit->startOperation();
- for( int i = 0 ; i < aSelPoints.size() ; i++ ){
- if( aCurrSect != aSelPoints[i].first ){
- aRemoveCnt = 0;
- aCurrSect = aSelPoints[i].first;
- }
- int aPntIndx = aSelPoints[i].second - aRemoveCnt;
- myEdit->removePoints(aCurrSect,aPntIndx, 1);
- mySectionView->pointsRemoved( aCurrSect, aPntIndx );
- aRemoveCnt++;
- }
- QList<int> aSections = mySectionView->getSelectedSections();
- for( int i = 0 ; i < aSections.size() ; i++ ){
- int aSectNum = aSections[i] - (i);
- myEdit->removeSection( aSectNum );
- mySectionView->sectionsRemoved( aSectNum );
- }
- myEdit->finishOperation();
- mySectionView->clearSelection();
- updateUndoRedo();
-}
-void CurveCreator_Widget::onMoveUp()
-{
- if( !myEdit )
- return;
- if( mySectionView->getSelectionType() == CurveCreator_TreeView::ST_SECTIONS ){
- //Move sections
- QList<int> aSections = mySectionView->getSelectedSections();
- for( int i = 0 ; i < aSections.size() ; i++ ){
- int anIndx = aSections[i];
- myEdit->moveSection( anIndx, anIndx-1);
- mySectionView->sectionsSwapped( anIndx, -1 );
- }
- }
- else{
- //Move points
- QList< QPair<int,int> > aPoints = mySectionView->getSelectedPoints();
- for( int i = 0 ; i < aPoints.size() ; i++ ){
- int aSection = aPoints[i].first;
- int aPoint = aPoints[i].second;
- myEdit->movePoint(aSection, aPoint, aPoint-2);
- mySectionView->pointsSwapped( aSection, aPoint, -1 );
- }
- }
- updateUndoRedo();
-}
-
-void CurveCreator_Widget::onMoveDown()
-{
- if( !myEdit )
- return;
- if( mySectionView->getSelectionType() == CurveCreator_TreeView::ST_SECTIONS ){
- //Move sections
- QList<int> aSections = mySectionView->getSelectedSections();
- for( int i = aSections.size()-1 ; i >=0 ; i-- ){
- int anIndx = aSections[i];
- myEdit->moveSection( anIndx, anIndx+1);
- mySectionView->sectionsSwapped( anIndx, 1 );
- }
- }
- else{
- //Move points
- QList< QPair<int,int> > aPoints = mySectionView->getSelectedPoints();
- for( int i = aPoints.size() - 1; i >= 0 ; i-- ){
- int aSection = aPoints[i].first;
- int aPoint = aPoints[i].second;
- myEdit->movePoint(aSection, aPoint, aPoint+1);
- mySectionView->pointsSwapped( aSection, aPoint, 1 );
- }
+ switch( getActionMode() ) {
+ case NoneMode:
+ removeSection();
+ break;
+ case ModificationMode:
+ removePoint();
+ break;
+ default:
+ break;
}
- updateUndoRedo();
}
void CurveCreator_Widget::onClearAll()
{
- if( !myEdit )
+ if( !myCurve )
return;
- myEdit->clear();
+ stopActionMode();
+ myCurve->clear();
mySectionView->reset();
- onSelectionChanged();
+ updateActionsStates();
updateUndoRedo();
}
void CurveCreator_Widget::onJoinAll()
{
- if( !myEdit )
+ if( !myCurve )
return;
- myEdit->join();
- mySectionView->reset();
- onSelectionChanged();
- updateUndoRedo();
-}
-
-void CurveCreator_Widget::onInsertSectionBefore()
-{
+ stopActionMode();
-}
-
-void CurveCreator_Widget::onInsertSectionAfter()
-{
-
-}
-
-void CurveCreator_Widget::onInsertPointBefore()
-{
-
-}
-
-void CurveCreator_Widget::onInsertPointAfter()
-{
+ std::list<int> aSectionsToJoin;
+ for( int i = 0, aNb = myCurve->getNbSections(); i < aNb ; i++ ){
+ aSectionsToJoin.push_back( i );
+ }
+ bool aRes = myCurve->join( aSectionsToJoin );
+ mySectionView->reset();
+ updateActionsStates();
+ updateUndoRedo();
}
void CurveCreator_Widget::onUndoSettings()
void CurveCreator_Widget::onSetSpline()
{
- if( !myEdit )
+ if( !myCurve )
return;
+ stopActionMode();
QList<int> aSelSections = mySectionView->getSelectedSections();
- myEdit->startOperation();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
- myEdit->setType(CurveCreator::BSpline, aSelSections[i]);
+ myCurve->setSectionType(aSelSections[i], CurveCreator::Spline );
mySectionView->sectionChanged(aSelSections[i]);
}
- myEdit->finishOperation();
updateUndoRedo();
}
void CurveCreator_Widget::onSetPolyline()
{
- if( !myEdit )
+ if( !myCurve )
return;
- myEdit->startOperation();
+ stopActionMode();
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
- myEdit->setType(CurveCreator::Polyline, aSelSections[i]);
- mySectionView->sectionChanged(aSelSections[i]);
+ myCurve->setSectionType( aSelSections[i], CurveCreator::Polyline );
+ mySectionView->sectionChanged( aSelSections[i] );
}
- myEdit->finishOperation();
updateUndoRedo();
}
void CurveCreator_Widget::onCloseSections()
{
- if( !myEdit )
+ if( !myCurve )
return;
- myEdit->startOperation();
+ stopActionMode();
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
- myEdit->setClosed(true, aSelSections[i]);
+ myCurve->setClosed(aSelSections[i], true);
mySectionView->sectionChanged(aSelSections[i]);
}
- myEdit->finishOperation();
updateUndoRedo();
}
void CurveCreator_Widget::onUncloseSections()
{
- if( !myEdit )
+ if( !myCurve )
return;
- myEdit->startOperation();
+ stopActionMode();
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
- myEdit->setClosed(false, aSelSections[i]);
+ myCurve->setClosed(aSelSections[i], false);
mySectionView->sectionChanged(aSelSections[i]);
}
- myEdit->finishOperation();
updateUndoRedo();
}
void CurveCreator_Widget::onUndo()
{
- if( !myEdit )
+ if( !myCurve )
return;
- myEdit->undo();
+
+ CurveCreator_ICurve::SectionToPointList aPoints;
+ startCurveModification( aPoints, false );
+ myCurve->undo();
+ finishCurveModification();
mySectionView->reset();
- updateUndoRedo();
}
void CurveCreator_Widget::onRedo()
{
- if( !myEdit )
+ if( !myCurve )
return;
- myEdit->redo();
+ CurveCreator_ICurve::SectionToPointList aPoints;
+ startCurveModification( aPoints, false );
+ myCurve->redo();
+ finishCurveModification();
mySectionView->reset();
- updateUndoRedo();
}
void CurveCreator_Widget::updateUndoRedo()
{
- QAction* anAct = myActionMap[UNDO_ID];
- if( anAct != 0 ){
- if( myEdit->getNbUndo() != 0 ){
- anAct->setEnabled(true);
- }
- else{
- anAct->setDisabled(true);
- }
+ if( !myCurve )
+ return;
+ QAction* anAct = myActionMap[UNDO_ID];
+ if( anAct != 0 ){
+ if( myCurve->getNbUndo() != 0 ){
+ anAct->setEnabled(true);
}
- anAct = myActionMap[REDO_ID];
- if( anAct != 0 ){
- if( myEdit->getNbRedo() != 0 ){
- anAct->setEnabled(true);
- }
- else{
- anAct->setDisabled(true);
- }
+ else{
+ anAct->setDisabled(true);
+ }
+ }
+ anAct = myActionMap[REDO_ID];
+ if( anAct != 0 ){
+ if( myCurve->getNbRedo() != 0 ){
+ anAct->setEnabled(true);
+ }
+ else{
+ anAct->setDisabled(true);
}
+ }
}
void CurveCreator_Widget::onContextMenu( QPoint thePoint )
{
QList<ActionId> aContextActions;
- aContextActions << CLEAR_ALL_ID << JOIN_ALL_ID << SEPARATOR_ID <<
+ aContextActions << CLEAR_ALL_ID << JOIN_ID << JOIN_ALL_ID << SEPARATOR_ID <<
CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID <<
SET_SECTIONS_SPLINE_ID;
QPoint aGlPoint = mySectionView->mapToGlobal(thePoint);
return mySectionView->getSelectedSections();
}
-QList< QPair< int, int > > CurveCreator_Widget::getSelectedPoints()
+void CurveCreator_Widget::setSelectedSections( const QList<int>& theSections )
{
- return mySectionView->getSelectedPoints();
+ mySectionView->setSelectedSections( theSections );
+ updateActionsStates();
+ updateUndoRedo();
}
-bool CurveCreator_Widget::isInstantSketchingEnabled() const
+/**
+ * According to the widget state, performs the remove action
+ */
+void CurveCreator_Widget::removeSelected()
{
- if( myNewPointEditor )
- return myNewPointEditor->isInstantSketchingEnabled();
- return false;
+ onRemove();
}
-void CurveCreator_Widget::setInstantSketchingEnabled( const bool theState )
+/**
+ * Checks whether there are some selection to be removed
+ */
+bool CurveCreator_Widget::removeEnabled()
{
- if( myNewPointEditor )
- myNewPointEditor->setInstantSketchingEnabled( theState );
+ bool isEnabled = getActionMode() == ModificationMode;
+ if ( !isEnabled ) {
+ QList<int> aSelSections = mySectionView->getSelectedSections();
+ CurveCreator_TreeView::SelectionType aSelType = mySectionView->getSelectionType();
+ isEnabled = aSelType == CurveCreator_TreeView::ST_SECTIONS &&
+ aSelSections.size() == 1;
+ }
+ return isEnabled;
+}
+
+void CurveCreator_Widget::setActionMode( const ActionMode& theMode )
+{
+ ActionMode aPrevMode = getActionMode();
+ QAction* aPrevAction = getAction( aPrevMode );
+ QAction* anAction = getAction( theMode );
+ switch ( theMode ) {
+ case NoneMode:
+ case AdditionMode: {
+ if ( aPrevAction ) {
+ if ( aPrevAction->isChecked() ) {
+ aPrevAction->setChecked( false );
+ }
+ }
+ if ( aPrevMode == ModificationMode )
+ onModificationMode( false );
+ if ( aPrevMode == AdditionMode )
+ onAdditionMode( false );
+
+ if ( theMode == AdditionMode )
+ {
+ anAction->setChecked( true );
+ onModeChanged( true );
+ }
+ }
+ break;
+ break;
+ case ModificationMode:
+ {
+ //TODO
+ }
+ break;
+ case DetectionMode:
+ break;
+ }
+}
+
+CurveCreator_Widget::ActionMode CurveCreator_Widget::getActionMode() const
+{
+ ActionMode aMode = NoneMode;
+
+ if ( myActionMap[ADDITION_MODE_ID]->isChecked() )
+ aMode = AdditionMode;
+ else if ( myActionMap[MODIFICATION_MODE_ID]->isChecked() )
+ aMode = ModificationMode;
+ else if ( myActionMap[DETECTION_MODE_ID]->isChecked() )
+ aMode = DetectionMode;
+
+ return aMode;
}
//=================================================================================
-// function : GeometryGUI::onGetPointByClick()
+// function : GeometryGUI::addCoordsByClick()
// purpose : Manage mouse press events in Additon mode
//=================================================================================
-void CurveCreator_Widget::onGetPointByClick( SUIT_ViewWindow* theViewWindow, QMouseEvent* pe )
+void CurveCreator_Widget::addCoordsByClick( QMouseEvent* pe )
{
- if ( myNewPointEditor && theViewWindow->getViewManager()->getType() == OCCViewer_Viewer::Type() &&
- pe->modifiers() != Qt::ControlModifier ) {
- OCCViewer_Viewer* anOCCViewer =
- ( (OCCViewer_ViewManager*)( theViewWindow->getViewManager() ) )->getOCCViewer();
- Handle(AIS_InteractiveContext) ic = anOCCViewer->getAISContext();
+ if (pe->button() != Qt::LeftButton)
+ return;
+
+ if ( pe->modifiers() != Qt::ControlModifier ) {
+ Handle(AIS_InteractiveContext) ic = getAISContext();
+ if ( ic.IsNull() )
+ return;
gp_Pnt aPnt;
else
ic->Select(); // New selection
- /*TopoDS_Shape aShape;
-
- ic->InitSelected();
- if ( ic->MoreSelected() )
- aShape = ic->SelectedShape();
-
- if ( !aShape.IsNull() && aShape.ShapeType() == TopAbs_VERTEX )
- aPnt = BRep_Tool::Pnt( TopoDS::Vertex( ic->SelectedShape() ) );
- else*/
{
- OCCViewer_ViewPort3d* vp = ((OCCViewer_ViewWindow*)theViewWindow)->getViewPort();
- aPnt = GEOMUtils::ConvertClickToPoint( pe->x(), pe->y(), vp->getView() );
+ OCCViewer_ViewPort3d* vp = getViewPort();
+ aPnt = CurveCreator_Utils::ConvertClickToPoint( pe->x(), pe->y(), vp->getView() );
}
// set the coordinates into dialog
CurveCreator::Coordinates aCoords;
if ( myCurve->getDimension() == 3 ) {
aCoords.push_back( aPnt.Z() );
}
- onAddNewPoint(aCoords);
-// myNewPointEditor->setCoordinates( aCoords );
+ addNewPoint(aCoords);
}
}
-//=================================================================================
-// function : GeometryGUI::onPointDrag()
-// purpose : Manage mouse move events in Modification mode
-//=================================================================================
-void CurveCreator_Widget::onPointDrag( SUIT_ViewWindow* theViewWindow, QMouseEvent* pe )
+/**
+ * Manage mouse press events
+ * \param theWindow an owner of the signal
+ * \param theEvent a mouse event
+ */
+void CurveCreator_Widget::onMousePress( SUIT_ViewWindow*, QMouseEvent* theEvent )
{
- if ( !(pe->buttons() & Qt::LeftButton) )
+ if ( theEvent->button() != Qt::LeftButton )
return;
- if ( (pe->pos() - myDragStartPosition).manhattanLength() < QApplication::startDragDistance() )
+
+ myPressedX = theEvent->x();
+ myPressedY = theEvent->y();
+
+ switch( getActionMode() ) {
+ case ModificationMode: {
+ //store initial cursor position for Drag&Drop
+ setDragStarted( true, theEvent->pos() );
+ break;
+ }
+ case AdditionMode: {
+ addCoordsByClick( theEvent );
+ break;
+ }
+ default:
+ break;
+ }
+}
+
+/**
+ * Manage mouse release events in Modification mode
+ * \param theWindow an owner of the signal
+ * \param theEvent a mouse event
+ */
+void CurveCreator_Widget::onMouseRelease( SUIT_ViewWindow*, QMouseEvent* theEvent )
+{
+ if ( getActionMode() != ModificationMode )
return;
-/*
- QDrag *drag = new QDrag(this);
- QMimeData *mimeData = new QMimeData;
-
- mimeData->setData(mimeType, data);
- drag->setMimeData(mimeData);
-
- Qt::DropAction dropAction = drag->exec(Qt::CopyAction | Qt::MoveAction);
- */
+
+ if ( myDragStarted ) {
+ bool isDragged = myDragged;
+ CurveCreator_ICurve::SectionToPointList aDraggedPoints;
+ QMap<CurveCreator_ICurve::SectionToPoint, std::deque< float > > anInitialDragPointsCoords;
+ if ( myDragged ) {
+ aDraggedPoints = myDragPoints;
+ anInitialDragPointsCoords = myInitialDragPointsCoords;
+ }
+
+ setDragStarted( false );
+
+ if ( aDraggedPoints.size() > 0 ) {
+ // Collect old coordinates of the dragged points
+ CurveCreator_ICurve::SectionToPointCoordsList anOldPoints;
+ foreach ( const CurveCreator_ICurve::SectionToPoint aSectionToPoint, anInitialDragPointsCoords.keys() ) {
+ CurveCreator::Coordinates aCoords = anInitialDragPointsCoords.value( aSectionToPoint );
+ anOldPoints.push_back( std::make_pair( aSectionToPoint, aCoords ) );
+ }
+
+ if ( myCurve->canPointsBeSorted() ) {
+ // Add old coordinates of the curve points (except the dragged points) to the list
+ for( int aSectionId = 0 ; aSectionId < myCurve->getNbSections() ; aSectionId++ ) {
+ CurveCreator::Coordinates aCoords;
+ for ( int aPointId = 0, aNb = myCurve->getNbPoints( aSectionId ); aPointId < aNb; aPointId++ ) {
+ aCoords = myCurve->getPoint( aSectionId, aPointId );
+ if ( aCoords.size() < 2 ) {
+ continue;
+ }
+
+ CurveCreator_ICurve::SectionToPoint aSectionToPoint = std::make_pair( aSectionId, aPointId );
+
+ if ( !anInitialDragPointsCoords.contains( aSectionToPoint ) ) {
+ anOldPoints.push_back( std::make_pair( aSectionToPoint, aCoords ) );
+ }
+ }
+ }
+
+ // Apply points sorting
+ CurveCreator_ICurve::SectionToPointList aPoints;
+ startCurveModification( aPoints, false );
+
+ myCurve->setSkipSorting( false );
+
+ CurveCreator_ICurve::SectionToPointCoordsList aCoordList;
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = aDraggedPoints.begin(),
+ aLast = aDraggedPoints.end();
+ for ( ; anIt != aLast; anIt++ ) {
+ int aSectionId = anIt->first;
+ int aPointId = anIt->second;
+ std::deque<float> aPos = myCurve->getPoint( aSectionId, aPointId );
+
+ aCoordList.push_back(
+ std::make_pair( std::make_pair( aSectionId, aPointId ), aPos ) );
+ }
+
+ myCurve->setSeveralPoints( aCoordList, false );
+
+ finishCurveModification( aDraggedPoints );
+ } else {
+ // if the drag of some points has happened, restore the drag selection
+ START_MEASURE_TIME;
+ setSelectedPoints( aDraggedPoints );
+ END_MEASURE_TIME( "drop" );
+ }
+
+ // Save drag difference
+ myCurve->saveCoordDiff( anOldPoints );
+ }
+ }
+ else // check whether the segment is clicked an a new point should be added to the segment
+ {
+ int aReleasedX = theEvent->x();
+ int aReleasedY = theEvent->y();
+ if ( myPressedX == aReleasedX && myPressedY == aReleasedY )
+ insertPointToSelectedSegment( aReleasedX, aReleasedY );
+ }
+
+ // updates the input panel table to show the selected point coordinates
+ updateLocalPointView();
+ updateUndoRedo();
+}
+
+/**
+ * Manage mouse move events in Modification mode
+ * \param theWindow an owner of the signal
+ * \param theEvent a mouse event
+ */
+void CurveCreator_Widget::onMouseMove( SUIT_ViewWindow*, QMouseEvent* theEvent )
+{
+ if ( getActionMode() != ModificationMode || !myDragStarted )
+ return;
+
+ QPoint aPos = theEvent->pos();
+ if ( (aPos - myDragStartPosition).manhattanLength() < QApplication::startDragDistance() )
+ return;
+
+ START_MEASURE_TIME;
+
+ moveSelectedPoints( aPos.x(), aPos.y() );
+ myDragStartPosition = aPos;
+
+ END_MEASURE_TIME( "drag" );
+}
+
+/**
+ * Set zero viewer by the last view closed in
+ * \param theManager a viewer manager
+ */
+void CurveCreator_Widget::onLastViewClosed( SUIT_ViewManager* theManager )
+{
+ myOCCViewer = 0;
+}
+
+void CurveCreator_Widget::onMousePress( QMouseEvent* theEvent )
+{
+ onMousePress( 0, theEvent );
+}
+
+void CurveCreator_Widget::onMouseRelease( QMouseEvent* theEvent )
+{
+ onMouseRelease( 0, theEvent );
+}
+
+void CurveCreator_Widget::onMouseMove( QMouseEvent* theEvent )
+{
+ onMouseMove( 0, theEvent );
+}
+
+void CurveCreator_Widget::onCellChanged( int theRow, int theColumn )
+{
+ int aCurrSect = myLocalPointView->getSectionId( theRow );
+ int aPntIndex = myLocalPointView->getPointId( theRow );
+
+ if ( aPntIndex < 0 )
+ return;
+
+ CurveCreator_ICurve::SectionToPointList aSelPoints;
+ startCurveModification( aSelPoints );
+
+ double aX = myLocalPointView->item( theRow, 2 )->data( Qt::UserRole ).toDouble();
+ double anY = myLocalPointView->item( theRow, 3 )->data( Qt::UserRole ).toDouble();
+ std::deque<float> aChangedPos;
+ aChangedPos.push_back( aX );
+ aChangedPos.push_back( anY );
+ myCurve->setPoint( aCurrSect, aPntIndex, aChangedPos );
+
+ finishCurveModification( aSelPoints );
+}
+
+/**
+ * Removes a selected section from the curve. Updates undo/redo status
+ */
+void CurveCreator_Widget::removeSection()
+{
+ stopActionMode();
+
+ QList<int> aSections = mySectionView->getSelectedSections();
+ for( int i = 0 ; i < aSections.size() ; i++ ){
+ int aSectNum = aSections[i] - (i);
+ myCurve->removeSection( aSectNum );
+ mySectionView->sectionsRemoved( aSectNum );
+ }
+ mySectionView->clearSelection();
+ updateUndoRedo();
+}
+
+/**
+ * Removes a selected points from the curve. Updates undo/redo status
+ */
+void CurveCreator_Widget::removePoint()
+{
+ CurveCreator_ICurve::SectionToPointList aPoints;
+ getSelectedPoints( aPoints );
+ if ( aPoints.size() == 0 )
+ return;
+
+ CurveCreator_ICurve::SectionToPointList aSelPoints;
+ startCurveModification( aSelPoints, false );
+
+ myCurve->removeSeveralPoints( aPoints );
+ finishCurveModification( CurveCreator_ICurve::SectionToPointList() );
+}
+
+void CurveCreator_Widget::addNewPoint(const CurveCreator::Coordinates& theCoords)
+{
+ if( !myCurve )
+ return;
+ QList<int> aSections = mySectionView->getSelectedSections();
+ if( aSections.size() == 0 ){
+ return;
+ }
+ int aSection = aSections[0];
+ myCurve->addPoints(theCoords, aSection); // add to the end of section
+ mySectionView->pointsAdded( aSection, myCurve->getNbPoints( aSection ) );
+ updateActionsStates();
+ updateUndoRedo();
+}
+
+void CurveCreator_Widget::insertPointToSelectedSegment( const int theX,
+ const int theY )
+{
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+
+ OCCViewer_ViewPort3d* aViewPort = getViewPort();
+ Handle(V3d_View) aView;
+ if ( aViewPort )
+ aView = aViewPort->getView();
+
+ if ( aContext.IsNull() || aView.IsNull() )
+ return;
+ gp_Pnt aPoint;
+ gp_Pnt aPoint1, aPoint2;
+ Handle(AIS_InteractiveObject) anAISObject = myCurve->getAISObject();
+ bool isFoundPoint = CurveCreator_Utils::pointOnObject( aView, anAISObject, theX, theY,
+ aPoint, aPoint1, aPoint2 );
+ if ( !isFoundPoint )
+ return;
+
+ // insert the point to the model curve
+ CurveCreator_ICurve::SectionToPointList aSelPoints;
+ startCurveModification( aSelPoints );
+
+ CurveCreator::Coordinates aCoords;
+ aCoords.push_back( aPoint.X() );
+ aCoords.push_back( aPoint.Y() );
+
+ CurveCreator_ICurve::SectionToPointList aPoints1, aPoints2;
+ findSectionsToPoints( aPoint1.X(), aPoint1.Y(), aPoints1 );
+ findSectionsToPoints( aPoint2.X(), aPoint2.Y(), aPoints2 );
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = aPoints1.begin(),
+ aLast = aPoints1.end();
+ int aSectionId = -1;
+ // find the indices of the neighbour point
+ // there can be a case when a new point is added into two sections
+ int aPoint1Id = -1, aPoint2Id = -1;
+ for ( ; anIt != aLast && aSectionId < 0; anIt++ ) {
+ int aSectionCur = anIt->first;
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt2 = aPoints2.begin(),
+ aLast2 = aPoints2.end();
+ for ( ; anIt2 != aLast2 && aSectionId < 0; anIt2++ ) {
+ if ( anIt2->first == aSectionCur ) {
+ aSectionId = aSectionCur;
+ aPoint1Id = anIt->second;
+ aPoint2Id = anIt2->second;
+ }
+ }
+ }
+
+ int anInsertPos = -1;
+ int aLastPoint = myCurve->getNbPoints( aSectionId )-1;
+ if ( ( aPoint1Id == aLastPoint && aPoint2Id == 0 ) ||
+ ( aPoint2Id == aLastPoint && aPoint1Id == 0 ) )
+ anInsertPos = -1; // if the section happens between first and last points
+ else
+ anInsertPos = aPoint1Id < aPoint2Id ? aPoint1Id + 1 : aPoint2Id + 1;
+
+ myCurve->addPoints( aCoords, aSectionId, anInsertPos );
+ mySectionView->pointsAdded( aSectionId, myCurve->getNbPoints( aSectionId ) );
+
+ finishCurveModification( aSelPoints );
+
+ setSelectedPoints();
+}
+
+void CurveCreator_Widget::moveSelectedPoints( const int theXPosition,
+ const int theYPosition )
+{
+ OCCViewer_ViewPort3d* aViewPort = getViewPort();
+ if ( !aViewPort )
+ return;
+
+ CurveCreator_ICurve::SectionToPointList aPoints;
+ startCurveModification( aPoints, false );
+
+ gp_Pnt aStartPnt = CurveCreator_Utils::ConvertClickToPoint( myDragStartPosition.x(),
+ myDragStartPosition.y(),
+ aViewPort->getView() );
+ gp_Pnt anEndPnt = CurveCreator_Utils::ConvertClickToPoint( theXPosition, theYPosition,
+ aViewPort->getView() );
+ double aXDelta = aStartPnt.X() - anEndPnt.X();
+ double anYDelta = aStartPnt.Y() - anEndPnt.Y();
+
+ CurveCreator_ICurve::SectionToPointCoordsList aCoordList;
+ std::deque<float> aChangedPos;
+ CurveCreator_ICurve::SectionToPointList::const_iterator anIt = myDragPoints.begin(),
+ aLast = myDragPoints.end();
+ for ( ; anIt != aLast; anIt++ ) {
+ int aSectionId = anIt->first;
+ int aPointId = anIt->second;
+ aChangedPos = myCurve->getPoint( aSectionId, aPointId );
+ if ( aChangedPos.size() < 2 )
+ continue;
+
+ // Remember drag points coordinates
+ if ( !myDragged ) {
+ myInitialDragPointsCoords.insert( std::make_pair( aSectionId, aPointId ), aChangedPos );
+ }
+
+ aChangedPos[0] = aChangedPos[0] - aXDelta;
+ aChangedPos[1] = aChangedPos[1] - anYDelta;
+
+ aCoordList.push_back(
+ std::make_pair(std::make_pair( aSectionId, aPointId ),
+ aChangedPos ));
+ }
+ myCurve->setSeveralPoints( aCoordList, false );
+
+ myDragged = true;
+ finishCurveModification( myDragPoints );
+}
+
+void CurveCreator_Widget::updateLocalPointView()
+{
+ if ( myDragStarted )
+ return;
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+ if ( aContext.IsNull() )
+ return;
+
+ CurveCreator_Utils::getSelectedPoints( aContext, myCurve, myLocalPoints );
+ int aNbPoints = myLocalPoints.size();
+
+ bool isRowLimit = aNbPoints > myLocalPointRowLimit;
+ myLocalPointView->setVisible( getActionMode() == ModificationMode && !isRowLimit );
+
+ if ( !isRowLimit ) {
+ bool isBlocked = myLocalPointView->blockSignals(true);
+
+ myLocalPointView->setLocalPointsToTable( myLocalPoints );
+
+ myLocalPointView->blockSignals( isBlocked );
+ }
+}
+
+/**
+ *
+ */
+void CurveCreator_Widget::setLocalPointContext( const bool theOpen, const bool isUpdateTable )
+{
+ CurveCreator_Utils::setLocalPointContext( myCurve, getAISContext(), theOpen );
+ if ( !theOpen && isUpdateTable )
+ updateLocalPointView();
+}
+
+/**
+ * Set drag operation started. Save the position and a list of dragged points
+ * \param theState the drag operation state: started/finished
+ * \param thePoint the start drag position
+ */
+void CurveCreator_Widget::setDragStarted( const bool theState, const QPoint& thePoint )
+{
+ if ( theState ) {
+ getSelectedPoints( myDragPoints );
+
+ myDragStarted = myDragPoints.size();
+ myDragStartPosition = thePoint;
+ if ( myDragStarted ) {
+ // change a viewer interaction style in order to avoid a select rectangle build
+ myDragInteractionStyle = changeInteractionStyle( SUIT_ViewModel::KEY_FREE );
+ myCurve->setSkipSorting( true );
+ }
+ }
+ else {
+ if ( myDragStarted )
+ changeInteractionStyle( myDragInteractionStyle );
+ myDragStarted = false;
+ myDragPoints.clear();
+ myInitialDragPointsCoords.clear();
+ }
+ myDragged = false;
+}
+
+void CurveCreator_Widget::getSelectedPoints( CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ thePoints.clear();
+ thePoints = myLocalPoints;
+}
+
+void CurveCreator_Widget::setSelectedPoints( const CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ if ( myDragStarted )
+ return;
+ Handle(AIS_InteractiveContext) aContext = getAISContext();
+ if ( aContext.IsNull() || !aContext->HasOpenedContext() )
+ return;
+
+ CurveCreator_Utils::setSelectedPoints( aContext, myCurve, thePoints );
+
+ updateLocalPointView();
+}
+
+void CurveCreator_Widget::stopActionMode()
+{
+ setActionMode( NoneMode );
+}
+
+/**
+ * Get viewer information before perform the curve modification.
+ * Take a list of selected cuve points an close local context.
+ * The context should be closed because the curve presentation is
+ * redisplayed and if it is not closed, when we close the local context
+ * later, the presentation shown in the local context is disappeared.
+ * \param thePoints an output list of curve selected points
+ * \param theFillPoints a flag whether the selection list should be filled
+ */
+void CurveCreator_Widget::startCurveModification(
+ CurveCreator_ICurve::SectionToPointList& thePoints,
+ const bool theFillPoints )
+{
+ if ( theFillPoints ) {
+ thePoints.clear();
+ getSelectedPoints( thePoints );
+ }
+ setLocalPointContext( false );
+}
+
+/**
+ * Restore the viewer state after the curve modification is done.
+ * Open local context and select given points inside it.
+ * \param thePoints a list of curve selected points
+ */
+void CurveCreator_Widget::finishCurveModification(
+ const CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ if ( getActionMode() == ModificationMode )
+ setLocalPointContext( true );
+ setSelectedPoints( thePoints );
+ updateUndoRedo();
+}
+
+/**
+ * Returns a point index in the model curve by the point coordinates in the viewer
+ * \param theX the X coordinate of the point
+ * \param theY the Y coordinate of the point
+ */
+int CurveCreator_Widget::findLocalPointIndex( int theSectionId, float theX, float theY )
+{
+ return CurveCreator_UtilsICurve::findLocalPointIndex( myCurve, theSectionId, theX, theY );
+}
+
+void CurveCreator_Widget::findSectionsToPoints( const double theX, const double theY,
+ CurveCreator_ICurve::SectionToPointList& thePoints )
+{
+ return CurveCreator_UtilsICurve::findSectionsToPoints( myCurve, theX, theY, thePoints );
+}
+
+void CurveCreator_Widget::convert( const CurveCreator_ICurve::SectionToPointList& thePoints,
+ QMap<int, QList<int> >& theConvPoints )
+{
+ return CurveCreator_UtilsICurve::convert( thePoints, theConvPoints );
+}
+
+/**
+ * Returns whethe the container has the value
+ * \param theList a container of values
+ * \param theValue a value
+ */
+bool CurveCreator_Widget::contains( const CurveCreator_ICurve::SectionToPointList& theList,
+ const CurveCreator_ICurve::SectionToPoint& theValue ) const
+{
+ return CurveCreator_UtilsICurve::contains( theList, theValue );
}
-// Copyright (C) 2013-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
-// version 2.1 of the License, or (at your option) any later version.
+// version 2.1 of the License.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
#ifndef CURVECREATOR_WIDGET_H
#define CURVECREATOR_WIDGET_H
-#include "CurveCreator_Curve.hxx"
+#include "CurveCreator_Macro.hxx"
#include "CurveCreator.hxx"
+#include "CurveCreator_ICurve.hxx"
#include <QWidget>
#include <QMap>
#include <SUIT_ViewWindow.h>
+#include <AIS_InteractiveObject.hxx>
+#include <AIS_InteractiveContext.hxx>
+
+#include <Geom_Curve.hxx>
+#include <V3d_View.hxx>
+#include <gp_Pnt.hxx>
+#include <TopoDS_Vertex.hxx> // TODO - remove
+
+class OCCViewer_Viewer;
+class OCCViewer_ViewPort3d;
+
+class AIS_ListOfInteractive;
class QAction;
class QPixmap;
-class CurveCreator_CurveEditor;
+class CurveCreator_TableView;
class CurveCreator_TreeView;
class CurveCreator_NewPointDlg;
class CurveCreator_NewSectionDlg;
class CURVECREATOR_EXPORT CurveCreator_Widget : public QWidget
{
- Q_OBJECT
+ Q_OBJECT
+
+public:
+ enum ActionFlags {
+ NoFlags = 0x00000000,
+ DisableDetectionMode = 0x00000001,
+ DisableNewSection = 0x00000002,
+ DisableClosedSection = 0x00000004
+ };
+
+ enum ActionMode {
+ NoneMode,
+ AdditionMode,
+ ModificationMode,
+ DetectionMode
+ };
+
public:
- explicit CurveCreator_Widget( QWidget* parent,
- CurveCreator_Curve *theCurve,
- Qt::WindowFlags fl=0 );
+ explicit CurveCreator_Widget( QWidget* parent,
+ CurveCreator_ICurve *theCurve,
+ const int theActionFlags = NoFlags,
+ const QStringList& theCoordTitles = QStringList(),
+ Qt::WindowFlags fl=0,
+ int theLocalPointRowLimit = 20);
- void setCurve( CurveCreator_Curve* theCurve );
+ // OCC viewer manipulation
+ void setOCCViewer( OCCViewer_Viewer* theViewer );
- QList<int> getSelectedSections();
- QList< QPair< int, int > > getSelectedPoints();
+ Handle(AIS_InteractiveContext) getAISContext();
+ OCCViewer_ViewPort3d* getViewPort();
+ int changeInteractionStyle( int theStyle );
- bool isInstantSketchingEnabled() const;
- void setInstantSketchingEnabled( const bool theState );
+ void reset();
+ void setCurve( CurveCreator_ICurve* theCurve );
+
+ QList<int> getSelectedSections();
+ void setSelectedSections( const QList<int>& theSections );
+
+ void removeSelected();
+ bool removeEnabled();
+
+ void setActionMode( const ActionMode& theMode );
+ ActionMode getActionMode() const;
signals:
- void selectionChanged();
- void subOperationStarted( QWidget* );
- void subOperationFinished( QWidget* );
+ void selectionChanged();
+ void subOperationStarted( QWidget*, bool );
+ void subOperationFinished( QWidget* );
public slots:
protected slots:
- void onAdditionMode(bool checked);
- void onModificationMode(bool checked);
- void onDetectPoints(bool checked);
- void onModeChanged(bool checked);
- void onNewSection();
- void onSelectionChanged();
- void onAddNewPoint(const CurveCreator::Coordinates& theCoords);
- void onAddNewSection();
- void onEditSection( int theSection );
- void onEditPoint( int theSection, int thePoint );
- void onModifyPoint();
- void onModifySection();
- void onCancelPoint();
- void onCancelSection();
- void onJoin();
- void onRemove();
- void onMoveUp();
- void onMoveDown();
- void onClearAll();
- void onJoinAll();
- void onInsertSectionBefore();
- void onInsertSectionAfter();
- void onSetSpline();
- void onSetPolyline();
- void onCloseSections();
- void onUncloseSections();
- void onInsertPointBefore();
- void onInsertPointAfter();
- void onUndo();
- void onRedo();
- void onUndoSettings();
- void onContextMenu(QPoint thePoint);
- void onGetPointByClick( SUIT_ViewWindow*, QMouseEvent* );
-// void onPointSelect( SUIT_ViewWindow*, QMouseEvent* );
- void onPointDrag( SUIT_ViewWindow*, QMouseEvent* );
+ void onAdditionMode(bool checked);
+ void onModificationMode(bool checked);
+ void onDetectionMode(bool checked);
+ void onModeChanged(bool checked);
+ void onNewSection();
+ void onSelectionChanged();
+ void onAddNewSection();
+ void onEditSection( int theSection );
+ void onModifySection();
+ void onCancelSection();
+ void onJoin();
+ void onRemove();
+ void onClearAll();
+ void onJoinAll();
+ void onSetSpline();
+ void onSetPolyline();
+ void onCloseSections();
+ void onUncloseSections();
+ void onUndo();
+ void onRedo();
+ void onUndoSettings();
+ void onContextMenu(QPoint thePoint);
+
+ void onMousePress( SUIT_ViewWindow*, QMouseEvent* theEvent );
+ void onMouseRelease( SUIT_ViewWindow*, QMouseEvent* theEvent );
+ void onMouseMove( SUIT_ViewWindow*, QMouseEvent* theEvent );
+ void onLastViewClosed( SUIT_ViewManager* theManager );
+
+ void onMousePress( QMouseEvent* theEvent );
+ void onMouseRelease( QMouseEvent* theEvent );
+ void onMouseMove( QMouseEvent* theEvent );
+
+ void onCellChanged( int theRow, int theColumn );
+
protected:
- enum ActionId{ UNDO_ID, REDO_ID, NEW_SECTION_ID, ADDITION_MODE_ID, REMOVE_ID, REMOVE_ALL_ID, JOIN_ID,
- JOIN_ALL_ID, UP_ID, DOWN_ID, INSERT_SECTION_BEFORE_ID, INSERT_SECTION_AFTER_ID,
- INSERT_POINT_BEFORE_ID, INSERT_POINT_AFTER_ID, CLOSE_SECTIONS_ID, UNCLOSE_SECTIONS_ID,
- SET_SECTIONS_POLYLINE_ID, SET_SECTIONS_SPLINE_ID, CLEAR_ALL_ID, SEPARATOR_ID,
- MODIFICATION_MODE_ID, DETECTION_MODE_ID };
+ void addCoordsByClick( QMouseEvent* );
+
+protected:
+ enum ActionId{ NONE_ID,
+ UNDO_ID,
+ REDO_ID,
+ NEW_SECTION_ID,
+ ADDITION_MODE_ID,
+ REMOVE_ID,
+ REMOVE_ALL_ID,
+ JOIN_ID,
+ JOIN_ALL_ID,
+ CLOSE_SECTIONS_ID,
+ UNCLOSE_SECTIONS_ID,
+ SET_SECTIONS_POLYLINE_ID,
+ SET_SECTIONS_SPLINE_ID,
+ CLEAR_ALL_ID,
+ SEPARATOR_ID,
+ MODIFICATION_MODE_ID,
+ DETECTION_MODE_ID
+ };
+
private:
- QAction* createAction( ActionId theId, const QString& theName, const QPixmap& theImage,
- const QString& theToolTip, const QKeySequence& theShortcut );
- QAction* getAction(ActionId theId);
- void updateUndoRedo();
+ OCCViewer_Viewer* getOCCViewer();
+
+ QAction* createAction( ActionId theId, const QString& theName, const QPixmap& theImage,
+ const QString& theToolTip, const QKeySequence& theShortcut );
+ QAction* getAction(ActionId theId);
+ QAction* getAction(ActionMode theMode);
+
+ void updateActionsStates();
+ void updateUndoRedo();
+
+ void removeSection();
+ void removePoint();
+ void addNewPoint(const CurveCreator::Coordinates& theCoords);
+ void insertPointToSelectedSegment( const int theXPosition,
+ const int theYPosition );
+ void moveSelectedPoints( const int theXPosition, const int theYPosition );
+ void updateLocalPointView();
+ void setLocalPointContext( const bool theOpen, const bool isUpdateTable = false );
+
+ void setDragStarted( const bool theState, const QPoint& thePoint = QPoint() );
+
+ void getSelectedPoints( CurveCreator_ICurve::SectionToPointList& thePoints );
+ void setSelectedPoints( const CurveCreator_ICurve::SectionToPointList& =
+ CurveCreator_ICurve::SectionToPointList() );
+
+ void stopActionMode();
+
+ void startCurveModification( CurveCreator_ICurve::SectionToPointList& thePoints,
+ const bool theFillPoints = true );
+ void finishCurveModification( const CurveCreator_ICurve::SectionToPointList& thePoints =
+ CurveCreator_ICurve::SectionToPointList() );
+
+ // curve algorithm
+ int findLocalPointIndex( int theSectionId, float theX, float theY );
+ void findSectionsToPoints( const double theX, const double theY,
+ CurveCreator_ICurve::SectionToPointList& thePoints );
+ void convert( const CurveCreator_ICurve::SectionToPointList& thePoints,
+ QMap<int, QList<int> >& theConvPoints );
+
+ bool contains( const CurveCreator_ICurve::SectionToPointList& theList,
+ const CurveCreator_ICurve::SectionToPoint& theValue ) const;
+
private:
- QMap<ActionId, QAction*> myActionMap;
- CurveCreator_Curve* myCurve;
- CurveCreator_CurveEditor* myEdit;
- CurveCreator_TreeView* mySectionView;
- CurveCreator_NewPointDlg* myNewPointEditor;
- CurveCreator_NewSectionDlg* myNewSectionEditor;
- int mySection;
- int myPointNum;
- QPoint myDragStartPosition;
+ QMap<ActionId, QAction*> myActionMap;
+ CurveCreator_ICurve* myCurve;
+ CurveCreator_TreeView* mySectionView;
+ CurveCreator_TableView* myLocalPointView;
+ CurveCreator_ICurve::SectionToPointList myLocalPoints;
+ CurveCreator_NewSectionDlg* myNewSectionEditor;
+ OCCViewer_Viewer* myOCCViewer;
+ int myLocalPointRowLimit;
+ int mySection;
+ int myPointNum;
+ bool myDragStarted;
+ QPoint myDragStartPosition;
+ int myDragInteractionStyle;
+ CurveCreator_ICurve::SectionToPointList myDragPoints;
+ QMap<CurveCreator_ICurve::SectionToPoint, CurveCreator::Coordinates> myInitialDragPointsCoords;
+ bool myDragged;
+ QByteArray myGuiState;
+ int myPressedX;
+ int myPressedY;
};
#endif // CURVECREATOR_WIDGET_H
${PROJECT_SOURCE_DIR}/src/GEOMGUI
${PROJECT_SOURCE_DIR}/src/GEOMBase
${PROJECT_SOURCE_DIR}/src/SKETCHER
+ ${PROJECT_SOURCE_DIR}/src/CurveCreator
${PROJECT_SOURCE_DIR}/src/ShapeRecognition
${PROJECT_SOURCE_DIR}/src/DlgRef
${PROJECT_BINARY_DIR}/src/DlgRef
GEOM
DlgRef
GEOMSketcher
+ CurveCreator
)
# optional sources
EntityGUI.h
EntityGUI_Widgets.h
EntityGUI_SketcherDlg.h
+ EntityGUI_PolylineDlg.h
EntityGUI_3DSketcherDlg.h
EntityGUI_IsolineDlg.h
EntityGUI_SubShapeDlg.h
EntityGUI_Widgets.h
EntityGUI_FieldDlg.h
EntityGUI_SketcherDlg.h
+ EntityGUI_PolylineDlg.h
EntityGUI_3DSketcherDlg.h
EntityGUI_IsolineDlg.h
EntityGUI_SubShapeDlg.h
EntityGUI_Widgets.cxx
EntityGUI_FieldDlg.cxx
EntityGUI_SketcherDlg.cxx
+ EntityGUI_PolylineDlg.cxx
EntityGUI_3DSketcherDlg.cxx
EntityGUI_IsolineDlg.cxx
EntityGUI_SubShapeDlg.cxx
#include "EntityGUI_FeatureDetectorDlg.h" // Feature Detection
#include "EntityGUI_PictureImportDlg.h" // Import Picture in viewer
#include "EntityGUI_FieldDlg.h" // Create/Edit Field
+#include "EntityGUI_PolylineDlg.h" // Create/Edit 2d polyline
#include "GEOMImpl_Types.hxx"
SUIT_MessageBox::warning(parent, tr("WRN_WARNING"), tr("NO_FIELD"));
break;
}
+ case GEOMOp::Op2dPolylineEditor: // POLYLINE EDITOR
+ getGeometryGUI()->ActiveWorkingPlane();
+ aDlg = new EntityGUI_PolylineDlg( getGeometryGUI(), parent );
+ break;
default:
app->putInfo( tr( "GEOM_PRP_COMMAND" ).arg( theCommandID ) );
break;
--- /dev/null
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#include "EntityGUI_PolylineDlg.h"
+#include <CurveCreator_Curve.hxx>
+#include <CurveCreator_Widget.h>
+#include <DlgRef.h>
+#include <GeometryGUI.h>
+
+#include <OCCViewer_ViewManager.h>
+#include <SalomeApp_Application.h>
+#include <SUIT_ResourceMgr.h>
+#include <SUIT_Session.h>
+
+#include <QGroupBox>
+#include <QVBoxLayout>
+
+
+//=================================================================================
+// function : Constructor
+// purpose :
+//=================================================================================
+EntityGUI_PolylineDlg::EntityGUI_PolylineDlg
+ (GeometryGUI* theGeometryGUI, QWidget* parent, bool modal, Qt::WindowFlags fl)
+ : GEOMBase_Skeleton( theGeometryGUI, parent, modal, fl )
+{
+ QPixmap image0( SUIT_Session::session()->resourceMgr()->loadPixmap( "GEOM", tr( "ICON_DLG_VECTOR_2P" ) ) );
+
+ /***************************************************************/
+ mainFrame()->GroupConstructors->setTitle(tr("GEOM_VECTOR"));
+ mainFrame()->RadioButton1->setIcon(image0);
+ mainFrame()->RadioButton2->setAttribute( Qt::WA_DeleteOnClose );
+ mainFrame()->RadioButton2->close();
+ mainFrame()->RadioButton3->setAttribute( Qt::WA_DeleteOnClose );
+ mainFrame()->RadioButton3->close();
+
+ myCurve = new CurveCreator_Curve( CurveCreator::Dim2d );
+ myEditorWidget = new CurveCreator_Widget (centralWidget(), myCurve);
+ myAddElementBox = new QGroupBox (tr("ADD_ELEMENT"), centralWidget());
+
+ QBoxLayout* anAddElementLayout = new QVBoxLayout( myAddElementBox );
+
+ anAddElementLayout->setMargin( 0 );
+ anAddElementLayout->setSpacing( 6 );
+
+ QVBoxLayout* layout = new QVBoxLayout( centralWidget() );
+
+ layout->setMargin( 0 );
+ layout->setSpacing( 6 );
+ layout->addWidget( myEditorWidget );
+ layout->addWidget( myAddElementBox );
+
+ /***************************************************************/
+
+ setHelpFileName( "create_vector_page.html" );
+
+ /* Initialisations */
+ Init();
+}
+
+//=================================================================================
+// function : Destructor
+// purpose :
+//=================================================================================
+EntityGUI_PolylineDlg::~EntityGUI_PolylineDlg()
+{
+ delete myCurve;
+}
+
+//=================================================================================
+// function : Init()
+// purpose :
+//=================================================================================
+void EntityGUI_PolylineDlg::Init()
+{
+ SalomeApp_Application *anApp = myGeomGUI->getApp();
+ OCCViewer_ViewManager *aViewManager = dynamic_cast<OCCViewer_ViewManager*>
+ (anApp->getViewManager(OCCViewer_Viewer::Type(), true));
+
+ myEditorWidget->setOCCViewer( aViewManager ? aViewManager->getOCCViewer() : 0 );
+
+ connect(myEditorWidget, SIGNAL(subOperationStarted(QWidget*, bool)),
+ this, SLOT(processStartedSubOperation(QWidget*, bool)));
+ connect(myEditorWidget, SIGNAL(subOperationFinished(QWidget*)),
+ this, SLOT(processFinishedSubOperation(QWidget*)));
+
+ myAddElementBox->hide();
+}
+
+//=================================================================================
+// function : createOperation
+// purpose :
+//=================================================================================
+GEOM::GEOM_IOperations_ptr EntityGUI_PolylineDlg::createOperation()
+{
+ return getGeomEngine()->GetICurvesOperations( getStudyId() );
+}
+
+//=================================================================================
+// function : isValid
+// purpose :
+//=================================================================================
+bool EntityGUI_PolylineDlg::isValid( QString& msg )
+{
+ return true;
+}
+
+//=================================================================================
+// function : execute
+// purpose :
+//=================================================================================
+bool EntityGUI_PolylineDlg::execute( ObjectList& objects )
+{
+ return true;
+}
+
+void EntityGUI_PolylineDlg::processStartedSubOperation( QWidget* theWidget, bool theIsEdit )
+{
+ myEditorWidget->setEnabled( false );
+
+ myAddElementBox->setTitle( theIsEdit ? tr( "EDIT_ELEMENT" ) : tr( "ADD_ELEMENT" ) );
+ QBoxLayout* anAddElementLayout = dynamic_cast<QBoxLayout*>( myAddElementBox->layout() );
+ anAddElementLayout->addWidget( theWidget );
+
+ theWidget->show();
+ myAddElementBox->show();
+}
+
+void EntityGUI_PolylineDlg::processFinishedSubOperation( QWidget* theWidget )
+{
+ myEditorWidget->setEnabled( true );
+
+ QBoxLayout* anAddElementLayout = dynamic_cast<QBoxLayout*>( myAddElementBox->layout() );
+ anAddElementLayout->removeWidget( theWidget );
+
+ theWidget->hide();
+ myAddElementBox->hide();
+}
+
+/**
+ * Redirect the delete action to editor widget
+ */
+void EntityGUI_PolylineDlg::deleteSelected()
+{
+ myEditorWidget->removeSelected();
+}
+
+/**
+ * Checks whether there are some to delete
+ */
+bool EntityGUI_PolylineDlg::deleteEnabled()
+{
+ return myEditorWidget->removeEnabled();
+}
--- /dev/null
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef ENTITYGUI_POLYLINEDLG_H
+#define ENTITYGUI_POLYLINEDLG_H
+
+
+#include <GEOMBase_Skeleton.h>
+
+
+class CurveCreator_Curve;
+class CurveCreator_Widget;
+class QGroupBox;
+
+
+//=================================================================================
+// class : EntityGUI_PolylineDlg
+// purpose :
+//=================================================================================
+class EntityGUI_PolylineDlg : public GEOMBase_Skeleton
+{
+ Q_OBJECT
+
+public:
+
+ EntityGUI_PolylineDlg (GeometryGUI*, QWidget* = 0,
+ bool = false, Qt::WindowFlags = 0);
+
+ virtual ~EntityGUI_PolylineDlg();
+
+ void deleteSelected();
+ bool deleteEnabled();
+
+protected:
+
+ // redefined from GEOMBase_Helper
+ virtual GEOM::GEOM_IOperations_ptr createOperation();
+ virtual bool isValid( QString& );
+ virtual bool execute( ObjectList& );
+
+private:
+
+ void Init();
+
+protected slots:
+
+ void processStartedSubOperation( QWidget*, bool );
+ void processFinishedSubOperation( QWidget* );
+
+private:
+
+ CurveCreator_Curve *myCurve;
+ CurveCreator_Widget *myEditorWidget;
+ QGroupBox *myAddElementBox;
+
+};
+
+#endif // ENTITYGUI_POLYLINEDLG_H
case GEOMOp::OpCreateField: // MENU FIELD - CREATE FIELD
case GEOMOp::OpEditField: // MENU FIELD - EDIT FIELD
case GEOMOp::OpEditFieldPopup: // POPUP MENU - EDIT FIELD
+ case GEOMOp::Op2dPolylineEditor: // MENU BASIC - POLYLINE EDITOR
libName = "EntityGUI";
break;
case GEOMOp::OpEdge: // MENU BUILD - EDGE
case GEOMOp::OpSharedShapes: // MENU OPERATION - GET SHARED SHAPES
case GEOMOp::OpExtrudedBoss: // MENU OPERATION - EXTRUDED BOSS
case GEOMOp::OpExtrudedCut: // MENU OPERATION - EXTRUDED CUT
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- case GEOMOp::OpCurveCreator: // MENU OPERATION - CURVE CREATOR
-#endif
libName = "OperationGUI";
break;
case GEOMOp::OpSewing: // MENU REPAIR - SEWING
createGeomAction( GEOMOp::OpFeatureDetect,"FEATURE_DETECTION" );
#endif
createGeomAction( GEOMOp::OpPictureImport,"PICTURE_IMPORT" );
+ createGeomAction( GEOMOp::Op2dPolylineEditor, "CURVE_CREATOR" );
createGeomAction( GEOMOp::OpEdge, "EDGE" );
createGeomAction( GEOMOp::OpWire, "WIRE" );
createGeomAction( GEOMOp::OpSharedShapes, "GET_SHARED_SHAPES" );
createGeomAction( GEOMOp::OpExtrudedCut, "EXTRUDED_CUT" );
createGeomAction( GEOMOp::OpExtrudedBoss, "EXTRUDED_BOSS" );
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- createGeomAction( GEOMOp::OpCurveCreator, "CURVE_CREATOR" );
-#endif
createGeomAction( GEOMOp::OpFillet1d, "FILLET_1D" );
createGeomAction( GEOMOp::OpFillet2d, "FILLET_2D" );
int newEntId = createMenu( tr( "MEN_NEW_ENTITY" ), -1, -1, 10 );
int basicId = createMenu( tr( "MEN_BASIC" ), newEntId, -1 );
- createMenu( GEOMOp::OpPoint, basicId, -1 );
- createMenu( GEOMOp::OpLine, basicId, -1 );
- createMenu( GEOMOp::OpCircle, basicId, -1 );
- createMenu( GEOMOp::OpEllipse, basicId, -1 );
- createMenu( GEOMOp::OpArc, basicId, -1 );
- createMenu( GEOMOp::OpCurve, basicId, -1 );
- createMenu( GEOMOp::Op2dSketcher, basicId, -1 );
- createMenu( GEOMOp::Op3dSketcher, basicId, -1 );
- createMenu( GEOMOp::OpIsoline, basicId, -1 );
- createMenu( separator(), basicId, -1 );
- createMenu( GEOMOp::OpVector, basicId, -1 );
- createMenu( GEOMOp::OpPlane, basicId, -1 );
- createMenu( GEOMOp::OpLCS, basicId, -1 );
+ createMenu( GEOMOp::OpPoint, basicId, -1 );
+ createMenu( GEOMOp::OpLine, basicId, -1 );
+ createMenu( GEOMOp::OpCircle, basicId, -1 );
+ createMenu( GEOMOp::OpEllipse, basicId, -1 );
+ createMenu( GEOMOp::OpArc, basicId, -1 );
+ createMenu( GEOMOp::OpCurve, basicId, -1 );
+ createMenu( GEOMOp::Op2dSketcher, basicId, -1 );
+ createMenu( GEOMOp::Op2dPolylineEditor, basicId, -1 );
+ createMenu( GEOMOp::Op3dSketcher, basicId, -1 );
+ createMenu( GEOMOp::OpIsoline, basicId, -1 );
+ createMenu( separator(), basicId, -1 );
+ createMenu( GEOMOp::OpVector, basicId, -1 );
+ createMenu( GEOMOp::OpPlane, basicId, -1 );
+ createMenu( GEOMOp::OpLCS, basicId, -1 );
createMenu( GEOMOp::OpOriginAndVectors, basicId, -1 );
int primId = createMenu( tr( "MEN_PRIMITIVES" ), newEntId, -1 );
createMenu( GEOMOp::OpChamfer, operId, -1 );
createMenu( GEOMOp::OpExtrudedBoss, operId, -1 );
createMenu( GEOMOp::OpExtrudedCut, operId, -1 );
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- createMenu( separator(), operId, -1 );
- createMenu( GEOMOp::OpCurveCreator, operId, -1 );
-#endif
//createMenu( GEOMOp::OpClipping, operId, -1 );
int repairId = createMenu( tr( "MEN_REPAIR" ), -1, -1, 10 );
// ---- create toolbars --------------------------
int basicTbId = createTool( tr( "TOOL_BASIC" ) );
- createTool( GEOMOp::OpPoint, basicTbId );
- createTool( GEOMOp::OpLine, basicTbId );
- createTool( GEOMOp::OpCircle, basicTbId );
- createTool( GEOMOp::OpEllipse, basicTbId );
- createTool( GEOMOp::OpArc, basicTbId );
- createTool( GEOMOp::OpCurve, basicTbId );
- createTool( GEOMOp::OpVector, basicTbId );
- createTool( GEOMOp::Op2dSketcher, basicTbId ); //rnc
- createTool( GEOMOp::Op3dSketcher, basicTbId ); //rnc
- createTool( GEOMOp::OpIsoline, basicTbId );
- createTool( GEOMOp::OpPlane, basicTbId );
- createTool( GEOMOp::OpLCS, basicTbId );
+ createTool( GEOMOp::OpPoint, basicTbId );
+ createTool( GEOMOp::OpLine, basicTbId );
+ createTool( GEOMOp::OpCircle, basicTbId );
+ createTool( GEOMOp::OpEllipse, basicTbId );
+ createTool( GEOMOp::OpArc, basicTbId );
+ createTool( GEOMOp::OpCurve, basicTbId );
+ createTool( GEOMOp::OpVector, basicTbId );
+ createTool( GEOMOp::Op2dSketcher, basicTbId ); //rnc
+ createTool( GEOMOp::Op2dPolylineEditor, basicTbId );
+ createTool( GEOMOp::Op3dSketcher, basicTbId ); //rnc
+ createTool( GEOMOp::OpIsoline, basicTbId );
+ createTool( GEOMOp::OpPlane, basicTbId );
+ createTool( GEOMOp::OpLCS, basicTbId );
createTool( GEOMOp::OpOriginAndVectors, basicTbId );
// int sketchTbId = createTool( tr( "TOOL_SKETCH" ) );
createTool( GEOMOp::OpChamfer, featTbId );
createTool( GEOMOp::OpExtrudedBoss, featTbId );
createTool( GEOMOp::OpExtrudedCut, featTbId );
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- createTool( GEOMOp::OpCurveCreator, featTbId );
-#endif
int buildTbId = createTool( tr( "TOOL_BUILD" ) );
createTool( GEOMOp::OpEdge, buildTbId );
OpCreateField = 3305, // MENU FIELD - CREATE FIELD
OpEditField = 3306, // MENU FIELD - EDIT FIELD
OpEditFieldPopup = 3307, // POPUP MENU - EDIT FIELD
+ Op2dPolylineEditor = 3308, // MENU NEW ENTITY - BASIC - POLYLINE EDITOR
// BuildGUI --------------------//--------------------------------
OpEdge = 3400, // MENU NEW ENTITY - BUILD - EDGE
OpWire = 3401, // MENU NEW ENTITY - BUILD - WIRE
OpSharedShapes = 3708, // MENU OPERATION - GET SHARED SHAPES
OpExtrudedBoss = 3709, // MENU OPERATION - ETRUDED BOSS
OpExtrudedCut = 3710, // MENU OPERATION - ETRUDED CUT
-#ifdef DEBUG_CURVE_CREATOR
- OpCurveCreator = 3799, // MENU OPERATION - CURVE CREATOR
-#endif
- // for debug purposes, to be removed
// RepairGUI -------------------//--------------------------------
OpSewing = 4000, // MENU REPAIR - SEWING
OpSuppressFaces = 4001, // MENU REPAIR - SUPPRESS FACES
${CMAKE_CURRENT_BINARY_DIR}
)
-IF(SALOME_GEOM_DEBUG_CC)
- # for debug purposes, to be removed
- INCLUDE_DIRECTORIES(${PROJECT_SOURCE_DIR}/src/CurveCreator)
-ENDIF()
-
# additional preprocessor / compiler flags
ADD_DEFINITIONS(
${CAS_DEFINITIONS}
SET(_link_LIBRARIES
GEOMBase
)
-IF(SALOME_GEOM_DEBUG_CC)
- # for debug purposes, to be removed
- LIST(APPEND _link_LIBRARIES CurveCreator)
-ENDIF()
# --- resources ---
#include <GeometryGUI.h>
#include "GeometryGUI_Operations.h"
-#include <SUIT_Session.h>
#include <SUIT_Desktop.h>
-#include <SUIT_ViewManager.h>
#include <SalomeApp_Application.h>
-#include <OCCViewer_ViewWindow.h>
-
-#include <TopTools_MapOfShape.hxx>
-#include <TopExp_Explorer.hxx>
-#include <Precision.hxx>
#include "OperationGUI_PartitionDlg.h" // Method PARTITION
#include "OperationGUI_ArchimedeDlg.h" // Method ARCHIMEDE
#include "OperationGUI_GetSharedShapesDlg.h"
#include "OperationGUI_ExtrudedFeatureDlg.h" // Methods EXTRUDED BOSS / CUT
-#ifdef DEBUG_CURVE_CREATOR
-// for debug purposes, to be removed
-#include "CurveCreator_Widget.h"
-#include <QVBoxLayout>
-#include <QPushButton>
-#endif
-
//=======================================================================
// function : OperationGUI()
// purpose : Constructor
case GEOMOp::OpExtrudedCut: (new OperationGUI_ExtrudedFeatureDlg (CUT, getGeometryGUI(), parent))->show(); break;
case GEOMOp::OpFillet1d: (new OperationGUI_Fillet1d2dDlg (getGeometryGUI(), parent, true))->show(); break;
case GEOMOp::OpFillet2d: (new OperationGUI_Fillet1d2dDlg (getGeometryGUI(), parent, false))->show(); break;
-#ifdef DEBUG_CURVE_CREATOR
- // for debug purposes, to be removed
- case GEOMOp::OpCurveCreator:
- {
- static CurveCreator_Curve *aStaticCurve = NULL;
-
- if (aStaticCurve == NULL) {
- aStaticCurve = new CurveCreator_Curve(CurveCreator::Dim2d);
- }
- if (CurveCreator::Dim2d == aStaticCurve->getDimension()) {
- OCCViewer_ViewWindow* vw = (OCCViewer_ViewWindow*)getGeometryGUI()->getApp()->activeViewManager()->getActiveView();
- vw->onTopView();
- }
-
- QDialog *aDialog = new QDialog(parent);
- QVBoxLayout *aMainLO = new QVBoxLayout;
- QPushButton *aQuitButton = new QPushButton(tr("Close"));
- CurveCreator_Widget *aWidget =
- new CurveCreator_Widget (aDialog, aStaticCurve);
-
- connect(aQuitButton, SIGNAL(clicked()), aDialog, SLOT(close()));
- aMainLO->addWidget(aWidget);
- aMainLO->addWidget(aQuitButton);
-
- aDialog->setLayout(aMainLO);
- aDialog->setAttribute(Qt::WA_DeleteOnClose);
- aDialog->show();
- }
- break;
-#endif
default:
app->putInfo(tr("GEOM_PRP_COMMAND").arg(theCommandID));
}
