partterminal.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 "partterminal.h"
#include "terminal.h"

PartTerminal::PartTerminal(QETElementEditor *editor, QGraphicsItem *parent) :
    CustomElementGraphicPart(editor, parent),
    m_orientation(Qet::North)
{
    updateSecondPoint();
    setZValue(100000);
}

PartTerminal::~PartTerminal() {
}

void PartTerminal::fromXml(const QDomElement &xml_elmt) {
    // lit la position de la borne
    qreal term_x = 0.0, term_y = 0.0;
    QET::attributeIsAReal(xml_elmt, "x", &term_x);
    QET::attributeIsAReal(xml_elmt, "y", &term_y);
    setPos(QPointF(term_x, term_y));
    
    // lit l'orientation de la borne
    m_orientation = Qet::orientationFromString(xml_elmt.attribute("orientation"));
    
    updateSecondPoint();
}

const QDomElement PartTerminal::toXml(QDomDocument &xml_document) const {
    QDomElement xml_element = xml_document.createElement("terminal");
    
    // ecrit la position de la borne
    xml_element.setAttribute("x", QString("%1").arg(scenePos().x()));
    xml_element.setAttribute("y", QString("%1").arg(scenePos().y()));
    
    
    // ecrit l'orientation de la borne
    xml_element.setAttribute("orientation", Qet::orientationToString(m_orientation));
    // Write name and number to XML
    
    return(xml_element);
}

void PartTerminal::paint(QPainter *p, const QStyleOptionGraphicsItem *options, QWidget *widget) {
    Q_UNUSED(widget);
    p -> save();
    
    // annulation des renderhints
    p -> setRenderHint(QPainter::Antialiasing,          false);
    p -> setRenderHint(QPainter::TextAntialiasing,      false);
    p -> setRenderHint(QPainter::SmoothPixmapTransform, false);
    
    QPen t;
    t.setWidthF(1.0);
    t.setCosmetic(options && options -> levelOfDetail < 1.0);
    
    // dessin de la borne en rouge
    t.setColor(isSelected() ? Terminal::neutralColor : Qt::red);
    p -> setPen(t);
    p -> drawLine(QPointF(0.0, 0.0), second_point);
    
    // dessin du point d'amarrage au conducteur en bleu
    t.setColor(isSelected() ? Qt::red : Terminal::neutralColor);
    p -> setPen(t);
    p -> setBrush(Terminal::neutralColor);
    p -> drawPoint(QPointF(0.0, 0.0));
    p -> restore();

    if (m_hovered)
        drawShadowShape(p);
}

QPainterPath PartTerminal::shape() const
{
    QPainterPath shape;
    shape.lineTo(second_point);

    QPainterPathStroker pps;
    pps.setWidth(1);

    return (pps.createStroke(shape));
}

QRectF PartTerminal::boundingRect() const
{
    QRectF br(QPointF(0, 0), second_point);
    br = br.normalized();

    qreal adjust = (SHADOWS_HEIGHT + 1) / 2;
    br.adjust(-adjust, -adjust, adjust, adjust);
    return(br);
}

void PartTerminal::setOrientation(Qet::Orientation ori)
{
    if (m_orientation == ori) return;
    prepareGeometryChange();
    m_orientation = ori;
    updateSecondPoint();
    emit orientationChanged();
}

void PartTerminal::updateSecondPoint() {
    qreal ts = 4.0; // terminal size
    switch(m_orientation) {
        case Qet::North: second_point = QPointF(0.0,  ts); break;
        case Qet::East : second_point = QPointF(-ts, 0.0); break;
        case Qet::South: second_point = QPointF(0.0, -ts); break;
        case Qet::West : second_point = QPointF(ts,  0.0); break;
    }
}

bool PartTerminal::isUseless() const {
    return(false);
}

QRectF PartTerminal::sceneGeometricRect() const {
    return(sceneBoundingRect());
}

void PartTerminal::startUserTransformation(const QRectF &initial_selection_rect) {
    Q_UNUSED(initial_selection_rect)
    saved_position_ = scenePos();
}

void PartTerminal::handleUserTransformation(const QRectF &initial_selection_rect, const QRectF &new_selection_rect) {
    QPointF mapped_point = mapPoints(initial_selection_rect, new_selection_rect, QList<QPointF>() << saved_position_).first();
    setPos(mapped_point);
}