From 8942991d2948056b674eaa2775210919f3d0cfca Mon Sep 17 00:00:00 2001 From: dismine Date: Mon, 29 Jul 2013 15:55:40 +0300 Subject: [PATCH] Add tool ShoulderPoint --- Valentina.pro | 11 +- cursor.qrc | 1 + cursor/shoulder_cursor.png | Bin 0 -> 1308 bytes dialogs/dialogalongline.cpp | 23 +- dialogs/dialogendline.cpp | 29 +-- dialogs/dialogincrements.h | 2 +- dialogs/dialogshoulderpoint.cpp | 146 +++++++++++++ dialogs/dialogshoulderpoint.h | 45 ++++ dialogs/dialogshoulderpoint.ui | 368 ++++++++++++++++++++++++++++++++ dialogs/dialogtool.cpp | 34 +++ dialogs/dialogtool.h | 3 + icon.qrc | 1 + icon/32x32/shoulder.png | Bin 0 -> 683 bytes mainwindow.cpp | 62 +++++- mainwindow.h | 9 +- mainwindow.ui | 24 ++- tools/vabstracttool.cpp | 12 ++ tools/vabstracttool.h | 1 + tools/vtoolalongline.cpp | 9 +- tools/vtoolendline.cpp | 9 +- tools/vtoolline.cpp | 9 +- tools/vtoolshoulderpoint.cpp | 156 ++++++++++++++ tools/vtoolshoulderpoint.h | 33 +++ tools/vtoolsimplepoint.cpp | 9 +- xml/vdomdocument.cpp | 42 ++++ 25 files changed, 951 insertions(+), 87 deletions(-) create mode 100644 cursor/shoulder_cursor.png create mode 100644 dialogs/dialogshoulderpoint.cpp create mode 100644 dialogs/dialogshoulderpoint.h create mode 100644 dialogs/dialogshoulderpoint.ui create mode 100644 icon/32x32/shoulder.png create mode 100644 tools/vtoolshoulderpoint.cpp create mode 100644 tools/vtoolshoulderpoint.h diff --git a/Valentina.pro b/Valentina.pro index 90541aca6..466a00d18 100644 --- a/Valentina.pro +++ b/Valentina.pro @@ -34,7 +34,9 @@ SOURCES += main.cpp\ dialogs/dialogline.cpp \ tools/vtoolalongline.cpp \ dialogs/dialogtool.cpp \ - dialogs/dialogalongline.cpp + dialogs/dialogalongline.cpp \ + tools/vtoolshoulderpoint.cpp \ + dialogs/dialogshoulderpoint.cpp HEADERS += mainwindow.h \ widgets/vmaingraphicsscene.h \ @@ -59,14 +61,17 @@ HEADERS += mainwindow.h \ dialogs/dialogline.h \ tools/vtoolalongline.h \ dialogs/dialogtool.h \ - dialogs/dialogalongline.h + dialogs/dialogalongline.h \ + tools/vtoolshoulderpoint.h \ + dialogs/dialogshoulderpoint.h FORMS += mainwindow.ui \ dialogs/dialogsinglepoint.ui \ dialogs/dialogincrements.ui \ dialogs/dialogendline.ui \ dialogs/dialogline.ui \ - dialogs/dialogalongline.ui + dialogs/dialogalongline.ui \ + dialogs/dialogshoulderpoint.ui RESOURCES += \ icon.qrc \ diff --git a/cursor.qrc b/cursor.qrc index 453c3545d..a0ac3a747 100644 --- a/cursor.qrc +++ b/cursor.qrc @@ -4,5 +4,6 @@ cursor/endline_cursor.png cursor/line_cursor.png cursor/alongline_cursor.png + cursor/shoulder_cursor.png diff --git a/cursor/shoulder_cursor.png b/cursor/shoulder_cursor.png new file mode 100644 index 0000000000000000000000000000000000000000..d425cea79186d242969436eb4a69fe5400f1f979 GIT binary patch literal 1308 zcmV+%1>^dOP)Vl&|00006VoOIv0RI60 z0RN!9r;`8x010qNS#tmY3ljhU3ljkVnw%H_000McNliru-3J{ABNIj=kput$06}y` zSad^gZEa<4bO1wAML|?gQaT`KWG!lNWoICEF)lD5D0OpbZf77#N=G0{P(?=|b~Z98 zEFf`pVQgu1c_2L?IWP*aMOc#n00dk~L_t(Y$HkU!OjUIl$3MUGCltFVY{j)`nIYxk z;&9gqifaQKUWN&-HrCdkiM4J6{}j8;e9?T>o7O8|xOx%J3f9JQt*s?2#|wfs78?Q6 z0@Dq)P{3;j%Jtmy^uph{JLokrx%OLCjM1*t&C*s%rS3f-ZEbBRr6d>(N_lyC zcE&XK^!A%l3d^z(5qf)j=e*}9Po7j6qup6+jE;^H zjYdb~@i;j-Iqw0VEScta0wW^0u8W8;GBU#C=N+_-TAfKVuOZ#wSUwJUX=17a9Ps>C9Zhyb}j9$OuK+Em4dsG87H8q`0BobZ6j~{;_nM}T@_YDJOz^}kBz&J1iBy{t^ zyUt8auh{d(>({SbnZ3Fqkjta1*D`q-);zgZUU{w21d1Q0r(sE6Zly-naA|IYTzkgnU=}aR~uNK zle5xN0Nb~3AMEPt3KbU@Gc+{h*HHm=z(@N2ec+Uipg_y;IPe5827C)_2AVZPzX79K zrYpcjAfRO$@qV2@0CI13>UzPPK918{k!q_(z~sC)uqQ1Y$surunGW+R@-w059uA1o(0> zohT1@PH!-xqq&o<1&V=lz?q6ITigvBO01uHdycomboBoxSecondPoint->findData(secondPointId); - if(index != -1){ - ui->comboBoxSecondPoint->setCurrentIndex(index); - } + ChangeCurrentData(ui->comboBoxSecondPoint, value); } qint64 DialogAlongLine::getFirstPointId() const{ @@ -97,10 +94,7 @@ qint64 DialogAlongLine::getFirstPointId() const{ void DialogAlongLine::setFirstPointId(const qint64 &value){ firstPointId = value; - qint32 index = ui->comboBoxFirstPoint->findData(firstPointId); - if(index != -1){ - ui->comboBoxFirstPoint->setCurrentIndex(index); - } + ChangeCurrentData(ui->comboBoxFirstPoint, value); } QString DialogAlongLine::getFormula() const{ @@ -118,18 +112,7 @@ QString DialogAlongLine::getTypeLine() const{ void DialogAlongLine::setTypeLine(const QString &value){ typeLine = value; - if(typeLine == "hair"){ - qint32 index = ui->comboBoxLineType->findText("Лінія"); - if(index != -1){ - ui->comboBoxLineType->setCurrentIndex(index); - } - } - if(typeLine == "none"){ - qint32 index = ui->comboBoxLineType->findText("Без лінії"); - if(index != -1){ - ui->comboBoxLineType->setCurrentIndex(index); - } - } + SetupTypeLine(ui->comboBoxLineType, value); } QString DialogAlongLine::getPointName() const{ diff --git a/dialogs/dialogendline.cpp b/dialogs/dialogendline.cpp index 664d5eb22..94001b2ba 100644 --- a/dialogs/dialogendline.cpp +++ b/dialogs/dialogendline.cpp @@ -62,10 +62,7 @@ DialogEndLine::DialogEndLine(const VContainer *data, QWidget *parent) : void DialogEndLine::ChoosedPoint(qint64 id, Scene::Type type){ if(type == Scene::Point){ VPointF point = data->GetPoint(id); - qint32 index = ui->comboBoxBasePoint->findText(point.name()); - if ( index != -1 ) { // -1 for not found - ui->comboBoxBasePoint->setCurrentIndex(index); - } + ChangeCurrentText(ui->comboBoxBasePoint, point.name()); this->show(); } } @@ -85,18 +82,7 @@ QString DialogEndLine::getTypeLine() const{ void DialogEndLine::setTypeLine(const QString &value){ typeLine = value; - if(typeLine == "hair"){ - qint32 index = ui->comboBoxLineType->findText("Лінія"); - if(index != -1){ - ui->comboBoxLineType->setCurrentIndex(index); - } - } - if(typeLine == "none"){ - qint32 index = ui->comboBoxLineType->findText("Без лінії"); - if(index != -1){ - ui->comboBoxLineType->setCurrentIndex(index); - } - } + SetupTypeLine(ui->comboBoxLineType, value); } QString DialogEndLine::getFormula() const{ @@ -117,18 +103,13 @@ void DialogEndLine::setAngle(const qint32 &value){ ui->spinBoxAngle->setValue(angle); } -qint64 DialogEndLine::getBasePointId() const -{ +qint64 DialogEndLine::getBasePointId() const{ return basePointId; } -void DialogEndLine::setBasePointId(const qint64 &value) -{ +void DialogEndLine::setBasePointId(const qint64 &value){ basePointId = value; - qint32 index = ui->comboBoxBasePoint->findData(basePointId); - if(index != -1){ - ui->comboBoxBasePoint->setCurrentIndex(index); - } + ChangeCurrentData(ui->comboBoxBasePoint, value); } void DialogEndLine::DialogAccepted(){ diff --git a/dialogs/dialogincrements.h b/dialogs/dialogincrements.h index 86e77c889..92019090d 100644 --- a/dialogs/dialogincrements.h +++ b/dialogs/dialogincrements.h @@ -28,7 +28,7 @@ signals: void haveLiteChange(); private: Ui::DialogIncrements *ui; - VContainer *data; + VContainer *data; // need because we must change data VDomDocument *doc; void InitialStandartTable(); void InitialIncrementTable(); diff --git a/dialogs/dialogshoulderpoint.cpp b/dialogs/dialogshoulderpoint.cpp new file mode 100644 index 000000000..801f6bf83 --- /dev/null +++ b/dialogs/dialogshoulderpoint.cpp @@ -0,0 +1,146 @@ +#include "dialogshoulderpoint.h" +#include "ui_dialogshoulderpoint.h" + +DialogShoulderPoint::DialogShoulderPoint(const VContainer *data, QWidget *parent) : + DialogTool(data, parent), ui(new Ui::DialogShoulderPoint) +{ + ui->setupUi(this); + number = 0; + listWidget = ui->listWidget; + labelResultCalculation = ui->labelResultCalculation; + labelDescription = ui->labelDescription; + radioButtonSizeGrowth = ui->radioButtonSizeGrowth; + radioButtonStandartTable = ui->radioButtonStandartTable; + radioButtonIncrements = ui->radioButtonIncrements; + radioButtonLengthLine = ui->radioButtonLengthLine; + lineEditFormula = ui->lineEditFormula; + flagFormula = false; + bOk = ui->buttonBox->button(QDialogButtonBox::Ok); + connect(bOk, &QPushButton::clicked, this, &DialogShoulderPoint::DialogAccepted); + flagName = false; + CheckState(); + QPushButton *bCansel = ui->buttonBox->button(QDialogButtonBox::Cancel); + connect(bCansel, &QPushButton::clicked, this, &DialogShoulderPoint::DialogRejected); + FillComboBoxTypeLine(ui->comboBoxLineType); + FillComboBoxPoints(ui->comboBoxP1Line); + FillComboBoxPoints(ui->comboBoxP2Line); + FillComboBoxPoints(ui->comboBoxPShoulder); + + connect(ui->toolButtonPutHere, &QPushButton::clicked, this, &DialogShoulderPoint::PutHere); + connect(ui->listWidget, &QListWidget::itemDoubleClicked, this, &DialogShoulderPoint::PutVal); + connect(ui->listWidget, &QListWidget::currentRowChanged, this, &DialogShoulderPoint::ValChenged); + + ShowBase(); + connect(ui->radioButtonSizeGrowth, &QRadioButton::clicked, this, &DialogShoulderPoint::SizeGrowth); + connect(ui->radioButtonStandartTable, &QRadioButton::clicked, this, &DialogShoulderPoint::StandartTable); + connect(ui->radioButtonIncrements, &QRadioButton::clicked, this, &DialogShoulderPoint::Increments); + connect(ui->radioButtonLengthLine, &QRadioButton::clicked, this, &DialogShoulderPoint::LengthLines); + connect(ui->toolButtonEqual, &QPushButton::clicked, this, &DialogShoulderPoint::EvalFormula); + connect(ui->lineEditNamePoint, &QLineEdit::textChanged, this, &DialogShoulderPoint::NamePointChanged); + connect(ui->lineEditFormula, &QLineEdit::textChanged, this, &DialogShoulderPoint::FormulaChanged); +} + +DialogShoulderPoint::~DialogShoulderPoint() +{ + delete ui; +} + +void DialogShoulderPoint::ChoosedPoint(qint64 id, Scene::Type type){ + if(type == Scene::Point){ + VPointF point = data->GetPoint(id); + if(number == 0){ + qint32 index = ui->comboBoxP1Line->findText(point.name()); + if ( index != -1 ) { // -1 for not found + ui->comboBoxP1Line->setCurrentIndex(index); + number++; + return; + } + } + if(number == 1){ + qint32 index = ui->comboBoxP2Line->findText(point.name()); + if ( index != -1 ) { // -1 for not found + ui->comboBoxP2Line->setCurrentIndex(index); + number++; + return; + } + } + if(number == 2){ + qint32 index = ui->comboBoxPShoulder->findText(point.name()); + if ( index != -1 ) { // -1 for not found + ui->comboBoxPShoulder->setCurrentIndex(index); + number = 0; + } + if(!isInitialized){ + this->show(); + } + } + } +} + +void DialogShoulderPoint::DialogAccepted(){ + pointName = ui->lineEditNamePoint->text(); + typeLine = GetTypeLine(ui->comboBoxLineType); + formula = ui->lineEditFormula->text(); + qint32 index = ui->comboBoxP1Line->currentIndex(); + p1Line = qvariant_cast(ui->comboBoxP1Line->itemData(index)); + index = ui->comboBoxP2Line->currentIndex(); + p2Line = qvariant_cast(ui->comboBoxP2Line->itemData(index)); + index = ui->comboBoxPShoulder->currentIndex(); + pShoulder = qvariant_cast(ui->comboBoxPShoulder->itemData(index)); + emit DialogClosed(QDialog::Accepted); +} + +qint64 DialogShoulderPoint::getPShoulder() const{ + return pShoulder; +} + +void DialogShoulderPoint::setPShoulder(const qint64 &value){ + pShoulder = value; + ChangeCurrentData(ui->comboBoxPShoulder, value); +} + +qint64 DialogShoulderPoint::getP2Line() const{ + return p2Line; +} + +void DialogShoulderPoint::setP2Line(const qint64 &value){ + p2Line = value; + ChangeCurrentData(ui->comboBoxP2Line, value); +} + +qint64 DialogShoulderPoint::getP1Line() const{ + return p1Line; +} + +void DialogShoulderPoint::setP1Line(const qint64 &value) +{ + p1Line = value; + ChangeCurrentData(ui->comboBoxP1Line, value); +} + +QString DialogShoulderPoint::getFormula() const{ + return formula; +} + +void DialogShoulderPoint::setFormula(const QString &value){ + formula = value; + ui->lineEditFormula->setText(formula); +} + +QString DialogShoulderPoint::getTypeLine() const{ + return typeLine; +} + +void DialogShoulderPoint::setTypeLine(const QString &value){ + typeLine = value; + SetupTypeLine(ui->comboBoxLineType, value); +} + +QString DialogShoulderPoint::getPointName() const{ + return pointName; +} + +void DialogShoulderPoint::setPointName(const QString &value){ + pointName = value; + ui->lineEditNamePoint->setText(pointName); +} diff --git a/dialogs/dialogshoulderpoint.h b/dialogs/dialogshoulderpoint.h new file mode 100644 index 000000000..dc7864ed9 --- /dev/null +++ b/dialogs/dialogshoulderpoint.h @@ -0,0 +1,45 @@ +#ifndef DIALOGSHOULDERPOINT_H +#define DIALOGSHOULDERPOINT_H + +#include "dialogtool.h" +#include "../options.h" +#include "../container/vcontainer.h" +#include "../container/calculator.h" + +namespace Ui { +class DialogShoulderPoint; +} + +class DialogShoulderPoint : public DialogTool +{ + Q_OBJECT +public: + explicit DialogShoulderPoint(const VContainer *data, QWidget *parent = 0); + ~DialogShoulderPoint(); + QString getPointName() const; + void setPointName(const QString &value); + QString getTypeLine() const; + void setTypeLine(const QString &value); + QString getFormula() const; + void setFormula(const QString &value); + qint64 getP1Line() const; + void setP1Line(const qint64 &value); + qint64 getP2Line() const; + void setP2Line(const qint64 &value); + qint64 getPShoulder() const; + void setPShoulder(const qint64 &value); +public slots: + virtual void ChoosedPoint(qint64 id, Scene::Type type); + virtual void DialogAccepted(); +private: + Ui::DialogShoulderPoint *ui; + qint32 number; + QString pointName; + QString typeLine; + QString formula; + qint64 p1Line; + qint64 p2Line; + qint64 pShoulder; +}; + +#endif // DIALOGSHOULDERPOINT_H diff --git a/dialogs/dialogshoulderpoint.ui b/dialogs/dialogshoulderpoint.ui new file mode 100644 index 000000000..8fcbc118b --- /dev/null +++ b/dialogs/dialogshoulderpoint.ui @@ -0,0 +1,368 @@ + + + DialogShoulderPoint + + + + 0 + 0 + 473 + 485 + + + + Dialog + + + + + + + + + 0 + 0 + + + + Відстань + + + + + + + + 0 + 0 + + + + + + + + ... + + + + :/icon/24x24/equal.png:/icon/24x24/equal.png + + + + 24 + 24 + + + + + + + + + 0 + 0 + + + + + 87 + 0 + + + + _ + + + + + + + + + + + + + + + + 0 + 0 + + + + Ім'я нової точки + + + + + + + + + + ... + + + + :/icon/24x24/putHere.png:/icon/24x24/putHere.png + + + + 24 + 24 + + + + + + + + + + + + + 0 + 0 + + + + Перша точка + + + + + + + + 0 + 0 + + + + + 145 + 0 + + + + + + + + + + + + + 0 + 0 + + + + Друга точка + + + + + + + + 0 + 0 + + + + + 143 + 0 + + + + + + + + + + + + + 0 + 0 + + + + Точка плеча + + + + + + + + 0 + 0 + + + + + 145 + 0 + + + + + + + + + + + + + 0 + 0 + + + + Тип лінії + + + + + + + + + + + + + + Вхідні данні + + + + + + + Розмір і зріст + + + true + + + + + + + Стандартна таблиця + + + + + + + Прибавки + + + + + + + true + + + Довжини ліній + + + + + + + false + + + Довжини дуг + + + + + + + false + + + Довжини сплайні + + + + + + + + + + + + + + + + + + + + + + + Qt::Horizontal + + + QDialogButtonBox::Cancel|QDialogButtonBox::Ok + + + + + + + + + + + buttonBox + accepted() + DialogShoulderPoint + accept() + + + 248 + 254 + + + 157 + 274 + + + + + buttonBox + rejected() + DialogShoulderPoint + reject() + + + 316 + 260 + + + 286 + 274 + + + + + diff --git a/dialogs/dialogtool.cpp b/dialogs/dialogtool.cpp index 0f6cf09b2..7e8e318d0 100644 --- a/dialogs/dialogtool.cpp +++ b/dialogs/dialogtool.cpp @@ -135,6 +135,35 @@ void DialogTool::ShowLengthLines(){ listWidget->setCurrentRow (0); } +void DialogTool::SetupTypeLine(QComboBox *box, const QString &value){ + if(value == "hair"){ + qint32 index = box->findText("Лінія"); + if(index != -1){ + box->setCurrentIndex(index); + } + } + if(value == "none"){ + qint32 index = box->findText("Без лінії"); + if(index != -1){ + box->setCurrentIndex(index); + } + } +} + +void DialogTool::ChangeCurrentText(QComboBox *box, const QString &value){ + qint32 index = box->findText(value); + if(index != -1){ + box->setCurrentIndex(index); + } +} + +void DialogTool::ChangeCurrentData(QComboBox *box, const qint64 &value){ + qint32 index = box->findData(value); + if(index != -1){ + box->setCurrentIndex(index); + } +} + void DialogTool::CheckState(){ Q_CHECK_PTR(bOk); bOk->setEnabled(flagFormula & flagName); @@ -302,6 +331,11 @@ void DialogTool::ValChenged(int row){ .arg(itable.getDescription()); labelDescription->setText(desc); } + if(radioButtonLengthLine->isChecked()){ + QString desc = QString("%1(%2) - %3").arg(item->text()).arg(data->GetLine(item->text())) + .arg("Довжина лінії"); + labelDescription->setText(desc); + } } void DialogTool::UpdateList(){ diff --git a/dialogs/dialogtool.h b/dialogs/dialogtool.h index 42260b699..a8d8acde3 100644 --- a/dialogs/dialogtool.h +++ b/dialogs/dialogtool.h @@ -70,6 +70,9 @@ protected: void ShowStandartTable(); void ShowIncrementTable(); void ShowLengthLines(); + void SetupTypeLine(QComboBox *box, const QString &value); + void ChangeCurrentText(QComboBox *box, const QString &value); + void ChangeCurrentData(QComboBox *box, const qint64 &value); }; #endif // DIALOGTOOL_H diff --git a/icon.qrc b/icon.qrc index 66955c589..0aaf6bc75 100644 --- a/icon.qrc +++ b/icon.qrc @@ -21,5 +21,6 @@ icon/32x32/segment.png icon/32x32/line.png icon/32x32/along_line.png + icon/32x32/shoulder.png diff --git a/icon/32x32/shoulder.png b/icon/32x32/shoulder.png new file mode 100644 index 0000000000000000000000000000000000000000..0c82b180b5e0311c2c09b091c12fbb816e65133a GIT binary patch literal 683 zcmV;c0#yBpP))88Zk4nRQwMRU-1f?Qn(|kF&CF`2DKR0+aLya^6X<)17?M- z4Y;44X-)I?iUgfS8}6YA3vdUwu&|2_bW4I3Z2d)oKSfoV@*o~zeProT{KzO?i_ZTN zBO}eud>@m^>5&orz-_F<#57@LCwY|^jy6Fsrj4wh;#2|KX21VAynYzzG@*jQrc?bzR&zFv!q>4EP!nci3(^O_UDr7S(@ z?bB^KmgR7J7-t=yNgA8G=YbLc=llBhH8H2_mmF#<%W(&t5ObR{@NcMJ#7`&%fU{2^ RJSqSH002ovPDHLkV1iXdFN6R9 literal 0 HcmV?d00001 diff --git a/mainwindow.cpp b/mainwindow.cpp index a5662ba15..779b86318 100644 --- a/mainwindow.cpp +++ b/mainwindow.cpp @@ -14,6 +14,7 @@ #include "tools/vtoolendline.h" #include "tools/vtoolline.h" #include "tools/vtoolalongline.h" +#include "tools/vtoolshoulderpoint.h" MainWindow::MainWindow(QWidget *parent) : QMainWindow(parent), ui(new Ui::MainWindow) @@ -49,6 +50,8 @@ MainWindow::MainWindow(QWidget *parent) : &MainWindow::ToolLine); connect(ui->toolButtonAlongLine, &QToolButton::clicked, this, &MainWindow::ToolAlongLine); + connect(ui->toolButtonShoulderPoint, &QToolButton::clicked, this, + &MainWindow::ToolShoulderPoint); data = new VContainer; CreateManTableIGroup (); @@ -277,6 +280,53 @@ void MainWindow::ClosedDialogAlongLine(int result){ ArrowTool(); } +void MainWindow::ToolShoulderPoint(bool checked){ + if(checked){ + CanselTool(); + tool = Tools::ShoulderPointTool; + QPixmap pixmap(":/cursor/shoulder_cursor.png"); + QCursor cur(pixmap, 2, 3); + ui->graphicsView->setCursor(cur); + helpLabel->setText("Виберіть точки."); + dialogShoulderPoint = new DialogShoulderPoint(data, this); + connect(scene, &VMainGraphicsScene::ChoosedObject, dialogShoulderPoint, + &DialogShoulderPoint::ChoosedPoint); + connect(dialogShoulderPoint, &DialogShoulderPoint::DialogClosed, this, + &MainWindow::ClosedDialogShoulderPoint); + } else { + ui->toolButtonShoulderPoint->setChecked(true); + } +} + +void MainWindow::ClosedDialogShoulderPoint(int result){ + if(result == QDialog::Accepted){ + QString formula = dialogShoulderPoint->getFormula(); + qint64 p1Line = dialogShoulderPoint->getP1Line(); + qint64 p2Line = dialogShoulderPoint->getP2Line(); + qint64 pShoulder = dialogShoulderPoint->getPShoulder(); + QString typeLine = dialogShoulderPoint->getTypeLine(); + QString pointName = dialogShoulderPoint->getPointName(); + + VPointF firstPoint = data->GetPoint(p1Line); + VPointF secondPoint = data->GetPoint(p2Line); + VPointF shoulderPoint = data->GetPoint(pShoulder); + + Calculator cal(data); + QString errorMsg; + qreal result = cal.eval(formula, &errorMsg); + if(errorMsg.isEmpty()){ + QPointF fPoint = VToolShoulderPoint::FindPoint(firstPoint, secondPoint, shoulderPoint, + result*PrintDPI/25.4); + qint64 id = data->AddPoint(VPointF(fPoint.x(), fPoint.y(), pointName, 5, 10)); + VToolShoulderPoint *point = new VToolShoulderPoint(doc, data, id, typeLine, formula, p1Line, + p2Line, pShoulder, Tool::FromGui); + scene->addItem(point); + connect(point, &VToolShoulderPoint::ChoosedPoint, scene, &VMainGraphicsScene::ChoosedItem); + } + } + ArrowTool(); +} + void MainWindow::showEvent( QShowEvent *event ){ QMainWindow::showEvent( event ); if( event->spontaneous() ){ @@ -388,17 +438,26 @@ void MainWindow::CanselTool(){ case Tools::EndLineTool: delete dialogEndLine; ui->toolButtonEndLine->setChecked(false); + scene->setFocus(Qt::OtherFocusReason); scene->clearSelection(); break; case Tools::LineTool: delete dialogLine; ui->toolButtonLine->setChecked(false); + scene->setFocus(Qt::OtherFocusReason); scene->clearFocus(); break; case Tools::AlongLineTool: delete dialogAlongLine; ui->toolButtonAlongLine->setChecked(false); - scene->clearFocus(); + scene->setFocus(Qt::OtherFocusReason); + scene->clearSelection(); + break; + case Tools::ShoulderPointTool: + delete dialogShoulderPoint; + ui->toolButtonShoulderPoint->setChecked(false); + scene->setFocus(Qt::OtherFocusReason); + scene->clearSelection(); break; } } @@ -658,6 +717,7 @@ void MainWindow::SetEnableTool(bool enable){ ui->toolButtonEndLine->setEnabled(enable); ui->toolButtonLine->setEnabled(enable); ui->toolButtonAlongLine->setEnabled(enable); + ui->toolButtonShoulderPoint->setEnabled(enable); } MainWindow::~MainWindow(){ diff --git a/mainwindow.h b/mainwindow.h index 29b091442..aba66f242 100644 --- a/mainwindow.h +++ b/mainwindow.h @@ -12,10 +12,11 @@ #include "dialogs/dialogincrements.h" #include "dialogs/dialogline.h" #include "dialogs/dialogalongline.h" +#include "dialogs/dialogshoulderpoint.h" +#include "dialogs/dialogendline.h" #include "tools/vtoolsimplepoint.h" #include "xml/vdomdocument.h" #include "container/vcontainer.h" -#include "dialogs/dialogendline.h" namespace Ui { class MainWindow; @@ -28,7 +29,8 @@ namespace Tools{ SinglePointTool, EndLineTool, LineTool, - AlongLineTool + AlongLineTool, + ShoulderPointTool }; } @@ -63,6 +65,8 @@ public slots: void ClosedDialogLine(int result); void ToolAlongLine(bool checked); void ClosedDialogAlongLine(int result); + void ToolShoulderPoint(bool checked); + void ClosedDialogShoulderPoint(int result); protected: virtual void keyPressEvent ( QKeyEvent * event ); virtual void showEvent( QShowEvent *event ); @@ -78,6 +82,7 @@ private: DialogEndLine *dialogEndLine; DialogLine *dialogLine; DialogAlongLine *dialogAlongLine; + DialogShoulderPoint *dialogShoulderPoint; VDomDocument *doc; VContainer *data; QComboBox *comboBoxDraws; diff --git a/mainwindow.ui b/mainwindow.ui index 12f1da402..b72654c2a 100644 --- a/mainwindow.ui +++ b/mainwindow.ui @@ -64,7 +64,7 @@ 0 0 - 154 + 156 81 @@ -79,10 +79,26 @@ - + + + false + ... + + + :/icon/32x32/shoulder.png:/icon/32x32/shoulder.png + + + + 24 + 24 + + + + true + @@ -218,7 +234,7 @@ 0 0 - 117 + 154 45 @@ -246,7 +262,7 @@ 0 0 - 117 + 154 45 diff --git a/tools/vabstracttool.cpp b/tools/vabstracttool.cpp index 38d73ecd0..74b447080 100644 --- a/tools/vabstracttool.cpp +++ b/tools/vabstracttool.cpp @@ -1,4 +1,5 @@ #include "vabstracttool.h" +#include VAbstractTool::VAbstractTool(VDomDocument *doc, VContainer *data, qint64 id){ this->doc = doc; @@ -11,6 +12,7 @@ VAbstractTool::VAbstractTool(VDomDocument *doc, VContainer *data, qint64 id){ connect(this->doc, &VDomDocument::ChangedNameDraw, this, &VAbstractTool::ChangedNameDraw); connect(this, &VAbstractTool::haveLiteChange, this->doc, &VDomDocument::haveLiteChange); connect(this->doc, &VDomDocument::FullUpdateFromFile, this, &VAbstractTool::FullUpdateFromFile); + connect(this, &VAbstractTool::FullUpdateTree, this->doc, &VDomDocument::FullUpdateTree); } void VAbstractTool::ChangedNameDraw(const QString oldName, const QString newName){ @@ -66,3 +68,13 @@ void VAbstractTool::AddLine(const qint64 &firstPointId, const qint64 &secondPoin VPointF secondPoint = data->GetPoint(secondPointId); data->AddLine(nameLine, QLineF(firstPoint.toQPointF(), secondPoint.toQPointF()).length()); } + +void VAbstractTool::AddToCalculation(const QDomElement &domElement){ + QDomElement calcElement; + bool ok = doc->GetActivCalculationElement(calcElement); + if(ok){ + calcElement.appendChild(domElement); + } else { + qCritical()<<"Не можу знайти тег калькуляції."<< Q_FUNC_INFO; + } +} diff --git a/tools/vabstracttool.h b/tools/vabstracttool.h index 40dd50412..ba1f2caaa 100644 --- a/tools/vabstracttool.h +++ b/tools/vabstracttool.h @@ -42,5 +42,6 @@ protected: void AddAttribute(QDomElement &domElement, const QString &name, const QString &value); QString GetNameLine(const qint64 &firstPoint, const qint64 &secondPoint) const; void AddLine(const qint64 &firstPointId, const qint64 &secondPointId) const; + void AddToCalculation(const QDomElement &domElement); }; #endif // VABSTRACTTOOL_H diff --git a/tools/vtoolalongline.cpp b/tools/vtoolalongline.cpp index 721d2c10e..e6845f0e7 100644 --- a/tools/vtoolalongline.cpp +++ b/tools/vtoolalongline.cpp @@ -8,7 +8,6 @@ VToolAlongLine::VToolAlongLine(VDomDocument *doc, VContainer *data, qint64 id, c const qint64 &firstPointId, const qint64 &secondPointId, const QString &typeLine, Tool::Enum typeCreation, QGraphicsItem *parent):VToolPoint(doc, data, id, parent){ - connect(this, &VToolAlongLine::FullUpdateTree, this->doc, &VDomDocument::FullUpdateTree); this->typeLine = typeLine; this->formula = formula; this->firstPointId = firstPointId; @@ -132,11 +131,5 @@ void VToolAlongLine::AddToFile(){ AddAttribute(domElement, "firstPoint", firstPointId); AddAttribute(domElement, "secondPoint", secondPointId); - QDomElement calcElement; - bool ok = doc->GetActivCalculationElement(calcElement); - if(ok){ - calcElement.appendChild(domElement); - } else { - qCritical()<<"Не можу знайти тег калькуляції."<< Q_FUNC_INFO; - } + AddToCalculation(domElement); } diff --git a/tools/vtoolendline.cpp b/tools/vtoolendline.cpp index 6ee187261..59aa635ac 100644 --- a/tools/vtoolendline.cpp +++ b/tools/vtoolendline.cpp @@ -8,7 +8,6 @@ VToolEndLine::VToolEndLine(VDomDocument *doc, VContainer *data, const qint64 &id const QString &typeLine, const QString &formula, const qint32 &angle, const qint64 &basePointId, Tool::Enum typeCreation, QGraphicsItem *parent):VToolPoint(doc, data, id, parent){ - connect(this, &VToolEndLine::FullUpdateTree, this->doc, &VDomDocument::FullUpdateTree); this->typeLine = typeLine; this->formula = formula; this->angle = angle; @@ -120,11 +119,5 @@ void VToolEndLine::AddToFile(){ AddAttribute(domElement, "angle", angle); AddAttribute(domElement, "basePoint", basePointId); - QDomElement calcElement; - bool ok = doc->GetActivCalculationElement(calcElement); - if(ok){ - calcElement.appendChild(domElement); - } else { - qCritical()<<"Не можу знайти тег калькуляції."<< Q_FUNC_INFO; - } + AddToCalculation(domElement); } diff --git a/tools/vtoolline.cpp b/tools/vtoolline.cpp index 6d966b0fc..7b10a15bb 100644 --- a/tools/vtoolline.cpp +++ b/tools/vtoolline.cpp @@ -5,7 +5,6 @@ VToolLine::VToolLine(VDomDocument *doc, VContainer *data, qint64 id, qint64 firstPoint, qint64 secondPoint, Tool::Enum typeCreation, QGraphicsItem *parent):VAbstractTool(doc, data, id), QGraphicsLineItem(parent){ - connect(this, &VToolLine::FullUpdateTree, this->doc, &VDomDocument::FullUpdateTree); this->firstPoint = firstPoint; this->secondPoint = secondPoint; @@ -87,13 +86,7 @@ void VToolLine::AddToFile(){ AddAttribute(domElement, "firstPoint", firstPoint); AddAttribute(domElement, "secondPoint", secondPoint); - QDomElement calcElement; - bool ok = doc->GetActivCalculationElement(calcElement); - if(ok){ - calcElement.appendChild(domElement); - } else { - qCritical()<<"Не можу знайти тег калькуляції."<< Q_FUNC_INFO; - } + AddToCalculation(domElement); } void VToolLine::hoverMoveEvent(QGraphicsSceneHoverEvent *event){ diff --git a/tools/vtoolshoulderpoint.cpp b/tools/vtoolshoulderpoint.cpp new file mode 100644 index 000000000..4e72d582e --- /dev/null +++ b/tools/vtoolshoulderpoint.cpp @@ -0,0 +1,156 @@ +#include "vtoolshoulderpoint.h" +#include +#include + +VToolShoulderPoint::VToolShoulderPoint(VDomDocument *doc, VContainer *data, const qint64 &id, + const QString &typeLine, const QString &formula, const qint64 &p1Line, + const qint64 &p2Line, const qint64 &pShoulder, Tool::Enum typeCreation, + QGraphicsItem * parent):VToolPoint(doc, data, id, parent){ + this->typeLine = typeLine; + this->formula = formula; + this->p1Line = p1Line; + this->p2Line = p2Line; + this->pShoulder = pShoulder; + + //Лінія, що з'єднує дві точки + VPointF p1L = data->GetPoint(p1Line); + VPointF point = data->GetPoint(id); + mainLine = new QGraphicsLineItem(QLineF(p1L.toQPointF(), point.toQPointF()), this); + mainLine->setFlag(QGraphicsItem::ItemStacksBehindParent, true); + if(typeLine == "none"){ + mainLine->setVisible(false); + } else { + mainLine->setVisible(true); + } + + AddLine(p1Line, id); + AddLine(p2Line, id); + + if(typeCreation == Tool::FromGui){ + AddToFile(); + } + +} + +QPointF VToolShoulderPoint::FindPoint(const QPointF &p1Line, const QPointF &p2Line, const QPointF &pShoulder, + const qreal &length){ + QLineF line = QLineF(p1Line, p2Line); + qreal dist = line.length(); + if(dist>length){ + qDebug()<<"A3П2="<=length){ + return line.p2(); + } + } +} + +void VToolShoulderPoint::FullUpdateFromFile(){ + QString name; + qreal mx, my; + QDomElement domElement = doc->elementById(QString().setNum(id)); + if(domElement.isElement()){ + name = domElement.attribute("name", ""); + mx = domElement.attribute("mx", "").toDouble()*PrintDPI/25.4; + my = domElement.attribute("my", "").toDouble()*PrintDPI/25.4; + typeLine = domElement.attribute("typeLine", ""); + formula = domElement.attribute("length", ""); + p1Line = domElement.attribute("p1Line", "").toLongLong(); + p2Line = domElement.attribute("p2Line", "").toLongLong(); + pShoulder = domElement.attribute("pShoulder", "").toLongLong(); + } + VPointF point = VAbstractTool::data->GetPoint(id); + RefreshBaseGeometry(name, point.x(), point.y(), mx, my); + VPointF p1L = VAbstractTool::data->GetPoint(p1Line); + mainLine->setLine(QLineF(p1L.toQPointF(), point.toQPointF())); + if(typeLine == "none"){ + mainLine->setVisible(false); + } else { + mainLine->setVisible(true); + } + + AddLine(p1Line, id); + AddLine(p2Line, id); +} + +void VToolShoulderPoint::FullUpdateFromGui(int result){ + if(result == QDialog::Accepted){ + QDomElement domElement = doc->elementById(QString().setNum(id)); + if(domElement.isElement()){ + domElement.setAttribute("name", dialogShoulderPoint->getPointName()); + domElement.setAttribute("typeLine", dialogShoulderPoint->getTypeLine()); + domElement.setAttribute("length", dialogShoulderPoint->getFormula()); + domElement.setAttribute("p1Line", QString().setNum(dialogShoulderPoint->getP1Line())); + domElement.setAttribute("p2Line", QString().setNum(dialogShoulderPoint->getP2Line())); + domElement.setAttribute("pShoulder", QString().setNum(dialogShoulderPoint->getPShoulder())); + emit FullUpdateTree(); + } + } + dialogShoulderPoint.clear(); +} + +void VToolShoulderPoint::ChangedActivDraw(const QString newName){ + if(nameActivDraw == newName){ + mainLine->setPen(QPen(Qt::black, widthHairLine)); + VToolPoint::ChangedActivDraw(newName); + } else { + mainLine->setPen(QPen(Qt::gray, widthHairLine)); + VToolPoint::ChangedActivDraw(newName); + } +} + +void VToolShoulderPoint::contextMenuEvent(QGraphicsSceneContextMenuEvent *event){ + if(!ignoreContextMenuEvent){ + QMenu menu; + QAction *actionOption = menu.addAction("Властивості"); + QAction *selectedAction = menu.exec(event->screenPos()); + if(selectedAction == actionOption){ + dialogShoulderPoint = + QSharedPointer(new DialogShoulderPoint(VAbstractTool::data)); + + connect(qobject_cast< VMainGraphicsScene * >(this->scene()), &VMainGraphicsScene::ChoosedObject, + dialogShoulderPoint.data(), &DialogShoulderPoint::ChoosedPoint); + connect(dialogShoulderPoint.data(), &DialogShoulderPoint::DialogClosed, this, + &VToolShoulderPoint::FullUpdateFromGui); + connect(doc, &VDomDocument::FullUpdateFromFile, dialogShoulderPoint.data(), &DialogShoulderPoint::UpdateList); + + VPointF p = VAbstractTool::data->GetPoint(id); + + dialogShoulderPoint->setTypeLine(typeLine); + dialogShoulderPoint->setFormula(formula); + dialogShoulderPoint->setP1Line(p1Line); + dialogShoulderPoint->setP2Line(p2Line); + dialogShoulderPoint->setPShoulder(pShoulder); + dialogShoulderPoint->setPointName(p.name()); + + dialogShoulderPoint->show(); + } + } +} + +void VToolShoulderPoint::AddToFile(){ + VPointF point = VAbstractTool::data->GetPoint(id); + QDomElement domElement = doc->createElement("point"); + + AddAttribute(domElement, "id", id); + AddAttribute(domElement, "type", "shoulder"); + AddAttribute(domElement, "name", point.name()); + AddAttribute(domElement, "mx", point.mx()/PrintDPI*25.4); + AddAttribute(domElement, "my", point.my()/PrintDPI*25.4); + + AddAttribute(domElement, "typeLine", typeLine); + AddAttribute(domElement, "length", formula); + AddAttribute(domElement, "p1Line", p1Line); + AddAttribute(domElement, "p2Line", p2Line); + AddAttribute(domElement, "pShoulder", pShoulder); + + AddToCalculation(domElement); +} diff --git a/tools/vtoolshoulderpoint.h b/tools/vtoolshoulderpoint.h new file mode 100644 index 000000000..6b3ea6174 --- /dev/null +++ b/tools/vtoolshoulderpoint.h @@ -0,0 +1,33 @@ +#ifndef VTOOLSHOULDERPOINT_H +#define VTOOLSHOULDERPOINT_H + +#include "vtoolpoint.h" +#include "../dialogs/dialogshoulderpoint.h" + +class VToolShoulderPoint : public VToolPoint +{ +public: + VToolShoulderPoint(VDomDocument *doc, VContainer *data, const qint64 &id, + const QString &typeLine, const QString &formula, const qint64 &p1Line, + const qint64 &p2Line, const qint64 &pShoulder, Tool::Enum typeCreation, + QGraphicsItem * parent = 0); + static QPointF FindPoint(const QPointF &p1Line, const QPointF &p2Line, const QPointF &pShoulder, + const qreal &length); +public slots: + virtual void FullUpdateFromFile(); + virtual void FullUpdateFromGui(int result); + virtual void ChangedActivDraw(const QString newName); +protected: + virtual void contextMenuEvent ( QGraphicsSceneContextMenuEvent * event ); + virtual void AddToFile(); +private: + QString typeLine; + QString formula; + qint64 p1Line; + qint64 p2Line; + qint64 pShoulder; + QGraphicsLineItem *mainLine; + QSharedPointer dialogShoulderPoint; +}; + +#endif // VTOOLSHOULDERPOINT_H diff --git a/tools/vtoolsimplepoint.cpp b/tools/vtoolsimplepoint.cpp index eecfd5da4..3ac7d9483 100644 --- a/tools/vtoolsimplepoint.cpp +++ b/tools/vtoolsimplepoint.cpp @@ -12,7 +12,6 @@ VToolSimplePoint::VToolSimplePoint (VDomDocument *doc, VContainer *data, qint64 id, Tool::Enum typeCreation, QGraphicsItem * parent ):VToolPoint(doc, data, id, parent){ - connect(this, &VToolSimplePoint::FullUpdateTree, this->doc, &VDomDocument::FullUpdateTree); if(typeCreation == Tool::FromGui){ AddToFile(); } @@ -30,13 +29,7 @@ void VToolSimplePoint::AddToFile(){ AddAttribute(domElement, "mx", point.mx()/PrintDPI*25.4); AddAttribute(domElement, "my", point.my()/PrintDPI*25.4); - QDomElement calcElement; - bool ok = doc->GetActivCalculationElement(calcElement); - if(ok){ - calcElement.appendChild(domElement); - } else { - qCritical("Не можу знайти тег калькуляції. VToolSimplePoint::AddSimplePoint"); - } + AddToCalculation(domElement); } void VToolSimplePoint::FullUpdateFromGui(int result){ diff --git a/xml/vdomdocument.cpp b/xml/vdomdocument.cpp index 331fcfe50..637d7cb8e 100644 --- a/xml/vdomdocument.cpp +++ b/xml/vdomdocument.cpp @@ -5,6 +5,7 @@ #include "../tools/vtoolendline.h" #include "../tools/vtoolline.h" #include "../tools/vtoolalongline.h" +#include "../tools/vtoolshoulderpoint.h" #include "../options.h" #include "../container/calculator.h" @@ -443,6 +444,47 @@ void VDomDocument::ParsePointElement(VMainGraphicsScene *scene, const QDomElemen } return; } + if(type == "shoulder"){ + if(!domElement.isNull()){ + QString name, typeLine, formula; + qreal mx=5, my=10; + qint64 id, p1Line, p2Line, pShoulder; + if(!domElement.isNull()){ + id = domElement.attribute("id", "").toLongLong(); + name = domElement.attribute("name", ""); + mx = domElement.attribute("mx","").toDouble()*PrintDPI/25.4; + my = domElement.attribute("my","").toDouble()*PrintDPI/25.4; + + typeLine = domElement.attribute("typeLine", ""); + formula = domElement.attribute("length", ""); + p1Line = domElement.attribute("p1Line", "").toLongLong(); + p2Line = domElement.attribute("p2Line", "").toLongLong(); + pShoulder = domElement.attribute("pShoulder", "").toLongLong(); + + VPointF firstPoint = data->GetPoint(p1Line); + VPointF secondPoint = data->GetPoint(p2Line); + VPointF shoulderPoint = data->GetPoint(pShoulder); + + Calculator cal(data); + QString errorMsg; + qreal result = cal.eval(formula, &errorMsg); + if(errorMsg.isEmpty()){ + QPointF fPoint = VToolShoulderPoint::FindPoint(firstPoint, secondPoint, shoulderPoint, + result*PrintDPI/25.4); + data->UpdatePoint(id,VPointF(fPoint.x(), fPoint.y(), name, mx, my)); + if(parse == Document::FullParse){ + VToolShoulderPoint *point = new VToolShoulderPoint(this, data, id, typeLine, formula, + p1Line, p2Line, pShoulder, + Tool::FromGui); + scene->addItem(point); + connect(point, &VToolShoulderPoint::ChoosedPoint, scene, + &VMainGraphicsScene::ChoosedItem); + } + } + } + } + return; + } } void VDomDocument::ParseLineElement(VMainGraphicsScene *scene, const QDomElement &domElement,