polygoneditor.cpp

Go to the documentation of this file.

/*
    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 "partpolygon.h"
#include "elementscene.h"
#include "qetmessagebox.h"
#include "styleeditor.h"
#include "QPropertyUndoCommand/qpropertyundocommand.h"

PolygonEditor::PolygonEditor(QETElementEditor *editor, PartPolygon *p, QWidget *parent) :
    ElementItemEditor(editor, parent),
    part(p),
    points_list(this),
    close_polygon(tr("Polygone fermé"), this)
{
    style_ = new StyleEditor(editor);
    
    // prepare la liste de points
    points_list.setColumnCount(2);
    QStringList headers;
    headers << tr("x") << tr("y");
    points_list.setHeaderLabels(headers);
    points_list.setRootIsDecorated(false);
    updateForm();
    
    // layout
    QVBoxLayout *layout = new QVBoxLayout(this);
    layout -> addWidget(style_);
    layout -> addWidget(new QLabel(tr("Points du polygone :")));
    layout -> addWidget(&points_list);
    layout -> addWidget(&close_polygon);
    layout->addStretch();
    
    updateForm();
}

PolygonEditor::~PolygonEditor() {
}

void PolygonEditor::updatePolygonPoints()
{
    if (!part) return;
    QPolygonF points = getPointsFromTree();
    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 != part->polygon())
    {
        QPropertyUndoCommand *undo = new QPropertyUndoCommand(part, "polygon", part->property("polygon"), points);
        undo->setText(tr("Modifier un polygone"));
        undoStack().push(undo);
    }
}

void PolygonEditor::updatePolygonClosedState()
{
    if (!part) return;
    bool close = close_polygon.isChecked();
    if (close != part->isClosed())
    {
        QPropertyUndoCommand *undo = new QPropertyUndoCommand(part, "closed", part->property("closed"), close);
        undo->setText(tr("Modifier un polygone"));
        undoStack().push(undo);
    }
}

void PolygonEditor::updateForm() {
    if (!part) return;
    activeConnections(false);
    while(points_list.takeTopLevelItem(0)) {}
    foreach(QPointF point, part -> polygon()) {
        point = part -> mapToScene(point);
        QStringList qsl;
        qsl << QString("%1").arg(point.x()) << QString("%1").arg(point.y());
        QTreeWidgetItem *qtwi = new QTreeWidgetItem(qsl);
        qtwi -> setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable | Qt::ItemIsSelectable);
        points_list.addTopLevelItem(qtwi);
    }
    close_polygon.setChecked(part -> isClosed());
    activeConnections(true);
}

bool PolygonEditor::setPart(CustomElementPart *new_part)
{
    if (!new_part)
    {
        if (part)
        {
            disconnect(part, &PartPolygon::polygonChanged, this, &PolygonEditor::updateForm);
            disconnect(part, &PartPolygon::closedChange, this, &PolygonEditor::updateForm);
        }
        part = nullptr;
        style_ -> setPart(nullptr);
        return(true);
    }
    if (PartPolygon *part_polygon = dynamic_cast<PartPolygon *>(new_part))
    {
        if (part == part_polygon) return true;
        if (part)
        {
            disconnect(part, &PartPolygon::polygonChanged, this, &PolygonEditor::updateForm);
            disconnect(part, &PartPolygon::closedChange, this, &PolygonEditor::updateForm);
        }
        part = part_polygon;
        style_ -> setPart(part);
        updateForm();
        connect(part, &PartPolygon::polygonChanged, this, &PolygonEditor::updateForm);
        connect(part, &PartPolygon::closedChange, this, &PolygonEditor::updateForm);
        return(true);
    }
    return(false);
}

CustomElementPart *PolygonEditor::currentPart() const {
    return(part);
}

QVector<QPointF> PolygonEditor::getPointsFromTree() {
    if (!part) return(QVector<QPointF>());
    QVector<QPointF> points;
    for(int i = 0 ; i < points_list.topLevelItemCount() ; ++ i) {
        QTreeWidgetItem *qtwi = points_list.topLevelItem(i);
        bool x_convert_ok, y_convert_ok;
        qreal x = qtwi -> text(0).toDouble(&x_convert_ok);
        qreal y = qtwi -> text(1).toDouble(&y_convert_ok);
        if (!x_convert_ok || !y_convert_ok) continue;
        points << part -> mapFromScene(QPointF(x, y));
    }
    return(points);
}

void PolygonEditor::validColumn(QTreeWidgetItem *qtwi, int column) {
    bool convert_ok;
    qtwi -> text(column).toDouble(&convert_ok);
    if (convert_ok) {
        points_list.closePersistentEditor(qtwi, column);
        updatePolygonPoints();
    } else points_list.openPersistentEditor(qtwi, column);
}

void PolygonEditor::activeConnections(bool active) {
    if (active) {
        connect(&close_polygon, SIGNAL(stateChanged(int)),                   this, SLOT(updatePolygonClosedState()));
        connect(&points_list,   SIGNAL(itemChanged(QTreeWidgetItem *, int)), this, SLOT(validColumn(QTreeWidgetItem *, int)));
    } else {
        disconnect(&close_polygon, SIGNAL(stateChanged(int)),                   this, SLOT(updatePolygonClosedState()));
        disconnect(&points_list,   SIGNAL(itemChanged(QTreeWidgetItem *, int)), this, SLOT(validColumn(QTreeWidgetItem *, int)));
    }
}