realAscot/qelectrotech-source-mirror
realAscot/qelectrotech-source-mirror
1
0
Fork 0
mirror of https://github.com/qelectrotech/qelectrotech-source-mirror.git synced 2025-09-13 20:23:04 +02:00
Code Packages Releases 1 Activity

Fix bug N°201: Line changes in the drawing area are not reflexted in the information area

Browse Source
This commit is contained in:
Claveau Joshua 2020-09-13 15:11:45 +02:00
parent 726b300999
commit 529027a350
7 changed files with 576 additions and 512 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sources/editor/elementitemeditor.h
View File

@ -36,7 +36,7 @@ class ElementItemEditor : public QWidget
// constructors, destructor
public:
ElementItemEditor(QETElementEditor *, QWidget * = nullptr);
~ElementItemEditor() override {};
~ElementItemEditor() override {}
private:
ElementItemEditor(const ElementItemEditor &);

14
sources/editor/graphicspart/partline.cpp
View File

@ -72,7 +72,7 @@ uint PartLine::requiredLengthForEndType(const Qet::EndType &end_type)
*/
void PartLine::paint(QPainter *painter, const QStyleOptionGraphicsItem *options, QWidget *widget)
{
Q_UNUSED(widget);
Q_UNUSED(widget)
if (isUseless()) return;
painter->save();
@ -246,8 +246,8 @@ void PartLine::adjusteHandlerPos()
*/
void PartLine::handlerMousePressEvent(QetGraphicsHandlerItem *qghi, QGraphicsSceneMouseEvent *event)
{
Q_UNUSED(qghi);
Q_UNUSED(event);
Q_UNUSED(qghi)
Q_UNUSED(event)
m_undo_command = new QPropertyUndoCommand(this, "line", QVariant(m_line));
m_undo_command->setText(tr("Modifier une ligne"));
@ -262,7 +262,7 @@ void PartLine::handlerMousePressEvent(QetGraphicsHandlerItem *qghi, QGraphicsSce
*/
void PartLine::handlerMouseMoveEvent(QetGraphicsHandlerItem *qghi, QGraphicsSceneMouseEvent *event)
{
Q_UNUSED(qghi);
Q_UNUSED(qghi)
QPointF new_pos = event->scenePos();
if (event->modifiers() != Qt::ControlModifier)
@ -274,6 +274,8 @@ void PartLine::handlerMouseMoveEvent(QetGraphicsHandlerItem *qghi, QGraphicsScen
m_line.setP1(new_pos);
else
m_line.setP2(new_pos);
emit lineChanged();
adjusteHandlerPos();
}
@ -285,8 +287,8 @@ void PartLine::handlerMouseMoveEvent(QetGraphicsHandlerItem *qghi, QGraphicsScen
*/
void PartLine::handlerMouseReleaseEvent(QetGraphicsHandlerItem *qghi, QGraphicsSceneMouseEvent *event)
{
Q_UNUSED(qghi);
Q_UNUSED(event);
Q_UNUSED(qghi)
Q_UNUSED(event)
m_undo_command->setNewValue(QVariant(m_line));
elementScene()->undoStack().push(m_undo_command);

424
sources/editor/lineeditor.cpp
View File

@ -1,424 +0,0 @@
/*
Copyright 2006-2020 The QElectroTech Team
This file is part of QElectroTech.
QElectroTech is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
QElectroTech is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "lineeditor.h"
#include "styleeditor.h"
#include "partline.h"
#include "qet.h"
#include "qeticons.h"
#include "QPropertyUndoCommand/qpropertyundocommand.h"
#include "elementscene.h"
/**
Constructeur
@param editor L'editeur d'element concerne
@param line La ligne a editer
@param parent le Widget parent
*/
LineEditor::LineEditor(QETElementEditor *editor, PartLine *line, QWidget *parent) :
ElementItemEditor(editor, parent),
part(line),
m_locked (false)
{
style_ = new StyleEditor(editor);
x1 = new QDoubleSpinBox();
y1 = new QDoubleSpinBox();
x2 = new QDoubleSpinBox();
y2 = new QDoubleSpinBox();
x1 -> setRange(-5000, 5000);
y1 -> setRange(-5000, 5000);
x2 -> setRange(-5000, 5000);
y2 -> setRange(-5000, 5000);
end1_type = new QComboBox();
end1_type -> addItem(QET::Icons::EndLineNone, tr("Normale", "type of the 1st end of a line"), Qet::None );
end1_type -> addItem(QET::Icons::EndLineSimple, tr("Flèche simple", "type of the 1st end of a line"), Qet::Simple );
end1_type -> addItem(QET::Icons::EndLineTriangle, tr("Flèche triangulaire", "type of the 1st end of a line"), Qet::Triangle);
end1_type -> addItem(QET::Icons::EndLineCircle, tr("Cercle", "type of the 1st end of a line"), Qet::Circle );
end1_type -> addItem(QET::Icons::EndLineDiamond, tr("Carré", "type of the 1st end of a line"), Qet::Diamond );
end2_type = new QComboBox();
end2_type -> addItem(QET::Icons::EndLineNone, tr("Normale", "type of the 2nd end of a line"), Qet::None );
end2_type -> addItem(QET::Icons::EndLineSimple, tr("Flèche simple", "type of the 2nd end of a line"), Qet::Simple );
end2_type -> addItem(QET::Icons::EndLineTriangle, tr("Flèche triangulaire", "type of the 2nd end of a line"), Qet::Triangle);
end2_type -> addItem(QET::Icons::EndLineCircle, tr("Cercle", "type of the 2nd end of a line"), Qet::Circle );
end2_type -> addItem(QET::Icons::EndLineDiamond, tr("Carré", "type of the 2nd end of a line"), Qet::Diamond );
end1_length = new QDoubleSpinBox();
end2_length = new QDoubleSpinBox();
QGridLayout *grid = new QGridLayout();
grid -> addWidget(new QLabel("x1"), 0, 0);
grid -> addWidget(x1, 0, 1);
grid -> addWidget(new QLabel("y1"), 0, 2);
grid -> addWidget(y1, 0, 3);
grid -> addWidget(new QLabel("x2"), 1, 0);
grid -> addWidget(x2, 1, 1);
grid -> addWidget(new QLabel("y2"), 1, 2);
grid -> addWidget(y2, 1, 3);
QGridLayout *grid2 = new QGridLayout();
grid2 -> addWidget(new QLabel(tr("Fin 1")), 0, 0);
grid2 -> addWidget(end1_type, 0, 1);
grid2 -> addWidget(end1_length, 0, 2);
grid2 -> addWidget(new QLabel(tr("Fin 2")), 1, 0);
grid2 -> addWidget(end2_type, 1, 1);
grid2 -> addWidget(end2_length, 1, 2);
QVBoxLayout *v_layout = new QVBoxLayout(this);
v_layout -> addWidget(style_);
v_layout -> addLayout(grid);
v_layout -> addLayout(grid2);
v_layout->addStretch();
updateForm();
}
/// Destructeur
LineEditor::~LineEditor()
{
}
void LineEditor::setUpChangeConnections()
{
m_change_connections << connect(part, &PartLine::lineChanged, this, &LineEditor::updateForm);
m_change_connections << connect(part, &PartLine::firstEndTypeChanged, this, &LineEditor::updateForm);
m_change_connections << connect(part, &PartLine::secondEndTypeChanged, this, &LineEditor::updateForm);
m_change_connections << connect(part, &PartLine::firstEndLengthChanged, this, &LineEditor::updateForm);
m_change_connections << connect(part, &PartLine::secondEndLengthChanged, this, &LineEditor::updateForm);
}
void LineEditor::disconnectChangeConnections()
{
for (QMetaObject::Connection c : m_change_connections) {
disconnect(c);
}
m_change_connections.clear();
}
/**
@brief LineEditor::setPart
Specifie to this editor the part to edit.
Note that an editor can accept or refuse to edit a part. This editor accept only PartLine.
@param new_part
@return
*/
bool LineEditor::setPart(CustomElementPart *new_part)
{
if (!new_part)
{
if (part)
{
disconnectChangeConnections();
}
part = nullptr;
return(true);
}
if (PartLine *part_line = dynamic_cast<PartLine *>(new_part))
{
if (part == part_line) return true;
if (part)
{
disconnectChangeConnections();
}
part = part_line;
updateForm();
setUpChangeConnections();
return(true);
}
return(false);
}
bool LineEditor::setParts(QList <CustomElementPart *> parts)
{
if (parts.isEmpty())
return false;
if (!setPart(parts.first()))
return false;
return style_->setParts(parts);
}
/**
@return la primitive actuellement editee, ou 0 si ce widget n'en edite pas
*/
CustomElementPart *LineEditor::currentPart() const
{
return(part);
}
QList<CustomElementPart*> LineEditor::currentParts() const
{
return style_->currentParts();
}
/**
@brief LineEditor::editedP1
@return The edited P1 in item coordinate
*/
QPointF LineEditor::editedP1() const
{
return part -> mapFromScene(x1->value(), y1->value());
}
/**
@brief LineEditor::editedP2
@return The edited P2 in item coordinate
*/
QPointF LineEditor::editedP2() const
{
return part -> mapFromScene(x2->value(), y2->value());
}
/// Met a jour le type de la premiere extremite
void LineEditor::updateLineEndType1()
{
if (m_locked) return;
m_locked = true;
QVariant end = end1_type -> itemData(end1_type->currentIndex());
for (auto part: style_->currentParts()) {
PartLine* line = static_cast<PartLine*>(part);
if (end != line->property("end1"))
{
QPropertyUndoCommand *undo = new QPropertyUndoCommand(line, "end1", line->property("end1"), end);
undo->setText(tr("Modifier une ligne"));
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
/// Met a jour la longueur de la premiere extremite
void LineEditor::updateLineEndLength1()
{
if (m_locked) return;
m_locked = true;
double length = end1_length->value();
for (auto part: style_->currentParts()) {
PartLine* line = static_cast<PartLine*>(part);
if (length != line->property("length1"))
{
QPropertyUndoCommand *undo = new QPropertyUndoCommand(line, "length1", line->property("length1"), length);
undo->setText(tr("Modifier une ligne"));
undo->enableAnimation();
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
/// Met a jour le type de la seconde extremite
void LineEditor::updateLineEndType2()
{
if (m_locked) return;
m_locked = true;
QVariant end = end2_type -> itemData(end2_type->currentIndex());
for (auto part: style_->currentParts()) {
PartLine* line = static_cast<PartLine*>(part);
if (end != line->property("end2"))
{
QPropertyUndoCommand *undo = new QPropertyUndoCommand(line, "end2", line->property("end2"), end);
undo->setText(tr("Modifier une ligne"));
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
/// Met a jour la longueur de la seconde extremite
void LineEditor::updateLineEndLength2()
{
if (m_locked) return;
m_locked = true;
double length = end2_length->value();
for (auto part: style_->currentParts()) {
PartLine* line = static_cast<PartLine*>(part);
if (length != line->property("length2"))
{
QPropertyUndoCommand *undo = new QPropertyUndoCommand(line, "length2", line->property("length2"), length);
undo->setText(tr("Modifier une ligne"));
undo->enableAnimation();
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
void LineEditor::lineEditingFinishedX1()
{
if (m_locked) return;
m_locked = true;
for (auto part: style_->currentParts()) {
PartLine* l = static_cast<PartLine*>(part);
QLineF line = l->property("line").toLineF();
QPointF p1 = l->mapFromScene(x1->value(), y1->value());
if (p1.x() != line.p1().x())
{
p1.setY(line.p1().y()); // restore old y value
line.setP1(p1);
QPropertyUndoCommand *undo = new QPropertyUndoCommand(l, "line", l->property("line"), line);
undo->setText(tr("Modifier une ligne"));
undo->enableAnimation();
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
void LineEditor::lineEditingFinishedY1()
{
if (m_locked) return;
m_locked = true;
for (auto part: style_->currentParts()) {
PartLine* l = static_cast<PartLine*>(part);
QLineF line = l->property("line").toLineF();
QPointF p1 = l->mapFromScene(x1->value(), y1->value());
if (p1.y() != line.p1().y())
{
p1.setX(line.p1().x()); // restore old x value
line.setP1(p1);
QPropertyUndoCommand *undo = new QPropertyUndoCommand(l, "line", l->property("line"), line);
undo->setText(tr("Modifier une ligne"));
undo->enableAnimation();
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
void LineEditor::lineEditingFinishedX2()
{
if (m_locked) return;
m_locked = true;
for (auto part: style_->currentParts()) {
PartLine* l = static_cast<PartLine*>(part);
QLineF line = l->property("line").toLineF();
QPointF p2 = l->mapFromScene(x2->value(), y2->value());
if (p2.x() != line.p1().x())
{
p2.setY(line.p2().y()); // restore old y value
line.setP2(p2);
QPropertyUndoCommand *undo = new QPropertyUndoCommand(l, "line", l->property("line"), line);
undo->setText(tr("Modifier une ligne"));
undo->enableAnimation();
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
void LineEditor::lineEditingFinishedY2()
{
if (m_locked) return;
m_locked = true;
for (auto part: style_->currentParts()) {
PartLine* l = static_cast<PartLine*>(part);
QLineF line = l->property("line").toLineF();
QPointF p2 = l->mapFromScene(x2->value(), y2->value());
if (p2.y() != line.p1().y())
{
p2.setX(line.p2().x()); // restore old y value
line.setP2(p2);
QPropertyUndoCommand *undo = new QPropertyUndoCommand(l, "line", l->property("line"), line);
undo->setText(tr("Modifier une ligne"));
undo->enableAnimation();
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
/**
@brief LineEditor::updateForm
Update the value of the widgets
*/
void LineEditor::updateForm()
{
if (!part) return;
activeConnections(false);
QPointF p1(part -> sceneP1());
QPointF p2(part -> sceneP2());
x1 -> setValue(p1.x());
y1 -> setValue(p1.y());
x2 -> setValue(p2.x());
y2 -> setValue(p2.y());
end1_type -> setCurrentIndex(end1_type->findData(part -> firstEndType()));
end1_length -> setValue(part -> firstEndLength());
end2_type -> setCurrentIndex(end2_type->findData(part -> secondEndType()));
end2_length -> setValue(part -> secondEndLength());
activeConnections(true);
}
/**
@brief LineEditor::activeConnections
Enable/disable connection between editor widget and slot editingFinished
True == enable | false == disable
@param active
*/
void LineEditor::activeConnections(bool active)
{
if (active)
{
connect(x1, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedX1()));
connect(y1, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedY1()));
connect(x2, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedX2()));
connect(y2, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedY2()));
connect(end1_type, SIGNAL(currentIndexChanged(int)), this, SLOT(updateLineEndType1()));
connect(end1_length, SIGNAL(editingFinished()), this, SLOT(updateLineEndLength1()));
connect(end2_type, SIGNAL(currentIndexChanged(int)), this, SLOT(updateLineEndType2()));
connect(end2_length, SIGNAL(editingFinished()), this, SLOT(updateLineEndLength2()));
}
else
{
disconnect(x1, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedX1()));
disconnect(y1, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedY1()));
disconnect(x2, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedX2()));
disconnect(y2, SIGNAL(editingFinished()), this, SLOT(lineEditingFinishedY2()));
disconnect(end1_type, SIGNAL(currentIndexChanged(int)), this, SLOT(updateLineEndType1()));
disconnect(end1_length, SIGNAL(editingFinished()), this, SLOT(updateLineEndLength1()));
disconnect(end2_type, SIGNAL(currentIndexChanged(int)), this, SLOT(updateLineEndType2()));
disconnect(end2_length, SIGNAL(editingFinished()), this, SLOT(updateLineEndLength2()));
}
}

81
sources/editor/lineeditor.h
View File

@ -1,81 +0,0 @@
/*
Copyright 2006-2020 The QElectroTech Team
This file is part of QElectroTech.
QElectroTech is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
QElectroTech is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef LINE_EDITOR_H
#define LINE_EDITOR_H
#include "elementitemeditor.h"
class PartLine;
class StyleEditor;
class QComboBox;
class QDoubleSpinBox;
/**
This class provides a widget to edit lines within the element editor.
*/
class LineEditor : public ElementItemEditor
{
Q_OBJECT
// constructors, destructor
public:
LineEditor(QETElementEditor *, PartLine * = nullptr, QWidget * = nullptr);
~LineEditor() override;
private:
LineEditor(const LineEditor &);
// attributes
private:
PartLine *part;
StyleEditor *style_;
QDoubleSpinBox *x1, *y1, *x2, *y2;
QComboBox *end1_type, *end2_type;
QDoubleSpinBox*end1_length, *end2_length;
bool m_locked;
QList <QMetaObject::Connection> m_change_connections;
// methods
public:
bool setPart(CustomElementPart *) override;
bool setParts(QList <CustomElementPart *> parts) override;
CustomElementPart *currentPart() const override;
QList<CustomElementPart*> currentParts() const override;
QPointF editedP1() const;
QPointF editedP2() const;
public slots:
void updateLineEndType1();
void updateLineEndLength1();
void updateLineEndType2();
void updateLineEndLength2();
void lineEditingFinishedX1();
void lineEditingFinishedY1();
void lineEditingFinishedX2();
void lineEditingFinishedY2();
void updateForm() override;
private:
void activeConnections(bool);
/**
@brief setUpChangeConnections
Setup the connection from the line(s) to the widget,
to update it when the line(s) are changed (moved ...)
*/
void setUpChangeConnections();
void disconnectChangeConnections();
};
#endif

340
sources/editor/ui/lineeditor.cpp Normal file
View File

@ -0,0 +1,340 @@
/*
Copyright 2006-2020 The QElectroTech Team
This file is part of QElectroTech.
QElectroTech is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
QElectroTech is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#include "lineeditor.h"
#include "ui_lineeditor.h"
#include "elementitemeditor.h"
#include "styleeditor.h"
#include "partline.h"
#include "QPropertyUndoCommand/qpropertyundocommand.h"
#include "elementscene.h"
#include "qeticons.h"
/**
* @brief LineEditor::LineEditor
* @param editor : Element editor who belong this editor
* @param part : part line to edit
* @param parent : parent widget
*/
LineEditor::LineEditor(QETElementEditor *editor, PartLine *part, QWidget *parent) :
ElementItemEditor(editor, parent),
ui(new Ui::LineEditor)
{
ui->setupUi(this);
ui->m_end1_cb->addItem(QET::Icons::EndLineNone, tr("Normale", "type of the 1st end of a line"), Qet::None );
ui->m_end1_cb->addItem(QET::Icons::EndLineSimple, tr("Flèche simple", "type of the 1st end of a line"), Qet::Simple );
ui->m_end1_cb->addItem(QET::Icons::EndLineTriangle, tr("Flèche triangulaire", "type of the 1st end of a line"), Qet::Triangle);
ui->m_end1_cb->addItem(QET::Icons::EndLineCircle, tr("Cercle", "type of the 1st end of a line"), Qet::Circle );
ui->m_end1_cb->addItem(QET::Icons::EndLineDiamond, tr("Carré", "type of the 1st end of a line"), Qet::Diamond );
ui->m_end2_cb->addItem(QET::Icons::EndLineNone, tr("Normale", "type of the 1st end of a line"), Qet::None );
ui->m_end2_cb->addItem(QET::Icons::EndLineSimple, tr("Flèche simple", "type of the 1st end of a line"), Qet::Simple );
ui->m_end2_cb->addItem(QET::Icons::EndLineTriangle, tr("Flèche triangulaire", "type of the 1st end of a line"), Qet::Triangle);
ui->m_end2_cb->addItem(QET::Icons::EndLineCircle, tr("Cercle", "type of the 1st end of a line"), Qet::Circle );
ui->m_end2_cb->addItem(QET::Icons::EndLineDiamond, tr("Carré", "type of the 1st end of a line"), Qet::Diamond );
m_style = new StyleEditor(editor);
ui->m_main_layout->insertWidget(0, m_style);
if (part) {
setPart(part);
}
}
/**
* @brief LineEditor::~LineEditor
*/
LineEditor::~LineEditor() {
delete ui;
}
/**
* @brief LineEditor::setPart
* Reimplemented from @ElementItemEditor
* @param part : part line to edit
* @return : true if the given part can be edited
*/
bool LineEditor::setPart(CustomElementPart *part)
{
if (m_part == part) {
return true;
}
if (!part)
{
if (m_part) {
disconnectChangeConnections();
}
m_part = nullptr;
return true;
}
if (PartLine *part_line = dynamic_cast<PartLine *>(part))
{
if (m_part) {
disconnectChangeConnections();
}
m_part = part_line;
updateForm();
setUpChangeConnections();
return true;
}
return false;
}
/**
* @brief LineEditor::setParts
* Reimplemented from @ElementItemEditor
* @param parts : parts to edit
* @return true if the parts can be edited
*/
bool LineEditor::setParts(QList<CustomElementPart *> parts)
{
if (parts.isEmpty()) {
return false;
}
if (!setPart(parts.first())) {
return false;
}
return m_style->setParts(parts);
}
/**
* @brief LineEditor::currentPart
* @return the current edited part or nullptr
*/
CustomElementPart *LineEditor::currentPart() const {
return m_part;
}
/**
* @brief LineEditor::currentParts
* @return A QList of edited parts
*/
QList<CustomElementPart *> LineEditor::currentParts() const {
return m_style->currentParts();
}
/**
* @brief LineEditor::updateForm
* Reimplemented from @ElementItemEditor
*/
void LineEditor::updateForm()
{
if (!m_part) {
return;
}
activeConnection(false);
QLineF line(m_part->sceneP1(),
m_part->sceneP2());
ui->m_x1_sb->setValue(line.x1());
ui->m_y1_sb->setValue(line.y1());
ui->m_x2_sb->setValue(line.x2());
ui->m_y2_sb->setValue(line.y2());
//ui->m_end1_cb
//ui->m_end_2_cb
ui->m_lenght1_sb->setValue(m_part->firstEndLength());
ui->m_lenght2_sb->setValue(m_part->secondEndLength());
activeConnection(true);
}
/**
* @brief LineEditor::setUpChangeConnections
* Make the connection use for update the form when line is edited out of this editor
*/
void LineEditor::setUpChangeConnections()
{
m_change_connections << connect(m_part, &PartLine::xChanged, this, &LineEditor::updateForm);
m_change_connections << connect(m_part, &PartLine::yChanged, this, &LineEditor::updateForm);
m_change_connections << connect(m_part, &PartLine::lineChanged, this, &LineEditor::updateForm);
m_change_connections << connect(m_part, &PartLine::firstEndLengthChanged, this, &LineEditor::updateForm);
m_change_connections << connect(m_part, &PartLine::firstEndLengthChanged, this, &LineEditor::updateForm);
m_change_connections << connect(m_part, &PartLine::secondEndTypeChanged, this, &LineEditor::updateForm);
m_change_connections << connect(m_part, &PartLine::secondEndLengthChanged, this, &LineEditor::updateForm);
}
/**
* @brief LineEditor::disconnectChangeConnections
* disconnect the connection
* use for update the form when line is edited out of this editor
*/
void LineEditor::disconnectChangeConnections()
{
for (auto connection : m_change_connections) {
disconnect(connection);
}
m_change_connections.clear();
}
/**
* @brief LineEditor::activeConnection
* Active or not the connection between the signals from widgets of this editor and the slots
* @param active
*/
void LineEditor::activeConnection(bool active)
{
if (active)
{
connect(ui->m_x1_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
connect(ui->m_y1_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
connect(ui->m_x2_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
connect(ui->m_y2_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
connect(ui->m_end1_cb, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &LineEditor::firstEndEdited);
connect(ui->m_end2_cb, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &LineEditor::secondEndEdited);
connect(ui->m_lenght1_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::firstEndLenghtEdited);
connect(ui->m_lenght2_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::secondEndLenghtEdited);
}
else
{
disconnect(ui->m_x1_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
disconnect(ui->m_y1_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
disconnect(ui->m_x2_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
disconnect(ui->m_y2_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::lineEdited);
disconnect(ui->m_end1_cb, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &LineEditor::firstEndEdited);
disconnect(ui->m_end2_cb, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged), this, &LineEditor::secondEndEdited);
disconnect(ui->m_lenght1_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::firstEndLenghtEdited);
disconnect(ui->m_lenght2_sb, &QDoubleSpinBox::editingFinished, this, &LineEditor::secondEndLenghtEdited);
}
}
/**
* @brief LineEditor::lineEdited
* slot
*/
void LineEditor::lineEdited()
{
if (m_locked) {
return;
}
m_locked = true;
QPointF p1(ui->m_x1_sb->value(), ui->m_y1_sb->value());
QPointF p2(ui->m_x2_sb->value(), ui->m_y2_sb->value());
QLineF line(m_part->mapFromScene(p1), m_part->mapFromScene(p2));
if (line != m_part->line()) {
QPropertyUndoCommand *undo = new QPropertyUndoCommand(m_part, "line", m_part->line(), line);
undo->setAnimated();
elementScene()->undoStack().push(undo);
}
m_locked = false;
}
/**
* @brief LineEditor::firstEndEdited
* slot
*/
void LineEditor::firstEndEdited()
{
if (m_locked) {
return;
}
m_locked = true;
QVariant end = ui->m_end1_cb->itemData(ui->m_end1_cb->currentIndex());
for (auto part: m_style->currentParts())
{
PartLine* line = static_cast<PartLine*>(part);
if (end != line->property("end1"))
{
QPropertyUndoCommand *undo = new QPropertyUndoCommand(line, "end1", line->property("end1"), end);
undo->setText(tr("Modifier une ligne"));
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
/**
* @brief LineEditor::firstEndLenghtEdited
* slot
*/
void LineEditor::firstEndLenghtEdited()
{
if (m_locked) {
return;
}
m_locked = true;
if (!qFuzzyCompare(ui->m_lenght1_sb->value(), m_part->firstEndLength())) {
QPropertyUndoCommand *undo = new QPropertyUndoCommand(m_part, "length1", m_part->firstEndLength(), ui->m_lenght1_sb->value());
undo->setAnimated();
elementScene()->undoStack().push(undo);
}
m_locked = false;
}
/**
* @brief LineEditor::secondEndEdited
* slot
*/
void LineEditor::secondEndEdited()
{
if (m_locked) {
return;
}
m_locked = true;
QVariant end = ui->m_end2_cb->itemData(ui->m_end2_cb->currentIndex());
for (auto part: m_style->currentParts())
{
PartLine* line = static_cast<PartLine*>(part);
if (end != line->property("end2"))
{
QPropertyUndoCommand *undo = new QPropertyUndoCommand(line, "end2", line->property("end2"), end);
undo->setText(tr("Modifier une ligne"));
elementScene()->undoStack().push(undo);
}
}
m_locked = false;
}
/**
* @brief LineEditor::secondEndLenghtEdited
* slot
*/
void LineEditor::secondEndLenghtEdited()
{
if (m_locked) {
return;
}
m_locked = true;
if (!qFuzzyCompare(ui->m_lenght2_sb->value(), m_part->secondEndLength())) {
QPropertyUndoCommand *undo = new QPropertyUndoCommand(m_part, "length2", m_part->secondEndLength(), ui->m_lenght2_sb->value());
undo->setAnimated();
elementScene()->undoStack().push(undo);
}
m_locked = false;
}

67
sources/editor/ui/lineeditor.h Normal file
View File

@ -0,0 +1,67 @@
/*
Copyright 2006-2020 The QElectroTech Team
This file is part of QElectroTech.
QElectroTech is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
QElectroTech is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with QElectroTech. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef LINEEDITOR_H
#define LINEEDITOR_H
#include "elementitemeditor.h"
namespace Ui {
class LineEditor;
}
class PartLine;
class StyleEditor;
/**
* @brief The LineEditor class
* Provide a widget editor used to edit the properties of a @PartLine
*/
class LineEditor : public ElementItemEditor
{
Q_OBJECT
public:
explicit LineEditor(QETElementEditor *editor, PartLine *part = nullptr, QWidget *parent = nullptr);
~LineEditor() override;
bool setPart(CustomElementPart *part) override;
bool setParts(QList <CustomElementPart *> parts) override;
CustomElementPart *currentPart() const override;
QList<CustomElementPart *> currentParts() const override;
void updateForm() override;
private:
void setUpChangeConnections();
void disconnectChangeConnections();
void activeConnection(bool active);
void lineEdited();
void firstEndEdited();
void firstEndLenghtEdited();
void secondEndEdited();
void secondEndLenghtEdited();
private:
PartLine *m_part = nullptr;
Ui::LineEditor *ui;
StyleEditor *m_style = nullptr;
QList <QMetaObject::Connection> m_change_connections;
bool m_locked = false;
};
#endif // LINEEDITOR_H

160
sources/editor/ui/lineeditor.ui Normal file
View File

@ -0,0 +1,160 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>LineEditor</class>
<widget class="QWidget" name="LineEditor">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>347</width>
<height>144</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<layout class="QVBoxLayout" name="m_main_layout">
<item>
<layout class="QGridLayout" name="gridLayout">
<item row="1" column="3">
<widget class="QDoubleSpinBox" name="m_y2_sb">
<property name="minimum">
<double>-1000000.000000000000000</double>
</property>
<property name="maximum">
<double>1000000.000000000000000</double>
</property>
</widget>
</item>
<item row="0" column="3">
<widget class="QDoubleSpinBox" name="m_y1_sb">
<property name="minimum">
<double>-1000000.000000000000000</double>
</property>
<property name="maximum">
<double>1000000.000000000000000</double>
</property>
</widget>
</item>
<item row="0" column="1">
<widget class="QDoubleSpinBox" name="m_x1_sb">
<property name="minimum">
<double>-1000000.000000000000000</double>
</property>
<property name="maximum">
<double>1000000.000000000000000</double>
</property>
</widget>
</item>
<item row="0" column="0">
<widget class="QLabel" name="label">
<property name="text">
<string>X1 :</string>
</property>
</widget>
</item>
<item row="0" column="2">
<widget class="QLabel" name="label_3">
<property name="text">
<string>Y1 :</string>
</property>
</widget>
</item>
<item row="1" column="0">
<widget class="QLabel" name="label_2">
<property name="text">
<string>X2 :</string>
</property>
</widget>
</item>
<item row="1" column="1">
<widget class="QDoubleSpinBox" name="m_x2_sb">
<property name="minimum">
<double>-1000000.000000000000000</double>
</property>
<property name="maximum">
<double>1000000.000000000000000</double>
</property>
</widget>
</item>
<item row="2" column="0">
<widget class="QLabel" name="label_5">
<property name="text">
<string>Fin 1 :</string>
</property>
</widget>
</item>
<item row="1" column="2">
<widget class="QLabel" name="label_4">
<property name="text">
<string>Y2 :</string>
</property>
</widget>
</item>
<item row="3" column="0">
<widget class="QLabel" name="label_6">
<property name="text">
<string>Fin 2 :</string>
</property>
</widget>
</item>
<item row="2" column="1">
<widget class="QComboBox" name="m_end1_cb"/>
</item>
<item row="3" column="1">
<widget class="QComboBox" name="m_end2_cb"/>
</item>
<item row="2" column="2">
<widget class="QLabel" name="label_7">
<property name="text">
<string>Longueur :</string>
</property>
</widget>
</item>
<item row="3" column="2">
<widget class="QLabel" name="label_8">
<property name="text">
<string>Longueur :</string>
</property>
</widget>
</item>
<item row="2" column="3">
<widget class="QDoubleSpinBox" name="m_lenght1_sb">
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>1.500000000000000</double>
</property>
</widget>
</item>
<item row="3" column="3">
<widget class="QDoubleSpinBox" name="m_lenght2_sb">
<property name="singleStep">
<double>0.100000000000000</double>
</property>
<property name="value">
<double>1.500000000000000</double>
</property>
</widget>
</item>
</layout>
</item>
<item>
<spacer name="verticalSpacer">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
<height>40</height>
</size>
</property>
</spacer>
</item>
</layout>
</widget>
<resources/>
<connections/>
</ui>