Element editor : improve polygon edition

sources/editor/ui/polygoneditor.cpp

@@ -0,0 +1,289 @@
+/*
+    Copyright 2006-2019 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 "polygoneditor.h"
+#include "ui_polygoneditor.h"
+#include "partpolygon.h"
+#include "elementscene.h"
+#include "qetmessagebox.h"
+#include "styleeditor.h"
+#include "QPropertyUndoCommand/qpropertyundocommand.h"
+
+/**
+ * @brief PolygonEditor::PolygonEditor
+ * @param editor
+ * @param part
+ * @param parent
+ */
+PolygonEditor::PolygonEditor(QETElementEditor *editor, PartPolygon *part, QWidget *parent) :
+    ElementItemEditor(editor, parent),
+    ui(new Ui::PolygonEditor),
+    m_part(part)
+{
+    ui->setupUi(this);
+    m_style = new StyleEditor(editor);
+    ui->m_main_layout->insertWidget(0, m_style);
+    updateForm();
+    ui->m_points_list_tree->installEventFilter(this);
+    ui->m_points_list_tree->addAction(ui->m_add_point_action);
+    ui->m_points_list_tree->addAction(ui->m_remove_point_action);
+}
+
+/**
+ * @brief PolygonEditor::~PolygonEditor
+ */
+PolygonEditor::~PolygonEditor() {
+    delete ui;
+}
+
+/**
+ * @brief PolygonEditor::setPart
+ * @param new_part
+ * @return
+ */
+bool PolygonEditor::setPart(CustomElementPart *new_part)
+{
+    if (!new_part)
+    {
+        if (m_part)
+        {
+            disconnect(m_part, &PartPolygon::polygonChanged, this, &PolygonEditor::updateForm);
+            disconnect(m_part, &PartPolygon::closedChange, this, &PolygonEditor::updateForm);
+        }
+        m_part = nullptr;
+        m_style -> setPart(nullptr);
+        return(true);
+    }
+    if (PartPolygon *part_polygon = dynamic_cast<PartPolygon *>(new_part))
+    {
+        if (m_part == part_polygon) return true;
+        if (m_part)
+        {
+            disconnect(m_part, &PartPolygon::polygonChanged, this, &PolygonEditor::updateForm);
+            disconnect(m_part, &PartPolygon::closedChange, this, &PolygonEditor::updateForm);
+            disconnect(m_part, &PartPolygon::xChanged, this, &PolygonEditor::updateForm);
+            disconnect(m_part, &PartPolygon::yChanged, this, &PolygonEditor::updateForm);
+        }
+        m_part = part_polygon;
+        m_style -> setPart(m_part);
+        updateForm();
+        connect(m_part, &PartPolygon::polygonChanged, this, &PolygonEditor::updateForm);
+        connect(m_part, &PartPolygon::closedChange, this, &PolygonEditor::updateForm);
+        connect(m_part, &PartPolygon::xChanged, this, &PolygonEditor::updateForm);
+        connect(m_part, &PartPolygon::yChanged, this, &PolygonEditor::updateForm);
+        return(true);
+    }
+    return(false);
+}
+
+/**
+ * @brief PolygonEditor::currentPart
+ * @return the curent edited part
+ */
+CustomElementPart *PolygonEditor::currentPart() const {
+    return m_part;
+}
+
+/**
+ * @brief PolygonEditor::updateForm
+ * Update the widget
+ */
+void PolygonEditor::updateForm()
+{
+    if (!m_part) {
+        return;
+    }
+
+    ui->m_points_list_tree->clear();
+
+    for(QPointF point : m_part->polygon())
+    {
+        point = m_part->mapToScene(point);
+        QTreeWidgetItem *qtwi = new QTreeWidgetItem();
+        qtwi->setData(0, Qt::EditRole, point.x());
+        qtwi->setData(1, Qt::EditRole, point.y());
+        qtwi -> setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled);
+        ui->m_points_list_tree->addTopLevelItem(qtwi);
+    }
+    ui->m_close_polygon_cb->setChecked(m_part->isClosed());
+    ui->m_remove_point_action->setEnabled(m_part->polygon().size() > 2 ? true : false);
+}
+
+/**
+ * @brief PolygonEditor::pointsFromTree
+ * @return the point of polygon from the current value of the tree editor
+ * if part coordinate.
+ */
+QVector<QPointF> PolygonEditor::pointsFromTree()
+{
+    QVector<QPointF> points;
+    if (!m_part) {
+        return points;
+    }
+
+    for(int i = 0 ; i < ui->m_points_list_tree->topLevelItemCount() ; ++ i)
+    {
+        QTreeWidgetItem *qtwi = ui->m_points_list_tree->topLevelItem(i);
+        bool x_convert_ok, y_convert_ok;
+        qreal x = qtwi->data(0, Qt::EditRole).toReal(&x_convert_ok);
+        qreal y = qtwi->data(1, Qt::EditRole).toReal(&y_convert_ok);
+        if (x_convert_ok && y_convert_ok) {
+            points << m_part->mapFromScene(QPointF(x, y));
+        }
+    }
+    return(points);
+}
+
+bool PolygonEditor::eventFilter(QObject *watched, QEvent *event)
+{
+    if (watched == ui->m_points_list_tree &&
+        event->type() == QEvent::FocusOut &&
+        m_part)
+    {
+        m_part->resetAllHandlerColor();
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * @brief PolygonEditor::on_m_close_polygon_cb_stateChanged
+ */
+void PolygonEditor::on_m_close_polygon_cb_stateChanged(int arg1)
+{
+    Q_UNUSED(arg1);
+
+    if (!m_part) {
+        return;
+    }
+    bool close = ui->m_close_polygon_cb->isChecked();
+    if (close != m_part->isClosed())
+    {
+        QPropertyUndoCommand *undo = new QPropertyUndoCommand(m_part, "closed", m_part->property("closed"), close);
+        undo->setText(tr("Modifier un polygone"));
+        undoStack().push(undo);
+    }
+}
+
+/**
+ * @brief PolygonEditor::on_m_points_list_tree_itemChanged
+ * Update the polygon according to the current value of the tree editor
+ */
+void PolygonEditor::on_m_points_list_tree_itemChanged(QTreeWidgetItem *item, int column)
+{
+    Q_UNUSED(item);
+    Q_UNUSED(column);
+
+    if (!m_part) {
+        return;
+    }
+
+    QPolygonF points = pointsFromTree();
+    if (points.count() < 2)
+    {
+        QET::QetMessageBox::warning(this, tr("Erreur", "message box title"), tr("Le polygone doit comporter au moins deux points.", "message box content"));
+        return;
+    }
+
+    if (points != m_part->polygon())
+    {
+        QPropertyUndoCommand *undo = new QPropertyUndoCommand(m_part, "polygon", m_part->property("polygon"), points);
+        undo->setText(tr("Modifier un polygone"));
+        undoStack().push(undo);
+    }
+}
+
+/**
+ * @brief PolygonEditor::on_m_points_list_tree_itemSelectionChanged
+ * Used to change the color of the current selected point.
+ */
+void PolygonEditor::on_m_points_list_tree_itemSelectionChanged()
+{
+        //Prevent when selection change but the widget ins't focused
+    if (!ui->m_points_list_tree->hasFocus()) {
+        return;
+    }
+
+    QTreeWidgetItem *qtwi = ui->m_points_list_tree->currentItem();
+    if (!qtwi || !m_part) {
+        return;
+    }
+
+    m_part->resetAllHandlerColor();
+    int index = ui->m_points_list_tree->indexOfTopLevelItem(qtwi);
+
+        //We need to check if index isn't out of range of polygon
+        //this case can occur when user remove the last point of the polygon
+        //with the context menu of the tree widget
+    if(index >= 0 &&
+       index < m_part->polygon().size())
+    {
+        m_part->setHandlerColor(m_part->polygon().at(index), QColor(0, 255, 128));
+    }
+}
+
+void PolygonEditor::on_m_add_point_action_triggered()
+{
+    QTreeWidgetItem *qtwi = ui->m_points_list_tree->currentItem();
+    if (!qtwi || !m_part) {
+        return;
+    }
+
+    int index = ui->m_points_list_tree->indexOfTopLevelItem(qtwi);
+    QPolygonF new_polygon = m_part->polygon();
+
+        //Special case when user add a point after the last point of the polygon
+    if (index == m_part->polygon().size()-1)
+    {
+        QPointF p = m_part->polygon().last();
+        p.rx()+=20;
+        p.ry()+=20;
+        new_polygon.append(p);
+    }
+    else
+    {
+        QPointF p = m_part->polygon().at(index) +
+                    m_part->polygon().at(index+1);
+        p/=2;
+        new_polygon.insert(index+1, p);
+    }
+
+        //Wrap the undo for avoid to merge the undo commands when user add several points.
+    QUndoCommand *undo = new QUndoCommand(tr("Ajouter un point à un polygone"));
+    new QPropertyUndoCommand(m_part, "polygon", m_part->polygon(), new_polygon, undo);
+    elementScene()->undoStack().push(undo);
+
+    m_part->resetAllHandlerColor();
+    m_part->setHandlerColor(m_part->polygon().at(index+1), QColor(0, 255, 128));
+}
+
+void PolygonEditor::on_m_remove_point_action_triggered()
+{
+    QTreeWidgetItem *qtwi = ui->m_points_list_tree->currentItem();
+    if (!qtwi || !m_part) {
+        return;
+    }
+
+    QPolygonF new_polygon = m_part->polygon();
+    new_polygon.removeAt(ui->m_points_list_tree->indexOfTopLevelItem(qtwi));
+
+        //Wrap the undo for avoid to merge the undo commands when user remove several points.
+    QUndoCommand *undo = new QUndoCommand(tr("Supprimer un point d'un polygone"));
+    new QPropertyUndoCommand(m_part, "polygon", m_part->polygon(), new_polygon, undo);
+    elementScene()->undoStack().push(undo);
+}