ForkMaster/geom
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/geom.git synced 2025-01-26 18:10:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

CurveCreator was updated

Browse Source
This commit is contained in:
mtn 2013-08-21 06:46:20 +00:00
parent 9b88d11eb3
commit 2c4464497c
11 changed files with 941 additions and 1349 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/CurveCreator/CurveCreator_Curve.hxx
View File

@ -33,6 +33,8 @@
#include <CurveCreator_Macro.hxx>
#include <CurveCreator_Operation.hxx>
#include <QString>
class CurveCreator_Section;
@ -40,7 +42,7 @@ class CurveCreator_Section;
* 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 <EFBFBD> start and end points <EFBFBD> in other words non-manifold curves
* are not supported.
*/
class CURVECREATOR_EXPORT CurveCreator_Curve
@ -83,7 +85,7 @@ public:
//! Get type of the specified section
CurveCreator::Type getType(const int theISection) const;
//! Get “closed” flag of the specified section
//! Get <EFBFBD>closed<EFBFBD> flag of the specified section
bool isClosed(const int theISection) const;
//! Returns specifyed section name
@ -144,7 +146,7 @@ protected:
const int theISection,
const int theIPnt);
/** Set “closed” flag of the specified section (all sections if
/** Set <EFBFBD>closed<EFBFBD> flag of the specified section (all sections if
* \a theISection is -1).
*/
void setClosed(const bool theIsClosed, const int theISection = -1);

2
src/CurveCreator/CurveCreator_CurveEditor.hxx
View File

@ -60,7 +60,7 @@ public:
//! Undo previous operation
void undo();
//! Redo last previously “undoed” operation
//! Redo last previously <EFBFBD>undoed<EFBFBD> operation
void redo();
//! Get number of available undo operations

170
src/CurveCreator/CurveCreator_NewPointDlg.cxx
View File

@ -11,122 +11,136 @@
#include <QLocale>
CurveCreator_NewPointDlg::CurveCreator_NewPointDlg(CurveCreator::Dimension theDim, QWidget *parent) :
QDialog(parent), myX(NULL), myY(NULL), myZ(NULL), myIsEdit(false)
QDialog(parent), myX(NULL), myY(NULL), myZ(NULL), myIsEdit(false)
{
QGridLayout* aCoordLay = new QGridLayout();
QGridLayout* aCoordLay = new QGridLayout();
QString aTitle = QString(tr("ADD_NEW_POINT"));
setWindowTitle(aTitle);
QString aTitle = QString(tr("ADD_NEW_POINT"));
setWindowTitle(aTitle);
QLabel* aLbl = new QLabel( tr("X_COORD"), this);
myX = new QDoubleSpinBox(this);
aCoordLay->addWidget(aLbl, 0, 0);
aCoordLay->addWidget(myX, 0, 1 );
QLabel* aLbl = new QLabel( tr("X_COORD"), this);
myX = new QDoubleSpinBox(this);
aCoordLay->addWidget(aLbl, 0, 0);
aCoordLay->addWidget(myX, 0, 1 );
aLbl = new QLabel( tr("Y_COORD"), this);
myY = new QDoubleSpinBox(this);
aCoordLay->addWidget(aLbl, 1, 0 );
aCoordLay->addWidget(myY, 1, 1 );
aLbl = new QLabel( tr("Y_COORD"), this);
myY = new QDoubleSpinBox(this);
aCoordLay->addWidget(aLbl, 1, 0 );
aCoordLay->addWidget(myY, 1, 1 );
if( theDim == CurveCreator::Dim3d ){
aLbl = new QLabel( tr("Z_COORD"), this);
myZ = new QDoubleSpinBox(this);
aCoordLay->addWidget(aLbl, 2,0 );
aCoordLay->addWidget(myZ, 2,1 );
}
myZLabel = new QLabel( tr("Z_COORD"), this);
myZ = new QDoubleSpinBox(this);
aCoordLay->addWidget(myZLabel, 2,0 );
aCoordLay->addWidget(myZ, 2,1 );
myBtnBox = new QDialogButtonBox(this);
myAddBtn = myBtnBox->addButton(tr("ADD_BTN"), QDialogButtonBox::AcceptRole );
myContBtn = myBtnBox->addButton(tr("ADD_CONTINUE_BTN"), QDialogButtonBox::ResetRole );
myBtnBox->addButton(tr("CANCEL"), QDialogButtonBox::RejectRole );
if( theDim != CurveCreator::Dim3d ){
myZ->hide();
myZLabel->hide();
}
connect( myBtnBox, SIGNAL(accepted()), this, SLOT(accept()));
connect( myBtnBox, SIGNAL(rejected()), this, SLOT(reject()));
connect( myBtnBox, SIGNAL(clicked(QAbstractButton*)), this, SLOT(onBtnClicked(QAbstractButton*) ));
QVBoxLayout* aMainLay = new QVBoxLayout();
aMainLay->addLayout(aCoordLay);
aMainLay->addWidget(myBtnBox);
setLayout(aMainLay);
clear();
updateTitle();
myBtnBox = new QDialogButtonBox(this);
myAddBtn = myBtnBox->addButton(tr("ADD_BTN"), QDialogButtonBox::AcceptRole );
myContBtn = myBtnBox->addButton(tr("ADD_CONTINUE_BTN"), QDialogButtonBox::ResetRole );
myBtnBox->addButton(tr("CANCEL"), QDialogButtonBox::RejectRole );
connect( myBtnBox, SIGNAL(accepted()), this, SLOT(accept()));
connect( myBtnBox, SIGNAL(rejected()), this, SLOT(reject()));
connect( myBtnBox, SIGNAL(clicked(QAbstractButton*)), this, SLOT(onBtnClicked(QAbstractButton*) ));
QVBoxLayout* aMainLay = new QVBoxLayout();
aMainLay->addLayout(aCoordLay);
aMainLay->addWidget(myBtnBox);
setLayout(aMainLay);
clear();
updateTitle();
}
void CurveCreator_NewPointDlg::setSectionName( const QString& theName )
{
mySectionName = theName;
updateTitle();
mySectionName = theName;
updateTitle();
}
void CurveCreator_NewPointDlg::setEditMode( bool isEdit )
{
myIsEdit = isEdit;
if( myIsEdit ){
myContBtn->hide();
myAddBtn->setText(tr("OK"));
}
else{
myContBtn->show();
myAddBtn->setText(tr("ADD_BTN"));
}
updateTitle();
myIsEdit = isEdit;
if( myIsEdit ){
myContBtn->hide();
myAddBtn->setText(tr("OK"));
}
else{
myContBtn->show();
myAddBtn->setText(tr("ADD_BTN"));
}
updateTitle();
}
void CurveCreator_NewPointDlg::updateTitle()
{
QString aTitle;
if( !myIsEdit ){
if( mySectionName.isEmpty() ){
aTitle = tr("ADD_NEW_POINT");
}
else{
aTitle = QString(tr("ADD_NEW_POINT_TO_%1")).arg(mySectionName);
}
QString aTitle;
if( !myIsEdit ){
if( mySectionName.isEmpty() ){
aTitle = tr("ADD_NEW_POINT");
}
else{
aTitle = tr("SET_POINT_COORDINATES");
aTitle = QString(tr("ADD_NEW_POINT_TO_%1")).arg(mySectionName);
}
setWindowTitle(aTitle);
}
else{
aTitle = tr("SET_POINT_COORDINATES");
}
setWindowTitle(aTitle);
}
CurveCreator::Coordinates CurveCreator_NewPointDlg::getCoordinates() const
{
CurveCreator::Coordinates aCoords;
double anX = myX->value();
aCoords.push_back(anX);
double anY = myY->value();
aCoords.push_back(anY);
if( myZ ){
double aZ = myZ->value();
aCoords.push_back(aZ);
}
return aCoords;
CurveCreator::Coordinates aCoords;
double anX = myX->value();
aCoords.push_back(anX);
double anY = myY->value();
aCoords.push_back(anY);
if( myZ->isVisible() ){
double aZ = myZ->value();
aCoords.push_back(aZ);
}
return aCoords;
}
void CurveCreator_NewPointDlg::onBtnClicked(QAbstractButton* theBtn )
{
if( myBtnBox->buttonRole(theBtn) == QDialogButtonBox::ResetRole ){
emit addPoint();
}
if( myBtnBox->buttonRole(theBtn) == QDialogButtonBox::ResetRole ){
emit addPoint();
}
}
void CurveCreator_NewPointDlg::clear()
{
initSpinBox(myX);
initSpinBox(myY);
if( myZ )
initSpinBox(myZ);
initSpinBox(myX);
initSpinBox(myY);
initSpinBox(myZ);
}
void CurveCreator_NewPointDlg::setDimension(CurveCreator::Dimension theDim)
{
if( theDim == CurveCreator::Dim2d ){
myZ->hide();
myZLabel->hide();
}
else{
myZ->show();
myZLabel->show();
}
}
void CurveCreator_NewPointDlg::setCoordinates( const CurveCreator::Coordinates& theCoords )
{
double anX = theCoords[0];
myX->setValue(anX);
double anY = theCoords[1];
myY->setValue(anY);
if( myZ && ( theCoords.size() == 3)){
double aZ = theCoords[2];
myZ->setValue(aZ);
}
double anX = theCoords[0];
myX->setValue(anX);
double anY = theCoords[1];
myY->setValue(anY);
if( theCoords.size() == 3 ){
double aZ = theCoords[2];
myZ->setValue(aZ);
}
}
//=======================================================================

43
src/CurveCreator/CurveCreator_NewPointDlg.h
View File

@ -9,35 +9,38 @@ class QDoubleSpinBox;
class QDialogButtonBox;
class QAbstractButton;
class QPushButton;
class QLabel;
class CurveCreator_NewPointDlg : public QDialog
{
Q_OBJECT
Q_OBJECT
public:
explicit CurveCreator_NewPointDlg(CurveCreator::Dimension theDim, QWidget *parent = 0);
CurveCreator::Coordinates getCoordinates() const;
void clear();
void setSectionName( const QString& theName );
void setEditMode( bool isEdit );
void setCoordinates( const CurveCreator::Coordinates& theCoords );
explicit CurveCreator_NewPointDlg(CurveCreator::Dimension theDim, QWidget *parent = 0);
CurveCreator::Coordinates getCoordinates() const;
void clear();
void setSectionName( const QString& theName );
void setEditMode( bool isEdit );
void setCoordinates( const CurveCreator::Coordinates& theCoords );
void setDimension(CurveCreator::Dimension theDim);
signals:
void addPoint();
void addPoint();
public slots:
protected slots:
void onBtnClicked(QAbstractButton* theBtn );
void onBtnClicked(QAbstractButton* theBtn );
protected:
void updateTitle();
void initSpinBox(QDoubleSpinBox *theSpinBox);
void updateTitle();
void initSpinBox(QDoubleSpinBox *theSpinBox);
private:
QDialogButtonBox* myBtnBox;
CurveCreator::Dimension myDim;
QDoubleSpinBox* myX;
QDoubleSpinBox* myY;
QDoubleSpinBox* myZ;
QPushButton* myContBtn;
QPushButton* myAddBtn;
bool myIsEdit;
QString mySectionName;
QDialogButtonBox* myBtnBox;
CurveCreator::Dimension myDim;
QDoubleSpinBox* myX;
QDoubleSpinBox* myY;
QDoubleSpinBox* myZ;
QLabel* myZLabel;
QPushButton* myContBtn;
QPushButton* myAddBtn;
bool myIsEdit;
QString mySectionName;
};
#endif // CURVECREATOR_NEWPOINTDLG_H

136
src/CurveCreator/CurveCreator_NewSectionDlg.cxx
View File

@ -1,5 +1,4 @@
#include "CurveCreator_NewSectionDlg.h"
#include "CurveCreator_Curve.hxx"
#include <SUIT_Session.h>
@ -14,110 +13,117 @@
#include <QPushButton>
CurveCreator_NewSectionDlg::CurveCreator_NewSectionDlg( QWidget *parent ) :
QDialog(parent)
QDialog(parent)
{
std::string aNameStr;
QGridLayout* aLay = new QGridLayout();
QLabel* aLbl = new QLabel(tr("NAME"), this);
myName = new QLineEdit(this);
aLay->addWidget(aLbl, 0, 0);
aLay->addWidget(myName, 0 , 1);
std::string aNameStr;
QGridLayout* aLay = new QGridLayout();
QLabel* aLbl = new QLabel(tr("NAME"), this);
myName = new QLineEdit(this);
aLay->addWidget(aLbl, 0, 0);
aLay->addWidget(myName, 0 , 1);
aLbl = new QLabel(tr("LINE_TYPE"));
myLineType = new QComboBox(this);
QPixmap aPolylineImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
myLineType->addItem(aPolylineImage, tr("POLYLINE_TYPE"));
QPixmap aSplineImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
myLineType->addItem(aSplineImage,tr("SPLINE_TYPE"));
myLineType->setCurrentIndex(0);
aLay->addWidget(aLbl, 1, 0);
aLay->addWidget(myLineType, 1 , 1);
aLbl = new QLabel(tr("LINE_TYPE"));
myLineType = new QComboBox(this);
aLbl = new QLabel(tr("LINE_CLOSED"));
myIsClosed = new QCheckBox(this);
aLay->addWidget(aLbl, 2, 0);
aLay->addWidget(myIsClosed, 2, 1);
SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
QPixmap aPolylinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
QPixmap aSplinePixmap(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
myBtnBox = new QDialogButtonBox(this);
myAddBtn = myBtnBox->addButton(tr("ADD_BTN"), QDialogButtonBox::AcceptRole );
myContBtn = myBtnBox->addButton(tr("ADD_CONTINUE_BTN"), QDialogButtonBox::ResetRole );
myBtnBox->addButton(tr("CANCEL"), QDialogButtonBox::RejectRole );
// QPixmap aPolylinePixmap = QPixmap(tr(":images/ICON_POLYLINE"));
// QPixmap aSplinePixmap = QPixmap(tr(":images/ICON_SPLINE"));
myLineType->addItem(aPolylinePixmap, tr("POLYLINE_TYPE"));
myLineType->addItem(aSplinePixmap, tr("SPLINE_TYPE"));
myLineType->setCurrentIndex(0);
aLay->addWidget(aLbl, 1, 0);
aLay->addWidget(myLineType, 1 , 1);
connect( myBtnBox, SIGNAL(accepted()), this, SLOT(accept()));
connect( myBtnBox, SIGNAL(rejected()), this, SLOT(reject()));
connect( myBtnBox, SIGNAL(clicked(QAbstractButton*)), this, SLOT(onBtnClicked(QAbstractButton*) ));
aLbl = new QLabel(tr("LINE_CLOSED"));
myIsClosed = new QCheckBox(this);
aLay->addWidget(aLbl, 2, 0);
aLay->addWidget(myIsClosed, 2, 1);
QVBoxLayout* aMainLay = new QVBoxLayout();
aMainLay->addLayout(aLay);
aMainLay->addWidget(myBtnBox);
setLayout(aMainLay);
myBtnBox = new QDialogButtonBox(this);
myAddBtn = myBtnBox->addButton(tr("ADD_BTN"), QDialogButtonBox::AcceptRole );
myContBtn = myBtnBox->addButton(tr("ADD_CONTINUE_BTN"), QDialogButtonBox::ResetRole );
myBtnBox->addButton(tr("CANCEL"), QDialogButtonBox::RejectRole );
connect( myBtnBox, SIGNAL(accepted()), this, SLOT(accept()));
connect( myBtnBox, SIGNAL(rejected()), this, SLOT(reject()));
connect( myBtnBox, SIGNAL(clicked(QAbstractButton*)), this, SLOT(onBtnClicked(QAbstractButton*) ));
QVBoxLayout* aMainLay = new QVBoxLayout();
aMainLay->addLayout(aLay);
aMainLay->addWidget(myBtnBox);
setLayout(aMainLay);
}
void CurveCreator_NewSectionDlg::setSectionParameters( const QString& theName, bool isClosed, CurveCreator::Type theType )
{
myName->setText(theName);
myIsClosed->setChecked(isClosed);
if( theType == CurveCreator::Polyline )
myLineType->setCurrentIndex(0);
myName->setText(theName);
myIsClosed->setChecked(isClosed);
if( theType == CurveCreator::Polyline )
myLineType->setCurrentIndex(0);
else
myLineType->setCurrentIndex(1);
}
void CurveCreator_NewSectionDlg::clear()
{
myName->setText("");
myIsClosed->setChecked(true);
myLineType->setCurrentIndex(0);
myName->setText("");
myIsClosed->setChecked(true);
myLineType->setCurrentIndex(0);
}
void CurveCreator_NewSectionDlg::setEditMode( bool isEdit )
{
myIsEdit = isEdit;
if( myIsEdit ){
myContBtn->hide();
myAddBtn->setText(tr("OK"));
}
else{
myContBtn->show();
myAddBtn->setText(tr("ADD_BTN"));
}
updateTitle();
myIsEdit = isEdit;
if( myIsEdit ){
myContBtn->hide();
myAddBtn->setText(tr("OK"));
}
else{
myContBtn->show();
myAddBtn->setText(tr("ADD_BTN"));
}
updateTitle();
}
QString CurveCreator_NewSectionDlg::getName() const
{
return myName->text();
return myName->text();
}
bool CurveCreator_NewSectionDlg::isClosed() const
{
return myIsClosed->isChecked();
return myIsClosed->isChecked();
}
CurveCreator::Type CurveCreator_NewSectionDlg::getSectionType() const
{
if( myLineType->currentIndex() == 0 )
return CurveCreator::Polyline;
else
return CurveCreator::BSpline;
if( myLineType->currentIndex() == 0 )
return CurveCreator::Polyline;
else
return CurveCreator::BSpline;
}
void CurveCreator_NewSectionDlg::updateTitle()
{
QString aTitle;
if( !myIsEdit )
aTitle = tr("ADD_NEW_SECTION");
else
aTitle = QString(tr("SET_SECTION_PARAMETERS"));
setWindowTitle(aTitle);
QString aTitle;
if( !myIsEdit )
aTitle = tr("ADD_NEW_SECTION");
else
aTitle = QString(tr("SET_SECTION_PARAMETERS"));
setWindowTitle(aTitle);
}
void CurveCreator_NewSectionDlg::setSectionName( const QString& theName )
{
myName->setText(theName);
myName->setText(theName);
}
void CurveCreator_NewSectionDlg::onBtnClicked(QAbstractButton* theBtn )
{
if( myBtnBox->buttonRole(theBtn) == QDialogButtonBox::ResetRole ){
emit addSection();
}
if( myBtnBox->buttonRole(theBtn) == QDialogButtonBox::ResetRole ){
emit addSection();
}
}

38
src/CurveCreator/CurveCreator_NewSectionDlg.h
View File

@ -16,34 +16,34 @@ class QDialogButtonBox;
class CurveCreator_NewSectionDlg : public QDialog
{
Q_OBJECT
Q_OBJECT
public:
explicit CurveCreator_NewSectionDlg(QWidget *parent = 0);
explicit CurveCreator_NewSectionDlg(QWidget *parent = 0);
QString getName() const;
bool isClosed() const;
CurveCreator::Type getSectionType() const;
QString getName() const;
bool isClosed() const;
CurveCreator::Type getSectionType() const;
void setSectionParameters( const QString& theName, bool isClosed, CurveCreator::Type theType );
void setSectionName(const QString& theName );
void clear();
void setEditMode( bool isEdit );
void setSectionParameters( const QString& theName, bool isClosed, CurveCreator::Type theType );
void setSectionName(const QString& theName );
void clear();
void setEditMode( bool isEdit );
signals:
void addSection();
void addSection();
public slots:
protected slots:
void onBtnClicked(QAbstractButton* theBtn );
void onBtnClicked(QAbstractButton* theBtn );
protected:
void updateTitle();
void updateTitle();
private:
QLineEdit* myName;
QComboBox* myLineType;
QCheckBox* myIsClosed;
bool myIsEdit;
QPushButton* myContBtn;
QPushButton* myAddBtn;
QDialogButtonBox* myBtnBox;
QLineEdit* myName;
QComboBox* myLineType;
QCheckBox* myIsClosed;
bool myIsEdit;
QPushButton* myContBtn;
QPushButton* myAddBtn;
QDialogButtonBox* myBtnBox;
};
#endif // CURVECREATOR_NEWSECTION_H

573
src/CurveCreator/CurveCreator_TreeView.cxx
View File

@ -1,5 +1,4 @@
#include "CurveCreator_TreeView.h"
#include "CurveCreator_Curve.hxx"
#include <SUIT_Session.h>
@ -11,412 +10,442 @@
#define ID_SECTION -1
CurveCreator_TreeViewModel::CurveCreator_TreeViewModel( CurveCreator_Curve* theCurve, QObject* parent ) :
QAbstractItemModel(parent), myCurve(theCurve)
QAbstractItemModel(parent), myCurve(theCurve)
{
QPixmap aSplineIcon(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
if( !aSplineIcon.isNull() )
myCachedIcons[ICON_SPLINE] = aSplineIcon;
SUIT_ResourceMgr* aResMgr = SUIT_Session::session()->resourceMgr();
QPixmap aSplineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
QPixmap aPolylineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
QPixmap aClosedSplineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_CLOSED_SPLINE")));
QPixmap aClosedPolylineIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_CLOSED_POLYLINE")));
QPixmap aPointIcon(aResMgr->loadPixmap("GEOM", tr("ICON_CC_POINT")));
QPixmap aPolylineIcon(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
if( !aPolylineIcon.isNull() )
myCachedIcons[ICON_POLYLINE] = aPolylineIcon;
/* QPixmap aSplineIcon(tr(":images/ICON_SPLINE"));
QPixmap aPolylineIcon(tr(":images/ICON_POLYLINE"));
QPixmap aClosedPolylineIcon(tr(":images/ICON_CLOSED_POLYLINE"));
QPixmap aClosedSplineIcon(tr(":images/ICON_CLOSED_SPLINE"));
QPixmap aPointIcon(tr(":images/ICON_POINT")); */
QPixmap aClosedPolylineIcon(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_CLOSED_POLYLINE")));
if( !aPolylineIcon.isNull() )
myCachedIcons[ICON_CLOSED_POLYLINE] = aClosedPolylineIcon;
if( !aSplineIcon.isNull() )
myCachedIcons[ICON_SPLINE] = aSplineIcon;
QPixmap aClosedSplineIcon(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_CLOSED_SPLINE")));
if( !aPolylineIcon.isNull() )
myCachedIcons[ICON_CLOSED_SPLINE] = aClosedSplineIcon;
if( !aPolylineIcon.isNull() )
myCachedIcons[ICON_POLYLINE] = aPolylineIcon;
QPixmap aPointIcon(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_POINT")));
if( !aPointIcon.isNull() )
myCachedIcons[ICON_POINT] = aPointIcon;
if( !aPolylineIcon.isNull() )
myCachedIcons[ICON_CLOSED_POLYLINE] = aClosedPolylineIcon;
if( !aPolylineIcon.isNull() )
myCachedIcons[ICON_CLOSED_SPLINE] = aClosedSplineIcon;
if( !aPointIcon.isNull() )
myCachedIcons[ICON_POINT] = aPointIcon;
}
int CurveCreator_TreeViewModel::columnCount(const QModelIndex & parent ) const
{
if( parent.internalId() == ID_SECTION )
return 1;
else
return 1;
if( parent.internalId() == ID_SECTION )
return 1;
else
return 1;
}
QVariant CurveCreator_TreeViewModel::data(const QModelIndex & index, int role ) const
{
int aRow = index.row();
int aColumn = index.column();
if( myCurve ){
if( index.internalId() == ID_SECTION ){
if( role == Qt::DisplayRole ){
if( aColumn == 0 )
return QString::fromStdString(myCurve->getSectionName(aRow));
return QVariant();
int aRow = index.row();
int aColumn = index.column();
if( myCurve ){
if( index.internalId() == ID_SECTION ){
if( role == Qt::DisplayRole ){
if( aColumn == 0 )
return QString::fromStdString(myCurve->getSectionName(aRow));
return QVariant();
}
else if( role == Qt::DecorationRole ){
if( aColumn == 0 ){
CurveCreator::Type aSectionType = myCurve->getType(aRow);
if( aSectionType == CurveCreator::Polyline ){
if( myCurve->isClosed(aRow) ){
return myCachedIcons[ICON_CLOSED_POLYLINE];
}
else if( role == Qt::DecorationRole ){
if( aColumn == 0 ){
CurveCreator::Type aSectionType = myCurve->getType(aRow);
if( aSectionType == CurveCreator::Polyline ){
if( myCurve->isClosed(aRow) ){
return myCachedIcons[ICON_CLOSED_POLYLINE];
}
else{
return myCachedIcons[ICON_POLYLINE];
}
}
else{
if( myCurve->isClosed(aRow) ){
return myCachedIcons[ICON_CLOSED_SPLINE];
}
else{
return myCachedIcons[ICON_SPLINE];
}
}
}
}
}
else{
if( role == Qt::DisplayRole ){
if( aColumn == 1 )
return QVariant();
// return "Point";
else if( aColumn == 0 ){
CurveCreator::Coordinates aCoords = myCurve->getCoordinates(index.internalId(),index.row() );
QString anOut;
if( myCurve->getDimension() == CurveCreator::Dim2d ){
anOut = QString(tr("X=%1, Y=%2")).arg(aCoords[0]).arg(aCoords[1]);
}
else{
anOut = QString(tr("X=%1, Y=%2, Z=%3")).arg(aCoords[0]).arg(aCoords[1]).arg(aCoords[2]);
}
return anOut;
}
}
else if( role == Qt::DecorationRole ){
if( aColumn == 0 ){
return myCachedIcons[ICON_POINT];
}
else{
return myCachedIcons[ICON_POLYLINE];
}
}
else{
if( myCurve->isClosed(aRow) ){
return myCachedIcons[ICON_CLOSED_SPLINE];
}
else{
return myCachedIcons[ICON_SPLINE];
}
}
}
}
}
return QVariant();
else{
if( role == Qt::DisplayRole ){
if( aColumn == 1 )
return QVariant();
// return "Point";
else if( aColumn == 0 ){
CurveCreator::Coordinates aCoords = myCurve->getCoordinates(index.internalId(),index.row() );
QString anOut;
if( myCurve->getDimension() == CurveCreator::Dim2d ){
anOut = QString(tr("X=%1, Y=%2")).arg(aCoords[0]).arg(aCoords[1]);
}
else{
anOut = QString(tr("X=%1, Y=%2, Z=%3")).arg(aCoords[0]).arg(aCoords[1]).arg(aCoords[2]);
}
return anOut;
}
}
else if( role == Qt::DecorationRole ){
if( aColumn == 0 ){
return myCachedIcons[ICON_POINT];
}
}
}
}
return QVariant();
}
QModelIndex CurveCreator_TreeViewModel::index(int row, int column, const QModelIndex & parent ) const
{
if( parent.isValid() ){
return createIndex(row, column, parent.row() );
}
else{
QModelIndex aParent = createIndex(row, column, ID_SECTION );
return aParent;
}
return QModelIndex();
if( parent.isValid() ){
return createIndex(row, column, parent.row() );
}
else{
QModelIndex aParent = createIndex(row, column, ID_SECTION );
return aParent;
}
return QModelIndex();
}
QModelIndex CurveCreator_TreeViewModel::parent(const QModelIndex & theIndex) const
{
if( !theIndex.isValid() )
return QModelIndex();
if( !theIndex.isValid() )
return QModelIndex();
if( theIndex.internalId() == ID_SECTION ){
return QModelIndex();
}
return createIndex( theIndex.internalId(), 0, ID_SECTION );
if( theIndex.internalId() == ID_SECTION ){
return QModelIndex();
}
return createIndex( theIndex.internalId(), 0, ID_SECTION );
}
int CurveCreator_TreeViewModel::rowCount(const QModelIndex & parent ) const
{
int aRowCnt = 0;
if( myCurve != NULL ){
if( !parent.isValid() ){
//Points level
aRowCnt = myCurve->getNbSections();
}
else{
//Section level
if( parent.internalId() == ID_SECTION ){
aRowCnt = myCurve->getNbPoints(parent.row());
}
}
int aRowCnt = 0;
if( myCurve != NULL ){
if( !parent.isValid() ){
//Points level
aRowCnt = myCurve->getNbSections();
}
return aRowCnt;
else{
//Section level
if( parent.internalId() == ID_SECTION ){
aRowCnt = myCurve->getNbPoints(parent.row());
}
}
}
return aRowCnt;
}
QModelIndex CurveCreator_TreeViewModel::sectionIndex( int theSection ) const
{
return createIndex( theSection, 0, ID_SECTION );
return createIndex( theSection, 0, ID_SECTION );
}
QModelIndex CurveCreator_TreeViewModel::pointIndex( int theSection, int thePoint ) const
{
return createIndex( thePoint, 0, theSection );
return createIndex( thePoint, 0, theSection );
}
bool CurveCreator_TreeViewModel::isSection( const QModelIndex& theIndx ) const
{
if( theIndx.internalId() == ID_SECTION )
return true;
return false;
if( theIndx.internalId() == ID_SECTION )
return true;
return false;
}
int CurveCreator_TreeViewModel::getSection( const QModelIndex& theIndx ) const
{
if( theIndx.internalId() == ID_SECTION )
return theIndx.row();
return theIndx.internalId();
if( theIndx.internalId() == ID_SECTION )
return theIndx.row();
return theIndx.internalId();
}
int CurveCreator_TreeViewModel::getPoint( const QModelIndex& theIndx ) const
{
if( theIndx.internalId() == ID_SECTION )
return -1;
return theIndx.row();
if( theIndx.internalId() == ID_SECTION )
return -1;
return theIndx.row();
}
void CurveCreator_TreeViewModel::setCurve( CurveCreator_Curve* theCurve )
{
myCurve = theCurve;
reset();
}
/*****************************************************************************************/
CurveCreator_TreeView::CurveCreator_TreeView( CurveCreator_Curve* theCurve, QWidget *parent) :
QTreeView(parent)
QTreeView(parent)
{
header()->hide();
setUniformRowHeights(true);
setContextMenuPolicy( Qt::CustomContextMenu );
CurveCreator_TreeViewModel* aModel = new CurveCreator_TreeViewModel(theCurve, this);
setModel(aModel);
setSelectionBehavior(SelectRows);
setSelectionMode(ExtendedSelection);
setExpandsOnDoubleClick(false);
connect( selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
this, SIGNAL(selectionChanged()) );
connect( this, SIGNAL(activated(QModelIndex)), this, SLOT(onActivated(QModelIndex)));
header()->hide();
setUniformRowHeights(true);
setContextMenuPolicy( Qt::CustomContextMenu );
CurveCreator_TreeViewModel* aModel = new CurveCreator_TreeViewModel(theCurve, this);
setModel(aModel);
setSelectionBehavior(SelectRows);
setSelectionMode(ExtendedSelection);
setExpandsOnDoubleClick(false);
connect( selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
this, SIGNAL(selectionChanged()) );
connect( this, SIGNAL(activated(QModelIndex)), this, SLOT(onActivated(QModelIndex)));
}
QList<int> CurveCreator_TreeView::getSelectedSections() const
{
QList<int> aSect;
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( !aModel )
return aSect;
QModelIndexList anIndxs = selectionModel()->selectedIndexes();
for( int i = 0 ; i < anIndxs.size() ; i++ ){
if( aModel->isSection(anIndxs[i]) ){
aSect << aModel->getSection( anIndxs[i] );
}
}
qSort(aSect.begin(), aSect.end());
QList<int> aSect;
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( !aModel )
return aSect;
QModelIndexList anIndxs = selectionModel()->selectedIndexes();
for( int i = 0 ; i < anIndxs.size() ; i++ ){
if( aModel->isSection(anIndxs[i]) ){
aSect << aModel->getSection( anIndxs[i] );
}
}
qSort(aSect.begin(), aSect.end());
return aSect;
}
void CurveCreator_TreeView::pointsAdded( int theSection, int thePoint, int thePointsCnt )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aSectIndx = aModel->sectionIndex( theSection );
rowsInserted(aSectIndx, thePoint, thePoint + thePointsCnt - 1 );
}
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aSectIndx = aModel->sectionIndex( theSection );
rowsInserted(aSectIndx, thePoint, thePoint + thePointsCnt - 1 );
}
}
void CurveCreator_TreeView::pointDataChanged( int theSection, int thePoint )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aPointIndx = aModel->pointIndex( theSection, thePoint );
dataChanged( aPointIndx, aPointIndx );
}
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aPointIndx = aModel->pointIndex( theSection, thePoint );
dataChanged( aPointIndx, aPointIndx );
}
}
void CurveCreator_TreeView::pointsRemoved( int theSection, int thePoint, int thePointsCnt )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aSectIndx = aModel->sectionIndex( theSection );
rowsRemoved(aSectIndx, thePoint, thePoint + thePointsCnt - 1 );
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
for( int i = 0 ; i < thePointsCnt ; i++ ){
QModelIndex aSectIndx = aModel->pointIndex(theSection, thePoint + i);
selectionModel()->select(aSectIndx,QItemSelectionModel::Deselect);
}
QModelIndex aSectIndx = aModel->sectionIndex( theSection );
rowsRemoved(aSectIndx, thePoint, thePoint + thePointsCnt - 1 );
}
}
void CurveCreator_TreeView::sectionAdded( int theSection )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
rowsInserted(QModelIndex(), theSection, theSection );
}
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
rowsInserted(QModelIndex(), theSection, theSection );
}
}
void CurveCreator_TreeView::sectionChanged( int theSection, int aSectCnt )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aFirstSectIndx = aModel->sectionIndex( theSection );
QModelIndex aLastSectIndx = aModel->sectionIndex( theSection + aSectCnt - 1);
dataChanged( aFirstSectIndx, aLastSectIndx );
}
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aFirstSectIndx = aModel->sectionIndex( theSection );
QModelIndex aLastSectIndx = aModel->sectionIndex( theSection + aSectCnt - 1);
dataChanged( aFirstSectIndx, aLastSectIndx );
}
}
void CurveCreator_TreeView::sectionsRemoved( int theSection, int theSectionCnt )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
this->rowsRemoved( QModelIndex(), theSection, theSection+theSectionCnt-1 );
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
for( int i = 0 ; i < theSectionCnt ; i++ ){
QModelIndex aSectIndx = aModel->sectionIndex(theSection + i);
this->selectionModel()->select(aSectIndx,QItemSelectionModel::Deselect);
}
rowsRemoved( QModelIndex(), theSection, theSection+theSectionCnt-1 );
}
}
void CurveCreator_TreeView::setIndexState( const QModelIndex& theIndx, bool& isExpanded, bool& isSelected, bool& isCurrent )
{
setExpanded( theIndx, isExpanded );
QItemSelectionModel::SelectionFlags aFlag = QItemSelectionModel::Select;
if( !isSelected ){
aFlag = QItemSelectionModel::Deselect;
}
selectionModel()->select( theIndx, aFlag );
setExpanded( theIndx, isExpanded );
QItemSelectionModel::SelectionFlags aFlag = QItemSelectionModel::Select;
if( !isSelected ){
aFlag = QItemSelectionModel::Deselect;
}
selectionModel()->select( theIndx, aFlag );
}
void CurveCreator_TreeView::getIndexInfo( const QModelIndex& theIndx, bool& isExpand, bool& isSelected, bool& isCurrent )
{
isExpand = isExpanded(theIndx);
isSelected = selectionModel()->isSelected(theIndx);
isCurrent = (theIndx == selectionModel()->currentIndex());
isExpand = isExpanded(theIndx);
isSelected = selectionModel()->isSelected(theIndx);
isCurrent = (theIndx == selectionModel()->currentIndex());
}
void CurveCreator_TreeView::swapIndexes( const QModelIndex& theFirst, const QModelIndex& theSecond )
{
bool isFirstSelected;
bool isFirstExpanded;
bool isFirstCurrent;
getIndexInfo( theFirst, isFirstExpanded, isFirstSelected, isFirstCurrent );
bool isFirstSelected;
bool isFirstExpanded;
bool isFirstCurrent;
getIndexInfo( theFirst, isFirstExpanded, isFirstSelected, isFirstCurrent );
bool isSecondSelected;
bool isSecondExpanded;
bool isSecondCurrent;
getIndexInfo( theSecond, isSecondExpanded, isSecondSelected, isSecondCurrent );
bool isSecondSelected;
bool isSecondExpanded;
bool isSecondCurrent;
getIndexInfo( theSecond, isSecondExpanded, isSecondSelected, isSecondCurrent );
setIndexState( theFirst, isSecondExpanded, isSecondSelected, isSecondCurrent );
setIndexState( theSecond, isFirstExpanded, isFirstSelected, isFirstCurrent );
dataChanged(theFirst,theFirst);
dataChanged(theSecond,theSecond);
setIndexState( theFirst, isSecondExpanded, isSecondSelected, isSecondCurrent );
setIndexState( theSecond, isFirstExpanded, isFirstSelected, isFirstCurrent );
dataChanged(theFirst,theFirst);
dataChanged(theSecond,theSecond);
}
void CurveCreator_TreeView::sectionsSwapped( int theSection, int theOffset )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aFirstIndex = aModel->sectionIndex( theSection );
QModelIndex aSecondIndex = aModel->sectionIndex( theSection + theOffset );
swapIndexes( aFirstIndex, aSecondIndex );
}
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
QModelIndex aFirstIndex = aModel->sectionIndex( theSection );
QModelIndex aSecondIndex = aModel->sectionIndex( theSection + theOffset );
swapIndexes( aFirstIndex, aSecondIndex );
}
}
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 );
}
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());
if( aModel ){
selectionModel()->clearSelection();
for( int i = 0 ; i < theList.size() ; i++ ){
QModelIndex aSectIndx = aModel->sectionIndex(theList[i]);
selectionModel()->select(aSectIndx, QItemSelectionModel::Select );
}
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel ){
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 );
}
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 );
}
}
}
bool pointLessThan(const QPair<int,int> &s1, const QPair<int,int> &s2)
{
if( s1.first < s2.first )
return true;
if( s1.first > s2.first )
return false;
return s1.second < s2.second;
if( s1.first < s2.first )
return true;
if( s1.first > s2.first )
return false;
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;
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());
if( !aModel )
return ST_NOSEL;
bool isPointSel = false;
bool isSectSel = false;
bool isOneSection = true;
int aSectNum = -1;
QModelIndexList aLst = selectionModel()->selectedIndexes();
for( int i = 0 ; i < aLst.size() ; i++ ){
if( aModel->isSection( aLst[i] ) ){
isSectSel = true;
}
else{
isPointSel = true;
if( aSectNum == -1 ){
aSectNum = aModel->getSection(aLst[i]);
}
else{
if( aSectNum != aModel->getSection( aLst[i] ) ){
isOneSection = false;
}
}
}
}
if( isSectSel && !isPointSel )
return ST_SECTIONS;
if( isPointSel && !isSectSel ){
if( isOneSection ){
return ST_POINTS_ONE_SECTION;
}
return ST_POINTS;
}
if( isPointSel && isSectSel )
return ST_MIXED;
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( !aModel )
return ST_NOSEL;
bool isPointSel = false;
bool isSectSel = false;
bool isOneSection = true;
int aSectNum = -1;
QModelIndexList aLst = selectionModel()->selectedIndexes();
for( int i = 0 ; i < aLst.size() ; i++ ){
if( aModel->isSection( aLst[i] ) ){
isSectSel = true;
}
else{
isPointSel = true;
if( aSectNum == -1 ){
aSectNum = aModel->getSection(aLst[i]);
}
else{
if( aSectNum != aModel->getSection( aLst[i] ) ){
isOneSection = false;
}
}
}
}
if( isSectSel && !isPointSel )
return ST_SECTIONS;
if( isPointSel && !isSectSel ){
if( isOneSection ){
return ST_POINTS_ONE_SECTION;
}
return ST_POINTS;
}
if( isPointSel && isSectSel )
return ST_MIXED;
return ST_NOSEL;
}
void CurveCreator_TreeView::onActivated( QModelIndex theIndx )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( !aModel )
return;
int aSect = aModel->getSection(theIndx);
if( aModel->isSection(theIndx) ){
emit sectionEntered( aSect );
return;
}
int aPointNum = aModel->getPoint( theIndx );
emit pointEntered( aSect, aPointNum );
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( !aModel )
return;
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 )
{
CurveCreator_TreeViewModel* aModel = dynamic_cast<CurveCreator_TreeViewModel*>(model());
if( aModel )
aModel->setCurve(theCurve);
reset();
}

82
src/CurveCreator/CurveCreator_TreeView.h
View File

@ -9,63 +9,67 @@ class CurveCreator_Curve;
class CurveCreator_TreeViewModel : public QAbstractItemModel
{
public:
CurveCreator_TreeViewModel( CurveCreator_Curve* 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;
virtual QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;
virtual QModelIndex parent(const QModelIndex & theIndex) const;
CurveCreator_TreeViewModel( CurveCreator_Curve* 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;
virtual QModelIndex index(int row, int column, const QModelIndex & parent = QModelIndex()) const;
virtual QModelIndex parent(const QModelIndex & theIndex) const;
QModelIndex sectionIndex( int theSection ) const;
QModelIndex pointIndex( int theSection, int thePoint ) const;
QModelIndex sectionIndex( int theSection ) const;
QModelIndex pointIndex( int theSection, int thePoint ) const;
bool isSection( const QModelIndex& theIndx ) const;
int getSection( const QModelIndex& theIndx ) const;
int getPoint( const QModelIndex& theIndx ) const;
void setCurve( CurveCreator_Curve* theCurve );
bool isSection( const QModelIndex& theIndx ) const;
int getSection( const QModelIndex& theIndx ) const;
int getPoint( const QModelIndex& theIndx ) const;
private:
enum IconType{ ICON_POLYLINE, ICON_SPLINE, ICON_CLOSED_SPLINE, ICON_CLOSED_POLYLINE, ICON_POINT };
enum IconType{ ICON_POLYLINE, ICON_SPLINE, ICON_CLOSED_SPLINE, ICON_CLOSED_POLYLINE, ICON_POINT };
private:
CurveCreator_Curve* myCurve;
QMap<IconType, QPixmap> myCachedIcons;
CurveCreator_Curve* myCurve;
QMap<IconType, QPixmap> myCachedIcons;
};
class CurveCreator_TreeView : public QTreeView
{
Q_OBJECT
Q_OBJECT
public:
enum SelectionType{ ST_NOSEL, ST_POINTS, ST_POINTS_ONE_SECTION, ST_SECTIONS, ST_MIXED };
enum SelectionType{ ST_NOSEL, ST_POINTS, ST_POINTS_ONE_SECTION, ST_SECTIONS, ST_MIXED };
public:
explicit CurveCreator_TreeView( CurveCreator_Curve* theCurve, QWidget *parent = 0);
SelectionType getSelectionType() const;
QList<int> getSelectedSections() const;
QList< QPair< int, int > > getSelectedPoints() const;
explicit CurveCreator_TreeView( CurveCreator_Curve* 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 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 sectionsRemoved( int theSection, int theSectionCnt=1 );
void sectionsSwapped( int theSection, int theOffset );
void sectionAdded( int theSection );
void sectionChanged(int theSection , int aSectCnt = 1);
void sectionsRemoved( int theSection, int theSectionCnt=1 );
void sectionsSwapped( int theSection, int theOffset );
void setSelectedSections( const QList<int>& theList );
void setSelectedPoints( const QList< QPair<int, int> >& thePointsList );
void setSelectedSections( const QList<int>& theList );
void setSelectedPoints( const QList< QPair<int, int> >& thePointsList );
void setCurve( CurveCreator_Curve* theCurve );
signals:
void selectionChanged();
void sectionEntered(int);
void pointEntered(int,int);
void selectionChanged();
void sectionEntered(int);
void pointEntered(int,int);
public slots:
protected slots:
void onActivated( QModelIndex theIndx );
void onActivated( QModelIndex theIndx );
protected:
void setIndexState( const QModelIndex& theIndx, bool& isExpanded, bool& isSelected, bool& isCurrent );
void swapIndexes( const QModelIndex& theFirst, const QModelIndex& theSecond );
void getIndexInfo( const QModelIndex& theIndx, bool& isExpanded, bool& isSelected, bool& isCurrent );
private:
CurveCreator_Curve* myCurve;
void setIndexState( const QModelIndex& theIndx, bool& isExpanded, bool& isSelected, bool& isCurrent );
void swapIndexes( const QModelIndex& theFirst, const QModelIndex& theSecond );
void getIndexInfo( const QModelIndex& theIndx, bool& isExpanded, bool& isSelected, bool& isCurrent );
};
#endif // CURVECREATOR_TREEVIEW_H

547
src/CurveCreator/CurveCreator_Widget.cpp
View File

@ -1,547 +0,0 @@
#include "CurveCreator_Widget.h"
#include "CurveCreator_TreeView.h"
#include "QVBoxLayout"
#include "CurveCreator_Curve.hxx"
#include "CurveCreator_CurveEditor.hxx"
#include "CurveCreator.hxx"
#include "CurveCreator_NewPointDlg.h"
#include "CurveCreator_NewSectionDlg.h"
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QLabel>
#include <QLineEdit>
#include <QGroupBox>
#include <QToolButton>
#include <QToolBar>
#include <QAction>
#include <QMenu>
CurveCreator_Widget::CurveCreator_Widget(QWidget *parent) :
QWidget(parent), myNewPointEditor(NULL)
{
//TODO remove it for debug only
myCurve = new CurveCreator_Curve(CurveCreator::Dim2d);
myEdit = new CurveCreator_CurveEditor( myCurve );
CurveCreator::Coordinates aCoords;
aCoords.push_back(10);
aCoords.push_back(20);
aCoords.push_back(1);
aCoords.push_back(2);
myEdit->addSection("",CurveCreator::BSpline, true, aCoords );
aCoords.clear();
aCoords.push_back(11);
aCoords.push_back(21);
aCoords.push_back(111);
aCoords.push_back(211);
aCoords.push_back(101);
aCoords.push_back(201);
aCoords.push_back(13);
aCoords.push_back(25);
myEdit->addSection("",CurveCreator::Polyline, false, aCoords );
aCoords.clear();
for( int i = 0 ; i < 1000000 ; i++ ){
double anX = ((double)i)/10000.;
double anY = ((double)i)/10000. + 3.4;
aCoords.push_back(anX);
aCoords.push_back(anY);
}
myEdit->addSection("",CurveCreator::Polyline, true, aCoords );
//TODO end debug
myNewPointEditor = new CurveCreator_NewPointDlg(myCurve->getDimension(), this);
connect( myNewPointEditor, SIGNAL(addPoint()), this, SLOT(onAddNewPoint()));
myNewSectionEditor = new CurveCreator_NewSectionDlg(this);
connect( myNewSectionEditor, SIGNAL(addSection()), this, SLOT(onAddNewSection()));
QHBoxLayout* aNameLayout = new QHBoxLayout();
QLabel* aNameLabel = new QLabel(tr("CURVE_NAME_TLT"), this);
aNameLayout->addWidget(aNameLabel);
QLineEdit* aNameEdit = new QLineEdit(this);
aNameLayout->addWidget(aNameEdit);
QGroupBox* aSectionGroup = new QGroupBox(tr("SECTION_GROUP_TLT"),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);
// QToolButton* anUndoBtn = new QToolButton(aTB);
QAction* anAct = createAction( UNDO_ID, tr("UNDO"), tr(":images/ICON_UNDO"), tr("UNDO_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Z) );
aTB->addAction(anAct);
anAct = createAction( REDO_ID, tr("REDO"), tr(":images/ICON_REDO"), tr("REDO_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Y) );
aTB->addAction(anAct);
aTB->addSeparator();
anAct = createAction( NEW_SECTION_ID, tr("ICON_NEW_SECTION"), tr(":images/ICON_NEW_SECTION"), tr("NEW_SECTION_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_N) );
connect(anAct, SIGNAL(triggered()), this, SLOT(onNewSection()) );
aTB->addAction(anAct);
anAct = createAction( INSERT_SECTION_BEFORE_ID, tr("INSERT_SECTION_BEFORE"), tr(":images/ICON_INSERT_SECTION_BEFORE"), 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"), tr(":images/ICON_INSERT_SECTION_AFTER"), tr("INSERT_SECTION_AFTER_TLT"),
QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Insert ) );
connect(anAct, SIGNAL(triggered()), this, SLOT(onInsertSectionAfter()) );
anAct = createAction( NEW_POINT_ID, tr("ICON_NEW_POINT"), tr(":images/ICON_NEW_POINT"), tr("NEW_POINT_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_P) );
connect(anAct, SIGNAL(triggered()), this, SLOT(onNewPoint()) );
aTB->addAction(anAct);
aTB->addSeparator();
anAct = createAction( INSERT_POINT_BEFORE_ID, tr("INSERT_POINT_BEFORE"), tr(":images/ICON_POINT_BEFORE"), 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"), tr(":images/ICON_POINT_AFTER"), 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"), tr(":images/ICON_CLOSE_SECTIONS"), 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"), tr(":images/ICON_UNCLOSE_SECTIONS"), 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"), tr(":images/ICON_POLYLINE"), 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"), tr(":images/ICON_SPLINE"), tr("SET_SPLINE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_R) );
connect(anAct, SIGNAL(triggered()), this, SLOT(onSetSpline()) );
anAct = createAction( REMOVE_ID, tr("ICON_REMOVE"), tr(":images/ICON_REMOVE"), 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("ICON_JOIN"), tr(":images/ICON_JOIN"), tr("JOIN_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Plus ) );
connect( anAct, SIGNAL(triggered()), this, SLOT(onJoin()) );
aTB->addAction(anAct);
aTB->addSeparator();
anAct = createAction( UP_ID, tr("ICON_STEP_UP"), tr(":images/ICON_STEP_UP"), tr("STEP_UP_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Up ) );
connect( anAct, SIGNAL(triggered()), this, SLOT(onMoveUp()) );
aTB->addAction(anAct);
anAct = createAction( DOWN_ID, tr("ICON_STEP_DOWN"), tr(":images/ICON_STEP_DOWN"), tr("STEP_DOWN"), QKeySequence(Qt::ControlModifier|Qt::Key_Down ) );
connect( anAct, SIGNAL(triggered()), this, SLOT(onMoveDown()) );
aTB->addAction(anAct);
anAct = createAction( CLEAR_ALL_ID, tr("CLEAR_ALL"), tr(":images/ICON_CLEAR_ALL"), tr("CLEAR_ALL_TLT"), QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Delete ) );
connect( anAct, SIGNAL(triggered()), this, SLOT( onClearAll()) );
aTB->addAction(anAct);
anAct = createAction( JOIN_ALL_ID, tr("JOIN_ALL"), tr(":images/ICON_JOIN_ALL"), tr("JOIN_ALL_TLT"), QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Plus ) );
connect( anAct, SIGNAL(triggered()), this, SLOT(onJoinAll()) );
aTB->addAction(anAct);
QVBoxLayout* aSectLayout = new QVBoxLayout();
aSectLayout->addWidget(aTB);
aSectLayout->addWidget(mySectionView);
aSectionGroup->setLayout(aSectLayout);
QVBoxLayout* aLay = new QVBoxLayout();
aLay->addLayout(aNameLayout);
aLay->addWidget(aSectionGroup);
setLayout(aLay);
onSelectionChanged();
}
void CurveCreator_Widget::onSelectionChanged()
{
QList<ActionId> anEnabledAct;
anEnabledAct << NEW_SECTION_ID;
int aSectCnt = myCurve->getNbPoints();
if( aSectCnt > 0 )
anEnabledAct << CLEAR_ALL_ID;
if( aSectCnt > 1 )
anEnabledAct << JOIN_ALL_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:{
break;
}
case CurveCreator_TreeView::ST_SECTIONS:{
if( aSelSections.size() > 1 ){
anEnabledAct << JOIN_ID;
}
if( aSelSections[0] > 0 ){
anEnabledAct << UP_ID;
}
if( aSelSections.size() == 1 ){
anEnabledAct << NEW_POINT_ID << INSERT_SECTION_BEFORE_ID << INSERT_SECTION_AFTER_ID;
}
if( aSelSections[ aSelSections.size() - 1 ] < ( myCurve->getNbSections() - 1 ) ){
anEnabledAct << DOWN_ID;
}
anEnabledAct << CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID << SET_SECTIONS_SPLINE_ID;
break;
}
case CurveCreator_TreeView::ST_POINTS_ONE_SECTION:{
if( aSelPoints[0].second > 0 ){
anEnabledAct << UP_ID;
}
int aLastIndex = aSelPoints.size()-1;
int aSect = aSelPoints[0].first;
if( aSelPoints[aLastIndex].second < (myCurve->getNbPoints(aSect) - 1)){
anEnabledAct << DOWN_ID;
}
if( aSelPoints.size() == 1){
anEnabledAct << INSERT_POINT_BEFORE_ID << INSERT_POINT_AFTER_ID;
}
break;
}
}
int aSelObjsCnt = aSelPoints.size() + aSelSections.size();
if( aSelObjsCnt > 0 ){
anEnabledAct << REMOVE_ID;
}
if( myCurve->getNbSections() > 0 ){
anEnabledAct << REMOVE_ALL_ID;
}
if( myCurve->getNbSections() > 1 ){
anEnabledAct << JOIN_ALL_ID;
}
QList<ActionId> anIds = myActionMap.keys();
for( int i = 0 ; i < anIds.size() ; i++ ){
if( myActionMap.contains(anIds[i]) ){
if( anEnabledAct.contains(anIds[i]) ){
myActionMap[anIds[i]]->setEnabled(true);
}
else{
myActionMap[anIds[i]]->setEnabled(false);
}
}
}
}
void CurveCreator_Widget::onNewPoint()
{
mySection= -1;
myPointNum = -1;
QList<int> aSelSection = mySectionView->getSelectedSections();
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);
if( myNewPointEditor->exec() == QDialog::Accepted ){
onAddNewPoint();
}
}
void CurveCreator_Widget::onAddNewPoint()
{
CurveCreator::Coordinates aCoords = myNewPointEditor->getCoordinates();
myEdit->insertPoints(aCoords, mySection, myPointNum );
mySectionView->pointsAdded( mySection, myPointNum );
myNewPointEditor->clear();
myPointNum++;
}
void CurveCreator_Widget::onNewSection()
{
myNewSectionEditor->clear();
myNewSectionEditor->setEditMode(false);
QString aSectName = QString( myCurve->getUnicSectionName().c_str() );
myNewSectionEditor->setSectionParameters(aSectName, true, CurveCreator::Polyline );
if( myNewSectionEditor->exec() == QDialog::Accepted ){
onAddNewSection();
}
}
void CurveCreator_Widget::onAddNewSection()
{
CurveCreator::Coordinates aCoords;
myEdit->addSection( myNewSectionEditor->getName().toStdString(), myNewSectionEditor->getSectionType(),
myNewSectionEditor->isClosed(), aCoords );
mySectionView->sectionAdded( mySection );
QString aNewName = QString(myCurve->getUnicSectionName().c_str());
myNewSectionEditor->setSectionName(aNewName);
mySection++;
}
QAction* CurveCreator_Widget::createAction( ActionId theId, const QString& theName, const QString& theImageName,
const QString& theToolTip, const QKeySequence& theShortcut )
{
QAction* anAct = new QAction(theName,this);
QIcon anIcon(theImageName);
if( !anIcon.isNull() ){
anAct->setIcon(anIcon);
}
anAct->setShortcut(theShortcut);
anAct->setToolTip(theToolTip);
myActionMap[theId] = anAct;
return anAct;
}
QAction* CurveCreator_Widget::getAction(ActionId theId)
{
if( myActionMap.contains(theId) )
return myActionMap[theId];
return NULL;
}
void CurveCreator_Widget::onEditSection( int theSection )
{
mySection = theSection;
QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
bool isClosed = myCurve->isClosed(theSection);
CurveCreator::Type aType = myCurve->getType(theSection);
myNewSectionEditor->setEditMode(true);
myNewSectionEditor->setSectionParameters( aSectName, isClosed, aType );
if( myNewSectionEditor->exec() == QDialog::Accepted ){
QString aName = myNewSectionEditor->getName();
bool isClosed = myNewSectionEditor->isClosed();
CurveCreator::Type aSectType = myNewSectionEditor->getSectionType();
myEdit->setClosed( isClosed, mySection );
myEdit->setName( aName.toStdString(), mySection );
myEdit->setType( aSectType, mySection );
mySectionView->sectionChanged(mySection);
}
}
void CurveCreator_Widget::onEditPoint( int theSection, int thePoint )
{
if( !myNewPointEditor ){
}
QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
myNewPointEditor->setEditMode(true);
myNewPointEditor->setSectionName(aSectName);
CurveCreator::Coordinates aCoords = myCurve->getCoordinates(theSection,thePoint);
myNewPointEditor->setCoordinates(aCoords);
if( myNewPointEditor->exec() == QDialog::Accepted ){
aCoords = myNewPointEditor->getCoordinates();
myEdit->setCoordinates(aCoords, theSection, thePoint);
mySectionView->pointDataChanged(theSection, thePoint );
}
}
void CurveCreator_Widget::onJoin()
{
QList<int> aSections = mySectionView->getSelectedSections();
if( aSections.size() == 0 ){
return;
}
int aMainSect = aSections[0];
int aMainSectSize = myCurve->getNbPoints(aMainSect);
for( int i = 1 ; i < aSections.size() ; i++ ){
int aSectNum = aSections[i] - (i-1);
myEdit->join( aMainSect, aSectNum );
mySectionView->sectionsRemoved( aSectNum );
}
int aNewSectSize = myCurve->getNbPoints(aMainSect);
if( aNewSectSize != aMainSectSize )
mySectionView->pointsAdded( aMainSect, aMainSectSize, aNewSectSize-aMainSectSize );
}
void CurveCreator_Widget::onRemove()
{
QList< QPair<int,int> > aSelPoints = mySectionView->getSelectedPoints();
int aCurrSect=-1;
int aRemoveCnt = 0;
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 );
}
mySectionView->clearSelection();
}
void CurveCreator_Widget::onMoveUp()
{
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 );
}
}
}
void CurveCreator_Widget::onMoveDown()
{
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 );
}
}
}
void CurveCreator_Widget::onClearAll()
{
myEdit->clear();
mySectionView->reset();
onSelectionChanged();
}
void CurveCreator_Widget::onJoinAll()
{
myEdit->join();
mySectionView->reset();
onSelectionChanged();
}
void CurveCreator_Widget::onInsertSectionBefore()
{
}
void CurveCreator_Widget::onInsertSectionAfter()
{
}
void CurveCreator_Widget::onInsertPointBefore()
{
}
void CurveCreator_Widget::onInsertPointAfter()
{
}
void CurveCreator_Widget::onUndoSettings()
{
}
void CurveCreator_Widget::onSetSpline()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setType(CurveCreator::BSpline, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onSetPolyline()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setType(CurveCreator::Polyline, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onCloseSections()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setClosed(true, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onUncloseSections()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setClosed(false, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onContextMenu( QPoint thePoint )
{
QList<ActionId> aContextActions;
aContextActions << CLEAR_ALL_ID << JOIN_ALL_ID << SEPARATOR_ID <<
INSERT_SECTION_BEFORE_ID << INSERT_SECTION_AFTER_ID << SEPARATOR_ID <<
CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID <<
SET_SECTIONS_SPLINE_ID << SEPARATOR_ID <<
INSERT_POINT_BEFORE_ID << INSERT_POINT_AFTER_ID;
QPoint aGlPoint = mySectionView->mapToGlobal(thePoint);
bool isVis = false;
QList<ActionId> aResAct;
for( int i = 0 ; i < aContextActions.size() ; i++ ){
if( aContextActions[i] != SEPARATOR_ID ){
if( myActionMap.contains(aContextActions[i]) ){
QAction* anAct = myActionMap[aContextActions[i]];
if( anAct->isEnabled() ){
aResAct << aContextActions[i];
isVis = true;
}
}
}
else{
aResAct << SEPARATOR_ID;
}
}
if( !isVis )
return;
QMenu* aMenu = new QMenu(this);
for( int i = 0 ; i < aResAct.size() ; i++ ){
if( aResAct[i] == SEPARATOR_ID ){
aMenu->addSeparator();
}
else{
QAction* anAct = myActionMap[aResAct[i]];
aMenu->insertAction(NULL, anAct);
}
}
aMenu->exec(aGlPoint);
}

687
src/CurveCreator/CurveCreator_Widget.cxx
View File

@ -1,11 +1,11 @@
#include "CurveCreator_NewPointDlg.h"
#include "CurveCreator_NewSectionDlg.h"
#include "CurveCreator_TreeView.h"
#include "CurveCreator_Widget.h"
#include "CurveCreator.hxx"
#include "CurveCreator_TreeView.h"
#include "QVBoxLayout"
#include "CurveCreator_Curve.hxx"
#include "CurveCreator_CurveEditor.hxx"
#include "CurveCreator.hxx"
#include "CurveCreator_NewPointDlg.h"
#include "CurveCreator_NewSectionDlg.h"
#include <SUIT_Session.h>
#include <SUIT_ResourceMgr.h>
@ -19,29 +19,25 @@
#include <QToolBar>
#include <QAction>
#include <QMenu>
#include <QPixmap>
CurveCreator_Widget::CurveCreator_Widget(QWidget* parent,
CurveCreator_Curve *theCurve,
Qt::WindowFlags fl ) :
QWidget(parent), myNewPointEditor(NULL)
CurveCreator_Curve *theCurve,
Qt::WindowFlags fl) :
QWidget(parent), myNewPointEditor(NULL), myNewSectionEditor(NULL), myEdit(NULL), myCurve(theCurve)
{
myCurve = theCurve;
myEdit = new CurveCreator_CurveEditor( myCurve );
if( myCurve )
myEdit = new CurveCreator_CurveEditor( myCurve );
myNewPointEditor = new CurveCreator_NewPointDlg(myCurve->getDimension(), this);
CurveCreator::Dimension aDim = CurveCreator::Dim3d;
if( myCurve )
aDim = myCurve->getDimension();
myNewPointEditor = new CurveCreator_NewPointDlg(aDim, this);
connect( myNewPointEditor, SIGNAL(addPoint()), this, SLOT(onAddNewPoint()));
myNewSectionEditor = new CurveCreator_NewSectionDlg(this);
connect( myNewSectionEditor, SIGNAL(addSection()), this, SLOT(onAddNewSection()));
/* QHBoxLayout* aNameLayout = new QHBoxLayout();
QLabel* aNameLabel = new QLabel(tr("CURVE_NAME_TLT"), this);
aNameLayout->addWidget(aNameLabel);
QLineEdit* aNameEdit = new QLineEdit(this);
aNameLayout->addWidget(aNameEdit); */
QGroupBox* aSectionGroup = new QGroupBox(tr("SECTION_GROUP_TLT"),this);
QGroupBox* aSectionGroup = new QGroupBox(tr("Sections"),this);
mySectionView = new CurveCreator_TreeView(myCurve, aSectionGroup);
connect( mySectionView, SIGNAL(selectionChanged()), this, SLOT( onSelectionChanged() ) );
@ -51,81 +47,113 @@ CurveCreator_Widget::CurveCreator_Widget(QWidget* parent,
QToolBar* aTB = new QToolBar(tr("TOOL_BAR_TLT"), aSectionGroup);
// QToolButton* anUndoBtn = new QToolButton(aTB);
QPixmap anUndoImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_UNDO")));
QAction* anAct = createAction( UNDO_ID, tr("UNDO"), anUndoImage, tr("UNDO_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Z) );
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 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) );
aTB->addAction(anAct);
QPixmap aRedoImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_REDO")));
anAct = createAction( REDO_ID, tr("REDO"), aRedoImage, tr("REDO_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Y) );
anAct = createAction( REDO_ID, tr("REDO"), aRedoPixmap, tr("REDO_TLT"),
QKeySequence(Qt::ControlModifier|Qt::Key_Y) );
aTB->addAction(anAct);
aTB->addSeparator();
QPixmap aNewSectImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_NEW_SECTION")));
anAct = createAction( NEW_SECTION_ID, tr("NEW_SECTION"), aNewSectImage, tr("NEW_SECTION_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_N) );
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);
anAct = createAction( INSERT_SECTION_BEFORE_ID, tr("INSERT_SECTION_BEFORE"), QPixmap(), tr("INSERT_SECTION_BEFORE_TLT"),
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"),
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()) );
QPixmap aNewPointImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_NEW_POINT")));
anAct = createAction( NEW_POINT_ID, tr("NEW_POINT"), aNewPointImage, tr("NEW_POINT_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_P) );
anAct = createAction( NEW_POINT_ID, tr("NEW_POINT"), aNewPointPixmap, tr("NEW_POINT_TLT"),
QKeySequence(Qt::ControlModifier|Qt::Key_P) );
connect(anAct, SIGNAL(triggered()), this, SLOT(onNewPoint()) );
aTB->addAction(anAct);
aTB->addSeparator();
anAct = createAction( INSERT_POINT_BEFORE_ID, tr("INSERT_POINT_BEFORE"), QPixmap(), tr("INSERT_POINT_BEFORE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_B) );
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) );
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) );
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) );
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()) );
QPixmap aPolylineImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_POLYLINE")));
anAct = createAction( SET_SECTIONS_POLYLINE_ID, tr("SET_SECTIONS_POLYLINE"), aPolylineImage, tr("SET_POLYLINE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_E) );
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()) );
QPixmap aSplineImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_SPLINE")));
anAct = createAction( SET_SECTIONS_SPLINE_ID, tr("SET_SECTIONS_SPLINE"), aSplineImage, tr("SET_SPLINE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_R) );
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()) );
QPixmap aRemoveImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_DELETE")));
anAct = createAction( REMOVE_ID, tr("REMOVE"), aRemoveImage, tr("REMOVE_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Delete ) );
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();
QPixmap aJoinImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_JOIN")));
anAct = createAction( JOIN_ID, tr("JOIN"), aJoinImage, tr("JOIN_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Plus ) );
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();
QPixmap aStepUpImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_ARROW_UP")));
anAct = createAction( UP_ID, tr("STEP_UP"), aStepUpImage, tr("STEP_UP_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Up ) );
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()) );
aTB->addAction(anAct);
QPixmap aStepDownImage(SUIT_Session::session()->resourceMgr()->loadPixmap("GEOM", tr("ICON_CC_ARROW_DOWN")));
anAct = createAction( DOWN_ID, tr("STEP_DOWN"), aStepDownImage, tr("STEP_DOWN_TLT"), QKeySequence(Qt::ControlModifier|Qt::Key_Down ) );
anAct = createAction( DOWN_ID, tr("STEP_DOWN"), aStepDownPixmap, tr("STEP_DOWN"),
QKeySequence(Qt::ControlModifier|Qt::Key_Down ) );
connect( anAct, SIGNAL(triggered()), this, SLOT(onMoveDown()) );
aTB->addAction(anAct);
anAct = createAction( CLEAR_ALL_ID, tr("CLEAR_ALL"), QPixmap(), tr("CLEAR_ALL_TLT"), QKeySequence(Qt::ControlModifier | Qt::ShiftModifier | Qt::Key_Delete ) );
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 ) );
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();
@ -139,294 +167,337 @@ CurveCreator_Widget::CurveCreator_Widget(QWidget* parent,
onSelectionChanged();
}
void CurveCreator_Widget::setCurve( CurveCreator_Curve* theCurve )
{
if( myEdit != NULL ){
delete myEdit;
myEdit = NULL;
}
myCurve = theCurve;
mySectionView->setCurve(myCurve);
if( myCurve != NULL ){
myEdit = new CurveCreator_CurveEditor(myCurve);
}
onSelectionChanged();
}
void CurveCreator_Widget::onSelectionChanged()
{
QList<ActionId> anEnabledAct;
QList<ActionId> anEnabledAct;
if( myCurve ){
anEnabledAct << NEW_SECTION_ID;
int aSectCnt = myCurve->getNbPoints();
if( aSectCnt > 0 )
anEnabledAct << CLEAR_ALL_ID;
anEnabledAct << CLEAR_ALL_ID;
if( aSectCnt > 1 )
anEnabledAct << JOIN_ALL_ID;
anEnabledAct << JOIN_ALL_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:{
break;
break;
}
case CurveCreator_TreeView::ST_SECTIONS:{
if( aSelSections.size() > 1 ){
anEnabledAct << JOIN_ID;
}
if( aSelSections[0] > 0 ){
anEnabledAct << UP_ID;
}
if( aSelSections.size() == 1 ){
anEnabledAct << NEW_POINT_ID << INSERT_SECTION_BEFORE_ID << INSERT_SECTION_AFTER_ID;
}
if( aSelSections[ aSelSections.size() - 1 ] < ( myCurve->getNbSections() - 1 ) ){
anEnabledAct << DOWN_ID;
}
anEnabledAct << CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID << SET_SECTIONS_SPLINE_ID;
break;
if( aSelSections.size() > 1 ){
anEnabledAct << JOIN_ID;
}
if( aSelSections[0] > 0 ){
anEnabledAct << UP_ID;
}
if( aSelSections.size() == 1 ){
anEnabledAct << NEW_POINT_ID << INSERT_SECTION_BEFORE_ID << INSERT_SECTION_AFTER_ID;
}
if( aSelSections[ aSelSections.size() - 1 ] < ( myCurve->getNbSections() - 1 ) ){
anEnabledAct << DOWN_ID;
}
anEnabledAct << CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID << SET_SECTIONS_SPLINE_ID;
break;
}
case CurveCreator_TreeView::ST_POINTS_ONE_SECTION:{
if( aSelPoints[0].second > 0 ){
anEnabledAct << UP_ID;
}
int aLastIndex = aSelPoints.size()-1;
int aSect = aSelPoints[0].first;
if( aSelPoints[aLastIndex].second < (myCurve->getNbPoints(aSect) - 1)){
anEnabledAct << DOWN_ID;
}
if( aSelPoints.size() == 1){
anEnabledAct << INSERT_POINT_BEFORE_ID << INSERT_POINT_AFTER_ID;
}
break;
if( aSelPoints[0].second > 0 ){
anEnabledAct << UP_ID;
}
int aLastIndex = aSelPoints.size()-1;
int aSect = aSelPoints[0].first;
if( aSelPoints[aLastIndex].second < (myCurve->getNbPoints(aSect) - 1)){
anEnabledAct << DOWN_ID;
}
if( aSelPoints.size() == 1){
anEnabledAct << INSERT_POINT_BEFORE_ID << INSERT_POINT_AFTER_ID;
}
break;
}
}
int aSelObjsCnt = aSelPoints.size() + aSelSections.size();
if( aSelObjsCnt > 0 ){
anEnabledAct << REMOVE_ID;
anEnabledAct << REMOVE_ID;
}
if( myCurve->getNbSections() > 0 ){
anEnabledAct << REMOVE_ALL_ID;
if( (myCurve->getNbSections() + myCurve->getNbPoints()) > 0 ){
anEnabledAct << REMOVE_ALL_ID;
}
if( myCurve->getNbSections() > 1 ){
anEnabledAct << JOIN_ALL_ID;
anEnabledAct << JOIN_ALL_ID;
}
QList<ActionId> anIds = myActionMap.keys();
for( int i = 0 ; i < anIds.size() ; i++ ){
if( myActionMap.contains(anIds[i]) ){
if( anEnabledAct.contains(anIds[i]) ){
myActionMap[anIds[i]]->setEnabled(true);
}
else{
myActionMap[anIds[i]]->setEnabled(false);
}
}
}
QList<ActionId> anIds = myActionMap.keys();
for( int i = 0 ; i < anIds.size() ; i++ ){
if( myActionMap.contains(anIds[i]) ){
if( anEnabledAct.contains(anIds[i]) ){
myActionMap[anIds[i]]->setEnabled(true);
}
else{
myActionMap[anIds[i]]->setEnabled(false);
}
}
}
}
void CurveCreator_Widget::onNewPoint()
{
mySection= -1;
myPointNum = -1;
QList<int> aSelSection = mySectionView->getSelectedSections();
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);
if( myNewPointEditor->exec() == QDialog::Accepted ){
onAddNewPoint();
if( !myEdit )
return;
mySection= -1;
myPointNum = -1;
QList<int> aSelSection = mySectionView->getSelectedSections();
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());
if( myNewPointEditor->exec() == QDialog::Accepted ){
onAddNewPoint();
}
}
void CurveCreator_Widget::onAddNewPoint()
{
CurveCreator::Coordinates aCoords = myNewPointEditor->getCoordinates();
myEdit->insertPoints(aCoords, mySection, myPointNum );
mySectionView->pointsAdded( mySection, myPointNum );
myNewPointEditor->clear();
myPointNum++;
if( !myEdit )
return;
CurveCreator::Coordinates aCoords = myNewPointEditor->getCoordinates();
myEdit->insertPoints(aCoords, mySection, myPointNum );
mySectionView->pointsAdded( mySection, myPointNum );
myNewPointEditor->clear();
myPointNum++;
onSelectionChanged();
}
void CurveCreator_Widget::onNewSection()
{
myNewSectionEditor->clear();
myNewSectionEditor->setEditMode(false);
QString aSectName = QString( myCurve->getUnicSectionName().c_str() );
myNewSectionEditor->setSectionParameters(aSectName, true, CurveCreator::Polyline );
if( myNewSectionEditor->exec() == QDialog::Accepted ){
onAddNewSection();
}
if( !myEdit )
return;
myNewSectionEditor->clear();
myNewSectionEditor->setEditMode(false);
QString aSectName = QString( myCurve->getUnicSectionName().c_str() );
myNewSectionEditor->setSectionParameters(aSectName, true, CurveCreator::Polyline );
if( myNewSectionEditor->exec() == QDialog::Accepted ){
onAddNewSection();
}
}
void CurveCreator_Widget::onAddNewSection()
{
CurveCreator::Coordinates aCoords;
myEdit->addSection( myNewSectionEditor->getName().toStdString(), myNewSectionEditor->getSectionType(),
myNewSectionEditor->isClosed(), aCoords );
mySectionView->sectionAdded( mySection );
QString aNewName = QString(myCurve->getUnicSectionName().c_str());
myNewSectionEditor->setSectionName(aNewName);
mySection++;
if( !myEdit )
return;
CurveCreator::Coordinates aCoords;
myEdit->addSection( myNewSectionEditor->getName().toStdString(), myNewSectionEditor->getSectionType(),
myNewSectionEditor->isClosed(), aCoords );
mySectionView->sectionAdded( mySection );
QString aNewName = QString(myCurve->getUnicSectionName().c_str());
myNewSectionEditor->setSectionName(aNewName);
mySection++;
onSelectionChanged();
}
QAction* CurveCreator_Widget::createAction( ActionId theId, const QString& theName,
const QPixmap& theImage, const QString& theToolTip,
const QKeySequence& theShortcut )
QAction* CurveCreator_Widget::createAction( ActionId theId, const QString& theName, const QPixmap& theImage,
const QString& theToolTip, const QKeySequence& theShortcut )
{
QAction* anAct = new QAction(theName,this);
if( !theImage.isNull() ){
anAct->setIcon(theImage);
}
anAct->setShortcut(theShortcut);
anAct->setToolTip(theToolTip);
myActionMap[theId] = anAct;
return anAct;
QAction* anAct = new QAction(theName,this);
if( !theImage.isNull() ){
anAct->setIcon(theImage);
}
anAct->setShortcut(theShortcut);
anAct->setToolTip(theToolTip);
myActionMap[theId] = anAct;
return anAct;
}
QAction* CurveCreator_Widget::getAction(ActionId theId)
{
if( myActionMap.contains(theId) )
return myActionMap[theId];
return NULL;
if( myActionMap.contains(theId) )
return myActionMap[theId];
return NULL;
}
void CurveCreator_Widget::onEditSection( int theSection )
{
mySection = theSection;
QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
bool isClosed = myCurve->isClosed(theSection);
CurveCreator::Type aType = myCurve->getType(theSection);
myNewSectionEditor->setEditMode(true);
myNewSectionEditor->setSectionParameters( aSectName, isClosed, aType );
if( myNewSectionEditor->exec() == QDialog::Accepted ){
QString aName = myNewSectionEditor->getName();
bool isClosed = myNewSectionEditor->isClosed();
CurveCreator::Type aSectType = myNewSectionEditor->getSectionType();
myEdit->setClosed( isClosed, mySection );
myEdit->setName( aName.toStdString(), mySection );
myEdit->setType( aSectType, mySection );
mySectionView->sectionChanged(mySection);
}
if( !myEdit )
return;
mySection = theSection;
QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
bool isClosed = myCurve->isClosed(theSection);
CurveCreator::Type aType = myCurve->getType(theSection);
myNewSectionEditor->setEditMode(true);
myNewSectionEditor->setSectionParameters( aSectName, isClosed, aType );
if( myNewSectionEditor->exec() == QDialog::Accepted ){
QString aName = myNewSectionEditor->getName();
bool isClosed = myNewSectionEditor->isClosed();
CurveCreator::Type aSectType = myNewSectionEditor->getSectionType();
myEdit->setClosed( isClosed, mySection );
myEdit->setName( aName.toStdString(), mySection );
myEdit->setType( aSectType, mySection );
mySectionView->sectionChanged(mySection);
}
}
void CurveCreator_Widget::onEditPoint( int theSection, int thePoint )
{
if( !myNewPointEditor ){
}
QString aSectName = QString::fromStdString( myCurve->getSectionName(theSection));
myNewPointEditor->setEditMode(true);
myNewPointEditor->setSectionName(aSectName);
CurveCreator::Coordinates aCoords = myCurve->getCoordinates(theSection,thePoint);
myNewPointEditor->setCoordinates(aCoords);
if( myNewPointEditor->exec() == QDialog::Accepted ){
aCoords = myNewPointEditor->getCoordinates();
myEdit->setCoordinates(aCoords, theSection, thePoint);
mySectionView->pointDataChanged(theSection, thePoint );
}
if( !myNewPointEditor )
return;
if( !myEdit )
return;
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);
if( myNewPointEditor->exec() == QDialog::Accepted ){
aCoords = myNewPointEditor->getCoordinates();
myEdit->setCoordinates(aCoords, theSection, thePoint);
mySectionView->pointDataChanged(theSection, thePoint );
}
}
void CurveCreator_Widget::onJoin()
{
QList<int> aSections = mySectionView->getSelectedSections();
if( aSections.size() == 0 ){
return;
}
int aMainSect = aSections[0];
int aMainSectSize = myCurve->getNbPoints(aMainSect);
for( int i = 1 ; i < aSections.size() ; i++ ){
int aSectNum = aSections[i] - (i-1);
myEdit->join( aMainSect, aSectNum );
mySectionView->sectionsRemoved( aSectNum );
}
int aNewSectSize = myCurve->getNbPoints(aMainSect);
if( aNewSectSize != aMainSectSize )
mySectionView->pointsAdded( aMainSect, aMainSectSize, aNewSectSize-aMainSectSize );
if( !myEdit )
return;
QList<int> aSections = mySectionView->getSelectedSections();
if( aSections.size() == 0 ){
return;
}
int aMainSect = aSections[0];
int aMainSectSize = myCurve->getNbPoints(aMainSect);
for( int i = 1 ; i < aSections.size() ; i++ ){
int aSectNum = aSections[i] - (i-1);
myEdit->join( aMainSect, aSectNum );
mySectionView->sectionsRemoved( aSectNum );
}
int aNewSectSize = myCurve->getNbPoints(aMainSect);
if( aNewSectSize != aMainSectSize )
mySectionView->pointsAdded( aMainSect, aMainSectSize, aNewSectSize-aMainSectSize );
}
void CurveCreator_Widget::onRemove()
{
QList< QPair<int,int> > aSelPoints = mySectionView->getSelectedPoints();
int aCurrSect=-1;
int aRemoveCnt = 0;
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++;
if( !myEdit )
return;
QList< QPair<int,int> > aSelPoints = mySectionView->getSelectedPoints();
int aCurrSect=-1;
int aRemoveCnt = 0;
for( int i = 0 ; i < aSelPoints.size() ; i++ ){
if( aCurrSect != aSelPoints[i].first ){
aRemoveCnt = 0;
aCurrSect = aSelPoints[i].first;
}
QList<int> aSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSections.size() ; i++ ){
int aSectNum = aSections[i] - (i);
myEdit->removeSection( aSectNum );
mySectionView->sectionsRemoved( aSectNum );
}
mySectionView->clearSelection();
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 );
}
mySectionView->clearSelection();
}
void CurveCreator_Widget::onMoveUp()
{
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 );
}
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 );
}
}
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 );
}
}
}
void CurveCreator_Widget::onMoveDown()
{
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 );
}
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 );
}
}
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 );
}
}
}
void CurveCreator_Widget::onClearAll()
{
myEdit->clear();
mySectionView->reset();
onSelectionChanged();
if( !myEdit )
return;
myEdit->clear();
mySectionView->reset();
onSelectionChanged();
}
void CurveCreator_Widget::onJoinAll()
{
myEdit->join();
mySectionView->reset();
onSelectionChanged();
if( !myEdit )
return;
myEdit->join();
mySectionView->reset();
onSelectionChanged();
}
void CurveCreator_Widget::onInsertSectionBefore()
@ -456,77 +527,85 @@ void CurveCreator_Widget::onUndoSettings()
void CurveCreator_Widget::onSetSpline()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setType(CurveCreator::BSpline, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
if( !myEdit )
return;
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setType(CurveCreator::BSpline, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onSetPolyline()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setType(CurveCreator::Polyline, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
if( !myEdit )
return;
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setType(CurveCreator::Polyline, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onCloseSections()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setClosed(true, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
if( !myEdit )
return;
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setClosed(true, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onUncloseSections()
{
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setClosed(false, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
if( !myEdit )
return;
QList<int> aSelSections = mySectionView->getSelectedSections();
for( int i = 0 ; i < aSelSections.size() ; i++ ){
myEdit->setClosed(false, aSelSections[i]);
mySectionView->sectionChanged(aSelSections[i]);
}
}
void CurveCreator_Widget::onContextMenu( QPoint thePoint )
{
QList<ActionId> aContextActions;
aContextActions << CLEAR_ALL_ID << JOIN_ALL_ID << SEPARATOR_ID <<
INSERT_SECTION_BEFORE_ID << INSERT_SECTION_AFTER_ID << SEPARATOR_ID <<
CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID <<
SET_SECTIONS_SPLINE_ID << SEPARATOR_ID <<
INSERT_POINT_BEFORE_ID << INSERT_POINT_AFTER_ID;
QPoint aGlPoint = mySectionView->mapToGlobal(thePoint);
bool isVis = false;
QList<ActionId> aResAct;
for( int i = 0 ; i < aContextActions.size() ; i++ ){
if( aContextActions[i] != SEPARATOR_ID ){
if( myActionMap.contains(aContextActions[i]) ){
QAction* anAct = myActionMap[aContextActions[i]];
if( anAct->isEnabled() ){
aResAct << aContextActions[i];
isVis = true;
}
}
}
else{
aResAct << SEPARATOR_ID;
QList<ActionId> aContextActions;
aContextActions << CLEAR_ALL_ID << JOIN_ALL_ID << SEPARATOR_ID <<
INSERT_SECTION_BEFORE_ID << INSERT_SECTION_AFTER_ID << SEPARATOR_ID <<
CLOSE_SECTIONS_ID << UNCLOSE_SECTIONS_ID << SET_SECTIONS_POLYLINE_ID <<
SET_SECTIONS_SPLINE_ID << SEPARATOR_ID <<
INSERT_POINT_BEFORE_ID << INSERT_POINT_AFTER_ID;
QPoint aGlPoint = mySectionView->mapToGlobal(thePoint);
bool isVis = false;
QList<ActionId> aResAct;
for( int i = 0 ; i < aContextActions.size() ; i++ ){
if( aContextActions[i] != SEPARATOR_ID ){
if( myActionMap.contains(aContextActions[i]) ){
QAction* anAct = myActionMap[aContextActions[i]];
if( anAct->isEnabled() ){
aResAct << aContextActions[i];
isVis = true;
}
}
}
if( !isVis )
return;
else{
aResAct << SEPARATOR_ID;
}
}
if( !isVis )
return;
QMenu* aMenu = new QMenu(this);
for( int i = 0 ; i < aResAct.size() ; i++ ){
if( aResAct[i] == SEPARATOR_ID ){
aMenu->addSeparator();
}
else{
QAction* anAct = myActionMap[aResAct[i]];
aMenu->insertAction(NULL, anAct);
}
QMenu* aMenu = new QMenu(this);
for( int i = 0 ; i < aResAct.size() ; i++ ){
if( aResAct[i] == SEPARATOR_ID ){
aMenu->addSeparator();
}
aMenu->exec(aGlPoint);
else{
QAction* anAct = myActionMap[aResAct[i]];
aMenu->insertAction(NULL, anAct);
}
}
aMenu->exec(aGlPoint);
}

4
src/CurveCreator/CurveCreator_Widget.h
View File

@ -21,7 +21,9 @@ public:
explicit CurveCreator_Widget( QWidget* parent,
CurveCreator_Curve *theCurve,
Qt::WindowFlags fl=0 );
void setCurve( CurveCreator_Curve* theCurve );
signals:
public slots: