diff --git a/sources/editor/elementitemeditor.h b/sources/editor/elementitemeditor.h index ca5892d75..cf35bcdb0 100644 --- a/sources/editor/elementitemeditor.h +++ b/sources/editor/elementitemeditor.h @@ -36,7 +36,7 @@ class ElementItemEditor : public QWidget // constructors, destructor public: ElementItemEditor(QETElementEditor *, QWidget * = nullptr); - ~ElementItemEditor() override {}; + ~ElementItemEditor() override {} private: ElementItemEditor(const ElementItemEditor &); diff --git a/sources/editor/graphicspart/partline.cpp b/sources/editor/graphicspart/partline.cpp index 7992bffdd..d499e31b7 100644 --- a/sources/editor/graphicspart/partline.cpp +++ b/sources/editor/graphicspart/partline.cpp @@ -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); diff --git a/sources/editor/lineeditor.cpp b/sources/editor/lineeditor.cpp deleted file mode 100644 index d2942dcb8..000000000 --- a/sources/editor/lineeditor.cpp +++ /dev/null @@ -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 . -*/ -#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(new_part)) - { - if (part == part_line) return true; - if (part) - { - disconnectChangeConnections(); - } - part = part_line; - updateForm(); - setUpChangeConnections(); - return(true); - } - return(false); -} - -bool LineEditor::setParts(QList 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 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(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(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(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(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(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(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(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(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())); - } -} diff --git a/sources/editor/lineeditor.h b/sources/editor/lineeditor.h deleted file mode 100644 index 9cf24ba05..000000000 --- a/sources/editor/lineeditor.h +++ /dev/null @@ -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 . -*/ -#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 m_change_connections; - - // methods - public: - bool setPart(CustomElementPart *) override; - bool setParts(QList parts) override; - CustomElementPart *currentPart() const override; - QList 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 diff --git a/sources/editor/ui/lineeditor.cpp b/sources/editor/ui/lineeditor.cpp new file mode 100644 index 000000000..bfeaf85bb --- /dev/null +++ b/sources/editor/ui/lineeditor.cpp @@ -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 . +*/ +#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(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 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 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(&QComboBox::currentIndexChanged), this, &LineEditor::firstEndEdited); + connect(ui->m_end2_cb, static_cast(&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(&QComboBox::currentIndexChanged), this, &LineEditor::firstEndEdited); + disconnect(ui->m_end2_cb, static_cast(&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(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(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; +} diff --git a/sources/editor/ui/lineeditor.h b/sources/editor/ui/lineeditor.h new file mode 100644 index 000000000..46d7f1910 --- /dev/null +++ b/sources/editor/ui/lineeditor.h @@ -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 . +*/ +#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 parts) override; + CustomElementPart *currentPart() const override; + QList 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 m_change_connections; + bool m_locked = false; +}; + +#endif // LINEEDITOR_H diff --git a/sources/editor/ui/lineeditor.ui b/sources/editor/ui/lineeditor.ui new file mode 100644 index 000000000..31320b397 --- /dev/null +++ b/sources/editor/ui/lineeditor.ui @@ -0,0 +1,160 @@ + + + LineEditor + + + + 0 + 0 + 347 + 144 + + + + Form + + + + + + + + -1000000.000000000000000 + + + 1000000.000000000000000 + + + + + + + -1000000.000000000000000 + + + 1000000.000000000000000 + + + + + + + -1000000.000000000000000 + + + 1000000.000000000000000 + + + + + + + X1 : + + + + + + + Y1 : + + + + + + + X2 : + + + + + + + -1000000.000000000000000 + + + 1000000.000000000000000 + + + + + + + Fin 1 : + + + + + + + Y2 : + + + + + + + Fin 2 : + + + + + + + + + + + + + Longueur : + + + + + + + Longueur : + + + + + + + 0.100000000000000 + + + 1.500000000000000 + + + + + + + 0.100000000000000 + + + 1.500000000000000 + + + + + + + + + Qt::Vertical + + + + 20 + 40 + + + + + + + + +