conductorproperties.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 "conductorproperties.h"
#include <QPainter>
#include <utility>

SingleLineProperties::SingleLineProperties() :
    hasGround(true),
    hasNeutral(true),
    is_pen(false),
    phases(1)
{
}

SingleLineProperties::~SingleLineProperties() {
}

void SingleLineProperties::setPhasesCount(int n) {
    phases = qBound(0, n, 3);
}

unsigned short int SingleLineProperties::phasesCount() {
    return(phases);
}

bool SingleLineProperties::isPen() const {
    return(hasNeutral && hasGround && is_pen);
}

void SingleLineProperties::draw(QPainter *painter, QET::ConductorSegmentType direction, const QRectF &rect) {
    // s'il n'y a rien a dessiner, on retourne immediatement
    if (!hasNeutral && !hasGround && !phases) return;
    
    // prepare le QPainter
    painter -> save();
    QPen pen(painter -> pen());
    pen.setCapStyle(Qt::FlatCap);
    pen.setJoinStyle(Qt::MiterJoin);
    pen.setStyle(Qt::SolidLine);
    pen.setWidthF(1);
    painter -> setPen(pen);
    painter -> setRenderHint(QPainter::Antialiasing, true);
    
    uint symbols_count = (hasNeutral ? 1 : 0) + (hasGround ? 1 : 0) - (isPen() ? 1 : 0) + phases;
    qreal interleave_base = (direction == QET::Horizontal ? rect.width() : rect.height());
    qreal interleave = interleave_base / (symbols_count + 1);;
    qreal symbol_width = interleave_base / 12;
    
    for (uint i = 1 ; i <= symbols_count ; ++ i) {
        // dessine le tronc du symbole
        QPointF symbol_p1, symbol_p2;
        if (direction == QET::Horizontal) {
            symbol_p1 = QPointF(rect.x() + (i * interleave) + symbol_width, rect.y() + rect.height() * 0.75);
            symbol_p2 = QPointF(rect.x() + (i * interleave) - symbol_width, rect.y() + rect.height() * 0.25);
        } else {
            symbol_p2 = QPointF(rect.x() + rect.width() * 0.75, rect.y() + (i * interleave) - symbol_width);
            symbol_p1 = QPointF(rect.x() + rect.width() * 0.25, rect.y() + (i * interleave) + symbol_width);
        }
        painter -> drawLine(QLineF(symbol_p1, symbol_p2));
        
        // dessine le reste des symboles terre et neutre
        if (isPen()) {
            if (i == 1) {
                drawPen(painter, direction, symbol_p2, symbol_width);
            }
        } else {
            if (hasGround && i == 1) {
                drawGround(painter, direction, symbol_p2, symbol_width * 2.0);
            } else if (hasNeutral && ((i == 1 && !hasGround) || (i == 2 && hasGround))) {
                drawNeutral(painter, direction, symbol_p2, symbol_width * 1.5);
            }
        }
    }
    painter -> restore();
}

void SingleLineProperties::drawGround(QPainter *painter, QET::ConductorSegmentType direction, QPointF center, qreal size) {
    painter -> save();
    
    // prepare le QPainter
    painter -> setRenderHint(QPainter::Antialiasing, false);
    QPen pen2(painter -> pen());
    pen2.setCapStyle(Qt::SquareCap);
    painter -> setPen(pen2);
    
    // dessine le segment representant la terre
    qreal half_size = size / 2.0;
    QPointF offset_point(
        (direction == QET::Horizontal) ? half_size : 0.0,
        (direction == QET::Horizontal) ? 0.0 : half_size
    );
    painter -> drawLine(
        QLineF(
            center + offset_point,
            center - offset_point
        )
    );
    
    painter -> restore();
}

void SingleLineProperties::drawNeutral(QPainter *painter, QET::ConductorSegmentType direction, QPointF center, qreal size) {
    Q_UNUSED(direction);
    painter -> save();
    
    // prepare le QPainter
    if (painter -> brush() == Qt::NoBrush) painter -> setBrush(Qt::black);
    painter -> setPen(Qt::NoPen);
    
    // desine le cercle representant le neutre
    painter -> drawEllipse(
        QRectF(
            center - QPointF(size / 2.0, size / 2.0),
            QSizeF(size, size)
        )
    );
    
    painter -> restore();
}

void SingleLineProperties::drawPen(QPainter *painter, QET::ConductorSegmentType direction, QPointF center, qreal size) {
    painter -> save();
    
    //painter -> setBrush(Qt::white);
    // desine le cercle representant le neutre
    //painter -> drawEllipse(
    //  QRectF(
    //      center - QPointF(size * 1.5 / 2.0, size * 1.5 / 2.0),
    //      QSizeF(size * 1.5, size * 1.5)
    //  )
    //);
    drawNeutral(painter, direction, center, size * 1.5);
    
    int offset = (size * 1.5 / 2.0);
    QPointF pos = center + (direction == QET::Horizontal ? QPointF(0.0, -offset - 0.5) : QPointF(offset + 0.5, 0.0));
    drawGround(painter, direction, pos, 2.0 * size);
    painter -> restore();
}

void SingleLineProperties::toXml(QDomElement &e) const {
    e.setAttribute("ground",  hasGround  ? "true" : "false");
    e.setAttribute("neutral", hasNeutral ? "true" : "false");
    e.setAttribute("phase",   phases);
    if (isPen()) e.setAttribute("pen", "true");
}

void SingleLineProperties::fromXml(QDomElement &e) {
    hasGround  = e.attribute("ground")  == "true";
    hasNeutral = e.attribute("neutral") == "true";
    setPhasesCount(e.attribute("phase").toInt());
    is_pen = (hasGround && hasNeutral && e.attribute("pen", "false") == "true");
}

ConductorProperties::ConductorProperties() :
    type(Multi),
    color(Qt::black),
    text("_"),
    text_size(9),
    cond_size(1),
    verti_rotate_text(270),
    horiz_rotate_text(0),
    m_show_text(true),
    m_one_text_per_folio(false),
    style(Qt::SolidLine)
{}

ConductorProperties::~ConductorProperties() {
}


void ConductorProperties::toXml(QDomElement &e) const
{
    e.setAttribute("type", typeToString(type));

    if (color != QColor(Qt::black))
        e.setAttribute("color", color.name());
    
    e.setAttribute("bicolor", m_bicolor? "true" : "false");
    e.setAttribute("color2", m_color_2.name());
    e.setAttribute("dash-size", QString::number(m_dash_size));
    
    if (type == Single)
        singleLineProperties.toXml(e);

    e.setAttribute("num", text);
    e.setAttribute("formula", m_formula);
    e.setAttribute("function", m_function);
    e.setAttribute("tension-protocol", m_tension_protocol);
    e.setAttribute("numsize", QString::number(text_size));
    e.setAttribute("condsize", QString::number(cond_size));
    e.setAttribute("displaytext", m_show_text);
    e.setAttribute("onetextperfolio", m_one_text_per_folio);
    e.setAttribute("vertirotatetext", QString::number(verti_rotate_text));
    e.setAttribute("horizrotatetext", QString::number(horiz_rotate_text));
    
    QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
    e.setAttribute("horizontal-alignment", me.valueToKey(m_horizontal_alignment));
    e.setAttribute("vertical-alignment", me.valueToKey(m_vertical_alignment));
    
    QString conductor_style = writeStyle();
    if (!conductor_style.isEmpty())
        e.setAttribute("style", conductor_style);
}


void ConductorProperties::fromXml(QDomElement &e)
{
        // get conductor color
    QColor xml_color= QColor(e.attribute("color"));
    color = (xml_color.isValid()? xml_color : QColor(Qt::black));
    
    QString bicolor_str = e.attribute("bicolor", "false");
    m_bicolor = bicolor_str == "true"? true : false;
    
    QColor xml_color_2 = QColor(e.attribute("color2"));
    m_color_2 = xml_color_2.isValid()? xml_color_2 : QColor(Qt::black);
    
    m_dash_size = e.attribute("dash-size", QString::number(1)).toInt();
    
        // read style of conductor
    readStyle(e.attribute("style"));
    
    if (e.attribute("type") == typeToString(Single))
    {
            // get specific properties for single conductor
        singleLineProperties.fromXml(e);
        type = Single;
    }
    else
        type = Multi;

    text                 = e.attribute("num");
    m_formula            = e.attribute("formula");
    m_function           = e.attribute("function");
    m_tension_protocol   = e.attribute("tension-protocol");
    text_size            = e.attribute("numsize", QString::number(9)).toInt();
    cond_size            = e.attribute("condsize", QString::number(1)).toDouble();
    m_show_text          = e.attribute("displaytext", QString::number(1)).toInt();
    m_one_text_per_folio = e.attribute("onetextperfolio", QString::number(0)).toInt();
    verti_rotate_text    = e.attribute("vertirotatetext").toDouble();
    horiz_rotate_text    = e.attribute("horizrotatetext").toDouble();
    
    QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
    m_horizontal_alignment = Qt::Alignment(me.keyToValue(e.attribute("horizontal-alignment", "AlignBottom").toStdString().data()));
    m_vertical_alignment = Qt::Alignment(me.keyToValue(e.attribute("vertical-alignment", "AlignRight").toStdString().data()));

        //Keep retrocompatible with version older than 0,4
        //If the propertie @type is simple (removed since QET 0,4), we set text no visible.
        //@TODO remove this code for qet 0.6 or later
    if (e.attribute("type") == "simple") m_show_text = false;
}

void ConductorProperties::toSettings(QSettings &settings, const QString &prefix) const
{
    settings.setValue(prefix + "color", color.name());
    settings.setValue(prefix + "bicolor", m_bicolor);
    settings.setValue(prefix + "color2", m_color_2.name());
    settings.setValue(prefix + "dash-size", m_dash_size);
    settings.setValue(prefix + "style", writeStyle());
    settings.setValue(prefix + "type", typeToString(type));
    settings.setValue(prefix + "text", text);
    settings.setValue(prefix + "formula", m_formula);
    settings.setValue(prefix + "function", m_function);
    settings.setValue(prefix + "tension-protocol", m_tension_protocol);
    settings.setValue(prefix + "textsize", QString::number(text_size));
    settings.setValue(prefix + "size", QString::number(cond_size));
    settings.setValue(prefix + "displaytext", m_show_text);
    settings.setValue(prefix + "onetextperfolio", m_one_text_per_folio);
    settings.setValue(prefix + "vertirotatetext", QString::number(verti_rotate_text));
    settings.setValue(prefix + "horizrotatetext", QString::number(horiz_rotate_text));
    
    QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
    settings.setValue(prefix + "horizontal-alignment", me.valueToKey(m_horizontal_alignment));
    settings.setValue(prefix + "vertical-alignment", me.valueToKey(m_vertical_alignment));

    singleLineProperties.toSettings(settings, prefix);
}

void ConductorProperties::fromSettings(QSettings &settings, const QString &prefix)
{
    QColor settings_color = QColor(settings.value(prefix + "color").toString());
    color = (settings_color.isValid()? settings_color : QColor(Qt::black));
    
    QColor settings_color_2 = QColor(settings.value(prefix + "color2").toString());
    m_color_2 = (settings_color_2.isValid()? settings_color_2 : QColor(Qt::black));
    
    m_bicolor   = settings.value(prefix + "bicolor", false).toBool();
    m_dash_size = settings.value(prefix + "dash-size", 1).toInt();
    
    QString setting_type = settings.value(prefix + "type", typeToString(Multi)).toString();
    type = (setting_type == typeToString(Single)? Single : Multi);

    singleLineProperties.fromSettings(settings, prefix);

    text                 = settings.value(prefix + "text", "_").toString();
    m_formula            = settings.value(prefix + "formula", "").toString();
    m_function           = settings.value(prefix + "function", "").toString();
    m_tension_protocol   = settings.value(prefix + "tension-protocol", "").toString();
    text_size            = settings.value(prefix + "textsize", "7").toInt();
    cond_size            = settings.value(prefix + "size", "1").toInt();
    m_show_text          = settings.value(prefix + "displaytext", true).toBool();
    m_one_text_per_folio = settings.value(prefix + "onetextperfolio", false).toBool();
    verti_rotate_text    = settings.value((prefix + "vertirotatetext"), "270").toDouble();
    horiz_rotate_text    = settings.value((prefix + "horizrotatetext"), "0").toDouble();
    
    QMetaEnum me = QMetaEnum::fromType<Qt::Alignment>();
    m_horizontal_alignment = Qt::Alignment(me.keyToValue(settings.value(prefix + "horizontal-alignment", "AlignBottom").toString().toStdString().data()));
    m_vertical_alignment = Qt::Alignment(me.keyToValue(settings.value(prefix + "vertical-alignment", "AlignRight").toString().toStdString().data()));
    
    readStyle(settings.value(prefix + "style").toString());
}

QString ConductorProperties::typeToString(ConductorType t)
{
    switch(t)
    {
        case Single: return("single");
        case Multi:  return("multi");
    }
    return QString();
}

void ConductorProperties::applyForEqualAttributes(QList<ConductorProperties> list)
{
    const QList<ConductorProperties> clist = std::move(list);
    
    if (clist.isEmpty())
        return;

    if (clist.size() == 1)
    {
        ConductorProperties cp = clist.first();
        color                = cp.color;
        m_bicolor            = cp.m_bicolor;
        m_color_2            = cp.m_color_2;
        m_dash_size          = cp.m_dash_size;
        text                 = cp.text;
        m_formula            = cp.m_formula;
        m_function           = cp.m_function;
        m_tension_protocol   = cp.m_tension_protocol;
        text_size            = cp.text_size;
        cond_size            = cp.cond_size;
        m_show_text          = cp.m_show_text;
        m_one_text_per_folio = cp.m_one_text_per_folio;
        verti_rotate_text    = cp.verti_rotate_text;
        horiz_rotate_text    = cp.horiz_rotate_text;
        m_vertical_alignment = cp.m_vertical_alignment;
        m_horizontal_alignment = cp.m_horizontal_alignment;

        return;
    }

    bool equal = true;
    QColor c_value;
    bool b_value;
    QString s_value;
    int i_value;
    double d_value;
    Qt::Alignment align_value;
    
        //Color
    c_value = clist.first().color;
    for(ConductorProperties cp : clist)
    {
        if (cp.color != c_value)
            equal = false;
    }
    if (equal)
        color = c_value;
    equal = true;
    
        //bicolor
    b_value = clist.first().m_bicolor;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_bicolor != b_value)
            equal = false;
    }
    if (equal)
        m_bicolor = b_value;
    equal = true;
    
        //second color
    c_value = clist.first().m_color_2;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_color_2 != c_value)
            equal = false;
    }
    if (equal)
        m_color_2 = c_value;
    equal = true;
    
        //Dash size
    i_value = clist.first().m_dash_size;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_dash_size != i_value)
            equal = false;
    }
    if (equal)
        m_dash_size = i_value;
    equal = true;

        //text
    s_value = clist.first().text;
    for(ConductorProperties cp : clist)
    {
        if (cp.text != s_value)
            equal = false;
    }
    if (equal)
        text = s_value;
    equal = true;

        //formula
    s_value = clist.first().m_formula;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_formula != s_value)
            equal = false;
    }
    if (equal)
        m_formula = s_value;
    equal = true;

        //function
    s_value = clist.first().m_function;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_function != s_value)
            equal = false;
    }
    if (equal)
        m_function = s_value;
    equal = true;

        //Tension protocol
    s_value = clist.first().m_tension_protocol;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_tension_protocol != s_value)
            equal = false;
    }
    if (equal)
        m_tension_protocol = s_value;
    equal = true;

        //text size
    i_value = clist.first().text_size;
    for(ConductorProperties cp : clist)
    {
        if (cp.text_size != i_value)
            equal = false;
    }
    if (equal)
        text_size = i_value;
    equal = true;

        //conductor size
    d_value = clist.first().cond_size;
    for(ConductorProperties cp : clist)
    {
        if (cp.cond_size != d_value)
            equal = false;
    }
    if (equal)
        cond_size = d_value;
    equal = true;

        //show text
    b_value = clist.first().m_show_text;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_show_text != b_value)
            equal = false;
    }
    if (equal)
        m_show_text = b_value;
    equal = true;

        //One text per folio
    b_value = clist.first().m_one_text_per_folio;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_one_text_per_folio != b_value)
            equal = false;
    }
    if (equal)
        m_one_text_per_folio = b_value;
    equal = true;

        //Text rotation for vertical conducor
    d_value = clist.first().verti_rotate_text;
    for(ConductorProperties cp : clist)
    {
        if (cp.verti_rotate_text != d_value)
            equal = false;
    }
    if (equal)
        verti_rotate_text = d_value;
    equal = true;

        //Text rotation for horizontal conducor
    d_value = clist.first().horiz_rotate_text;
    for(ConductorProperties cp : clist)
    {
        if (cp.horiz_rotate_text != d_value)
            equal = false;
    }
    if (equal)
        horiz_rotate_text = d_value;
    equal = true;
    
        //Text alignment for horizontal conducor
    align_value = clist.first().m_horizontal_alignment;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_horizontal_alignment != align_value)
            equal = false;
    }
    if (equal)
        m_horizontal_alignment = align_value;
    equal = true;
    
        //Text alignment for vertical conducor
    align_value = clist.first().m_vertical_alignment;
    for(ConductorProperties cp : clist)
    {
        if (cp.m_vertical_alignment != align_value)
            equal = false;
    }
    if (equal)
        m_vertical_alignment = align_value;
    equal = true;
}

ConductorProperties ConductorProperties::defaultProperties()
{
    QSettings settings;

    ConductorProperties def;
    def.fromSettings(settings, "diagrameditor/defaultconductor");

    return(def);
}

bool ConductorProperties::operator==(const ConductorProperties &other) const
{
    return(
        other.type == type &&\
        other.color == color &&\
        other.m_bicolor == m_bicolor &&\
        other.m_color_2 == m_color_2 &&\
        other.m_dash_size == m_dash_size &&\
        other.style == style &&\
        other.text == text &&\
        other.m_formula == m_formula &&\
        other.m_function == m_function &&\
        other.m_tension_protocol == m_tension_protocol &&\
        other.m_show_text == m_show_text &&\
        other.text_size == text_size &&\
        other.cond_size == cond_size &&\
        other.verti_rotate_text == verti_rotate_text &&\
        other.horiz_rotate_text == horiz_rotate_text &&\
        other.singleLineProperties == singleLineProperties &&\
        other.m_one_text_per_folio == m_one_text_per_folio &&\
        other.m_horizontal_alignment == m_horizontal_alignment &&\
        other.m_vertical_alignment == m_vertical_alignment
    );
}

bool ConductorProperties::operator!=(const ConductorProperties &other) const{
    return(!(*this == other));
}

void ConductorProperties::readStyle(const QString &style_string) {
    style = Qt::SolidLine; // style par defaut
    
    if (style_string.isEmpty()) return;
    
    // recupere la liste des couples style / valeur
    QStringList styles = style_string.split(";", QString::SkipEmptyParts);
    
    QRegExp rx("^\\s*([a-z-]+)\\s*:\\s*([a-z-]+)\\s*$");
    foreach (QString style_str, styles) {
        if (rx.exactMatch(style_str)) {
            QString style_name = rx.cap(1);
            QString style_value = rx.cap(2);
            if (style_name == "line-style") {
                if (style_value == "dashed") style = Qt::DashLine;
                else if (style_value == "dashdotted") style = Qt::DashDotLine;
                else if (style_value == "normal") style = Qt::SolidLine;
            }
        }
    }
}

QString ConductorProperties::writeStyle() const {
    if (style == Qt::DashLine) {
        return("line-style: dashed;");
    } else if (style == Qt::DashDotLine) {
        return("line-style: dashdotted");
    } else {
        return(QString());
    }
}

int SingleLineProperties::operator==(const SingleLineProperties &other) const {
    return(
        other.hasGround == hasGround &&\
        other.hasNeutral == hasNeutral &&\
        other.is_pen == is_pen &&\
        other.phases == phases
    );
}

int SingleLineProperties::operator!=(const SingleLineProperties &other) const {
    return(!(other == (*this)));
}

void SingleLineProperties::toSettings(QSettings &settings, const QString &prefix) const {
    settings.setValue(prefix + "hasGround",  hasGround);
    settings.setValue(prefix + "hasNeutral", hasNeutral);
    settings.setValue(prefix + "phases",     phases);
    settings.setValue(prefix + "pen",        is_pen);
}

void SingleLineProperties::fromSettings(QSettings &settings, const QString &prefix) {
    hasGround  = settings.value(prefix + "hasGround",  true).toBool();
    hasNeutral = settings.value(prefix + "hasNeutral", true).toBool();
    phases     = settings.value(prefix + "phases",     1).toInt();
    is_pen     = settings.value(prefix + "pen",        false).toBool();
}